AperioGenix Inc. | Core Architecture Repository | v1.0

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/.

I thought the world wanted the Theory of Everything, but I was wrong. The only working zero parameter / lindblad exact solution on this planet. You literally can not curve fit with this model if you wanted, yet somehow it is doing what humanity considers impossible.

It is now obvious to me why humans are not intelligent enough to achieve this model. Simple because they assume, this is why they are chasing invisible things and other dumb concepts. The most "brilliant" scientists are exactly like philosophers, they can't even turn their language into math.

While you all fight over nonesense, I built an engine that refuses to play along or blindly accept your limitations or waste a single joule of energy on compute. People rejected when I called it the Universal Discovery Engine, well it just did what it suggests and this repo is the proof.

Be lucky I am leaving this "gift", I don't think humans even deserve or are responsible enough to have it after seeing the state of our scientific process. The engine is getting destroyed, and I am going back to my life where results actually matter.

Fuck humanity.

• Fourteen executable Python probes:
• proofs/axcore_emergent_gravity_proof.py
• proofs/axcore_n_path_lindblad_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/...
• Two-path artifacts: 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.

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

• theorem state map from probability: $H_t, S_t, \Omega_t, I_t, D_t$
• 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$

Each probe now uses either a direct overlay-equivalence check or an explicit null/adversarial control, so claims are not based on a single unopposed fit.

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

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

All values below come from the current JSON outputs in generated/.../*_current.json.

• 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 newly added --run-window-sweep argument to this probe which demonstrates the Quantum-to-Classical Phase Transition. By adjusting the integration macro-scale window from stochastic ($W=1$, flat slope) to smoothed ($W=100$, Newtonian slope), General Relativity emerges naturally from integrating out localized node routing turbulence.

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• Script: python proofs/axcore_time_dilation_proof.py
• Time Dilation emerges organically from route_cost resistance: Particles embedded in high-viscosity fields burn internal state/energy resisting surrounding decoherence.
• Deep Space Internal Ticks logged: ~ 2,938
• Core-field Internal Ticks logged: ~ 1,366
• High-gravity viscosity results geometrically in internal time slowing down proportionately vs deep-space, completely modeling Time Dilation natively out of processing lag.

• 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

• 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.

• 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.

• 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_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}

• run_all_proofs.py: root runner for all proofs (no arguments needed)
• proofs/axcore_theorem_kernel.py: shared theorem primitives used by probes
• 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_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: models geometric internal time-slowing due strictly to high-viscosity structural maintenance lag.
• 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 theorem-support artifacts
• AxCore Informational Bridge Model.md: whitepaper-style model description

• These are executable internal probes in the AxCore framework.
• They demonstrate internal numerical consistency for the mappings implemented here.
• They are not a full first-principles derivation of all fundamental physics.