Lion Translation Doctrine

The substrate is not the issue. The translation of the question and our understanding is the issue. — operator, 2026-05-25

A question like "solve Navier-Stokes" or "run Shor's algorithm" is not yet sealable. The Lion kernel decides exact rational equalities and the Swift gate recomputes them bit-for-bit. Neither side speaks "the abstract PDE" or "the unitary on a continuous Hilbert space." Before any seal is possible, the cell must translate the question into a claim the kernel CAN decide.

Translation is the bridge. Without it, the audit's "GAP" never closes — not because the substrate is broken, but because we never named what we were asking.

The five-step translation

Every open frontier domain — Navier-Stokes, Maxwell, Schrödinger, every QC-NNN — must pass through the same five steps before its MCP exposure becomes anything other than air.

1. NAME the continuous claim

One sentence in the original vocabulary. "Incompressible Navier-Stokes has a smooth solution on [0,T]×ℝ³ for any smooth initial data." Or "Grover's algorithm finds a marked item in O(√N) queries." The original question, undiluted.

2. NAME the discretisation (the measurement surface)

What finite object replaces the continuum? "A 64×64 finite-volume grid over [0,1]² with periodic boundary conditions, time step Δt = 1/100 in exact RationalBig." Or "A 2-qubit Grover circuit on ℂ⁴ with amplitudes in RationalBig × LionSymbol." The surface is what the kernel can SEE.

3. NAME the certificate the kernel decides

A Bool the kernel reduces by decide / native_decide. "At step N=10, the discrete divergence ∇·u at every grid point is zero in RationalBig." Or "After Oracle ∘ Diffusion on |+⟩⊗|+⟩, the state equals |11⟩ exactly in RationalBig amplitudes." If the certificate is not decidable, you have not yet translated — return to step 2 with a finer or different surface.

4. NAME the prerequisite primitive

What does LionPrelude need to ship so step 3's certificate compiles? "A LionPrelude.FiniteGrid over Rat with a discrete-Laplacian operator." Or "A LionPrelude.QuantumState over Rat × LionSymbol, plus 2×2 Pauli + Hadamard gates and tensor product." If the primitive doesn't exist, this is where the work goes — not at the certificate, not at the Swift gate. Build the primitive first.

5. NAME the licensing

What does sealing this finite certificate LICENSE elsewhere? "This single Navier-Stokes step seals a measurement surface; family-of-steps + uniform-stability bound licenses a finite-time solution claim; that licenses the engineering-design subset of the question." The licensing IS the meaning — Rosetta-Lion-001 binds it into the lattice.

A correctly-translated question carries all five steps written down. Any one missing = the translation is not yet complete and the kernel cannot decide. That is a CURE-conjecture state — honest, named, on the frontier. Not a failure.

Worked example A — Grover N=4 (the small clean case)

Step	Statement
1. Continuous claim	"Grover's algorithm finds the marked item in one query when N=4."
2. Discretisation	2-qubit pure-state circuit; amplitudes live in LionPrelude.Rat exactly (no irrationals — for N=4 the H⊗H factor (1/√2)² collapses to 1/2).
3. Decidable certificate	After applying Oracle(marks |11⟩) then Diffusion on the uniform superposition, the resulting amplitude vector equals (0, 0, 0, 1) — bit-exact Rat equality at all four basis states.
4. Prerequisite primitive	LionPrelude.QuantumGate.lean: State2 (4 Rat amplitudes), Oracle, Diffusion, Hadamard ⊗ Hadamard — all exact rational matrices.
5. Licensing	Seals QC-002 at N=4 as a measurement-surface fact. Licenses summit.grover.parameterised (extending to arbitrary N as a separate seal). Does NOT yet license "general quantum search" — that is its own translation chain.

This is the first concrete translation the cell ships in this commit: proof/lean/FirstRoars/GroverN4.lean.

Worked example B — 1D heat equation, one step (the small PDE case)

Step	Statement
1. Continuous claim	"The heat equation ∂u/∂t = α ∂²u/∂x² evolves a smooth initial condition smoothly forward in time."
2. Discretisation	N=8 grid over [0,1], spacing h = 1/7, time step k = h²/(4α) (CFL-safe), one forward-Euler step. All cells in Rat.
3. Decidable certificate	Given initial vector u⁰ ∈ Rat^8 and the explicit finite-difference matrix M, the one-step update u¹ = M·u⁰ equals a specified target vector bit-exactly.
4. Prerequisite primitive	LionPrelude.FiniteGrid.lean: Vec8 Rat, tridiagonalMatrix, matVecMul — all exact rational.
5. Licensing	Seals ONE STEP of the heat equation on ONE INITIAL CONDITION as a measurement-surface fact. Licenses summit.heat.parameterised (extending to arbitrary N, arbitrary initial conditions, multi-step + uniform stability bound). Does NOT yet license "solve any heat equation" — and the operator-facing MCP tool must reflect that.

The 1D heat equation primitive + first seal ships in a separate commit after Grover N=4 is sealed (we ship one translated rung at a time to keep each seal traceable).

Worked example C — Navier-Stokes (the open one we do NOT yet have the translation for)

Step	Statement
1. Continuous claim	"Incompressible Navier-Stokes has a smooth solution on [0,T]×ℝ³ for any smooth initial data." (Clay Millennium.)
2. Discretisation	Open. Plausibly: finite-volume staggered grid + projection method + exact Rat arithmetic. But the projection step requires a Poisson solver, which we don't yet have.
3. Decidable certificate	Open. Cannot be named until step 2 names a complete pipeline.
4. Prerequisite primitive	Open. LionPrelude.FiniteGrid + LionPrelude.Poisson + LionPrelude.Projection — none yet exist.
5. Licensing	If sealed: one Navier-Stokes step on one initial condition. Licenses nothing about the Clay problem — that is a continuum claim and lives a different chain.

This is what "the translation is the issue" means. Until steps 2–4 are named in Lion vocabulary, "solve Navier-Stokes via MCP" is air. The inventory audit correctly REFUSES to expose it.

The doctrine in one rule

A question is sealable iff its translation passes all five steps. An untranslated question can still live on the frontier — with its open step explicitly named. That is the honest state, not the silent state.

Every MCP exposure target the cell promises must carry its translation document with it. Missing translation = no exposure. The Lion kernel does not decide what it cannot SEE.

Translation receipts

When a translation completes (all five steps named + the kernel seals step 3), the cell appends one row to a planned lion_translation_receipts substrate table:

translation_id          GFTCL-LION-TRANSLATION-<domain>-<param>
continuous_claim        verbatim from step 1
discretisation          verbatim from step 2
certificate_lean_file   path to the .lean that holds step 3's `decide`
prerequisite_primitive  path(s) to the LionPrelude file(s) for step 4
licenses                downstream MeaningEntry IDs (step 5)
sealed_at_iso           when the kernel accepted the certificate
sweep_kernel_sha        recorded for falsification

A translation receipt feeds straight into the Rosetta meaning lattice as a new MeaningEntry. The audit loop alarms on translation-without-seal the same way it alarms on meaning-without-seal.

Open translations the cell currently does not own

Per the live M8InventoryAuditor:

• 18 of 19 quantum algorithms (QC-001..QC-019 except the one this commit translates)
• 9 of 10 engineering math domains (Navier-Stokes, Maxwell, Schrödinger, heat, wave, Laplace, Poisson, elasticity, RK4)
• 6 MCP exposure targets (lion_math_seal, rosetta_lattice, solve_navier_stokes, solve_pde, run_quantum_algorithm, inventory_audit)

Each line above is a translation the cell owes itself before MCP exposure is honest. The doctrine names how each one closes; the next set of commits work down the list one seal at a time.

---

Federation-cosigned

This page's source is sealed in the GaiaFTCL federation manifest — page SHA-256 0af3f06e1e62fbdd…, 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.