Repository navigation
Releases
The Fejer-York TT Pipeline for RSD (Retained Structure Dynamics)
RSD Paper I / Paper II Support Scripts
This package is a dependency-ordered, executable support bundle for the numerical and export layers used by the Paper I / Paper II development path.
Paper I : https://doi.org/10.5281/zenodo.20066463
Paper II: https://doi.org/10.5281/zenodo.19862180
It is designed around three rules:
run.pyis the only dependency gatekeeper. Scripts receive upstream values through declared command-line inputs rather than reading upstream JSON files directly.- Formula-bearing scripts carry standardized headers and formula-local provenance comments so explicit constants and ratios are documented where they enter the computation.
- Outputs are written as JSON ledgers under
outputs/, with high-precision numeric strings rather than binary float state.
The package is not intended to replace the papers. It executable-codifies the formulas, certificates, and export computations that the papers theoremize.
Quick start
python -m pip install -r requirements.txt
python run.py m_e.py --force
python run.py a_e.py --forceOn Windows, run_all.cmd runs the main support targets in dependency order.
Runner contract
Use:
python run.py <script_name.py> [--force]run.py declares each target, its produced JSON fields, and the upstream fields required to run it. If a required value is produced by another script, run.py runs that producer first unless a cached JSON output already exists. --force reruns the requested target while still reusing existing dependency outputs when available.
Scripts should not silently import target quantities or circular dependencies. Values used in formulas should arrive through the runner’s declared CLI mapping and be recorded in the script output JSON.
Header standard
Every Python script uses the same top-level documentation layout:
ETHOS
WHAT THIS CERTIFIES
THEORY PROVENANCE
INPUTS
DERIVATION
OUTPUT
RUN CONTRACT
WARNING CONDITIONS
The headers are intentionally local. They avoid paper section-number references and instead document the formula role, provenance status, and run contract directly in the script. Formula-local RSD-SOURCE comments remain beside the highest-risk expressions.
Main target scripts
Core Paper-I/Paper-II scalar chain
m.py— first odd branch with the required dyadic richness condition.edge_parity.py— mid-edge parity quotient and Fejér lock ratio.xq.py— Fejér quarter-lock root and derivatives.h4.py— exact spherical harmonic moments.cq.py— York-quartic constant certificate.chitt.py— TT response scale from the York constant.m4.py— unified Bessel–Laplace moment ladder forM4,M6,M8,M10and associated defects.kappa.py— retained curvature normalizationkappa_infty.j2.py,zparity.py,num_orbits.py,zdir.py,a1g_xi_tt.py,gamma.py— mid-edge amplitude factors and product assembly.omega0.py— carrier-local retained TT clock scalar and alpha slot.l_e.py— scalar-volume electron packet length.m_e.py— SI electron mass bridge fromomega0andL_e.
Electron anomaly and normal-form support
pion_split.py— charged/neutral retained pion split ratio.a_e.py— paired retained/released electron anomaly readout.moments_symbol.py— symbolicQ_nBessel-moment ladder.sgamma.py—S_gammanormal-form ladder and normalized coefficients.
Spectrum and export support
lepton_ratios.py— lepton and hadron ratio support ledger.particle_masses.py— absolute mass propagation from the electron bridge and internal ratios.spectrum_table.py— generated spectrum table support output.uv_scales.py— UV/clock scale exports.gravity_norm.py— neutral self-resolution normalization.weak_masses.py— weak-facing mass support output.scalar_hole.py— scalar-hole support output.support_stencil.py—S32 -> P19and stencil-weight certificate.born_hellinger.py— Hellinger tangent normalization certificate.
Supporting utilities
alpha.py— legacy/full Fejér–York alpha assembly with uncertainty propagation.dL2.py— quadratic lock correction used by the legacy alpha assembly.hypothesis.py— protocol/window helper.utils.py— shared script helpers.run_utils.py— runner-side parsing helpers.
Typical commands
# Electron mass bridge
python run.py m_e.py --force
# Electron anomaly
python run.py a_e.py --force
# Pion split
python run.py pion_split.py --force
# Normal-form ladder
python run.py sgamma.py --force
# UV scale exports
python run.py uv_scales.py --force
# Full generated spectrum table
python run.py spectrum_table.py --forceOutputs
Every script writes a JSON file of the form:
outputs/<script_stem>.json
The JSON ledgers record inputs, intermediates, outputs, status, and metadata where applicable. The zip intentionally ships without cached JSON outputs except outputs/.gitkeep.
Current source files
a1g_xi_tt.py
a_e.py
alpha.py
born_hellinger.py
chitt.py
cq.py
dL2.py
edge_parity.py
gamma.py
gravity_norm.py
h4.py
hypothesis.py
j2.py
kappa.py
l_e.py
lepton_ratios.py
m.py
m4.py
m_e.py
moments_symbol.py
num_orbits.py
omega0.py
particle_masses.py
pion_split.py
scalar_hole.py
sgamma.py
spectrum_table.py
support_stencil.py
utils.py
uv_scales.py
weak_masses.py
xq.py
zdir.py
zparity.py
Requirements
- Python 3.11 recommended
mpmath,numpy, andsympyas listed inrequirements.txt
Install with:
python -m pip install -r requirements.txtNotes on audit posture
The package has been pruned to remove legacy audit-only scripts and repo-level duplicate audit documents. The README is the only repo-level guide; detailed provenance belongs in the standardized script headers and inline formula comments.
The strongest support spine is:
omega0.py -> l_e.py -> m_e.py
pion_split.py -> a_e.py
moments_symbol.py -> sgamma.py
uv_scales.py / gravity_norm.py / support_stencil.py / born_hellinger.py
Formula-led spectrum support scripts remain explicitly documented in their headers so their theorem status is visible where formulas enter.
License
See LICENSE.
The Fejer-York TT Pipeline to α: Minimal Repro
Deterministic “theoretical experiment” scripts that produce the key
certificates/constants referenced in the paper.
- No network access required
- CPU only, fast, fully reproducible
- Outputs written to
outputs/as JSON (strings for numerics; no Python floats)
What this is
This repo contains a multi-script, reproducible pipeline that ties together:
-
The TT–sector normalization (
$\kappa_\infty$ ) obtained by combining a signed ($\chi_{\mathrm{TT}}$ ) with the$\chi$ –free quantity ($\Delta := M_4/3-\mathbb{E}[u_x^4]$ ) (seekappa.py). The quantity ($M_4$ ) itself is computed via stabilized Bessel–Laplace integrals with a$\sqrt{X}$ tail extrapolation (seem4.py). -
The Fejér–York lock that produces the effective length (
$L_{\mathrm{eff}}$ ), reduced mass ($m_r=e^{L_{\mathrm{eff}}/m}$ ), and a prediction for
$$\alpha^{-1} = \frac{\kappa_\infty, m}{e^{2L_{\mathrm{eff}}/m}-1}, .$$ -
Explicit error control: absolutely convergent series/pieces with printed
remainder bounds, and bracketed/bisected lock solution. -
Ablations/diagnostics: dyadic gate & isolation at the EL lock, parity and
A1g factors assembled from small, auditable scripts.
Scope note: this minimal repro implements the baseline Bessel route for
$\kappa_\infty$ . There is no separate “Route A” continuum cross-check in
this repo, and no commutator$z_\chi$ experiments.
Components (src/)
-
xq.py— Fejér quarter-FWHM lock ($K(x_q)=8/15$ ) via rigorous bisection;
emitsx_q,L0=log(15/8), and derivativesfpp,f3,f4.
JSON carries high-precision decimal strings only (no float echoes). -
m.py— EL-lock isolation + dyadic gate over oddm; reports firstm
that passes: oddness, dyadic richness proxyord_m(2) ≥ 18, and Fejér isolation
atx_q. -
m4.py— Exact Bessel–Laplace evaluation of$M_4$ with identical kernel and
$\sqrt{X}$ tail model; prints round-by-round cutoffs and the width of recent$M_4$
values; emits tail-span stats in JSON. -
kappa.py— TT baseline certificate for$\kappa_\infty$ using$\chi_{\mathrm{TT}}$
and the$\chi$ –free$\Delta$ (orM4+E[u^4]), with optional propagation of a supplied
$|\delta \Delta|$ into$|\delta \kappa|$ . -
h4.py— Exact$S^2$ moments for the cubic$A_{1g}$ quartic harmonic
$H_4$ :$\langle H_4^2\rangle$ ,$\langle H_4^3\rangle$ ,$\langle H_4^4\rangle$
(Dirichlet moments; rationals + high-precision echoes). -
cq.py— York–quartic constant:
Monte‑Carlo certificate for$C_{\hat Q}$ constancy and the exact canonical
$C_Q = 11/780$ . -
chitt.py— Linear-response scale$\chi_{\mathrm{TT}} = 3,C_Q$ (exact-fraction aware). -
j2.py— Quarter-hop Jacobian$^2$ certificate at mid-edge: emitsJ2 = 4/3
(with small surgical checks; JSON carries the rational). -
zparity.py— Parity factor$\zeta_{\text{parity}} = 8,\mathbb{E}[u_x^2 u_y^2 u_z^2]$
via separated mp.mpf quadratures (reconstructs1/105→8/105). -
edge_parity.py— Mid-edge parity/Jacobian quotient$\gamma_{\text{edge}}=15/16$ ,
also records the Fejér lock condition$K(x_q)=8/15$ . -
num_orbits.py— “Five equal mid-edge sectors”: enumerate 12 edge directions,
collapse to 6 antipodal classes, and group into 5 parity sectors (canonical paper
partition). -
zdir.py— Directional share from internal split:
$\zeta_{\text{dir}} = 8/25$ and$\zeta_{\text{wedge}} = \zeta_{\text{dir}}/N$ (K‑independent). -
a1g_xi_tt.py— A1g/normalization helper used in the amplitude chain
(emits the A1g projection coefficient consumed bygamma.py). -
gamma.py— Unified mid-edge amplitude
$\Gamma = \zeta_{\text{parity}} \cdot J_2 \cdot \zeta_{\text{dir}} \cdot C_{A1g}$
(CLI-only product; exact reconstruction when possible). -
dL2.py— Quadratic correction
$\Delta L^{(2)} = \tfrac12 f''(x_q),\langle H_4^2\rangle,(\chi_{\mathrm{TT}}\Gamma)^2$ . -
alpha.py— Final assembly of$L_{\mathrm{eff}}$ ,$m_r=e^{L_{\mathrm{eff}}/m}$ ,
and$\alpha^{-1}$ ; propagates Fejér-series remainders and a supplied absolute
$\delta\kappa$ into errors. -
hypothesis.py— Protocol/window helper. -
utils.py— Shared helpers: CLI parsing (parse_number), JSON writers, ledger
printing, rational reconstruction, deterministic output filenames, etc.
Runner (dependency-aware)
A lightweight orchestrator lives at the repo top-level:
run.py— infers dependencies from a single target and from the
inputs/outputs mapping; pulls required values from prior JSON artifacts; builds
the exact CLI for each dependency; and runs only the missing pieces.
Usage
python run.py <script_name.py> [--force]<script_name.py>must be one of the scripts declared inCONFIG["scripts"]
insiderun.py(see the list above).--forcere-runs the target even if its default JSON already exists.
Typical invocations
# End-to-end observables. Will run everything needed for alpha.json in order.
python run.py alpha.py
# Baseline κ∞ certificate (pulls χ_TT and E[u^4] from deps)
python run.py kappa.py
# Amplitude Γ (pulls z_parity, J2, z_dir, C_A1g)
python run.py gamma.py
# Freshen just the lock & curvature (and anything it depends on)
python run.py xq.py --forceWhat the runner actually does
- Infers deps by scanning the target’s declared
inputsfor variables whose
producer is another script (e.g.,alpha.pyneedsm_first→ produced bym.py). - Extracts values from the producers’ JSON using dot paths and optional
type components (e.g.,kappa_infty.float:24,m_first.int,
C_Q.rational,kappa_infty.bounds.abs.float). - Builds flags from the mapping and executes
python src/<script>.py .... - Caches per-script JSON at
outputs/<script>.json. If present, deps are
skipped unless--forceis supplied for the target (deps are still reused
from cache).
Requirements
- Python 3.11 recommended
mpmath(and any other packages listed inrequirements.txt)
Install once:
python -m pip install -r requirements.txtQuick start (macOS / Linux)
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
# One command to generate final observables (and all prerequisites)
python run.py alpha.pyManual pipeline (advanced / explicit)
# 1) Lock & curvature
python src/xq.py --auto-bracket --dps 80
# 2) Dyadic/isolation gate (pass the x_q decimal from outputs/xq.json)
python src/m.py --xq "<x_q_decimal>"
# 3) Core scalars
python src/h4.py
python src/cq.py
python src/chitt.py
python src/j2.py
python src/zparity.py
python src/edge_parity.py
python src/num_orbits.py
python src/zdir.py --num-sectors 5
python src/gamma.py --z-parity 8/105 --j2 4/3 --z-dir 8/25 --c-a1g "<C_A1g>"
# 4) κ∞ and corrections
python src/m4.py --E-u4 1/5
python src/kappa.py --chi-tt 11/260 --E-u4 1/5
python src/dL2.py --fpp "<fpp>" --H4-sq 16/525 --chi-tt 11/260 --Gamma "<Gamma>"
# 5) Final observables (supply J2 or s=√J2, plus H4^3,H4^4 from h4.py)
python src/alpha.py --m 19 --kappa "<kappa>" --dkappa "<dkappa_abs>" --x-q "<x_q>" --L0 "<L0>" --deltaL2 "<ΔL2>" --Gamma "<Gamma>" --f3 "<f3>" --f4 "<f4>" --H4-m3 384/125125 --H4-m4 22784/10635625 --J2 4/3Windows (PowerShell)
Activate with. .\.venv\Scripts\Activate.ps1then:python run.py alpha.pyA convenience wrapper is also provided:
run_all.cmd.
Expected checks (sanity)
After a successful pass with defaults you should typically see:
-
outputs/m.json⇒"m_first": 19(row form=19showsord2: 18,
dyadic_pass: true,isolation_pass: true). -
outputs/xq.json⇒x_q ≈ 1.3297024653…,L0 = log(15/8),
and high-precision decimals forfpp,f3,f4(no float fields). -
outputs/kappa.json⇒ a stableκ_∞value with a printed tail-span bound. -
outputs/alpha.json⇒$m_r$ ,$\alpha^{-1}$ , and an error breakdown
consistent with Fejér tails +$\delta\kappa$ .
How things plug together
-
xq.py→x_q,L0,fpp,f3,f4 -
m.py→ validates odd-mdyadic/isolation atx_q -
h4.py,cq.py,chitt.py,j2.py,zparity.py,edge_parity.py,
num_orbits.py,zdir.py,a1g_xi_tt.py,midedge_blend_ratio_mc.py→ small audited factors -
gamma.py→ combines parity/Jacobian/direction/A1g into$\Gamma$ -
m4.py→ computes$M_4$ $\to$ tail-span -
kappa.py→ combines$\chi_{\mathrm{TT}}$ and$\Delta$ to get$\kappa_\infty$ -
dL2.py→ quadratic lock correction$\Delta L^{(2)}$ -
alpha.py→ assembles$L_{\mathrm{eff}}$ , propagates errors, outputs$m_r$ ,$\alpha^{-1}$ -
run.py→ give it a target (e.g.,alpha.py) and it will infer and run all prerequisites.
All scripts follow the same CLI contract and the shared helpers in utils.py.
Re-running & cache
- Each script writes
outputs/<script>.json. run.pyreuses those artifacts; to recompute a target from scratch, pass--force:python run.py xq.py --force
Troubleshooting
- Module not found: activate the venv and (re)install requirements.
- Precision: raise
--dps(forxq.py) or tighten tolerances if you need finer brackets/series tails. - Runner says “Missing required value”: ensure the producer script for that value has written its JSON (or just invoke the higher-level target so
run.pyruns deps automatically). - Help/usage:
python run.pywith wrong args prints the usage banner.
License
See LICENSE for code licensing.
The Scalar–Singlet Saddle (S³): Minimal Repro
Deterministic “theoretical experiment” scripts that produce the key
certificates/constants referenced in the paper.
- No network access required
- CPU only, fast, fully reproducible
- Outputs written to
outputs/as JSON (strings for numerics; no Python floats)
What this is
This repo contains a multi-script, reproducible pipeline that ties together:
- The TT–sector normalization ( \kappa_\infty ) computed ab initio via
stabilized Schlömilch/Bessel integrals. - The Fejér–York lock that produces the effective length (L_{\mathrm{eff}}),
reduced mass (m_r=e^{L_{\mathrm{eff}}/m}), and a prediction for
( \alpha^{-1} = \kappa_\infty m/(e^{2L_{\mathrm{eff}}/m}-1)). - Explicit error control: absolutely convergent series/pieces with printed
remainder bounds, and bracketed/bisected lock solution. - Ablations/diagnostics: dyadic gate & isolation at the EL lock, parity and
A1g factors assembled from small, auditable scripts.
Scope note: this minimal repro implements the baseline Bessel route for
( \kappa_\infty ). There is no separate “Route A” continuum cross-check in
this repo, and no commutator (z_\chi) experiments.
Components (src/)
xq.py— Fejér quarter-FWHM lock (K(x_q)=8/15) via rigorous bisection;
emitsx_q,L0=log(15/8), and derivativesfpp,f3,f4.
JSON carries high-precision decimal strings only (no float echoes).m.py— EL-lock isolation + dyadic gate over oddm; reports firstm
that passes: oddness, dyadic richness proxyord_m(2) ≥ 18, and Fejér isolation
atx_q.kappa.py— TT baseline certificate for ( \kappa_\infty ) using exact
stabilized Bessel kernels with √X tail extrapolation and an internal tail-span
bound.h4.py— Exact S² moments for the cubic (A_{1g}) quartic harmonic
(H_4): ⟨H4²⟩, ⟨H4³⟩, ⟨H4⁴⟩ (Dirichlet moments; rationals + high-precision echoes).cq.py— York–quartic constant:
Monte-Carlo certificate for (C_{\hat Q}) constancy and the exact canonical
( C_Q = 11/780 ).chitt.py— Linear-response scale ( \chi_{TT} = 3,C_Q ) (exact-fraction aware).j2.py— Quarter-hop Jacobian² certificate at mid-edge: emitsJ2 = 4/3
(with small surgical checks; JSON carries the rational).zparity.py— Parity factor ( \zeta_{\text{parity}} = 8,\mathbb{E}[u_x^2 u_y^2 u_z^2] )
via separated mp.mpf quadratures (reconstructs1/105→8/105).edge_parity.py— Mid-edge parity/Jacobian quotient ( \gamma_{\text{edge}}=15/16 ),
also records the Fejér lock condition (K(x_q)=8/15).num_orbits.py— “Five equal mid-edge sectors”: enumerate 12 edge directions,
collapse to 6 antipodal classes, and group into 5 parity sectors (canonical paper
partition).zdir.py— Main-lobe share from lock:
( \zeta_{\text{dir}} = (3/5),R ), ( \zeta_{\text{wedge}} = \zeta_{\text{dir}}/N )
for lock ratioR(e.g.8/15) and sector countN(e.g.5).a1g_xi_tt.py— A1g/normalization helper used in the amplitude chain
(emits the A1g projection coefficient consumed bygamma.py).midedge_blend_ratio_mc.py— Mid-edge blend ratio Monte Carlo (auxiliary).gamma.py— Unified mid-edge amplitude
( \Gamma = \zeta_{\text{parity}} \cdot J_2 \cdot \zeta_{\text{dir}} \cdot C_{A1g} )
(CLI-only product; exact reconstruction when possible).dL2.py— Quadratic correction
( \Delta L^{(2)} = \tfrac12 f''(x_q),\langle H_4^2\rangle,(\chi_{TT}\Gamma)^2 ).alpha.py— Final assembly of (L_{\mathrm{eff}}), (m_r=e^{L_{\mathrm{eff}}/m}),
and ( \alpha^{-1} ); propagates Fejér-series remainders and a supplied absolute
( \delta\kappa ) into errors.hypothesis.py— Protocol/window helper.utils.py— Shared helpers: CLI parsing (parse_number), JSON writers, ledger
printing, rational reconstruction, deterministic output filenames, etc.
Runner (dependency-aware)
A lightweight orchestrator lives at the repo top-level:
run.py— infers dependencies from a single target and from the
inputs/outputs mapping; pulls required values from prior JSON artifacts; builds
the exact CLI for each dependency; and runs only the missing pieces.
Usage
python run.py <script_name.py> [--force]<script_name.py>must be one of the scripts declared inCONFIG["scripts"]
insiderun.py(see the list above).--forcere-runs the target even if its default JSON already exists.
Typical invocations
# End-to-end observables. Will run everything needed for alpha.json in order.
python run.py alpha.py
# Baseline κ∞ certificate (pulls χ_TT and E[u^4] from deps)
python run.py kappa.py
# Amplitude Γ (pulls z_parity, J2, z_dir, C_A1g)
python run.py gamma.py
# Freshen just the lock & curvature (and anything it depends on)
python run.py xq.py --forceWhat the runner actually does
- Infers deps by scanning the target’s declared
inputsfor variables whose
producer is another script (e.g.,alpha.pyneedsm_first→ produced bym.py). - Extracts values from the producers’ JSON using dot paths and optional
type components (e.g.,kappa_infty.float:24,m_first.int,
C_Q.rational,kappa_infty.bounds.abs.float). - Builds flags from the mapping and executes
python src/<script>.py .... - Caches per-script JSON at
outputs/<script>.json. If present, deps are
skipped unless--forceis supplied for the target (deps are still reused
from cache).
Requirements
- Python 3.11 recommended
mpmath(and any other packages listed inrequirements.txt)
Install once:
python -m pip install -r requirements.txtQuick start (macOS / Linux)
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
# One command to generate final observables (and all prerequisites)
python run.py alpha.pyManual pipeline (advanced / explicit)
If you prefer to drive each step yourself:
# 1) Lock & curvature
python src/xq.py --auto-bracket --dps 80
# 2) Dyadic/isolation gate (pass the x_q decimal from outputs/xq.json)
python src/m.py --xq "<x_q_decimal>"
# 3) Core scalars
python src/h4.py
python src/cq.py
python src/chitt.py
python src/j2.py
python src/zparity.py
python src/edge_parity.py
python src/num_orbits.py
python src/zdir.py --lock-ratio 8/15 --num-sectors 5
python src/gamma.py --z-parity 8/105 --j2 4/3 --z-dir 8/25 --c-a1g "<C_A1g>"
# 4) κ∞ and corrections
python src/kappa.py --chi-tt 11/260 --E-u4 1/5
python src/dL2.py --fpp "<fpp>" --H4-sq 16/525 --chi-tt 11/260 --Gamma "<Gamma>"
# 5) Final observables (supply J2 or s=√J2, plus H4^3,H4^4 from h4.py)
python src/alpha.py --m 19 --kappa "<kappa>" --dkappa "<dkappa_abs>" --x-q "<x_q>" --L0 "<L0>" --deltaL2 "<ΔL2>" --Gamma "<Gamma>" --f3 "<f3>" --f4 "<f4>" --H4-m3 384/125125 --H4-m4 22784/10635625 --J2 4/3Windows (PowerShell)
Activate with. .\.venv\Scripts\Activate.ps1then:python run.py alpha.pyA convenience wrapper is also provided:
. un_all.cmd.
Expected checks (sanity)
After a successful pass with defaults you should typically see:
outputs/m.json⇒"m_first": 19(row form=19showsord2: 18,
dyadic_pass: true,isolation_pass: true).outputs/xq.json⇒x_q ≈ 1.3297024653…,L0 = log(15/8),
and high-precision decimals forfpp,f3,f4(no float fields).outputs/kappa.json⇒ a stableκ_∞value with a printed tail-span bound.outputs/alpha.json⇒ (m_r), ( \alpha^{-1} ), and an error breakdown
consistent with Fejér tails + ( \delta\kappa ).
How things plug together
xq.py→x_q,L0,fpp,f3,f4m.py→ validates odd-mdyadic/isolation atx_qh4.py,cq.py,chitt.py,j2.py,zparity.py,edge_parity.py,
num_orbits.py,zdir.py,a1g_xi_tt.py,midedge_blend_ratio_mc.py→ small audited factorsgamma.py→ combines parity/Jacobian/direction/A1g into ( \Gamma )kappa.py→ computes ( \kappa_\infty ) (baseline)dL2.py→ quadratic lock correction ( \Delta L^{(2)} )alpha.py→ assembles (L_{\mathrm{eff}}), propagates errors, outputs (m_r), ( \alpha^{-1} )run.py→ give it a target (e.g.,alpha.py) and it will infer and run all prerequisites.
All scripts follow the same CLI contract and the shared helpers in utils.py.
Re-running & cache
- Each script writes
outputs/<script>.json. run.pyreuses those artifacts; to recompute a target from scratch, pass--force:python run.py xq.py --force
Troubleshooting
- Module not found: activate the venv and (re)install requirements.
- Precision: raise
--dps(forxq.py) or tighten tolerances if you need finer brackets/series tails. - Runner says “Missing required value”: ensure the producer script for that value has written its JSON (or just invoke the higher-level target so
run.pyruns deps automatically). - Help/usage:
python run.pywith wrong args prints the usage banner.
License
See LICENSE for code licensing. If a separate data license applies to files in
outputs/, see the repository notes.
The Scalar–Singlet Saddle (S³): Minimal Repro
Deterministic “theoretical experiment” scripts that produce the key
certificates/constants referenced in the paper.
- No network access required
- CPU only, fast, fully reproducible
- Outputs written to
outputs/
What this is
This repo contains a single-file, reproducible pipeline that ties together:
- TT sector normalization (\kappa_\infty) computed ab initio (Bessel-factorized baseline) with an independent continuum “Route A” cross-check (TT-complete via symmetry ×6, polar patch around the diagonal, and (r_0!\to!0) extrapolation).
- The Fejér–York lock that produces the effective length (L_{\mathrm{eff}}), the small parameter (\varepsilon), reduced mass (m_r=1/\varepsilon), and a prediction for (\alpha^{-1}) from the same rigidity pipeline.
- Rigorous error control: absolutely convergent expressions, analytic tail/remainder bounds, and guarded quadrature near the (t_1!\approx!0) singular manifold.
- Ablations & diagnostics: York toggle, parity “what-if”, sensitivity (d(\alpha^{-1})/dL), cached vs. computed (\kappa_\infty), and convergence/extrapolation scans.
- Commutator experiments (z_\chi): projector-based and true low-(q) commutator probes that do not alter the kinematic York coefficient (used only for diagnostics; CODATA is shown for context rather than as an input).
The goal is to blunt “numerology” critiques by (i) deriving every ingredient from the same (L_{\mathrm{eff}})/rigidity scheme with explicit bounds, and (ii) providing an out-of-sector cross-check (Route A) that shares no discretization artifacts with the baseline.
Highlights
- One-file run: No figures, just scalars suitable for the paper’s “Lock Universality and Ablations” section.
- Two independent (\kappa_\infty) routes:
- Baseline: Bessel-factorized TT integrals.
- Route A: Continuum integral with TT completion (×6), polar patch around (t_2=t_3=0), and linear (r_0)-extrapolation to remove the regulated core.
- Fejér–York lock (series-exact): (L_0=\log(15/8)), York increment (11/1560), odd/even tails evaluated with absolute convergence and rigorous bounds.
- Precision on rails: Configurable decimal precision for the lock and integrators; all tolerances are finite and guarded (no infinite loops).
- Remainder bounds everywhere: Poisson-summed/series tails and polar-patch contributions carry explicit, printed bounds.
- Ablations you can trust: York toggle, optional parity knob, and first-order (\Delta L) needed to match an external target (diagnostic only).
- Sensitivity reporting: Exact (d(\alpha^{-1})/dL) at the evaluated (L_{\mathrm{eff}}) to translate tiny theory shifts into ppb predictions.
- Convergence dashboards: GL node sweeps, Richardson-style extrapolation for Route A, and slope diagnostics.
- Safe near singularities: Open-interval and polar decompositions plus small-(r) analytic limits avoid division-by-zero traps.
- Cache or compute: Use the cached (\kappa_\infty) for quick runs or recompute both routes when you want a clean ab initio pass.
- Transparent (z_\chi) probes: Implements projector and true commutator measurements to quantify (not force) any mismatch; by design, York’s kinematic coefficient is unchanged by these probes.
Requirements
- Python 3.11 (recommended)
- Packages pinned in
requirements.txt(e.g.mpmath)
Install once:
python -m pip install -r requirements.txtQuick start (Windows PowerShell)
python -m venv .venv
. .\.venv\Scripts\Activate.ps1
python -m pip install -r requirements.txt
.\run_all.cmdQuick start (macOS / Linux)
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt
# Manual sequence (same as run_all.cmd)
python run.py xq.py --force
python run.py m.py --force # run.py passes --xq from xq.py into m.py
python run.py kappa.py --force
python run.py a1g.py --force
python run.py alpha.py --forceTip: Omit
--forceto re-use cached results inoutputs/.
Expected checks (sanity)
After a successful run you should see:
outputs/m.json"m_first": 19- Row for
m=19shows"ord2": 18,"dyadic_pass": true,"isolation_pass": true
outputs/xq.jsonx_q ≈ 1.3297024653297962…L0 = log(15/8)
outputs/alpha.jsonalpha^{-1} ≈ 137.035999176279489…- Internal uncertainty split consistent with the paper
How things plug together
xq.pycomputes the EL-lock abscissax_q(Fejér lock).m.pyreads--xqvia utils and certifies the dyadic gate & isolation at the EL lock.kappa.pyproduces the Schlömilch/Bessel integral certificateκ∞.a1g.pyand companions derive group-theoretic factors used in the master relation.alpha.pyassembles everything to reproduce the predictedα^{-1}.
All scripts follow the same CLI contract and shared helpers in utils.py.
Re-running & cache
Results are cached under outputs/. Use --force on any run.py <script> --force
invocation to recompute that step from scratch.
Troubleshooting
- Module not found: activate the virtual environment (
. .\.venv\Scripts\Activate.ps1on Windows orsource .venv/bin/activateon Unix) and reinstall requirements. - Different Python version: prefer Python 3.11 to match expected numerics and JSON formatting.
License
See LICENSE for code licensing. If a separate data license applies to files in outputs/, see the repository notes.
Cite this software
BibTeX
@software{stieger_york_fejer_dL2_2025_v110,
author = {Gustav Stieger},
title = {quantumagi/york: York--Fej{\'e}r $\Delta L^{2}$ (v1.0)},
version = {v1.0.1},
year = {2025},
publisher = {Zenodo},
doi = {10.5281/zenodo.17179996},
url = {https://doi.org/10.5281/zenodo.17179996}
}Related Paper
BibTeX
@misc{Stieger2025S3,
author = {Stieger, Gustav},
title = {The Scalar--Singlet Saddle (S$^3$): Predicting the Fine-Structure Constant $\alpha$ from a Strict Variational Principle},
howpublished = {Zenodo},
year = {2025},
month = {September},
doi = {10.5281/zenodo.17180680},
url = {https://doi.org/10.5281/zenodo.17180680},
note = {Preprint, version v1.1-preprint. License: Other (Not open/All rights reserved).}
}Changelog
v1.0 (initial):
- Minimal script set (
src/), deterministicoutputs/, PowerShell runner, and JSON quick checks. - Matches paper constants and downstream ((\alpha^{-1}, m_r)) within the stated tolerances.
V1.0.1:
- MIT LICENSE added.
v1.1:
- Scripts added/updated
York–Fejér ΔL² (v1.0)
What this is.
A minimal, theory-first, reproducible package that derives the universal quadratic lock correction
(\Delta L^{(2)}=\tfrac12,f''(x_q),\langle H_4^2\rangle,\chi_{\mathrm{TT}}^2,\Gamma^2)
from York–cubic geometry and verifies its propagation into ((\alpha^{-1}, m_r)) with fixed-seed, deterministic Python scripts.
Highlights
- No tuning or fitting; every factor is fixed by symmetry/calculus/sampling lemmas.
- Deterministic outputs under fixed seeds.
- One-shot runner (
run_all.ps1) plus a tiny verifier (quick_check.py). - Outputs live in
outputs/and mirror script names.
What’s included
.
├─ src/
│ ├─ fejer_lock_alpha.py
│ ├─ fejer_lock_sensitivity.py
│ ├─ fejer_quarter_fwhm.py
│ ├─ kappa_infty_solver.py
│ ├─ midedge_dirichlet_gamma.py
│ ├─ spherical_H4_norm.py
│ └─ york_constant_axis.py
├─ outputs/
│ ├─ fejer_lock_alpha.json
│ ├─ fejer_lock_sensitivity.json
│ ├─ fejer_quarter_fwhm.json
│ ├─ kappa_infty_solver.json
│ ├─ midedge_dirichlet_gamma.json
│ ├─ spherical_H4_norm.json
│ └─ york_constant_axis.json
├─ run_all.ps1
├─ quick_check.py
├─ requirements.txt
├─ LICENSE
└─ README.md
Reproduce in ~30 seconds
Requirements: Python 3.10+ on Windows; mpmath and numpy.
# from repo root
python -m pip install --upgrade pip
pip install mpmath numpy
# run everything & write outputs/
.\run_all.ps1
# smoke-test the numerical claims
python quick_check.py
If PowerShell execution is blocked:
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\run_all.ps1
Non-Windows / no PowerShell? Run the scripts individually:
python src/midedge_dirichlet_gamma.py -o outputs/midedge_dirichlet_gamma.json
python src/kappa_infty_solver.py -o outputs/kappa_infty_solver.json
python src/fejer_lock_alpha.py -o outputs/fejer_lock_alpha.json
python src/fejer_lock_sensitivity.py -o outputs/fejer_lock_sensitivity.json
python quick_check.py
Verified outputs (v1.0)
The runner produces (matching the paper and theory):
midedge_dirichlet_gamma.json→"delta_L2": 3.071538094072599e-09kappa_infty_solver.json→"kappa_infty": 0.499268512001529552fejer_lock_alpha.json→"alpha_inv_final": 137.0359991762865fejer_lock_sensitivity.json→"ALL_PASSED": true
quick_check.py asserts these within tight tolerances and prints ALL PASS on success.
Notes on numerics
- High-precision paths use
mpmath(dps set inside scripts) and exact rationals where possible. - All seeds fixed; no randomized fitting or parameter tuning.
- Scripts are idempotent—re-running overwrites the same JSON with the same values.
Cite this software
BibTeX
@software{stieger_york_fejer_dL2_2025_v101,
author = {Gustav Stieger},
title = {quantumagi/york: York--Fej{\'e}r $\Delta L^{2}$ (v1.0)},
version = {v1.0.1},
year = {2025},
publisher = {Zenodo},
doi = {10.5281/zenodo.17095843},
url = {https://doi.org/10.5281/zenodo.17095843}
}Changelog
v1.0 (initial):
- Minimal script set (
src/), deterministicoutputs/, PowerShell runner, and JSON quick checks. - Matches paper constants and downstream ((\alpha^{-1}, m_r)) within the stated tolerances.
V1.0.1:
- MIT LICENSE added.
York–Fejér ΔL^(2): Preregistered Reproducible Package (v1.0)
York–Fejér ΔL² (v1.0)
What this is.
A minimal, theory-first, reproducible package that derives the universal quadratic lock correction
(\Delta L^{(2)}=\tfrac12,f''(x_q),\langle H_4^2\rangle,\chi_{\mathrm{TT}}^2,\Gamma^2)
from York–cubic geometry and verifies its propagation into ((\alpha^{-1}, m_r)) with fixed-seed, deterministic Python scripts.
Highlights
- No tuning or fitting; every factor is fixed by symmetry/calculus/sampling lemmas.
- Deterministic outputs under fixed seeds.
- One-shot runner (
run_all.ps1) plus a tiny verifier (quick_check.py). - Outputs live in
outputs/and mirror script names.
What’s included
.
├─ src/
│ ├─ fejer_lock_alpha.py
│ ├─ fejer_lock_sensitivity.py
│ ├─ fejer_quarter_fwhm.py
│ ├─ kappa_infty_solver.py
│ ├─ midedge_dirichlet_gamma.py
│ ├─ spherical_H4_norm.py
│ └─ york_constant_axis.py
├─ outputs/
│ ├─ fejer_lock_alpha.json
│ ├─ fejer_lock_sensitivity.json
│ ├─ fejer_quarter_fwhm.json
│ ├─ kappa_infty_solver.json
│ ├─ midedge_dirichlet_gamma.json
│ ├─ spherical_H4_norm.json
│ └─ york_constant_axis.json
├─ run_all.ps1
├─ quick_check.py
├─ requirements.txt
└─ README.md
Reproduce in ~30 seconds
Requirements: Python 3.10+ on Windows; mpmath and numpy.
# from repo root
python -m pip install --upgrade pip
pip install mpmath numpy
# run everything & write outputs/
.\run_all.ps1
# smoke-test the numerical claims
python quick_check.py
If PowerShell execution is blocked:
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\run_all.ps1
Non-Windows / no PowerShell? Run the scripts individually:
python src/midedge_dirichlet_gamma.py -o outputs/midedge_dirichlet_gamma.json
python src/kappa_infty_solver.py -o outputs/kappa_infty_solver.json
python src/fejer_lock_alpha.py -o outputs/fejer_lock_alpha.json
python src/fejer_lock_sensitivity.py -o outputs/fejer_lock_sensitivity.json
python quick_check.py
Verified outputs (v1.0)
The runner produces (matching the paper and theory):
midedge_dirichlet_gamma.json→"delta_L2": 3.071538094072599e-09kappa_infty_solver.json→"kappa_infty": 0.499268512001529552fejer_lock_alpha.json→"alpha_inv_final": 137.0359991762865fejer_lock_sensitivity.json→"ALL_PASSED": true
quick_check.py asserts these within tight tolerances and prints ALL PASS on success.
Notes on numerics
- High-precision paths use
mpmath(dps set inside scripts) and exact rationals where possible. - All seeds fixed; no randomized fitting or parameter tuning.
- Scripts are idempotent—re-running overwrites the same JSON with the same values.
How to cite
If you’re citing the code & data release (recommended for DOI):
York–Fejér ΔL²: Reproducible Derivation (v1.0).
GitHub + Zenodo, 2025. DOI: add-your-Zenodo-DOI
BibTeX template:
@software{york_fejer_deltal2_v1_0,
title = {York–Fejér ΔL^2: Reproducible Derivation (v1.0)},
author = {<Your Name>},
year = {2025},
version = {v1.0},
url = {https://github.com/<org-or-user>/york},
doi = {10.5281/zenodo.XXXXX}
}
License
MIT (see LICENSE).
Changelog
v1.0 (initial):
- Minimal script set (
src/), deterministicoutputs/, PowerShell runner, and JSON quick checks. - Matches paper constants and downstream ((\alpha^{-1}, m_r)) within the stated tolerances.