Foundation Ledger Floor T0 Bridge Ledger T0 Identification Certificate

The two-state shadow

A ledger is a discrete record of events, and in Recognition Science an extensive ledger is a function that assigns to each possible distinction a natural number: how many times that distinction has been recognized. The T0 floor is the framework's simplest cost object, a two-state system that answers only whether any recognition has happened at all. The declaration ledger_t0_identification_certificate is a machine-checked certificate that these two objects are the same thing, seen at different resolutions.

The bridge is a truncation map. It takes an extensive ledger, which can count 0, 1, 2, 3 recognitions, and sends it to the floor: false if the ledger is empty, true if it holds any recognition at all. The certificate proves this map is a homomorphism, meaning ledger addition projects onto Boolean OR: posting a recognition in either of two ledgers lights the floor. It proves the map is surjective, so every floor state is the shadow of some ledger. And it proves the floor's cost is the clamp of the extensive ledger cost to {0,1}, so the two-state system carries exactly the information of whether the extensive cost is zero or positive.

The certificate also proves a kernel identification: two ledgers have the same shadow exactly when they agree on having zero extensive cost. This is what makes the floor a genuine quotient of the ledger, not an unrelated choice. The consistency predicate of the floor is precisely "the ledger is costless." On a single primitive distinction, the floor cost is literally the Boolean recognition cost of the truncated natural-number multiplicity.

In Recognition Science, this certificate closes a formal gap: before it, the T0 floor and the extensive ledger sat side by side with no proven connection. Now the floor is the forced two-state truncation of the ledger. The certificate does not claim that the extensive ledger itself is derived from first principles, nor that the truncation map is unique, nor that the ledger's weights are determined. It establishes the identification, not the origin of the ledger's content.

/-- The Phase-2 ledger-to-T0 identification is a theorem. -/
theorem ledger_t0_identification_certificate :
    LedgerT0IdentificationCertificate where
  bridge := fun h => ledger_floor_t0_bridge h _ (fun _ => one_pos)
  rank1_cost_is_truncation := fun h n => rank1_cost_is_boolean_truncation h () n
  floor_is_quotient_of_ledger := fun h => ledgerToFloor_surjective h ()

/-- The shadow is a homomorphism from ledger addition to Boolean `OR`: posting
recognition in either summand lights the two-state floor. -/
theorem ledgerShadow_add {I : Type v} (Γ Δ : DefectLedger I) :
    ledgerShadow (Γ + Δ) = (ledgerShadow Γ || ledgerShadow Δ) := by
  unfold ledgerShadow
  by_cases hΓ : Γ = 0
  · by_cases hΔ : Δ = 0
    · simp [hΓ, hΔ]
    · simp [hΓ, hΔ]
  · have hsum : Γ + Δ ≠ 0 := fun hc => hΓ (ledger_add_eq_zero_iff.mp hc).1
    simp [hΓ, hsum]

/-- The shadow lift surjects onto the T0 floor: every floor state is the shadow
of some ledger, so the floor is a genuine quotient (shadow) of the ledger. The
single primitive distinction `i₀` witnesses the marked state. -/
theorem ledgerToFloor_surjective {K : Type*} (h : ∃ x y : K, x ≠ y)
    {I : Type v} (i₀ : I) :
    Function.Surjective (ledgerToFloor (I := I) h) := by
  intro q
  by_cases hq : forcedQuotientBoolEquiv h q = false
  · refine ⟨0, ?_⟩
    unfold ledgerToFloor
    rw [ledgerShadow_zero]
    exact (Equiv.symm_apply_eq _).mpr hq.symm
  · have hqt : forcedQuotientBoolEquiv h q = true := by
      cases hb : forcedQuotientBoolEquiv h q
      · exact absurd hb hq
      · rfl
    refine ⟨Finsupp.single i₀ 1, ?_⟩
    unfold ledgerToFloor
    have hne : Finsupp.single i₀ (1 : ℕ) ≠ 0 := by
      rw [Ne, Finsupp.single_eq_zero]; exact one_ne_zero
    rw [ledgerShadow_eq_true_iff.mpr hne]
    exact (Equiv.symm_apply_eq _).mpr hqt.symm

/-- On a single primitive distinction with unit weight, the T0 floor cost is
literally the Boolean recognition cost of the truncated natural-number
multiplicity: `C = boolRecognitionCost ∘ booleanTruncation`. -/
theorem rank1_cost_is_boolean_truncation {K : Type*} (h : ∃ x y : K, x ≠ y)
    {I : Type v} (i₀ : I) (n : ℕ) :
    (forcedQuotientRecognitionCost h).C (ledgerToFloor h (Finsupp.single i₀ n)) =
      TMinus1ToT0.boolRecognitionCost.C (booleanTruncation n) := by
  rw [forcedQuotientRecognitionCost_transport]
  unfold ledgerToFloor
  rw [Equiv.apply_symm_apply, ledgerShadow_single]

theorem ledgerShadow_eq_false_iff {I : Type v} {Γ : DefectLedger I} :
    ledgerShadow Γ = false ↔ Γ = 0 := by
  unfold ledgerShadow
  by_cases hΓ : Γ = 0 <;> simp [hΓ]

What this page does not claim

The certificate does not derive the extensive ledger's content or weights from first principles. The certificate does not claim the truncation map is unique among all possible bridges. The certificate does not assert that the extensive ledger itself is the fundamental object of the framework.

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/Foundation/LedgerFloorT0Bridge.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: