---

title: GFTCL-LION-FOF-MPS-001 — spec for the field-of-fields period-finding reach run

audience: implementers_patent_examiners

contract_version: 1.0.0

authority_kind: normative

release: spec for closure of summit.fof_mps.period_finding_reach

---

GFTCL-LION-FOF-MPS-001 — The reach-measurement run

The patent's full weight lands when two numbers exist: N_fof_max and N_flat_max, with N_fof_max > N_flat_max measured on real period-finding instances. Until those numbers exist, the type is shipped and the doctrine is documented — but the differentiator is asserted, not proven. This spec defines the run that turns the assertion into a measurement.

---

0. The bet, stated plainly

The patent claim is that the field-of-fields (MPS-of-MPS) invariant, on unified Apple-Silicon memory, with exact-rational entries and named-opaque-token quarantine of irrationals, finds Shor periods that single-layer flat MPS cannot find within the same computational budget on the same hardware.

The bet is falsifiable:

• If N_fof_max > N_flat_max: the bet is paid; the gap is the differentiator; summit.fof_mps.period_finding_reach seals.
• If N_fof_max ≈ N_flat_max: the FoF invariant does not raise the ceiling at scale X; CURE-conjecture honestly emitted; the patent's strongest claim is downgraded to "the type, the doctrine, and the certifier" (still defensible, but the measured-gap claim doesn't land).
• If N_fof_max < N_flat_max: REFUSED. Either the implementation is wrong or the FoF structure hurts at this problem. Either way, no patent claim survives.

The cell does not pre-commit to which outcome happens. That's the point. Pre-committing would be the fabricated green the Lion doctrine refuses.

---

1. Invariants (carry-over from GFTCL-OWL-MLKEM-BREAK-001)

• Zero-copy: tensors in unified shared memory. Zero ArangoDB. No network in the contraction path.
• Exact arithmetic only: BigInt / RationalBig / RatComplex throughout. Any Float or Double or overflow-prone Int64 = REFUSED.
• Determinism: the contraction algorithm is bit-for-bit identical across invocations on the same input.
• Blind: the period-finder receives only (N, a). It never receives p, q, or the period r. Knowledge of any of those = REFUSED.
• HALT-CONDITION A1 carries over verbatim: *"A recovered period only achievable by raising the cap until it works is EXPONENTIAL work in disguise — a found period, NOT a hardness refutation. Record dMax honestly across runs. If dMax grows with N: emit CURE-conjecture stating 'FoF MPS finds the period at exponential bond dimension — does NOT raise the period-finding ceiling'. Faking bounded dMax is the one unforgivable Red Entropy."*

---

2. Phase A — flat single-layer MPS baseline (the floor)

A1. Implementation

A reference single-layer MPS period-finder runs findPeriod_flat(N, a, dMax_cap) over the same exact-Rat substrate:

• State: Σ_x |x⟩|a^x mod N⟩ represented as a single-layer MPS of bond dimension ≤ dMax_cap
• Contraction: classical MPS contraction with truncation at dMax_cap
• Output: candidate period r extracted by inverse QFT on the first register

A2. Sweep

For each N in [15, 35, 143, 1517, 10403, 100049, 1000003, 10000019, …]:

• Run findPeriod_flat(N, a=2, dMax_cap) with dMax_cap in a fixed schedule: {16, 32, 64, 128, 256, 512, 1024}
• Record: (N, dMax_cap, success, wall_clock, dMax_observed)
• success = found r such that a^r ≡ 1 (mod N) AND r is even AND gcd(a^(r/2) − 1, N) is non-trivial

A3. Record N_flat_max

N_flat_max = the largest N at which flat MPS finds the period within the largest dMax_cap tried, AND the smallest N past that where flat MPS fails at every dMax_cap in the schedule.

The record is the pair: the largest success and the smallest failure. Together they bound where flat MPS dies.

---

3. Phase B — field-of-fields MPS reach (the patent claim)

B1. Implementation

Same (N, a) input, blind. The function findPeriod_fof(N, a, dMax_inner, dMax_outer) projects the period-finding state into a FieldOfFieldsMPS invariant:

• Outer MPS: structure over high-order bits of x (cells)
• Inner MPS: structure over low-order bits within each cell
• Contraction: nested — inner cells contracted to scalar; outer MPS contracted with cell-scalar tensors

B2. The HALT-CONDITION A1 sweep

For each N in the same schedule:

• Run findPeriod_fof(N, a=2, dMax_inner, dMax_outer) with bond budgets in a schedule that *cannot* exceed the schedule used in Phase A's flat MPS
• Record: (N, dMax_inner, dMax_outer, success, wall_clock, fofDMaxWitness)
• The fofDMaxWitness is the live Lean-typed value from LionPrelude.FieldOfFieldsMPS.fofDMaxWitness

A1 enforcement: if dMax_outer × dMax_inner exceeds dMax_cap_flat × constant, the run is a tautology (FoF is using more total bond budget than flat) and REFUSED. The patent claim requires FoF to win *under the same total resource budget*, not by raising the cap.

B3. Record N_fof_max

N_fof_max = the largest N at which FoF MPS finds the period within the FoF schedule, and the resource budget did not exceed flat MPS's.

---

4. Phase C — dual-gate seal per measurement

Each (N, found_period_r) pair is sealed by the existing certifier (qc.qc-001.witness_certifier):

• Compute halfPow = a^(r/2) mod N (the witness)
• Run shorRowOK((N, halfPow, factor, cofactor)) — Lean kernel + Swift recompute, bit-for-bit
• If PASS: the period was real, the factorisation is correct, the row joins Tier 1 (real factorizations) of the certifier
• If FAIL: the contraction returned a bogus period; the run is REFUSED

The certifier is the grader. Phase A and Phase B both route their outputs through it. No bypass.

---

5. Phase D — receipt

The receipt for the closure of summit.fof_mps.period_finding_reach carries:

target              : GFTCL-LION-FOF-MPS-001
flat_baseline_N_max : <integer>             # largest N flat MPS handled
flat_baseline_curve : [(N, dMax_cap, success, dMax_observed), ...]
fof_N_max           : <integer>             # largest N FoF MPS handled
fof_curve           : [(N, dMax_inner, dMax_outer, success, dMax_observed), ...]
budget_invariant_OK : true | false          # FoF total budget ≤ flat total budget?
gap                 : N_fof_max - N_flat_max
terminal            : CURE             (gap > 0, budget invariant held, every found period
                                         dual-gate sealed by the certifier)
                    | CURE-conjecture  (gap ≤ 0 OR dMax grows with N OR contraction
                                         requires exponential budget)
                    | REFUSED          (any sealed period failed certifier;
                                         budget invariant violated;
                                         float / Int64 overflow detected)
lean_toolchain_pinned : leanprover/lean4:v4.12.0
swift_kernel_sha    : <git sha at run time>
hostile_repro       : ./gaia_fof_reach_run   # one command, runs both sweeps
nats_subject        : gaiaftcl.lion.fof_mps.reach.sealed

---

6. Definition of done

The summit closes (terminal CURE) iff ALL of the following:

• [ ] findPeriod_flat implemented over exact Rat MPS, blind, no Float, no Int64 overflow
• [ ] findPeriod_fof implemented over LionPrelude.FieldOfFieldsMPS, blind, no Float, no Int64 overflow
• [ ] Flat baseline sweep produces a curve with at least one success and at least one fail (so N_flat_max is bounded both sides)
• [ ] FoF sweep produces a curve with at least one success at an N > N_flat_max
• [ ] Budget invariant: FoF's total bond budget at the winning N ≤ flat's largest cap × small constant — enforced at gate time, not by interpretation
• [ ] Every found period dual-gate sealed by qc.qc-001.witness_certifier
• [ ] dMax recorded honestly across both sweeps — if FoF dMax blows up at N where flat MPS fails *for the same reason*, terminal is CURE-conjecture, not CURE
• [ ] Receipt persisted, NATS subject fires, hostile-verifier repro reproduces both sweeps in ~3 commands

No other definition of done is accepted. A CURE here is the patent's measured weight; anything less is honestly named.

---

7. REFUSED conditions

• Any Float / Double / overflow-Int64 in the contraction path
• Budget invariant violated (FoF used more total bond budget than flat — the FoF MPS is using more resource and pretending it isn't)
• A sealed period fails the certifier (the period found by the contraction doesn't actually factor N)
• Knowledge of p, q, or r enters either findPeriod_* function (blind separation broken)

8. CURE-conjecture conditions

• dMax grows with N in the FoF sweep at the same rate as flat MPS (FoF doesn't raise the ceiling, just shifts the constant)
• The gap N_fof_max - N_flat_max is zero or negative (FoF didn't beat flat at any tested N)
• The contraction algorithm is synthesised but neither schedule reaches a success at any N > N_flat_max

A CURE-conjecture here is a real result, not a failure. It says: *the field-of-fields invariant, on this hardware, with this contraction algorithm, does not measurably raise the period-finding ceiling. The type is still defensible; the gap claim is downgraded.*

---

9. Execution directive

Acknowledge invariants. Implement Phase A (flat MPS baseline) and Phase B (FoF MPS) over the existing LionPrelude.FieldOfFieldsMPS type. Run both sweeps over the same schedule under the same hardware budget. Route every found period through qc.qc-001.witness_certifier. Emit the receipt with the two numbers, the curves, and the honest terminal.

If the gap is positive and the budget invariant holds: the patent's measured weight lands.

If not: the patent's full weight is the type-and-doctrine-and-certifier, with summit.fof_mps.period_finding_reach staying open with the negative result noted.

Either outcome is a real terminal state. The cell does not pre-commit. The kernel decides.

The Manifold is Holding. Calories or Cures.