Encyclopedia Holography Holography Ledger Owner Map Cut

ARTICLE 5 claims 5 theorems

Holography Ledger Owner Map Cut

A ledger can name who owns each committed unit without copying from a proof, and that naming alone separates debits from credits.

Verify this page

The owner map cut

In Recognition Science, a ledger is a discrete record of events, and each event is a unit committed to an account on one side, debit or credit. The ledger owner map cut is the part of the framework that answers a simple question: given a ledger's state, can you tell, for every committed unit, which account and side it belongs to, using only the state itself? The construction proves you can. It builds a map from each committed unit to its owner, an account and side pair, and it does so without looking at any proof of how the unit got there. The map reads only the two ledger states, before and after a step, and recovers the posting, the single account and side that changed.

The construction is concrete. Each account and side pair gets a slot, and the map orders units by counting how many units each owner already has. The theorem ownerMap_of_unique_owner shows the simplest case: if a ledger has exactly one committed unit and that unit belongs to account k on side side, the map sends the unit to (k, side). The theorem postingOfBoundaryStep_of_post shows the general step: from a legal ledger state, posting to an account and side is exactly what the boundary data recovers. The separation of debit from credit is a theorem too, ownerMap_separates_debit_credit: the map assigns different boundary functions to a debit posting and a credit posting at the same aperture, so the side is not lost in the encoding.

The construction also proves the map is faithful in a strong sense. The theorem ownerMap_fiber_card says the number of units mapped to a given owner equals that owner's count in the ledger. The theorem ownerMap_insertPos says that after a posting, the new unit lands at the position the owner's count predicts. A constant assignment, one that ignores the ledger state, fails this test: constant_owner_assignment_not_bucket_correct shows no fixed owner can match the counts for every ledger. The map is therefore not an arbitrary choice but the one forced by the counts themselves.

In Recognition Science, this construction establishes that one legal tick, one step of the ledger, is an owned boundary extension. The posting is recoverable from the owner-map boundary data, and the side is part of that data. The construction is a channel-addressed boundary: each committed unit is addressed by its canonical owner, and nothing is copied from a tick proof. The next arc, still open, is the bridge from this occurrence-bearing carrier to pair-kernel physical source normalization and the RemainingPhysicalEquality statement. The construction's forcing path binds no sourceScale, hbar, G, or Real.pi; its axioms are limited to the standard three, propext, Classical.choice, and Quot.sound.

THEOREM ownerMap · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean
ownerMap · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean:259 
noncomputable def ownerMap {d : Nat} (L : LedgerState d) :
    Fin (ledgerCommittedUnits L) → Fin d × Side :=
  fun i =>
    ownerOfSlot d (Classical.choose (exists_owner_slot L i))
      (Classical.choose_spec (exists_owner_slot L i)).1
THEOREM postingOfBoundaryStep_of_post · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean
postingOfBoundaryStep_of_post · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean:399 
theorem postingOfBoundaryStep_of_post {d : Nat} [NeZero d] {L : LedgerState d}
    (hn : NonnegLedger (d := d) L) (k : Fin d) (side : Side) :
    postingOfBoundaryStep L (post L k side) = (k, side) := by
  classical
  have hprop :
      ownerCount (post L k side) k side = ownerCount L k side + 1 ∧
        (∀ k' side', (k', side') ≠ (k, side) →
          ownerCount (post L k side) k' side' = ownerCount L k' side') := by
    constructor
    · simp [ownerCount_post hn k side k side]
    · intro k' side' hne
      simp [ownerCount_post hn k side k' side', hne]
  have hε :=
    Classical.epsilon_spec
      (p := fun p : Fin d × Side =>
        ownerCount (post L k side) p.1 p.2 = ownerCount L p.1 p.2 + 1 ∧
          (∀ k' side', (k', side') ≠ p →
            ownerCount (post L k side) k' side' = ownerCount L k' side'))
      ⟨(k, side), hprop⟩
  set p := postingOfBoundaryStep L (post L k side)
  have hform := ownerCount_post hn k side p.1 p.2
  by_cases heq : (p.1, p.2) = (k, side)
  · exact heq
  · have h1 : ownerCount (post L k side) p.1 p.2 = ownerCount L p.1 p.2 := by
      simpa [heq] using hform
    have h2 : ownerCount (post L k side) p.1 p.2 = ownerCount L p.1 p.2 + 1 := hε.1
    omega
THEOREM ownerMap_separates_debit_credit · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean
ownerMap_separates_debit_credit · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean:485 
theorem ownerMap_separates_debit_credit (d : Nat) [NeZero d] :
    let L0 : LedgerState d := { debit := fun _ => 0, credit := fun _ => 0 }
    let k : Fin d := ⟨0, Nat.pos_of_ne_zero (NeZero.ne d)⟩
    let Ld := post L0 k Side.debit
    let Lc := post L0 k Side.credit
    ledgerCommittedUnits Ld = 1 ∧
      ledgerCommittedUnits Lc = 1 ∧
      ownerMap Ld ⟨0, by
        have h := (ownerCount_post_zero (d := d)).2.2.1
        exact Nat.lt_of_lt_of_eq Nat.zero_lt_one h.symm⟩ ≠
      ownerMap Lc ⟨0, by
        have h := (ownerCount_post_zero (d := d)).2.2.2
        exact Nat.lt_of_lt_of_eq Nat.zero_lt_one h.symm⟩ := by
  intro L0 k Ld Lc
  have h := ownerCount_post_zero (d := d)
  refine ⟨h.2.2.1, h.2.2.2, ?_⟩
  have hd := ownerMap_of_unique_owner Ld k Side.debit h.2.2.1 h.1
  have hc := ownerMap_of_unique_owner Lc k Side.credit h.2.2.2 h.2.1
  intro heq
  exact (by decide : Side.debit ≠ Side.credit)
    (congrArg Prod.snd (hd.symm.trans (heq.trans hc)))
THEOREM ownerMap_fiber_card · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean
ownerMap_fiber_card · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean:306 
theorem ownerMap_fiber_card {d : Nat} (L : LedgerState d)
    (k : Fin d) (side : Side) :
    (Finset.univ.filter (fun i : Fin (ledgerCommittedUnits L) =>
      ownerMap L i = (k, side))).card =
      ownerCount L k side := by
  classical
  set a := bucketStart L k side with ha
  set b := insertPos L k side with hb
  have hab : b = a + ownerCount L k side := by simp [hb, ha, insertPos]
  have hle : b ≤ ledgerCommittedUnits L := insertPos_le_units L k side
  let s : Finset (Fin (ownerCount L k side)) := Finset.univ
  have hcard : s.card = ownerCount L k side := by simp [s]
  refine Eq.trans ?_ hcard
  refine (Finset.card_bij
    (fun (t : Fin (ownerCount L k side)) (_ : t ∈ s) =>
      (⟨a + t.val, by
          have ht : t.val < ownerCount L k side := t.isLt
          have hlt : a + t.val < a + ownerCount L k side := Nat.add_lt_add_left ht a
          exact lt_of_lt_of_le (hab ▸ hlt) hle⟩ :
        Fin (ledgerCommittedUnits L)))
    ?_ ?_ ?_).symm
  · intro t _
    simp only [Finset.mem_filter, Finset.mem_univ, true_and]
    refine ownerMap_eq_of_mem_bucket L _ k side (Nat.le_add_right a t.val) ?_
    have ht : t.val < ownerCount L k side := t.isLt
    have : a + t.val < a + ownerCount L k side := Nat.add_lt_add_left ht a
    simpa [hb, insertPos, ha] using this
  · intro t1 t2 _ _ heq
    exact Fin.ext (Nat.add_left_cancel (congrArg Fin.val heq))
  · intro i hi
    simp only [Finset.mem_filter, Finset.mem_univ, true_and] at hi
    have hmem := mem_bucket_of_ownerMap L i
    rw [hi] at hmem
    have hlo : a ≤ i.val := by simpa [ha, bucketStart] using hmem.1
    have hhi : i.val < a + ownerCount L k side := by
      simpa [hb, insertPos, ha] using hmem.2
    refine ⟨⟨i.val - a,
        Nat.sub_lt_left_of_lt_add hlo (by omega : i.val < a + ownerCount L k side)⟩,
      by simp [s], Fin.ext (by simp [Nat.add_sub_of_le hlo])⟩
THEOREM constant_owner_assignment_not_bucket_correct · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean
constant_owner_assignment_not_bucket_correct · IndisputableMonolith/Holography/LedgerOwnerMapCut.lean:622 
theorem constant_owner_assignment_not_bucket_correct {d : Nat} [NeZero d]
    (p0 : Fin d × Side) :
    ¬ (∀ (L : LedgerState d) (k : Fin d) (side : Side),
        (Finset.univ.filter (fun _ : Fin (ledgerCommittedUnits L) =>
          p0 = (k, side))).card = ownerCount L k side) := by
  classical
  intro h
  let L0 : LedgerState d := { debit := fun _ => 0, credit := fun _ => 0 }
  let k : Fin d := ⟨0, Nat.pos_of_ne_zero (NeZero.ne d)⟩
  let Ld := post L0 k Side.debit
  let Lc := post L0 k Side.credit
  have hz := ownerCount_post_zero (d := d)
  have hUd : ledgerCommittedUnits Ld = 1 := hz.2.2.1
  have hUc : ledgerCommittedUnits Lc = 1 := hz.2.2.2
  have hD := h Ld k Side.debit
  have hC := h Lc k Side.credit
  have hcardD :
      (Finset.univ.filter (fun _ : Fin (ledgerCommittedUnits Ld) =>
        p0 = (k, Side.debit))).card =
        if p0 = (k, Side.debit) then 1 else 0 := by
    split_ifs with hp
    · simp [hp, hUd]
    · simp [hp]
  have hcardC :
      (Finset.univ.filter (fun _ : Fin (ledgerCommittedUnits Lc) =>
        p0 = (k, Side.credit))).card =
        if p0 = (k, Side.credit) then 1 else 0 := by
    split_ifs with hp
    · simp [hp, hUc]
    · simp [hp]
  rw [hcardD, hz.1] at hD
  rw [hcardC, hz.2.1] at hC
  have hpD : p0 = (k, Side.debit) := by
    by_cases hp : p0 = (k, Side.debit)
    · exact hp
    · simp [hp] at hD
  have hpC : p0 = (k, Side.credit) := by
    by_cases hp : p0 = (k, Side.credit)
    · exact hp
    · simp [hp] at hC
  exact (by decide : Side.debit ≠ Side.credit)
    (congrArg Prod.snd (hpD.symm.trans hpC))

What this page does not claim

The construction does not prove the bridge from this occurrence-bearing carrier to pair-kernel physical source normalization. The construction does not derive any physical constants such as hbar or G. The construction does not establish that the owner map is unique among all possible maps, only that a constant one fails.

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/Holography/LedgerOwnerMapCut.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