Encyclopedia Holography Holography Ledger Owner Map Cut Posting Of Boundary Step Of Legal Atomic Tick

ARTICLE 5 claims 5 theorems

Holography Ledger Owner Map Cut Posting Of Boundary Step Of Legal Atomic Tick

A formal proof shows that each legal tick in a recognition ledger can be traced back to one specific owner, using only the ledger's own records.

Verify this page

The posting of a boundary step

A ledger, a discrete record of events, can be read in two ways. One way looks at the whole state: how many units each account holds. Another way looks at the boundary, the cut between what has been committed and what has not. The declaration postingOfBoundaryStep_of_legalAtomicTick connects these two views for a single legal tick, the smallest allowed change in the ledger.

In plain language, the theorem says this: when the ledger makes one legal tick, the tick can be assigned to exactly one owner, meaning one account on one side, debit or credit. The assignment is not copied from the tick's own proof. It is recovered from the two ledger states alone, the state before the tick and the state after. The declaration proves that the posting is recoverable from the owner-map boundary data, and that debit and credit produce different boundary functions at the same aperture.

The proof works by counting. Each owner has a count of committed units. A posting is the unique pair whose count increased by one between the two states. The declaration postingOfBoundaryStep_of_post shows that posting a unit to an owner produces exactly that owner as the posting of the boundary step. The declaration ownerMap_separates_debit_credit shows that a debit posting and a credit posting yield different boundary functions, so the side is not lost in the boundary data.

In Recognition Science, this is a step toward showing that the ledger's own records carry enough information to reconstruct its history. The theorem is machine-checked, with axioms limited to the standard three: propositional extensionality, choice, and quotient soundness. No physical constants enter the forcing path.

The declaration does not claim that this occurrence-bearing carrier connects to physical source normalization. That bridge remains open. It also does not claim that any arbitrary assignment of owners to units is bucket-correct; the theorem constant_owner_assignment_not_bucket_correct shows that a constant assignment fails.

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 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 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 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 declaration does not bridge to pair-kernel physical source normalization or RemainingPhysicalEquality. The declaration does not introduce physical constants such as hbar or G into the forcing path. The declaration does not claim that any arbitrary owner assignment is bucket-correct.

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