Delta Kernel Examples Zero Add Certified

A certified arithmetic fact

The statement zero_add_certified is a formal theorem about ordinary arithmetic: for every natural number n, 0 + n = n. This is the familiar identity taught in elementary school, but here it is established through a specific pipeline. The framework's machine-checked library of formal theorems constructs a derivation tree, audits it with a small checker, and then exports the result to a host theorem about natural numbers. The export step is what the name 'certified' points to: the final theorem carries a guarantee that its proof used no choice axioms.

The derivation itself proceeds by induction. The base case, 0 + 0 = 0, follows directly from the recursion equations for addition. The step case assumes 0 + m = m and derives 0 + (m+1) = m+1 using the successor rule for addition. The checker accepts this tree and records the tier as quantifier-free induction, meaning the induction was applied to a formula without quantifiers. A separate example demonstrates induction on a quantified formula, which the checker marks with a different tier flag. The distinction matters because it shows the kernel is precise about what kind of reasoning it admits.

The framework also provides a contrast case involving the law of excluded middle. The same decidable disjunction, 0 = 0 or not (0 = 0), can be derived in two ways: one uses the excluded-middle posit explicitly, and the other uses a direct introduction rule. The checker records whether the posit was needed. For the concrete instance, the direct route leaves the ledger empty, showing the schematic posit was never required. This illustrates how the ledger tracks which assumptions a proof actually depends on.

In Recognition Science, the ledger, a discrete record of every recognition event and its cost, is the foundation for deriving physical constants. The zero_add_certified example does not touch physics directly. It demonstrates the kernel's integrity: the checker, not the host's proof search, accepts the derivation trees. The theorem is verified by decide and rfl against the executable checker, with no external mathematical library involved. This is a worked example of the framework's claim that its proofs are audited to the kernel's standard axioms.

What the declaration does not claim is equally important. It does not assert that the framework's physical derivations are complete, nor that this arithmetic fact explains any physical phenomenon. It does not claim that the excluded-middle posit is invalid, only that this particular instance does not need it. The example is a tool demonstration, not a physical result. Its value lies in showing that the kernel can certify a basic arithmetic truth from first principles, with the axiom closure recorded explicitly.

/-- Exported to the host: `∀ n, 0 + n = n` over `Nat`, certified through the
δ-kernel. The proof term routes through `sound_forced`, so its axiom
closure is choice-free; `#print axioms` below is the audit. -/
theorem zero_add_certified (n : Nat) : 0 + n = n :=
  sound_forced zeroAdd_forced (fun _ => 0) n

/-- The full induction derivation for `∀x, 0 + x = x`. -/
def zeroAdd : Deriv := .ind zeroAddFormula (.addZero .zero) zeroAddStep

/-- The kernel accepts `zeroAdd` with the EMPTY ledger: no posits, and the
QF tier (the induction formula is quantifier-free, so `indFull` stays
`false`). FORCED @ QF-IND. -/
theorem zeroAdd_forced :
    check [] zeroAdd = some (.all zeroAddFormula, .empty) := by
  decide

/-- The kernel accepts `zeroAdd` with the EMPTY ledger: no posits, and the
QF tier (the induction formula is quantifier-free, so `indFull` stays
`false`). FORCED @ QF-IND. -/
theorem zeroAdd_forced :
    check [] zeroAdd = some (.all zeroAddFormula, .empty) := by
  decide

/-- The kernel accepts `fullIndDemo` and posts the TIER flag: ledger
`ofIndFull` = no posits, full-induction tier. FORCED @ FULL-IND. -/
theorem fullIndDemo_tier :
    check [] fullIndDemo = some (.all quantFormula, .ofIndFull) := by
  decide

/-- Route B proves the SAME formula with the EMPTY ledger: FORCED. -/
theorem forcedRoute_forced :
    check [] forcedRoute = some (.disj zeroEq zeroEq.neg, .empty) := by
  decide

/-- Route A posts `em`: the verdict is CONDITIONAL {EM}. -/
theorem emRoute_posts_em :
    check [] emRoute = some (.disj zeroEq zeroEq.neg, .ofEM) := by
  decide

What this page does not claim

This theorem does not establish any physical result or constant. The example does not claim the excluded-middle posit is invalid, only that this instance avoids it. The declaration does not prove that all arithmetic identities can be certified without choice axioms.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/DeltaKernel/Examples.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: