Skip to content

Releases

The Fejer-York TT Pipeline for RSD (Retained Structure Dynamics)

Choose a tag to compare

@quantumagi quantumagi released this 19 May 14:36

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.py is 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 --force

On 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 for M4, M6, M8, M10 and associated defects.
  • kappa.py — retained curvature normalization kappa_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 from omega0 and L_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 — symbolic Q_n Bessel-moment ladder.
  • sgamma.py — S_gamma normal-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 -> P19 and 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 --force

Outputs

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, and sympy as listed in requirements.txt

Install with:

python -m pip install -r requirements.txt

Notes 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

Choose a tag to compare

@quantumagi quantumagi released this 15 Oct 08:07

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]$) (see kappa.py). The quantity ($M_4$) itself is computed via stabilized Bessel–Laplace integrals with a $\sqrt{X}$ tail extrapolation (see m4.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;
    emits x_q, L0=log(15/8), and derivatives fpp, f3, f4.
    JSON carries high-precision decimal strings only (no float echoes).

  • m.py — EL-lock isolation + dyadic gate over odd m; reports first m
    that passes: oddness, dyadic richness proxy ord_m(2) ≥ 18, and Fejér isolation
    at x_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$ (or M4 + 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: emits J2 = 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 (reconstructs 1/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 by gamma.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 in CONFIG["scripts"]
    inside run.py (see the list above).
  • --force re-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 --force

What the runner actually does

  • Infers deps by scanning the target’s declared inputs for variables whose
    producer is another script (e.g., alpha.py needs m_first → produced by m.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 --force is supplied for the target (deps are still reused
    from cache).

Requirements

  • Python 3.11 recommended
  • mpmath (and any other packages listed in requirements.txt)

Install once:

python -m pip install -r requirements.txt

Quick 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.py

Manual 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/3

Windows (PowerShell)
Activate with . .\.venv\Scripts\Activate.ps1 then:

python run.py alpha.py

A 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 for m=19 shows ord2: 18,
    dyadic_pass: true, isolation_pass: true).

  • outputs/xq.json ⇒ x_q ≈ 1.3297024653…, L0 = log(15/8),
    and high-precision decimals for fpp, 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-m dyadic/isolation at x_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.py reuses 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 (for xq.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.py runs deps automatically).
  • Help/usage: python run.py with wrong args prints the usage banner.

License

See LICENSE for code licensing.

The Scalar–Singlet Saddle (S³): Minimal Repro

Choose a tag to compare

@quantumagi quantumagi released this 12 Oct 03:17

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;
    emits x_q, L0=log(15/8), and derivatives fpp, f3, f4.
    JSON carries high-precision decimal strings only (no float echoes).
  • m.py — EL-lock isolation + dyadic gate over odd m; reports first m
    that passes: oddness, dyadic richness proxy ord_m(2) ≥ 18, and Fejér isolation
    at x_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: emits J2 = 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 (reconstructs 1/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 ratio R (e.g. 8/15) and sector count N (e.g. 5).
  • a1g_xi_tt.py — A1g/normalization helper used in the amplitude chain
    (emits the A1g projection coefficient consumed by gamma.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 in CONFIG["scripts"]
    inside run.py (see the list above).
  • --force re-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 --force

What the runner actually does

  • Infers deps by scanning the target’s declared inputs for variables whose
    producer is another script (e.g., alpha.py needs m_first → produced by m.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 --force is supplied for the target (deps are still reused
    from cache).

Requirements

  • Python 3.11 recommended
  • mpmath (and any other packages listed in requirements.txt)

Install once:

python -m pip install -r requirements.txt

Quick 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.py

Manual 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/3

Windows (PowerShell)
Activate with . .\.venv\Scripts\Activate.ps1 then:

python run.py alpha.py

A 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 for m=19 shows ord2: 18,
    dyadic_pass: true, isolation_pass: true).
  • outputs/xq.json ⇒ x_q ≈ 1.3297024653…, L0 = log(15/8),
    and high-precision decimals for fpp, 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-m dyadic/isolation at x_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 )
  • 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.py reuses 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 (for xq.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.py runs deps automatically).
  • Help/usage: python run.py with 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

Choose a tag to compare

@quantumagi quantumagi released this 22 Sep 21:29

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

Quick start (Windows PowerShell)

python -m venv .venv
. .\.venv\Scripts\Activate.ps1
python -m pip install -r requirements.txt
.\run_all.cmd

Quick 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 --force

Tip: Omit --force to re-use cached results in outputs/.

Expected checks (sanity)

After a successful run you should see:

  • outputs/m.json
    • "m_first": 19
    • Row for m=19 shows "ord2": 18, "dyadic_pass": true, "isolation_pass": true
  • outputs/xq.json
    • x_q ≈ 1.3297024653297962…
    • L0 = log(15/8)
  • outputs/alpha.json
    • alpha^{-1} ≈ 137.035999176279489…
    • Internal uncertainty split consistent with the paper

How things plug together

  • xq.py computes the EL-lock abscissa x_q (Fejér lock).
  • m.py reads --xq via utils and certifies the dyadic gate & isolation at the EL lock.
  • kappa.py produces the Schlömilch/Bessel integral certificate κ∞.
  • a1g.py and companions derive group-theoretic factors used in the master relation.
  • alpha.py assembles 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.ps1 on Windows or source .venv/bin/activate on 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

DOI

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

DOI

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/), deterministic outputs/, 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)

Choose a tag to compare

@quantumagi quantumagi released this 10 Sep 22:44

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-09
  • kappa_infty_solver.json → "kappa_infty": 0.499268512001529552
  • fejer_lock_alpha.json → "alpha_inv_final": 137.0359991762865
  • fejer_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

DOI

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/), deterministic outputs/, 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)

Choose a tag to compare

@quantumagi quantumagi released this 10 Sep 21:24

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-09
  • kappa_infty_solver.json → "kappa_infty": 0.499268512001529552
  • fejer_lock_alpha.json → "alpha_inv_final": 137.0359991762865
  • fejer_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/), deterministic outputs/, PowerShell runner, and JSON quick checks.
  • Matches paper constants and downstream ((\alpha^{-1}, m_r)) within the stated tolerances.