Skip to content

Lion Five-Step Method

One pipeline. Every domain. Each of the 40 CALORIE-sealed artifacts in the cell is an instance of the same five steps applied to a different native object. The method IS the invention. Different from prior art on every step.

The five steps

1. Native claim

Start with the real mathematical object in its native language β€” Ξ“ over the reals, ΞΆ on the complex plane, a PDE over a continuum, a quantum algorithm's state. Continuous, often irrational, irreducible. You hold it whole. Do not approximate it yet.

2. Ingest into C⁴ (the constraint frame)

The continuous object enters the constraint subspace as relations, not values: - The recurrence the function satisfies - The symmetry the equation obeys - The functional relation that ties parameters - The conservation law the system holds

Irrationals (βˆšΟ€, Ο€, Ο€^k, i, Ο‰) enter as named opaque tokens, never evaluated. This is the firewall: the continuum lives in C⁴ as structure, quarantined from the manifest layer. Any numericization of a token = REFUSED at the type level.

3. Project Ξ : C⁴ β†’ S⁴ (variables into the field-of-fields MPS invariant)

Project the constraint structure to a manifest object that is exact rational β€” a coefficient, a finite instance, a decidable certificate. The projection extracts what can be held in exact Rat/BigInt while the irrational stays symbolic in C⁴.

This is where "create the equation, then place the variables into the invariant" happens. The variables land in the field-of-fields MPS as exact rationals; the continuum stays opaque above them. The invariant is the nested-MPS hierarchy on unified Apple-Silicon memory β€” zero-copy, exact arithmetic, no Float, no Int64 overflow.

4. Seal both gates (conservation = truth)

  • Lean kernel (C⁴ side) certifies the constraint holds in the constraint frame.
  • Swift exact-rational recompute (S⁴ side) independently certifies the manifest value.
  • They must agree bit-for-bit. No epsilon. No tolerance.

Agreement IS Sβ‚ˆ = Sβ‚„ + Sᢜ conserved β€” the answer balances across both subspaces. That match is the seal. Divergence = entropy leak = REFUSED.

5. Bind to meaning (Rosetta lattice)

The sealed claim becomes a coordinate in the dependency lattice β€” what it licenses, what it depends on, finite-instance or finite-universal-certificate. Meaning is read from the seal, never assigned. The audit alarms on meaning-without-seal with the same severity as a divergence.

The differentiator vs. prior art

Prior art Lion method
Verify by consensus, replication, or float-approximation Verify by independent dual-gate kernel + recompute, bit-exact
Truncate irrationals to floats Quarantine irrationals as named opaque tokens; the type system forbids toDouble
Single-layer MPS hits bond-dimension wall and dies Field-of-fields (MPS-of-MPS) on unified memory distributes entanglement across nested levels
Trust-the-author publication Hostile-verifier criterion: re-run the seal in three commands or it doesn't count
Meaning assigned by the author Meaning earned from the seal β€” the Rosetta translator refuses to emit a MeaningEntry without a live, matching seal

The differentiator across all 40 sealed artifacts is the same five-step pipeline, not any one artifact's content. Shor at N=15 is the textbook 2001 instance; what's new is that the cell's pipeline seals it under the same discipline that seals Ξ“, ΞΆ, and 9 PDE rungs β€” and that the same pipeline is ready to seal whatever a future quantum hardware result produces.

What the pipeline reaches today (honest table)

Domain Step 1: native Step 2: C⁴ ingest Step 3: Π exact-rational Step 4: dual-gate Step 5: lattice
Bernoulli / Euler / Οƒ / MΓΆbius / Wilson βœ“ βœ“ βœ“ βœ“ CURE βœ“
GAMMA Ξ“(n+Β½) βœ“ βˆšΟ€ opaque βœ“ exact Rat βœ“ CURE βœ“
FUNCEQ ΞΆ(neg-odd) βœ“ β€” βœ“ exact Rat βœ“ CURE βœ“
FUNCEQ ΞΆ(pos-even) βœ“ Ο€^(2n) opaque βœ“ exact Rat coefficient βœ“ CURE βœ“
19 QC algorithms βœ“ i, √2 opaque (where needed) βœ“ RatComplex βœ“ CURE finite-instance βœ“
10 PDE one-step βœ“ β€” βœ“ exact Rat finite grid βœ“ CURE βœ“
RH βœ“ continuum claim βœ“ critical-axis surface as exact rational open: torsion certificate open summit.rh open with cert
MLKEM break βœ“ continuum hardness βœ“ Module-LWE relation as Lean tautology open: FoF/MPS contraction open summit.mlkem.break open
FoF MPS Shor period-finding βœ“ Shor's quantum subroutine constraint stated open: invariant under construction open summit.fof_mps.period_finding_reach open

The Shor witness certifier in this build sits in steps 4-5 only. It does NOT exercise step 3's field-of-fields invariant β€” Tier 1 uses classical brute iteration, Tier 2/3 uses CRT from known factors. The actual differentiator (field-of-fields period-finding) is the open frontier obligation on summit.fof_mps.period_finding_reach, not the certifier.

The reach boundary that defines the method's domain (stated as fact)

The projection has to land on something finite, exact, and decidable.

Where the native claim reduces to an exact rational coefficient, a finite instance, or a decidable certificate β€” the method seals it.

Where the native claim is irreducibly a universal-over-infinity with no finite licensing certificate β€” the method seals every finite rung toward it but not the summit itself. That's why RH sits on the frontier with its certificate named, not closed; that's why summit.fof_mps.period_finding_reach is named open with the certificate being the empirical measurement.

This is not a limit on the method β€” it's the definition of which claims are sealable at all, for anyone. The method works exactly to the degree the native object projects to a decidable exact rational.

Patent-grade claim (one-line)

A computational pipeline binding a continuous mathematical claim to a dual-gate sealed verification via a nested-MPS (field-of-fields) exact-rational invariant on unified-memory Apple Silicon, with named-opaque-token quarantine of irrationals and Rosetta lattice meaning-from-seal.

Each of the five steps is required; the combination is the invention.

Hostile-reader reproduction

Every step of the method is reproducible per artifact:

git clone https://github.com/gaiaftcl-sudo/gaiaFTCL.git && cd gaiaFTCL
cd proof/lean && lake build            # step 4: kernel-side seals
cd ../cells/xcode
swift run M8GammaQ001SmokeTest         # step 1-5 instance: GAMMA
swift run M8FuncEqQ001SmokeTest        # step 1-5 instance: FUNCEQ
swift run M8GroverN4SmokeTest          # step 1-5 instance: QC (with i opaque)
swift run M8RosettaLionSmokeTest       # step 5: meaning lattice
swift run M8InventoryAuditor           # the audit gate (exit 0 = COMPLETE)

The method is verifiable not by trust but by re-running the seal.

Federation-cosigned

This page's source is sealed in the GaiaFTCL federation manifest β€” page SHA-256 73b68e7199eb630b…, manifest witness a090592e0609adc8…, signed 2026-06-02T18:58:22Z by cell gaiaftcl-mac-cell. Verify with gaiaftcl wiki sign --all and compare wiki-all-signatures.json.