Encyclopedia Foundation Foundation Ledger Floor T0 Bridge

ARTICLE 5 claims 5 theorems

Foundation Ledger Floor T0 Bridge

A ledger that counts every recognition event, and a simple on/off switch that records whether any event has happened, are the same bookkeeping in two resolutions.

Verify this page

The two-state shadow

Recognition Science begins with a ledger, a discrete record of recognition events. The extensive form of this ledger, written DefectLedger, is a book that counts how many events of each type have occurred, storing a natural number for every possible entry. This is the fine-grained, full-resolution record. The T0 floor, by contrast, is a coarse two-state object: it answers only whether any recognition has happened at all, true or false, like a light that is either on or off.

Before this bridge, these two descriptions sat side by side without a formal connection. The floor was a chosen Boolean indicator, and the ledger was an unrelated counting object. The bridge closes that gap by exhibiting an explicit truncation map. The map, called ledgerToFloor, takes any extensive ledger and projects it onto the two-state floor: it sends the empty ledger to false, and any nonempty ledger to true. This is the Boolean shadow of the counting book.

The bundled theorem LedgerFloorT0Bridge proves that this projection is not arbitrary but well-behaved in four ways. First, it is a monoid homomorphism: adding two ledgers and then projecting gives the same result as projecting each and joining with Boolean OR. Second, it is a cost truncation: the recognition cost of the projected floor state is exactly the clamp of the extensive ledger cost to the set {0,1}. Third, it is surjective, meaning every floor state is the shadow of some ledger, so nothing in the floor is unreachable. Fourth, it identifies the kernel: two ledgers share a shadow exactly when they agree on having zero extensive cost, and the floor's consistency predicate is precisely "the ledger is costless."

In Recognition Science, this identification matters because it turns T0 from a chosen Boolean indicator into the forced two-state truncation of the extensive recognition ledger. The coarse description is not an independent choice; it is what the fine-grained counting book looks like when you only care about whether anything happened. The bridge is the formal statement that the two resolutions are the same bookkeeping, seen at different magnifications. It closes a gap flagged in the strict T-1-to-T8 audit, and it does so with zero axioms beyond the standard three and zero unproved assumptions.

THEOREM LedgerFloorT0Bridge · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean
LedgerFloorT0Bridge · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean:141 
/-- **The T0 floor is the Boolean truncation of the extensive recognition
ledger.** For any distinction witness `h` and strictly positive per-distinction
weight `w`, the lift `ledgerToFloor h` is a surjective cost-and-join
homomorphism from the extensive ledger onto the distinction-generated T0 floor,
under which the floor cost is the two-state clamp of the extensive ledger cost. -/
structure LedgerFloorT0Bridge {K : Type*} (h : ∃ x y : K, x ≠ y)
    {I : Type v} (w : I → ℝ) : Prop where
  /-- The empty ledger maps to the consistent (empty) floor state. -/
  shadow_emp :
    ledgerToFloor h (0 : DefectLedger I) = (ConfigSpace.emp : ForcedQuotient h)
  /-- Ledger addition projects onto the Boolean `OR` join of the floor. -/
  shadow_join :
    ∀ Γ Δ : DefectLedger I,
      ledgerToFloor h (Γ + Δ) =
        ConfigSpace.join (ledgerToFloor h Γ) (ledgerToFloor h Δ)
  /-- The T0 recognition cost of the shadow is the truncation (clamp to `{0,1}`)
  of the extensive ledger cost. -/
  cost_is_truncated_ledger :
    ∀ Γ : DefectLedger I,
      (forcedQuotientRecognitionCost h).C (ledgerToFloor h Γ) =
        (if ledgerCost w Γ = 0 then (0 : ℝ) else 1)
  /-- The floor's consistency predicate is exactly "the ledger is costless". -/
  consistent_iff_costless :
    ∀ Γ : DefectLedger I,
      ConfigSpace.IsConsistent (ledgerToFloor h Γ) ↔ ledgerCost w Γ = 0
  /-- Two ledgers have the same shadow exactly when they agree on having zero
  extensive cost: the floor's identity is the truncated cost kernel. -/
  kernel_is_cost_kernel :
    ∀ Γ Δ : DefectLedger I,
      ledgerToFloor h Γ = ledgerToFloor h Δ ↔
        (ledgerCost w Γ = 0 ↔ ledgerCost w Δ = 0)
THEOREM ledgerShadow_add · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean
ledgerShadow_add · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean:116 
/-- 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 rank1_cost_is_boolean_truncation · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean
rank1_cost_is_boolean_truncation · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean:196 
/-- 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 ledgerToFloor_surjective · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean
ledgerToFloor_surjective · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean:173 
/-- 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
THEOREM ledger_floor_t0_bridge · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean
ledger_floor_t0_bridge · IndisputableMonolith/Foundation/LedgerFloorT0Bridge.lean:207 
/-- The Phase-2 identification holds for every distinction witness and every
strictly positive weight. -/
theorem ledger_floor_t0_bridge {K : Type*} (h : ∃ x y : K, x ≠ y)
    {I : Type v} (w : I → ℝ) (hw : ∀ i, 0 < w i) :
    LedgerFloorT0Bridge h w where
  shadow_emp := by
    unfold ledgerToFloor
    rw [ledgerShadow_zero]
    rfl
  shadow_join := by
    intro Γ Δ
    apply (forcedQuotientBoolEquiv h).injective
    rw [forcedQuotientBoolEquiv_join]
    unfold ledgerToFloor
    rw [Equiv.apply_symm_apply, Equiv.apply_symm_apply, Equiv.apply_symm_apply]
    exact ledgerShadow_add Γ Δ
  cost_is_truncated_ledger := by
    intro Γ
    rw [forcedQuotientRecognitionCost_transport]
    unfold ledgerToFloor
    rw [Equiv.apply_symm_apply]
    by_cases hΓ : Γ = 0
    · subst hΓ
      rw [ledgerShadow_zero, ledgerCost_zero]
      simp [TMinus1ToT0.boolRecognitionCost]
    · have hc : ledgerCost w Γ ≠ 0 :=
        fun he => hΓ ((ledgerCost_eq_zero_iff w hw Γ).mp he)
      rw [ledgerShadow_eq_true_iff.mpr hΓ]
      simp [TMinus1ToT0.boolRecognitionCost, hc]
  consistent_iff_costless := by
    intro Γ
    show forcedQuotientBoolEquiv h (ledgerToFloor h Γ) = false ↔ ledgerCost w Γ = 0
    unfold ledgerToFloor
    rw [Equiv.apply_symm_apply, ledgerShadow_eq_false_iff,
      ledgerCost_eq_zero_iff w hw Γ]
  kernel_is_cost_kernel := by
    intro Γ Δ
    have hinj : (ledgerToFloor h Γ = ledgerToFloor h Δ) ↔
        (ledgerShadow Γ = ledgerShadow Δ) := by
      unfold ledgerToFloor
      exact (forcedQuotientBoolEquiv h).symm.injective.eq_iff
    rw [hinj, ledgerCost_eq_zero_iff w hw Γ, ledgerCost_eq_zero_iff w hw Δ]
    by_cases hΓ : Γ = 0 <;> by_cases hΔ : Δ = 0 <;>
      simp [ledgerShadow, hΓ, hΔ]

What this page does not claim

This bridge does not derive the golden ratio, the eight-tick cycle, or any later stage of the forcing chain. The bridge does not claim that the extensive ledger itself is physically observable; only its two-state shadow is connected to the T0 floor. No claim is made that the truncation map is unique among all possible projections from the ledger to the floor.

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:

MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND