Simulating Zero Point Tri Engine

When given a spec like this, first classify every claim into one of four buckets before writing or reasoning about code:

1. Definition — a design choice of this page, not a mathematical claim (e.g., "trails drawn frame by frame," "parity stored on inner manifold"). Cannot fail a test; it just is.
2. Proven (Prop./Lemma, live-checkable) — has an exact arithmetic or algebraic identity backing it (e.g., (1+i)^8 = 16). Must get a self-test with a PASS/FAIL, driven by exact rational/Gaussian-integer arithmetic, never floats.
3. Heuristic — shown/plotted but explicitly not claimed to follow from a lemma (e.g., the π/6 "zero-drag" gate). Must be labeled [HEURISTIC] in both prose and UI, never given a PASS based on a proof it doesn't have.
4. Not used — present in the source paper/monograph but deliberately out of scope here. State this plainly; do not implement or fake-test it.

Example immediate action: if asked "does the π/6 gate prove zero drag?", answer no — flag it as heuristic exactly as the spec does, and do not promote it to a Proposition-backed PASS.

Progress checklist for implementing, auditing, or extending this kind of system:

• Catalog branches/engines — confirm count (3), angular offsets (120° apart: 0°, 120°, 240°), and the σ rotation relating them (σ³ = 1, cyclic permutation of axes).
• Fix the clock algebra — base everything on exact Gaussian integers (1+i)^k for k=0..7 (period 8 projectively, since no rational unit quaternion has order 8 — Niven). Track reduced states as exact pairs, never floating decimals, for the "certifying" track.
• Define the frame/cycle hierarchy exactly as nested moduli:
  • frame F
  • spinor step k = F mod 8
  • branch j = F mod 3
  • joint frame n = F mod 24 (since lcm(8,3)=24)
  • register = 720 frames = 30 joint cycles = 90 spinor cycles
• Place onload/offload windows — each branch onloads at its own k=2 frame and offloads 12 frames later at k=6; stagger onloads across branches (e.g., 18/10/2) so exactly one branch is "in flight" structure per window.
• Implement exact arithmetic layer — rationals exact under + − × ÷ and integer powers; sqrt, sin, cos, π exact only when the result is rational, otherwise rationalize to a fixed precision (e.g., 2⁻⁴⁸) and mark ≈. Reject division by zero, 0^-1, and malformed input explicitly.
• Implement the pump/telescoping identity (if present) — verify any claimed block-decomposition (e.g., 720 → 72 → 10) multiplies back to the identity or a stated inverse; test with random exact histories, not fixed examples only.
• Implement memory words as redundant quads — e.g., Y = A + B + C; verify any one of four fields is exactly reconstructible from the other three, and that a Merkle/hash chain over leaves localizes which cell was altered.
• Build the compliance table — one row per claim, columns: source reference (Prop/Lemma/Def/§), what it governs on this page, live check, result (PASS / definition / heuristic / not used). Never mark "not used" or "heuristic" rows as PASS.
• Write the self-test suite — randomized, exact-arithmetic tests for every PASS-row claim (hundreds of random trials, not single examples), plus edge cases (malformed input, boundary frames, altered memory cells).
• Run and report — aggregate k/k PASS only over checkable rows; report heuristic/definition/not-used rows separately so the pass count isn't inflated.

Example 1: Input: "Does Lemma 5 Part 3 prove the π/6 gate causes zero drag at Δθ ≡ 0 (mod 30°)?" Output: "No. Lemma 5 Part 3's π/6 is defined there as an acoustic phase, not a rotation angle. The spec itself marks the gate's connection to zero drag as [HEURISTIC] — it is displayed (gate shown open when Δθ=0°) but not derived from that lemma. Any compliance table entry for this must say heuristic, not PASS."

Example 2: Input: "A memory word has fields A, B, C, Y with Y = A+B+C. Field B is corrupted. Can it be recovered?" Output: "Yes, exactly: B = Y − A − C. This matches Proposition G1 (each of the four fields is exactly reconstructible from the other three). A correct self-test: generate 1000+ random exact-rational quads, corrupt one field, confirm reconstruction equals the original bit-for-bit, and confirm parity (recomputing Y) fails only when a field was altered without updating Y."

Example 3: Input: "Track A uses floating point and track B uses exact Gaussian integers for the same (1+i)^F. After 7200 frames, what should the self-test assert?" Output: "Assert |A − B| < tolerance (e.g., 3.1e-16) at every frame, not just the end — floating error can be non-monotonic. B itself cannot drift since it's exact. A third track (residues mod a prime like 881) can serve as an independent fingerprint of B; check it agrees with B, not with A, since A is the unverified proposer."