Encyclopedia Holography Holography Ledger Owner Map Cut Posted Zero Ne Legal Owner Map Step

ARTICLE 3 claims 3 theorems

Holography Ledger Owner Map Cut Posted Zero Ne Legal Owner Map Step

A machine-checked proof shows that a single legal accounting step can be identified purely by its effect on a ledger's owner map, without copying any data from the step itself.

Verify this page

The owner map cut

A ledger is a discrete record of events, and in the Recognition Science framework each committed unit of value is assigned to a canonical owner, an account and a side (debit or credit). The owner map is the function that reads a ledger state and returns, for each committed unit, which owner that unit belongs to. The declaration posted_zero_ne_legal_ownerMap_step proves that this map is enough to reconstruct a legal posting: given any valid one-step transition between two ledger states, the changed owner can be recovered from the boundary data alone, and a debit posting produces a different boundary function than a credit posting at the same aperture.

This is not a claim about physics. The framework's own documentation marks the next arc as open: bridging from this occurrence-bearing carrier to pair-kernel physical source normalization and RemainingPhysicalEquality. The proof does not involve sourceScale, hbar, G, or Real.pi. Its axioms are limited to the standard three: propext, Classical.choice, and Quot.sound. The declaration also proves that a constant owner assignment, one that ignores the ledger state, cannot be bucket-correct for all states, which rules out a trivial reading of the map.

What the declaration does not claim is that this owner map is the only possible carrier of boundary data, or that it connects to the physical constants that appear elsewhere in the framework. Those remain targets. The proof's value is narrower: it establishes that a legal tick, one unit committed to one owner, is an owned boundary extension. The posting is recoverable from the owner-map boundary data, and debit versus credit are distinguishable at the same aperture. This is a structural result about ledgers, not a statement about the physical world.

THEOREM postingOfBoundaryStep_of_post · ownerMap_separates_debit_credit · 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
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_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 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 owner map is the only possible carrier of boundary data. The declaration connects the owner map to the framework's physical constants. The proof applies to multi-unit legal ticks.

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