# Reality Bit Engine

**Version:** 0.20.0
**Originating framework:** Anthony Michael Collado  
**Status:** Compilable mathematical research prototype, not a validated theory
of nature

Reality Bit Engine is a standard-library-only C++17 implementation of the
computable core of the seven-layer Projective Ripple Reality framework.

The engine now provides 101 directly testable capabilities:

1. stores a complete declared seven-layer state as a canonical 848-bit payload;
2. represents scalar quantities as exact binary increments rather than floating
   approximations;
3. infers every cause compatible with linear bit-effects over \(GF(2)\);
4. separates ordinary transformations from transformations requiring the
   framework's four-condition alignment gate;
5. computes fixed-point cat-state decoherence and two-path interference;
6. converts real slit geometry into exact 64-bit phase without runtime floats;
7. tests the language against published decoherence and complementarity
   invariants;
8. executes multi-qubit state-vector circuits using fixed-point complex bits;
9. supplies the approximately universal `H + T + CNOT` gate basis plus
   arbitrary Phase64 rotations, measurement and Grover diffusion;
10. compiles the line-oriented RBE-Q circuit language and runs Bell, CHSH,
    Deutsch, Grover, teleportation and bit-flip correction demonstrations.
11. calculates the thermal occupation and excited-state population associated
    with a frequency/temperature pair;
12. evaluates an ideal red-sideband selective-cooling design and its effective
    mode temperature.
13. solves the inverse frequency/temperature requirement for a target thermal
    population;
14. models non-equilibrium active reset with independent upward and downward
    transition rates;
15. searches primitive integer synchronization relations across typed D4-D7
    rates;
16. calculates observation-layer frequency aliases;
17. calculates inductive and magnetic-field storage plus sinusoidal generator
    voltage;
18. scores candidate hardware designs and extracts their error/power/throughput
    Pareto frontier while enforcing an explicit energy ledger.
19. discovers the complete degree-bounded Boolean invariant space of a finite
    deterministic rule;
20. returns exact counterexamples for false invariant candidates;
21. proves complete cycle, fixed-point and transient statistics by exhaustive
    finite-state traversal;
22. searches all 256 elementary cellular-automaton rules and ranks candidates;
23. discovers shortest modular linear recurrences from a training prefix and
    tests them on untouched data;
24. emits deterministic transition and result certificates with explicit
    evidence levels.
25. decides exactly whether a finite upper rule induces an autonomous
    deterministic law through a lower projection;
26. returns the first same-effect/different-future fiber conflict and every
    possible projected successor;
27. pushes explicitly supplied integer microstate measures into exact rational
    lower transition probabilities;
28. computes the coarsest future-equivalent deterministic refinement and its
    minimum fixed-width hidden-bit requirement;
29. proves whether a conserved upper Boolean quantity is expressible as a
    lower conservation law;
30. decomposes arbitrary-length positive dimension indices into a local layer
    and winding without fixed-integer overflow;
31. decomposes signed time ticks into a unique cycle winding and phase; and
32. classifies finite cycle twists as identity loops, reversible permutations,
    or information-losing folds and calculates exact closure periods.
33. parses provenance-bearing measured quantum-hardware datasets with a frozen,
    outcome-independent train/holdout rule;
34. fits the observable composite \(g=\pi\circ T\) without claiming that effects
    uniquely identify the latent transition and projection;
35. scores untouched predictions against both constant and simpler physical
    decay baselines with uncertainty coverage; and
36. emits dataset and held-out prediction certificates while warning when a
    requested prediction is an unvalidated extrapolation.
37. applies arbitrary-direction Lorentz boosts and checks Minkowski invariance;
38. transforms energy-momentum four-vectors and verifies the invariant mass shell;
39. calculates timelike proper time and rejects spacelike real-time requests;
40. calculates Schwarzschild clock, escape, lensing, orbital and curvature observables;
41. constructs Christoffel symbols, Ricci curvature and the Einstein tensor from
    a supplied numerical four-metric;
42. verifies flat Minkowski curvature and Schwarzschild exterior vacuum curvature;
43. numerically checks every Lagarias inequality equivalent to the Riemann
    Hypothesis through a declared finite integer limit;
44. emits an RH prefix certificate that explicitly preserves the open all-integer boundary;
45. verifies CNF assignments, solves SAT with DPLL and independently checks
    bounded formulas by exhaustive enumeration;
46. generates finite pigeonhole contradictions and emits SAT/UNSAT certificates;
47. proves a parameterized smooth two-dimensional Taylor–Green Navier–Stokes
    family and its viscous energy identity; and
48. converts each prize target into an explicit missing universal step instead
    of relabeling finite computation as a Millennium solution;
49. maps positive inequality operands onto bounded D0 barycentric coordinates
    and freezes their signed distance from the equality boundary;
50. exhaustively maps every bounded CNF assignment by its exact number of
    violated clauses;
51. freezes SAT minimum-distance witnesses, degeneracy and complete violation
    histograms; and
52. verifies a smooth three-dimensional ABC Navier-Stokes eigenflow while
    retaining the worst dimensionless PDE residual at its spacetime coordinate.
53. certifies finite Lagarias cases using exact integer interval arithmetic
    and proved exponential/logarithm tail bounds in a Python companion;
54. independently checks SAT error geometry and rejects a false
    near-satisfaction stopping rule; and
55. exports field-only ABC samples for independent finite differences, injected
    fault diagnosis, refinement studies, and untouched holdout tests.
56. supplies exact finite base-case certificates for a written Lagarias proof
    covering every integer with at most two distinct prime factors;
57. derives and checks minimum violated-clause costs and ground-state counts
    for every size of the specified pigeonhole CNF family; and
58. uses exact rational Fourier algebra to reject proposed universal
    Navier–Stokes energy/enstrophy estimates with explicit smooth fields.
59. exports portable scoped certificates and verifies them without importing
    the generator or engine;
60. exactly counts the specified SAT histograms through a row recurrence
    quotiented by column permutations; and
61. challenges the verifier with deliberately corrupted data, assumptions,
    coverage, and claims, preserving each rejection reason.
62. applies written monotonicity and canonical/record reductions to a finite
    all-integer Lagarias verification through a declared cutoff;
63. records exact counterexamples to an insufficient harmonic lower-bound
    strategy and a fixed-capacity continuation summary; and
64. checks the amplitude/multiplier identity ruling out universal monotonicity
    of every positive-order homogeneous Sobolev quadratic fluid energy.
65. validates exact rational Fourier initial data for real, mean-zero,
    divergence-free periodic fluid fields;
66. certifies an explicit sufficient condition for global smoothness and a
    growing radius of analyticity of the full unforced three-dimensional
    Navier–Stokes solution; and
67. distinguishes a certified hypothesis, failure of the sufficient smallness
    condition, and unresolved arithmetic precision using outward square-root
    bounds and exact rational comparisons.
68. decomposes an exact initial field into a known decaying shear and a
    perturbation, retaining the full nonlinear error in a written estimate;
69. certifies sufficiently small perturbations of that possibly large shear
    for all time, including a three-dimensional field outside v0.14's
    total-smallness condition; and
70. gives an explicit time and full-norm bound at which the certified solution
    enters the earlier small-data analyticity theorem.
71. generates exact rational piecewise polynomial Galerkin reference trajectories;
72. bounds vector time polynomials over entire intervals with Bernstein witnesses;
73. reconstructs the full projected PDE residual, including every nonzero output
    mode outside the simulated reference support;
74. constructs rational piecewise affine error supersolutions and certifies
    their differential inequalities between all time nodes;
75. independently verifies trajectory continuity, full residual coverage,
    error bounds, and the handoff to all-time smoothness using a standalone checker;
76. finds counterexamples to endpoint-only and retained-mode-only shortcuts
    and rejects deliberately corrupted trajectory certificates; and
77. searches a declared refinement ladder and stops at its first independently
    accepted trajectory certificate, preserving failed sufficient bounds.
78. maximizes a constrained scalar error quadratic while retaining positive
    dissipation for the written smooth-continuation argument;
79. generates rounded rational nonlinear references with exact divergence
    freedom, conjugate symmetry, and continuous endpoint joins;
80. independently checks the full rounding and omitted-mode residual under
    the sharper sufficient estimate; and
81. freezes a four-configuration comparison on identical initial data,
    including an input certified only by combining the two new methods.
82. ranks omitted Fourier-mode pairs by exact integrated residual caps;
83. reuses cached reference bounds across certificate parameter searches,
    while retaining full independent mathematical verification;
84. searches local error caps with a positive dissipation reserve;
85. independently checks those segment-wise caps and the all-time handoff;
86. refines finite-state abstractions to find inductive safety certificates;
87. returns concrete bad-state paths when an apparent failure is real; and
88. audits property, domain, problem identity, and finite versus unbounded
    evidence before supporting a requested claim.
89. enumerates eight hypothetical truth assignments to three precisely stated targets;
90. checks propositional case splits while retaining their unproved premises;
91. compiles finite bad-state reachability into an exact SAT encoding;
92. independently checks SAT assignments and clause-justified UNSAT trees;
93. uses the finite shortest-path bound to certify safety at every path length;
94. transfers safety through a fully checked state map in the proved direction; and
95. verifies exact nonnegative matrix comparison bounds, including a contracting
    three-error loop, without assuming those errors represent the prize problems.
96. certifies complete observational equivalence under every finite word of allowed linear maps;
97. classifies exact paired squared-distance readings into complete compatible-state fibers;
98. recovers energy weights when a finite shear-frequency grid is specified;
99. certifies distinct smooth shear flows whose energy derivatives agree through a declared order;
100. checks an exact counterexample to inferring critical-line zeros from reflection symmetry alone; and
101. freezes strict one-bit local minima of a satisfiable CNF family, without inferring a general complexity bound.

Version 0.20 implements [null-axis probes and observability](NULL_AXIS_OBSERVABILITY.md).
Known additive pushes cannot expose the kernel of a fixed linear readout;
allowed maps that mix hidden and visible coordinates can. The engine computes
the complete observation space using at most the declared state dimension
in basis rows, with an independent closure and nullspace check. Paired
squared-distance probes recover signed coordinates when sufficiently informative,
and otherwise report the remaining point, pair, sphere, or empty fiber.

```sh
python3 tools/null_axis_lab.py
python3 tools/verify_null_axis.py results/null-axis-v020/mixing-probe.json
python3 tools/verify_null_axis.py results/null-axis-v020/shear-order-two.json
python3 tools/challenge_null_axis.py
```

Use `py -3` on Windows. The written shear theorem shows that any fixed finite
list of energy derivatives fails to define an autonomous law for all these
smooth flows. With a specified four-frequency grid, four measurements recover
the energy weights exactly. Eighteen targeted tests and 31 rejected corruptions
validate the implementation; 23 standalone example certificates pass.
All three prize problems remain unresolved. No physical grid, new dimension,
formal-kernel verification, or mathematical novelty is claimed. The numerical
C++ implementation is unchanged.

Version 0.19 adds [universes and proof bridges](UNIVERSES_AND_PROOF_BRIDGES.md).
The engine proves finite-system safety by checked SAT certificates and transfers
it through a verified simulation map. The five-state example reduces from
25 SAT variables and 77 clauses to a three-state target with 9 variables and
20 clauses. Exact matrix witnesses also verify the conditional theorem
`d <= A*d + b` and `(I-A)^(-1) >= 0` imply `d <= (I-A)^(-1)*b` for finite
nonnegative vectors. Zero forcing closes the supplied contracting loop.

```sh
python3 tools/universe_engine.py
python3 tools/verify_universe_bridge.py results/universes-v019/transfer.json
python3 tools/verify_universe_bridge.py results/universes-v019/coupled-zero.json
python3 tools/challenge_universe_bridge.py
```

On Windows use `py -3` in place of `python3`. Sixteen targeted test methods
pass, including 640 graph/horizon comparisons, 80 small CNF comparisons,
and 64 exact matrix cases; the separate suite rejects 32 deliberate corruptions.
All eight prize truth assignments remain unconditionally open. A circular
chain of assumed implications does not decide their truth, and no proved
coupling of actual RH, complexity, and fluid defects has been supplied.
These are Python standard-library modules, with written proofs and an
independent program checker. No formal-kernel, novelty, or Millennium proof
claim is made; the C++ numerical implementation is unchanged.

Version 0.18 implements the [shared proof structure and directed search](PROOF_SEARCH_DIRECTION.md).
It now independently certifies the frozen perturbation-0.5 fluid input.
Residual-directed mode selection expands the reference to 32 modes; local
error control certifies all 2,048 affine segments through time four and
gives a full norm below 0.70240, inside the all-time small-data region.
The earlier reference and fixed-cap policies remain frozen as failed
sufficient estimates on this same input.

```sh
python3 tools/verify_local_trajectory.py results/local-cap-certificate-v018.json
python3 tools/refinement_engine.py --refine --local-caps --output results/rebuilt-certificate.json
python3 tools/induction_engine.py
python3 tools/proof_director.py
```

The generic finite-system backend returns a checked inductive invariant or
an actual counterexample, refining spurious abstract paths along the way.
The director rechecks scoped RH, SAT, induction, and fluid evidence and
records the missing universal arguments. Twenty-three targeted test methods
include 160 seeded finite-system comparisons; all 24 deliberate corruptions
of a small local-cap certificate are rejected. These are standard-library
Python companions, with no formal proof-assistant or Millennium resolution
claim. The C++ numerical implementation is unchanged.

Version 0.17 adds a [sharper bound and nonlinear reference](SHARP_TRAJECTORY_BOUND.md).
For the fixed interacting field with viscosity one and perturbation 0.1,
neither change alone passes the declared comparison. Together they produce
a standalone-accepted certificate with maximum error below 0.04424 through
time four and a full norm below 0.05144 at the all-time small-data handoff.
The reference retains 18 Fourier wavevectors; its full residual includes
56 additional output modes per interval. Twelve targeted tests passed and
23 deliberate corruptions of the 0.01 certificate were rejected.

```sh
python3 tools/sharp_trajectory.py --epsilon 1/10 --output results/sharp-larger-input-v017.json
python3 tools/verify_sharp_trajectory.py results/sharp-larger-input-v017.json
python3 tools/compare_sharp_trajectory.py results/sharp-larger-input-v017.json
```

These Python standard-library companions need no C++ compilation. The
same configuration at perturbation 0.5 still fails its sufficient envelope;
that result is preserved in `results/sharp-next-limit-v017.json`. The new
coverage is a scoped consequence of the written PDE argument. Mathematical
novelty, formal-kernel verification, general large-data regularity, RH,
and P versus NP are not established.

Version 0.16 implements the three [trajectory validation components](TRAJECTORY_PROOF.md)
specified in v0.15. The main computed reference has 32 intervals, 158 affine
error segments, and 384 occurrences of nonzero residual modes outside its
support. The standalone checker certifies error below 0.000045 through time 4,
where the full norm is below 0.036664 and the earlier all-time theorem applies.

```sh
python3 tools/trajectory_lab.py
python3 tools/verify_trajectory.py results/trajectory-certificate-v016.json
python3 tools/challenge_trajectory.py results/trajectory-certificate-v016.json
python3 tools/search_trajectory.py
```

Use `--initial-field input.json` for another supported exact initial field;
the generator also accepts `--degree`, `--steps`, `--end`, `--bits`, and
`--envelope-resolution`. All candidate certificates require independent
verification. Eleven new test methods passed; all 17 corruptions were rejected.
The bounded search retains an unresolved coarse case and an accepted finer case.
This validates supported polynomial references against a written sufficient PDE
theorem. It does not solve general large-data regularity or claim formal-kernel
verification. The example's initial data were already covered by v0.15;
the advancement is the new computed-reference validation mechanism.

Version 0.15 adds a [relative fluid certificate and next development plan](NEXT_WALL.md).
It proves and checks a sufficient error bound around an exact decaying shear.
The included interacting field has initial Fourier norm above twice viscosity,
while its perturbation satisfies the new sufficient theorem. This expands
the engine's certificate coverage using established stability methods.
Arbitrary large-data regularity and general numerical trajectory validation
remain outside the implementation.

```sh
python3 tools/relative_fluid_certificate.py examples/relative-fluid/large_shear_small_3d_perturbation.json
python3 -m unittest discover -s tests -p 'test_relative_fluid.py' -v
```

Nine new test methods and six expected example outcomes passed. The report
`results/relative-fluid-v015.json` preserves exact bounds, source fingerprints,
and an omitted quadratic term caught and corrected by independent Fourier
convolution. `NEXT_WALL.md` specifies continuous-time residual and omitted-mode
bounds as the next prerequisites for validating computed reference trajectories.

Version 0.14 adds a [computable all-time fluid bound](GLOBAL_FLUID_BOUND.md).
Given an exact upper bound B on the sum of Fourier coefficient magnitudes
divided by their frequencies, B < viscosity certifies global smoothness by
the stated small-data theorem. This is an implementation of an established
mathematical method, with a written proof for the declared normalization.
It is not a general large-data result or a Millennium solution.

```sh
python3 tools/global_fluid_certificate.py examples/global-fluid/small_interacting.json
python3 -m unittest discover -s tests -p 'test_global_fluid.py' -v
```

Eleven new test methods and all seven expected example outcomes passed.
`results/global-fluid-v014.json` preserves the exact bounds and fingerprints.
The proof controls every future time of the full PDE; it does not assume
that evolution remains confined to the initially listed Fourier modes.
The initial modes must nevertheless be exact, with all unlisted initial
coefficients zero. Unknown tails from measurements are not covered.

Version 0.13 adds [mathematical reductions and obstructions](MISSING_ARGUMENTS.md).
The bounded run verifies the Lagarias inequality for every integer through
10^24 using 172,513 canonical candidates and 148 certified record cases,
under the written reduction proofs and exact-arithmetic implementation.
The reduction is known in the literature; no novelty, verification record,
formal-kernel verification, or Millennium solution is claimed.

```sh
python3 tools/proof_gap_lab.py --output results/my-proof-gaps.json
```

Nine new test methods passed. The frozen record is
`results/proof-gaps-v013.json`. Its new arguments are not automatically
covered by the v0.12 standalone verifier, which retains its previous scope.

Version 0.12 adds a [standalone certificate verifier](CERTIFICATE_VERIFIER.md).
It independently checks the RH base cases with rational lower polynomials,
SAT histograms with a counting recurrence, and fluid identities with real
trigonometric moments and vortex stretching. The valid certificate passed;
26 deliberate corruptions were rejected; ten new test methods passed.

```sh
python3 tools/verify_certificate.py results/portable-certificate-v1.json
```

On Windows, replace `python3` with `py -3`. These two files alone suffice:
`tools/verify_certificate.py` and `results/portable-certificate-v1.json`.
The checker is not a formally verified proof kernel and does not certify any
Millennium solution. The v0.11 proofs and frozen source fingerprints are
preserved unchanged.

Version 0.11 adds [restricted proofs and failed proof routes](PROOF_ATTEMPTS.md),
with an exact-arithmetic Python companion. It does not solve any Millennium
problem. The general arguments are written proofs; bounded checks test their
arithmetic and implementation. Run from the project root:

```sh
python3 tools/proof_routes.py --output results/my-proof-routes.json
python3 -m unittest discover -s tests -p 'test_proof_routes.py' -v
```

The frozen [proof-route records](results/proof-routes-v1.json) include 1,023 RH
base cases, 112,938 assignments across 21 SAT sizes, and exact Fourier
counterexamples. No C++ numerical behavior changed in v0.11; the executable's
version label was updated. Historical v0.10 source and executable hashes in
its frozen audit still identify that earlier release.

Version 0.10 tests whether the v0.9 residual representation helps diagnose
faults. It also corrects two logical shortcuts: a satisfied inequality need
not have zero signed slack, and a tiny numerical residual need not imply an
accurate parameter. See [INDEPENDENT_AUDIT.md](INDEPENDENT_AUDIT.md) and the
replayable inputs and outputs in [the frozen audit](results/residual-audit-v010.json).

After compiling, run the optional Python 3.10+ standard-library companion:

    python3 tools/residual_audit.py --engine build/reality-bit-engine --output results/my-audit.json

On Windows, use py -3 and build/reality-bit-engine.exe.

The governing rule is:

\[
\boxed{\text{effects identify a class of compatible causes, not automatically one cause}}
\]

## Build on Windows

The easiest route is Visual Studio Build Tools 2022 or newer with **Desktop
development with C++** installed.

1. Extract the project.
2. Open **Developer Command Prompt for VS** in the project directory.
3. Run:

```bat
build.bat
```

This produces:

```text
build\reality-bit-engine.exe
build\reality-bit-tests.exe
build\reality-quantum-tests.exe
build\reality-quantum-compute-tests.exe
build\reality-quantum-thermal-tests.exe
build\reality-quantum-discovery-tests.exe
build\reality-math-discovery-tests.exe
build\reality-law-descent-tests.exe
build\reality-cyclic-dimension-tests.exe
build\reality-measured-prediction-tests.exe
build\reality-relativity-tests.exe
build\reality-prize-lab-tests.exe
```

The same script also supports MinGW-w64 when `g++` is on `PATH`.

## Build on Linux or macOS

```sh
chmod +x build.sh
./build.sh
```

Or use CMake:

```sh
cmake -S . -B build
cmake --build build --config Release
ctest --test-dir build -C Release --output-on-failure
```

## Commands

```text
reality-bit-engine spec
reality-bit-engine demo
reality-bit-engine gf2-demo
reality-bit-engine dyadic 3 -4
reality-bit-engine clock 3500
reality-bit-engine quantum-demo
reality-bit-engine qcompute-demo
reality-bit-engine qrun examples/bell.rbeq
reality-bit-engine thermal 5 20
reality-bit-engine cooling-demo
reality-bit-engine discovery-demo
reality-bit-engine optimize-thermal 0.001
reality-bit-engine reset-model 0.1 100000 100 100
reality-bit-engine resonance4 5000000000 4979000000 13000000 8000000 3
reality-bit-engine energy-ledger 0 10 0 12 0 0
reality-bit-engine math-discovery-demo
reality-bit-engine ca-simulate 30 12 1 40
reality-bit-engine ca-discover 150 5 1
reality-bit-engine ca-dynamics 30 12
reality-bit-engine ca-scan 8 1 10
reality-bit-engine recurrence 1000003 6 0 1 1 2 3 5 8 13 21 34 55 89
reality-bit-engine law-demo
reality-bit-engine law-analyze examples/law-hidden.rbelaw
reality-bit-engine law-simulate examples/law-hidden.rbelaw 2 12
reality-bit-engine law-invariant examples/law-clean.rbelaw 0011
reality-bit-engine cycle-demo
reality-bit-engine dimension-address 777
reality-bit-engine time-address -1
reality-bit-engine cycle-twist 7 1 0
reality-bit-engine measure-fit examples/sycamore-xeb-measured.rbemeasure
reality-bit-engine measure-predict examples/sycamore-xeb-measured.rbemeasure 53 18
reality-bit-engine relativity-demo
reality-bit-engine lorentz 12 3 -4 1 0.3 -0.2 0.1
reality-bit-engine schwarzschild 1.98847e30 6.957e8 6.957e8 5.790905e10 0.20563
reality-bit-engine curvature-demo
reality-bit-engine prize-demo 1000000
reality-bit-engine truth-distance-demo 5000000
reality-bit-engine rh-lagarias 5000000
reality-bit-engine pnp-demo
reality-bit-engine navier-demo
reality-bit-engine cat-demo
reality-bit-engine slit-observe 800 200
reality-bit-engine slit-screen 600 500000 1000000000 600000 1000000
reality-bit-engine published-tests
```

- `spec` prints the exact bit layout and default ULPs.
- `demo` exercises a seven-layer state, the gate, effect filtering, and the
  exact Boolean inverse solver.
- `gf2-demo` solves a small effect-to-cause system using XOR only.
- `dyadic TICKS EXPONENT` represents the exact value
  `TICKS * 2^EXPONENT`.
- `clock YEARS` evaluates the optional 1000-human-years-per-divine-day model.
- `cat-demo` compares a coherent cat with the corresponding classical mixture.
- `slit-observe MAX MIN` infers visibility and ideal distinguishability from
  observed fringe extrema.
- `slit-screen` computes the normalized local detection probability from
  integer-nanometre apparatus geometry and visibility per million.
- `published-tests` evaluates the encoded experimental invariants.
- `qcompute-demo` runs six foundational circuit and protocol checks.
- `qrun FILE` compiles an RBE-Q program, prints its leading exact
  probabilities, and samples its requested number of shots.
- `thermal F_GHZ T_MK` relates a transition quantum to an ideal thermal bath.
- `cooling-demo` evaluates temperature thresholds and a hypothetical
  mode-selective red-sideband cooler.
- `discovery-demo` runs the thermal-gap, active-reset, typed-rate, aliasing and
  magnetic-ledger discoveries.
- `optimize-thermal P` finds the warmest ideal equilibrium temperature at a
  range of transition frequencies and the minimum room-temperature gap.
- `reset-model` solves the driven two-rate reset master equation.
- `resonance4` searches primitive integer relations among four typed rates.
- `energy-ledger` checks claimed input, output, loss and stored-energy changes.
- `math-discovery-demo` runs exact invariant, dynamics, rule-search and
  recurrence discoveries.
- `ca-simulate` executes a periodic elementary cellular automaton.
- `ca-discover` constructs and solves every invariant equation in the declared
  algebraic-normal-form degree space.
- `ca-dynamics` proves the complete attractor structure of one finite rule.
- `ca-scan` exhaustively ranks all 256 elementary rules for one finite ring.
- `recurrence` fits a modular recurrence to the declared training prefix and
  tests it on the remaining samples.
- `law-analyze` proves or refutes deterministic descent through a finite
  projection and computes the minimum deterministic refinement.
- `law-simulate` prints the upper and projected lower trajectory.
- `law-invariant` checks whether a supplied upper Boolean invariant is
  conserved and expressible below.
- `dimension-address` evaluates the exact decomposition
  `index = winding*cycle-length + local-layer` for arbitrarily long indices.
- `time-address` performs signed Euclidean cycle/phase decomposition.
- `cycle-twist` proves whether one-winding state evolution is reversible and,
  for a permutation, computes its exact finite period when it fits 64 bits.
- `measure-fit` fits training-only Sycamore XEB fidelity parameters and scores
  every untouched holdout observation against two declared baselines.
- `measure-predict` evaluates the fitted composite projection law at a requested
  circuit width and depth, with an explicit extrapolation warning.
- **relativity-demo** checks Lorentz invariance, solar Schwarzschild
  observables and numerical vacuum curvature.
- **lorentz** applies an arbitrary three-direction boost to a four-vector whose
  temporal coordinate is \(ct\).
- **schwarzschild** evaluates exterior observables for a supplied mass,
  radius, light impact parameter and elliptical orbit.
- **curvature-demo** calculates Ricci and Einstein tensors from Minkowski and
  Schwarzschild metrics and compares them with nonzero Schwarzschild curvature.
- **prize-demo** runs all three bounded Millennium laboratories.
- **truth-distance-demo** runs the upgraded D0 barycentric residual,
  SAT-landscape and frozen 3D PDE-coordinate attack.
- **rh-lagarias** exhaustively checks the Lagarias RH-equivalent inequality
  only through the declared finite \(N\).
- **pnp-demo** compares DPLL and exhaustive certificates on a finite
  pigeonhole contradiction.
- **navier-demo** verifies analytic Taylor–Green and three-dimensional ABC
  solution families and their energy identities without claiming arbitrary
  three-dimensional regularity.

Read [TRUTH_DISTANCE.md](TRUTH_DISTANCE.md) for the D0 barycentric coordinate,
SAT violation landscape, typed PDE residual map, and exact proof boundaries.

## What “everything in bits” means

Every encoded state-changing quantum-core operation is integer or bitwise.
Serialized states, projections, masks, phase arithmetic, constraint checks,
cause solving and Q30 circuit evolution are deterministic across conforming
C++17 implementations. The thermal and discovery modules deliberately use
`long double` for physical exponentials, logarithms and SI estimates; those
outputs are numerical engineering approximations, not bit-exact physical truth.

This does **not** mean that a finite computer can calculate literally every
truth. Some causes are observationally indistinguishable, some mathematical
problems are uncomputable, measurements have finite information, and nonlinear
systems can require more resources than a physical computer contains.

The precise claim is:

> Every finite state, observation, rule, and uncertainty admitted by the
> declared schema can be encoded and manipulated as bits without hidden
> floating-point rounding.

Read [SPECIFICATION.md](SPECIFICATION.md) for the complete algebra, bit layout,
ULP definitions, biblical-clock convention, and formal limits.

Read [QUANTUM_VALIDATION.md](QUANTUM_VALIDATION.md) for the cat density matrix,
decoherence map, slit geometry, published observations, seven-layer mapping,
and falsification criteria.

Read [QUANTUM_COMPUTING.md](QUANTUM_COMPUTING.md) for the state-vector algebra,
gate set, exact measurement algorithm, RBE-Q grammar, demonstrations, scaling
limit, and the distinction between simulation and physical quantum hardware.

Read [QUANTUM_COOLING.md](QUANTUM_COOLING.md) for the GHz-to-kelvin relation,
absolute-zero boundary, existing cooling methods, inverse-microwave mechanism,
and Selective Quantum Entropy Extractor proposal.

Read [QUANTUM_DISCOVERY.md](QUANTUM_DISCOVERY.md) for the constrained hardware
optimizer, non-equilibrium reset, D4-D7 typed rates, alias detection, magnetic
energy ledger, Tesla boundary and proposed high-gap hybrid architecture.

Read [MATHEMATICAL_DISCOVERY.md](MATHEMATICAL_DISCOVERY.md) for evidence levels,
the Boolean-invariant completeness theorem, counterexamples, finite dynamics,
autonomous rule scanning, modular recurrence discovery and proof certificates.

Read [LAW_DESCENT.md](LAW_DESCENT.md) for the projective factorization theorem,
stochastic pushforward, minimum hidden-state refinement and invariant descent.

Read [CYCLIC_DIMENSIONS.md](CYCLIC_DIMENSIONS.md) for the seven-step
layer/winding address, cyclic time, loop-versus-helix distinction and cycle
twist classification.

Read [MEASURED_PREDICTION.md](MEASURED_PREDICTION.md) for the real Sycamore
dataset, frozen split, identifiability theorem, fitted coefficients, untouched
predictions, baselines, uncertainty coverage and limitations.

Read [RELATIVITY.md](RELATIVITY.md) for Lorentz boosts, invariant mass,
Schwarzschild observables, the numerical Einstein-tensor kernel, seven-layer
mapping and covariance boundary.

Read [MILLENNIUM_LAB.md](MILLENNIUM_LAB.md) for the Riemann,
\(P\)-versus-\(NP\) and Navier–Stokes attacks, exact certificates, proposed
next lemmas and the specific infinite step still missing from each problem.

## Source layout

```text
src/reality_bits.hpp   public data structures and algorithms
src/reality_bits.cpp   exact implementation
src/quantum_bits.hpp   Q1.30 quantum types and public operations
src/quantum_bits.cpp   integer CORDIC, cat, slit, and duality implementation
src/quantum_compute.hpp fixed-point state-vector and RBE-Q public interface
src/quantum_compute.cpp gates, measurement, parser, protocols, and algorithms
src/quantum_thermal.hpp thermal-population and sideband-cooling interface
src/quantum_thermal.cpp Boltzmann and selective-cooling calculations
src/quantum_discovery.hpp hardware-search and energy-ledger public interface
src/quantum_discovery.cpp optimizer, reset, resonance, alias and magnet calculations
src/mathematical_discovery.hpp exact finite theorem-discovery public interface
src/mathematical_discovery.cpp invariants, dynamics, scans and recurrences
src/law_descent.hpp    projective law, refinement and invariant interface
src/law_descent.cpp    exhaustive fiber and future-equivalence proofs
src/cyclic_dimensions.hpp arbitrary-index and cycle-twist interface
src/cyclic_dimensions.cpp exact decimal addressing and permutation analysis
src/measured_prediction.hpp measured projection-law fitting interface
src/measured_prediction.cpp parser, regression, holdout scoring and certificates
src/relativity.hpp     special/general relativity public interface
src/relativity.cpp     boosts, Schwarzschild observables and curvature kernel
src/prize_lab.hpp      finite Millennium-laboratory public interface
src/prize_lab.cpp      Lagarias, SAT and Taylor-Green proof laboratories
src/main.cpp           command-line program
tests/tests.cpp        deterministic verification suite
tests/quantum_tests.cpp quantum and experimental-invariant verification
tests/compute_tests.cpp circuit, algorithm, parser, and stress verification
tests/thermal_tests.cpp frequency-temperature and cooling verification
tests/discovery_tests.cpp optimization, reset, resonance, alias and ledger tests
tests/math_discovery_tests.cpp finite theorem and recurrence adversarial tests
tests/law_descent_tests.cpp quotient-law and minimum-refinement proofs
tests/cyclic_dimension_tests.cpp arbitrary-index and exhaustive twist checks
tests/measured_prediction_tests.cpp leakage, parser and held-out prediction tests
tests/relativity_tests.cpp Lorentz, mass-shell, Schwarzschild and tensor tests
tests/prize_lab_tests.cpp RH-prefix, SAT and Navier–Stokes adversarial tests
examples/*.rbeq        directly runnable RBE-Q programs
examples/*.rbelaw      finite upper-law and projection programs
examples/*.rbemeasure  frozen measured training and holdout observations
```

## Scientific boundary

The software demonstrates that the algebra is executable. It does not establish
that nature has exactly seven layers, that the selected ULPs are fundamental
physical quanta, that the optional biblical time scale is a physical conversion,
or that external authorization can be measured by the program.

It is a classical simulator. It does not turn a conventional PC into physical
quantum hardware and does not obtain an exponential hardware advantage. A full
state vector necessarily stores \(2^n\) complex amplitudes.

The `ExternallyAuthorized` gate flag is deliberately an input. The engine never
renames an unexplained residual “God” and never infers divine authorization from
an unusual output.

Likewise, a finite checked prefix, bounded SAT enumeration or exact smooth
solution family is never called a Millennium Prize solution. Version 0.10
embeds the remaining open boundary in every prize-lab certificate.