AxCore: The Informational Bridge Model

AperioGenix Inc. | Core Architecture Repository | v1.0

Read First

• Golden Retriever Edition - completely self-contained, made-for-dummies version of the paper
• Full Paper - full technical paper

TL;DR

AxCore is an executable model of one idea:

If a system has finite energy and finite compute, it naturally contracts from flexible multi-path behavior into stable cached behavior.

This repo gives runnable probes for that idea. You can run them and reproduce the outputs in generated/.

Read the results with the same scope used in the paper: this repo contains one exact contraction theorem, several exact algebraic bridge checks, and a larger set of probe-level measurements under explicit controls and calibrations.

Why This Architecture Is Different

Strategically, this repo is arguing for AxCore as a stronger unification architecture than a stack of disconnected effect-specific models. The claim is not "physics is finished." The claim is that AxCore turns multiple effects into one executable benchmark layer.

1. One metric, many effects. Route cost is reused as the shared ledger for decoherence, gravity-like attraction, time-slowing, and mass-equivalent energy.
2. Forward executable scaling. The mass bridge does not just quote 0.511 MeV; it solves for the substrate capacity that yields electron parity from a measured route cost and then checks that scaling against a copied forward runtime run.
3. Endogenous decoherence. Classicalization is modeled as a budget problem, not an observer miracle.
4. Compact law reuse. The same small law family is reused across the probes instead of introducing a separate formal system for each domain.
5. Benchmarkability. The copied runtime artifacts can fail. If the kernel bridge or the 45.4M-dimension forward mass run missed badly, the repo would expose that directly.

Feature	Standard sector-style framing	AxCore bridge framing
Mathematical unity	Different formalisms for different sectors	Shared runtime currency: route cost
Mass scale	Observed constants inserted into the theory	Substrate-capacity scaling applied to measured route costs
Decoherence	External/open-system postulate	Endogenous budget-driven contraction
Time	Coordinate plus separate dynamical law	Internal tick throughput under route burden
Testing style	Analytic fit plus specialized solvers	Shared-kernel probes plus copied runtime benchmarks

What This Snapshot Contains

• Twenty-one executable Python probes:
• proofs/axcore_emergent_gravity_proof.py
• proofs/axcore_n_path_lindblad_proof.py
• proofs/axcore_landauer_erasure_proof.py
• proofs/axcore_cga5_particle_catalog_proof.py
• proofs/axcore_mass_resolution_scaling_proof.py
• proofs/axcore_forward_mass_parity_proof.py
• proofs/axcore_lag_ceiling_proof.py
• proofs/axcore_strong_confinement_proof.py
• proofs/axcore_weak_decay_proof.py
• proofs/axcore_quantum_phase_transition_proof.py
• proofs/axcore_double_slit_proof.py
• proofs/axcore_vs_einstein_mond_proof.py
• proofs/axcore_resolution_limit_proof.py
• proofs/axcore_entanglement_aliasing_proof.py
• proofs/axcore_area_law_proof.py
• proofs/axcore_kleiber_biocore_proof.py
• proofs/axcore_life_metabolic_loop_proof.py
• proofs/axcore_time_dilation_proof.py
• proofs/axcore_vsl_cavity_proof.py
• proofs/axcore_boson_sampling_proof.py
• proofs/axcore_biocore_steric_fold_proof.py
• Shared theorem kernel used across probes: proofs/axcore_theorem_kernel.py
• Shared support-check module used across probes: proofs/axcore_support_tests.py
• Root runner for all probes: run_all_proofs.py
• Generated outputs (PNG/CSV/JSON): generated/...
• Artifact inputs and two-path traces: artifacts/...
• Theory document: AxCore Informational Bridge Model.md

Note: this repository contains standalone mathematical and executable probe artifacts. It does not include proprietary AperioGenix engine source code.

The Shared Kernel (Now Consistent Across Probes)

All probes use the same theorem-kernel primitives from proofs/axcore_theorem_kernel.py:

• shared state map from probability: $H_t, S_t, \Omega_t, I_t, D_t$ where $S_t$ is a routing-balance term, not conventional sparsity
• semantic/geometric route cost
• finite energy update $E_{t+1} = \text{clip}(E_t - \mathcal{L}t + \text{recharge}, 0, E{\max})$
• contraction map $\kappa_t = (E_t / E_{\max})^\gamma$
• thermodynamic calibration bridge (Landauer anchored, with Joule, MeV, and inverse-capacity helpers):
• $\text{joules_per_full_budget} = N_{\text{bit-eq}} \cdot k_B T \ln 2$
• $E_{J,t} = (E_t/E_{\max}) \cdot \text{joules_per_full_budget}$
• $\Delta Q_t = ((E_t - E_{t+1})/E_{\max}) \cdot \text{joules_per_full_budget}$
• $m_{\text{MeV}} = (\mathcal{L}t / E{\max}) \cdot \text{joules_per_full_budget} / (1 \text{ MeV in Joules})$

Each probe now uses either a direct overlay-equivalence check or an explicit null/adversarial control, so the README claims should be read as either exact kernel identities or probe-level results under the stated conditions.

Thermodynamic Calibration (Kernel API)

from proofs.axcore_theorem_kernel import (
    joules_per_full_budget,
    energy_to_joules,
    delta_q_joules,
    normalized_dissipation_to_mev_landauer,
)

j_full = joules_per_full_budget(n_bit_eq=1_000_000, temperature_k=300.0)
e_j = energy_to_joules(e_t=0.5, e_max=1.0, j_per_full_budget=j_full)
q_j = delta_q_joules(e_before=0.72, e_after=0.181, e_max=1.0, j_per_full_budget=j_full)
m_mev = normalized_dissipation_to_mev_landauer(burn_t=0.25, e_max=1.0, n_bit_eq=1_000_000, temperature_k=300.0)

At 300 K and N_bit-eq = 1,000,000, this gives:

• j_full = 2.870978885078724e-15 J
• e_j (50% budget) = 1.435489442539362e-15 J
• q_j (0.72 -> 0.181) = 1.547457619057432e-15 J
• m_mev (25% dissipative burn) = 0.004479810190951025 MeV

Quick Start

Requirements

• Python 3.10+ (3.11 recommended)
• numpy
• matplotlib

Install and Run

pip install numpy matplotlib

# Run everything (default, no arguments)
python run_all_proofs.py

# Or run any single probe
python proofs/axcore_emergent_gravity_proof.py

Current Reproducible Outputs

All values below come from the current JSON outputs in generated/.../*_current.json. Some are exact bridge checks; others are calibrated or probe-level measurements and should be read that way.

1) Emergent Gravity

• Script: python proofs/axcore_emergent_gravity_proof.py
• Cost-proxy slope (inverse_r): -1.882302468992497
• Trajectory-derived slope (inverse_r): -1.8494362391682408
• Cost-proxy null slope: 0.007209077040617918
• Trajectory null slope: 0.294016253901303
• Adversarial monotone surrogate set:
• inverse_r: cost -1.882302468992497, trajectory -1.8494362391682408
• inverse_r2_pivot: cost -2.3003885552684937, trajectory -1.8828373958354612
• exp_pivot: cost -2.1271547464637868, trajectory -1.8724222453754826
• lorentz_pivot: cost -2.0029606760492182, trajectory -1.8648960217335133
• adversarial_stair_pivot: cost -1.877007652760369, trajectory -1.849173131566794
• adversarial_warp_pivot: cost -1.9369331483240906, trajectory -1.8682055082535465
• Harness flags:
• supports_surrogate_robustness_cost_proxy = true
• supports_surrogate_robustness_trajectory = true
• supports_measurement_agreement = true
• supports_strict_harness = true

There is also a --run-window-sweep argument to this probe which shows a scale-dependent change in the measured slope. By adjusting the integration macro-scale window from stochastic ($W=1$, flat slope) to smoothed ($W=100$, near-Newtonian slope), the harness illustrates how coarse-graining changes the effective radial falloff over the sampled range.

2) N-Path Lindblad Overlay

• Script: python proofs/axcore_n_path_lindblad_proof.py
• RMSE (off-diagonal overlay): 6.905985859359126e-20
• Max absolute overlay error: 1.3010426069826053e-18
• Support flag: supports_lindblad_overlay = true

3) Quantum-to-Classical Phase Transition

• Script: python proofs/axcore_quantum_phase_transition_proof.py
• Max RMSE across ticks: 1.9626155733547188e-18
• Final energy: 0.0
• Final kappa: 0.0
• Support flag: supports_machine_precision_overlay = true

4) Double-Slit Decoherence (with Null)

• Script: python proofs/axcore_double_slit_proof.py
• Primary final coherence: 0.0
• Null final coherence (no budget depletion): 1.0
• Primary interference decay ratio: 0.0
• Null interference decay ratio: 1.0
• Support flag: supports_thermodynamic_decoherence_vs_null = true

5) AxCore vs Einstein vs MOND (Measured Slope)

• Script: python proofs/axcore_vs_einstein_mond_proof.py
• Measured AxCore slope: -1.86197838324592 (derived from simulation, not hardcoded)
• Error vs -2: 0.13802161675407998
• Shuffled-radius null slope: 0.1653049184843184
• Support flag: supports_inverse_square_like_behavior = true

6) Resolution Limit / Lattice Nyquist Boundary (with Null)

• Script: python proofs/axcore_resolution_limit_proof.py
• Primary sub-lattice slope: -1.0634643326537123
• Null sub-lattice slope (coarse-cap control): 4.5447147494667146e-17
• Primary growth factor (min-scale vs unit-scale): 8809.113704039733
• Divergence gain vs null: 8809.113704039733
• Support flag: supports_resolution_limit_divergence_vs_null = true

7) Entanglement as Shared Routing Table (with Controls)

• Script: python proofs/axcore_entanglement_aliasing_proof.py
• Mean prior delta on A-updates (shared alias): 0.03897326806850622
• Mean prior delta on A-updates (isolated): 0.0
• Mean prior delta on A-updates (delayed-copy): 0.0
• Mean delayed-copy prior delta one tick later: 0.06632656901805263
• Support flag: supports_pointer_aliasing_nonlocal_update_vs_controls = true

8) Area Law / Boundary Throughput (with Null)

• Script: python proofs/axcore_area_law_proof.py
• Boundary-model slope vs area: 1.0
• Boundary-model slope vs volume: 0.6849159299700465
• Null-model slope vs volume: 1.0
• Large-scale throughput ratio (null over boundary): 7.977462437395659
• Support flag: supports_area_law_boundary_bottleneck_vs_null = true

9) Kleiber Bridge / BioCore Scaling (with Null)

• Script: python proofs/axcore_kleiber_biocore_proof.py
• Main slope (B vs M): 0.7898246790884726
• Null slope (B vs M, volume-wide writes): 0.9999999999999994
• Slope separation: 0.2101753209115268
• Support flag: supports_kleiber_scaling_vs_null = true

10) Life as a Metabolic Routing Loop (with Null)

• Script: python proofs/axcore_life_metabolic_loop_proof.py
• Main births: 20
• Null births (no harvest): 0
• Alive AUC gain (main/null): 83.53333333333333
• Starvation rate (main): 0.013168395849960097
• Starvation rate (null): 0.39166666666666666
• Support flag: supports_life_metabolic_loop_vs_null = true

11) Time Dilation as Processor Lag

• Script: python proofs/axcore_time_dilation_proof.py
• The probe measures fewer internal ticks near the core than in deep space over the same macro-budget.
• Deep Space Internal Ticks logged: ~ 2,938
• Core-field Internal Ticks logged: ~ 1,366
• The result is interpreted in-repo as processor-lag time slowing in the tested setup, not as a complete first-principles derivation of relativistic time dilation.

12) VSL Cavity / Mode Exclusion Probe

• Script: python proofs/axcore_vsl_cavity_proof.py
• Free-space entropy: 1.0
• Cavity-core entropy: 0.3003513160224718
• Free-space viscosity $\Omega$: 0.5
• Cavity-core viscosity $\Omega$: 0.7448770393921349
• Local speed ratio in cavity (c_local/c0): 1.4897540787842698
• Main speed gain: 48.97540787842698%
• Null speed gain (no cavity mode exclusion): 0.0%
• Support flag: supports_vsl_cavity_mode_exclusion = true

13) Boson Sampling / Thermodynamic Fallback

• Script: python proofs/axcore_boson_sampling_proof.py
• Emulates the highly dispersive optical network used in Jiuzhang to test "Quantum Supremacy".
• Maps how maintaining coherent unitary interference cascades in high dispersion $H_t + S_t$ drains computational energy $E_t$.
• Final Coherence Retention ($\kappa$): 0.0
• The system gracefully abandons calculating the exponentially complex "Ideal Quantum" solution and transitions cleanly into simple probabilistic Classical scattering mid-network.

14) BioCore Action: Steric Repulsion Constraint

• Script: python proofs/axcore_biocore_steric_fold_proof.py
• An amino acid chain starts unfolded (random walk), yielding high computational dispersion and generating immense route-cost ($\Omega$ spikes).
• As the energy drops and $\kappa \to 0$, the mathematical thermodynamic "pull" crushes dispersion to save compute, while steric hindrance (atomic volume constraints) enforce physical space.
• The outcome geometrically bounces and packs into a stable 3D fold that tightly matches theoretical atomic volume limits without requiring an ML database of molecular behavior.

15) Thermodynamic Bit Erasure / Landauer Bridge

• Script: python proofs/axcore_landauer_erasure_proof.py
• Simulates a forced high-entropy to classical overwrite trajectory and computes route-cost dissipation using the shared theorem kernel.
• Converts normalized dissipation to Joules with the kernel Landauer bridge: joules_per_full_budget = N_bit_eq * k_B * T * ln(2).
• Total normalized route cost: 2.295240612312979
• Total Joules dissipated: 6.589587334125724e-15
• Theoretical Landauer minimum (N=1e6, T=300K): 2.8709788850787237e-15
• Thermodynamic overhead ratio: 2.295240612312979
• Support flag: supports_physical_thermodynamics = true

16) Strong Nuclear Topology / Confinement Gradient

• Script: python proofs/axcore_strong_confinement_proof.py
• Measures pull-apart work versus separation for a locked pair under theorem-kernel route cost.
• Uses a matched deconfined null channel to ensure growth is not just baseline route-cost drift.
• Peak step cost (main): 8.613046409726428
• Peak step cost (null): 0.7904329884454572
• Cumulative work (main): 73.11042500759241
• Cumulative work (null): 16.43881392999976
• Tail step ratio (main/null): 11.707460976510372
• Work growth exponent (main): 1.9791318475383535
• Work growth exponent (null): 1.6151899834752341
• Support flag: supports_strong_confinement = true

17) Weak Transition / Metastable Decay

• Script: python proofs/axcore_weak_decay_proof.py
• Runs metastable-to-stable transition trials under finite energy and local noise.
• Compares against a stable-geometry null with the same theorem kernel dynamics.
• Main decay fraction: 1.0
• Null decay fraction: 0.0
• Main mean decay tick: 6.365
• Main median decay tick: 6.0
• Null median decay tick: 1000.0
• Mean released Joules (main): 1.9277745813736125e-15
• Mean released Joules (null): 0.0
• Release ratio (main/null): 1927.7745813736124
• Support flag: supports_weak_decay_transition = true

18) CGA5 Particle Catalog / Theorem-Kernel Bridge

• Script: python proofs/axcore_cga5_particle_catalog_proof.py
• Source artifact: artifacts/axcore_cga5_particle_catalog_current.json
• Uses an exact copied runtime JSON from the external AxCore CPP CGA5 sweep and recomputes its thermodynamic mass equivalents through the shared theorem kernel.
• Max bridge absolute error: 0.0 MeV
• Kernel bridge RMSE: 0.0 MeV
• Constraint-count null RMSE: 1.5463972889867672e-06 MeV
• Measured mass order (lightest to heaviest): Circle -> Motor -> Sphere -> Point-Pair -> Point
• Support flags:
• supports_kernel_mass_bridge = true
• supports_topology_specific_splitting = true
• supports_particle_catalog_bridge = true

19) Mass-Resolution Scaling Lemma

• Script: python proofs/axcore_mass_resolution_scaling_proof.py
• Source artifact: artifacts/axcore_cga5_particle_catalog_current.json
• Uses the measured Point-Pair route cost from the copied CGA5 runtime artifact and inverts the shared theorem-kernel Landauer bridge to solve for the substrate capacity required to hit target mass-equivalents.
• Baseline Point-Pair mass at 1024 dims: 1.1523001371740657e-05 MeV
• Electron parity (0.511 MeV) requires 1453132518.1531758 bit-eq, or 45410391.192286745 HDC dimensions.
• Up-quark parity (2.2 MeV) requires 6256147827.665338 bit-eq, or 195504619.6145418 HDC dimensions.
• Max round-trip absolute error: 4.440892098500626e-16 MeV
• Required-capacity ratio (up/electron): 4.305283757338553
• Support flag: supports_mass_resolution_scaling = true

20) Forward Mass-Parity Validation

• Script: python proofs/axcore_forward_mass_parity_proof.py
• Source artifacts: artifacts/axcore_cga5d_forward_fixed_dim_45410391.json, artifacts/axcore_cga5_particle_catalog_current.json
• Uses the copied forward 45.4M-dimension runtime artifact to validate that the shared theorem kernel reproduces the runtime masses exactly and that the Point-Pair topology lands near electron parity in a raw forward run.
• Point-Pair forward mass: 0.5009360767138339 MeV
• Point-Pair electron absolute error: 0.010063923286166121 MeV
• Point-Pair electron relative error: 0.01969456611774192
• Max bridge absolute error: 0.0 MeV
• Topology order preserved vs low-dimension catalog: true
• Route-drift vs parity-error mismatch: 4.151026560678117e-09
• Support flag: supports_forward_mass_parity = true

21) Finite Lag Ceiling / Redshift Floor

• Script: python proofs/axcore_lag_ceiling_proof.py
• Source artifact: generated/axcore_time_dilation_proof/axcore_time_dilation_proof_current.json
• Combines the measured deep-space baseline from the time-dilation probe with an explicit bounded theorem-kernel action ceiling under benchmark weights.
• Deep-space rest cost: 0.10306250000000002
• Observed near-core cost: 0.18166666666666664
• Benchmark action ceiling: 3.285
• Observed core lag factor: 1.7626844552253886
• Max lag factor: 31.87386294724075
• Minimum internal tick floor: 0.031373668188736686
• SR beta-equivalent at ceiling: 0.9995077253050039
• For comparison, standard SR at 0.9995c gives gamma ≈ 31.6, numerically close to the AxCore ceiling.
• The classic CERN muon storage-ring time-dilation result was reported at gamma ≈ 29.3, just below the AxCore benchmark ceiling.
• Interpreted conservatively, the new proof places the AxCore lag ceiling in the same extreme-relativistic regime as familiar textbook and accelerator examples; it does not yet prove that physical SR literally saturates at the AxCore benchmark.
• Support flag: supports_lag_ceiling = true

Output Locations

• generated/axcore_emergent_gravity_proof/axcore_emergent_gravity_proof_current.{json,csv,png}
• generated/axcore_emergent_gravity_proof/axcore_emergent_gravity_proof_current_surrogates.csv
• generated/axcore_n_path_lindblad_proof/axcore_n_path_lindblad_proof_current.{json,csv,png}
• generated/axcore_landauer_erasure_proof/axcore_landauer_erasure_proof_current.{json,csv,png}
• generated/axcore_cga5_particle_catalog_proof/axcore_cga5_particle_catalog_proof_current.{json,csv,png}
• generated/axcore_mass_resolution_scaling_proof/axcore_mass_resolution_scaling_proof_current.{json,csv,png}
• generated/axcore_forward_mass_parity_proof/axcore_forward_mass_parity_proof_current.{json,csv,png}
• generated/axcore_lag_ceiling_proof/axcore_lag_ceiling_proof_current.{json,csv,png}
• generated/axcore_strong_confinement_proof/axcore_strong_confinement_proof_current.{json,csv,png}
• generated/axcore_weak_decay_proof/axcore_weak_decay_proof_current.{json,csv,png}
• generated/axcore_quantum_phase_transition_proof/axcore_quantum_phase_transition_proof_current.{json,csv,png}
• generated/axcore_double_slit_proof/axcore_double_slit_proof_current.{json,csv,png}
• generated/axcore_double_slit_proof/axcore_double_slit_proof_current_tick_metrics.csv
• generated/axcore_vs_einstein_mond_proof/axcore_vs_einstein_mond_proof_current.{json,csv,png}
• generated/axcore_vs_einstein_mond_proof/axcore_vs_einstein_mond_proof_current_binned.csv
• generated/axcore_resolution_limit_proof/axcore_resolution_limit_proof_current.{json,csv,png}
• generated/axcore_entanglement_aliasing_proof/axcore_entanglement_aliasing_proof_current.{json,csv,png}
• generated/axcore_area_law_proof/axcore_area_law_proof_current.{json,csv,png}
• generated/axcore_kleiber_biocore_proof/axcore_kleiber_biocore_proof_current.{json,csv,png}
• generated/axcore_life_metabolic_loop_proof/axcore_life_metabolic_loop_proof_current.{json,csv,png}
• generated/axcore_time_dilation_proof/axcore_time_dilation_proof_current.{json,png}
• generated/axcore_vsl_cavity_proof/axcore_vsl_cavity_proof_current.{json,csv,png}
• generated/axcore_boson_sampling_proof/axcore_boson_sampling_proof_current.{json,png}
• generated/axcore_biocore_steric_fold_proof/axcore_biocore_steric_fold_proof_current.{json,png}
• artifacts/axcore_cga5_particle_catalog_current.json
• artifacts/axcore_cga5d_forward_fixed_dim_45410391.json

Repository Map

• run_all_proofs.py: root runner for all proofs (no arguments needed)
• proofs/axcore_theorem_kernel.py: shared theorem primitives used by probes, including Landauer-based normalized-budget to Joules and MeV calibration helpers plus inverse capacity scaling helpers
• proofs/axcore_support_tests.py: shared statistical support checks for all probe support flags
• proofs/axcore_emergent_gravity_proof.py: emergent gravity harness with adversarial monotone surrogates and trajectory-derived acceleration checks
• proofs/axcore_n_path_lindblad_proof.py: AxCore decoherence map vs Lindblad overlay
• proofs/axcore_landauer_erasure_proof.py: forced-memory erasure probe mapping AxCore normalized route cost to physical Joules via Landauer calibration
• proofs/axcore_cga5_particle_catalog_proof.py: bridge probe that takes the external CPP CGA5 catalog as a measured artifact and verifies its route-cost-to-mass map against the shared theorem kernel
• proofs/axcore_mass_resolution_scaling_proof.py: fixed-route-cost scaling lemma that inverts the shared thermodynamic bridge to estimate the substrate capacity required for electron and up-quark mass parity
• proofs/axcore_forward_mass_parity_proof.py: forward-validation probe that checks the copied 45.4M-dimension runtime run against the shared kernel and tests Point-Pair electron proximity plus topology-order preservation
• proofs/axcore_lag_ceiling_proof.py: bounded-action lag-ceiling probe that combines the measured time-dilation baseline with a theorem-kernel action ceiling to derive a finite processor-lag redshift floor
• proofs/axcore_strong_confinement_proof.py: confinement-gradient probe comparing locked-pair pull-apart work against a deconfined null
• proofs/axcore_weak_decay_proof.py: metastable decay transition probe with stable-geometry null and Landauer-mapped release accounting
• proofs/axcore_quantum_phase_transition_proof.py: snapshot-based phase transition with overlay metrics
• proofs/axcore_double_slit_proof.py: budget-driven double-slit decoherence with no-depletion null
• proofs/axcore_vs_einstein_mond_proof.py: measured AxCore slope vs Newton/MOND references + null
• proofs/axcore_resolution_limit_proof.py: sub-lattice divergence probe with coarse-cap null
• proofs/axcore_entanglement_aliasing_proof.py: shared-pointer aliasing vs isolated and delayed-copy controls
• proofs/axcore_area_law_proof.py: area-law throughput scaling vs volume-write null
• proofs/axcore_kleiber_biocore_proof.py: Kleiber-like scaling vs volume-write null
• proofs/axcore_life_metabolic_loop_proof.py: self-sustaining routing-agent ecology vs no-harvest null
• proofs/axcore_time_dilation_proof.py: measures reduced internal tick throughput near the core and interprets it as processor-lag time slowing within the probe harness.
• proofs/axcore_vsl_cavity_proof.py: resonant-cavity mode-exclusion probe mapping local entropy depression to viscosity and local wave-speed ratio shift.
• proofs/axcore_boson_sampling_proof.py: models the collapse of computational complexity into classical probabilistic distributions during high-dispersion optical routing (Jiuzhang optical limits).
• proofs/axcore_biocore_steric_fold_proof.py: bridges mathematical scaling limits to a practical packing fold by mapping thermodynamic starvation pressure against simulated physical atomic volume thresholds.
• generated/: current run outputs and figures
• artifacts/: two-path support artifacts plus copied external runtime bridge inputs
• AxCore Informational Bridge Model.md: whitepaper-style model description

Scope

• These are executable internal probes in the AxCore framework.
• They demonstrate internal numerical consistency for the mappings implemented here, plus controlled probe-level behavior under the stated harnesses.
• Some results are exact within the repo's equations and overlays; others are calibrated bridges or empirical fits from the probes.
• They are not a full first-principles derivation of all fundamental physics.