# Actual Julia reproduction record

## Environment actually used

* UTC date: **2026-09-12**. Exact run start times are in `evidence/run_manifest.toml`.
* Operating system: **Ubuntu 24.04.3 LTS**, Linux kernel **6.18.35**, x86_64, glibc **2.39**.
* Julia: **1.11.6**, official Linux x86_64 binary release, 64-bit, one Julia thread.
* Executable in this session: `/tmp/omega-julia-runtime/julia-1.11.6/bin/julia`.
* Project directory in this session: `/workspace/scratch/4e72849e4bf1/omega_julia/OMEGA_NAUGHT_Julia_Proof_v0.1`.
* Julia dependencies: bundled standard libraries `SHA`, `TOML`, and `Dates`; no third-party Julia packages were installed or used.
* Python **3.12.14** was used for archive inspection, document/inventory preparation, and packaging. The new mathematical certificate computations and ledger verification were executed in Julia.

Julia was initially absent. The official 1.11.6 runtime was downloaded and its SHA-256 checked against the [Julia release inventory](https://julialang.org/downloads/oldreleases/):

```text
URL: https://julialang-s3.julialang.org/bin/linux/x64/1.11/julia-1.11.6-linux-x86_64.tar.gz
Bytes: 286557288
SHA256: e99e52e2029d845097c68f2372d836186f0eb3fb897a9dde0bdf9ee9250d03d5
```

The runtime archive is not bundled. Once Julia is installed, the proof companion needs no network access. `julia-version` records the tested release; the compatibility range in `Project.toml` is not a claim that other releases have been tested.

## Commands and exit statuses

The code was inspected before execution. A preliminary import and an initial full `-O0` development run completed successfully. After the proof text and reproduction driver were in place, these final two complete runs were made through:

```bash
/tmp/omega-julia-runtime/julia-1.11.6/bin/julia --startup-file=no --project=. scripts/reproduce.jl
```

The driver invoked the following equivalent project-local commands. Its manifest preserves the actual absolute commands, including Julia's inherited executable and system-image arguments.

| Command | Exit status | Observed elapsed seconds |
|---|---:|---:|
| `julia --startup-file=no --project=. -O0 --check-bounds=yes run_proofs.jl evidence/O0` | 0 | 13.667960706 |
| `julia --startup-file=no --project=. -O3 --check-bounds=yes run_proofs.jl evidence/O3` | 0 | 19.151318258 |

The reproduction driver itself exited **0**. Both logs contain the completed group counts and no failed check. All six files below were compared **byte for byte**, and all agreed. Their exact SHA-256 hashes are in `evidence/optimization_comparison.tsv`.

1. `rational_enclosures.tsv`
2. `polynomial_certificates.tsv`
3. `state_certificate.csv`
4. `gap_blocks.csv`
5. `precision_sweep.csv`
6. `results.toml`

These wall-clock observations include compilation and process overhead. They are empirical execution records, not a performance theorem or a claim that one optimization mode is faster.

The following supporting commands also ran successfully:

```bash
julia --startup-file=no --version
julia --startup-file=no --project=. scripts/export_guides.jl
julia --startup-file=no --project=. examples/reconstruction.jl
```

The example decoded seed 32767 from both its 23-step ledger and its first remainder, and reconstructed the exact radius `32767/8` in the retained three-dimensional frame. Its signed generic example with `A=-2`, `B=3`, and seed `-17` also decoded to `-17`.

## Evidence classes and results

| Evidence class | What was actually checked | What establishes the universal statement |
|---|---|---|
| Analytically justified rational enclosure | Integer-square-root endpoints, Machin alternating sums, rational pi/phi/lambda bounds and exact comparisons | P01 proves the enclosure formulas and their analytic remainder bounds |
| Exact symbolic calculation | 97 zero polynomial residuals, plus nonzero and expansion controls | Substitution soundness under the two analytically established relations; positivity and module laws are retained separately |
| Exhaustive finite verification | Every one of 32,768 canonical states, all 128 gap blocks, every recorded transition in 32,768 length-23 ledgers | Finite conjunction covers exactly `D`; P07 and P11 supply two complete floor arguments |
| Exact finite implementation tests | 60,390 generated signed-ledger cases; 22,680 candidate records, of which 2,624 were admissible; rational scalar, grid, placement and reconstruction cases | P09 supplies induction and admissibility/uniqueness proofs for the complete integer domains |
| Analytic induction and implication | Arguments written out in P03–P13 and indexed for every source theorem | Human-checkable mathematics; Julia does not kernel-check the inferences |
| Numerical testing | 31 positive dyadic geometric scales at 256-bit BigFloat precision | Illustrations only; none is a premise of the exact certificate chain |

The census reproduced 753,664 transitions: 300,871 began at positive states and 452,793 began at absorbing zero. The maximum extinction depth was ten and the exact sum of extinction depths was 300,871. Every complete 23-step record and every intermediate retained state was reconstructed.

The minimum gap was 34,535,026,732 at seed 20,706. Intersecting all exact floor constraints returned `[4196/12343,7039/20706)`. The exact decimal sweep gave:

```text
p:           0      1      2      3      4     5    6   7   8..18
mismatches: 32765  32756  32716  32239  22720  5246  414  39  0
```

The all-natural-precision result follows from P08. The all-natural-depth trajectory and extinction results follow by induction. The full-period inverse result follows from the modular identity. No infinite enumeration is claimed for any of these.

## Source integrity and archived evidence

The supplied archive was `OMEGA_NAUGHT_Lean_Proof_v0.1(1).zip`, with SHA-256:

```text
f77f83d0edd127b5377f7c796963ec9d0cb5610bae14116361b9c6aec8437178
```

Its 29 files total 98,418 uncompressed bytes. Every file in `reference/Lean/` was compared directly with its original ZIP member and was byte-identical. Julia independently verified all 28 entries in the original `SHA256SUMS`. That inventory omits its own hash, explaining the difference between 29 files and 28 original entries.

The source contains exactly 147 named theorem declarations. The Julia inventory check compares the complete set of names and each declaration's verbatim text with `THEOREMS.toml`, checks that each proof chapter exists, and checks that every entry has an individual proof step. It does not purport to elaborate Lean syntax or infer implicit binders; the preserved source and its section context remain authoritative.

The files under `reference/Lean/evidence/` are **archived supplied build and axiom logs**. The new files directly under `evidence/` are **fresh Julia evidence**. Agreement with supplied counts is reported only where fresh computations were performed.

## Checks not performed in this translation

* The Lean project was not freshly rebuilt or its kernel axioms re-audited during the Julia work. Its source and archived logs are included unchanged.
* Julia does not mechanically verify every logical inference in the analytic proof strings. Standard differentiation, integration, trigonometry, exponential laws, rank-nullity, and induction remain written mathematical dependencies, as identified in the guides.
* Other Julia releases, other architectures and operating systems, and the entire `S/2` seed period were not exhaustively tested. The full-period statement has an analytic modular proof and selected endpoint probes; only `D` was enumerated completely.
* Statistical workbooks, codec benchmarks, network models, prior Python runs, older cited papers, and the internal frozen SRSD implementation were not re-executed or independently audited for this Julia deliverable. They supply no hidden premise to the new certificate computations.

After any local changes, `scripts/check_inventory.jl` checks the distributed hashes and will correctly report changed files. Re-running the reproduction driver updates timestamps and empirical elapsed times; those metadata need not be byte-identical to this archived run even though the six mathematical certificate files should agree on the tested runtime.