Foundation Ledger Floor T0 Bridge Ledger To Floor Surjective

The two-state shadow

In Recognition Science, a ledger is a discrete record of events, written as a table that counts how many times each possible recognition has been posted. The ledger is extensive: it can hold any natural number of entries, so it can distinguish one posting from two, or two from three. The T0 floor is a coarser object, a two-state indicator that only answers whether any recognition has happened at all. The declaration ledgerToFloor_surjective establishes that this coarse indicator is a genuine shadow of the full ledger, not a separate construction.

The map works by sending a ledger to false if it is empty and to true if it contains at least one entry. Surjectivity means that every floor state is hit: for every possible on/off summary, there exists some ledger that produces it. The empty ledger produces the off state, and a ledger with a single posting at any primitive distinction produces the on state. Nothing in the two-state floor is unreachable; the shadow covers its whole target.

The result is part of a larger identification bundle. The same map is a monoid homomorphism, meaning that adding two ledgers and then taking the shadow gives the same answer as taking the shadows and joining them with Boolean OR. It is also a cost truncation: the recognition cost of the shadow equals the extensive ledger cost clamped to the set {0, 1}. Two ledgers share a shadow exactly when they agree on having zero extensive cost, so the floor's identity is the truncated cost kernel. Together these facts turn T0 from a chosen Boolean indicator into the forced two-state truncation of the extensive ledger.

The declaration does not claim that the floor preserves the full information of the ledger. A shadow that distinguishes only empty from non-empty cannot recover the multiplicity of postings; the extensive ledger remains the finer object. It also does not claim that the map is injective, and indeed it is not: many different ledgers collapse to the same on state. What the theorem establishes is that the two-state floor is a quotient of the ledger, a genuine projection that loses only the counting detail while preserving the distinction between nothing and something.

/-- 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

/-- 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]

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 map is not injective; many different ledgers can produce the same on state. The floor does not preserve the multiplicity of postings, only the distinction between empty and non-empty. The theorem does not derive the recognition cost function itself; it only relates two existing cost objects.

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: