Holography Owner Indexed Horizon Cut Boundary Profile Determines Nonneg State

The boundary profile

A ledger (a discrete record of events, each assigned to an account and a side, debit or credit) can be summarized by its boundary profile (a function that counts, for each account and each side, how many entries sit there). The classical question is how much information this summary retains. The answer proved in the framework's machine-checked library of formal theorems is that, for ledgers in which no account is overdrawn, the boundary profile is a complete fingerprint: two such ledgers with the same profile are the same ledger, meaning their debit and credit entries match exactly.

The proof runs through a structural identity. The boundary profile is built from a per-account, per-side count called ownerCount (the number of entries owned by that account on that side). The theorem boundaryProfile_determines_nonneg_state states that if two nonnegative ledgers (where nonnegative means no account's balance goes below zero) have equal boundary profiles, then their debit and credit arrays are equal. The key lemma is that the profile determines each ownerCount individually, and from those counts the full state is recovered. This is a formal result in the framework's library, with axioms limited to the standard logical principles; it holds for any positive number of accounts.

The theorem does not claim that every conceivable assignment of counts is realizable as a ledger. A separate result shows that a constant profile, one where every account and side has the same fixed count, cannot arise from any ledger, so the map from ledgers to profiles is injective but not surjective. Nor does the theorem address the physical meaning of the ledger: the bridge from this owner-indexed structure to physical source normalization remains open. The framework models the reading of every committed unit as an active posted bit, a definitional choice, not a derived fact.

What the result changes is the status of the boundary profile in the framework's holography program: it is not a lossy summary but a complete encoding of the nonnegative state. That makes the profile a legitimate candidate for a boundary description of the ledger's interior, since no information is discarded. The open question is whether that boundary description connects to the physical pair-kernel source, a step the framework has not yet derived.

theorem boundaryProfile_determines_nonneg_state {d : Nat} {L L2 : LedgerState d}
    (hn : NonnegLedger (d := d) L) (hn2 : NonnegLedger (d := d) L2)
    (h : boundaryProfile L = boundaryProfile L2) :
    L.debit = L2.debit ∧ L.credit = L2.credit := by
  have hcount : ∀ k side, ownerCount L k side = ownerCount L2 k side :=
    (boundaryProfile_eq_iff_ownerCounts L L2).1 h
  constructor
  · funext k
    simp [(nonneg_entries_of_ownerCount hn k).1,
      (nonneg_entries_of_ownerCount hn2 k).1, hcount k Side.debit]
  · funext k
    simp [(nonneg_entries_of_ownerCount hn k).2,
      (nonneg_entries_of_ownerCount hn2 k).2, hcount k Side.credit]

theorem boundaryProfile_eq_iff_ownerCounts {d : Nat} (L L2 : LedgerState d) :
    boundaryProfile L = boundaryProfile L2 ↔
      ∀ k side, ownerCount L k side = ownerCount L2 k side := by
  constructor
  · intro h k side
    exact congrFun h (k, side)
  · intro h
    funext p
    exact h p.1 p.2

/-- Free assignment: a constant profile cannot match true fiber sizes for
states with different owner counts. -/
theorem free_assignment_not_boundaryProfile {d : Nat} [NeZero d]
    (n : Nat) :
    ¬ (∀ L : LedgerState d, ∀ p : Fin d × Side, boundaryProfile L p = n) := by
  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
  have hz := ownerCount_post_zero (d := d)
  have h0 : boundaryProfile L0 (k, Side.debit) = n := h L0 (k, Side.debit)
  have h1 : boundaryProfile Ld (k, Side.debit) = n := h Ld (k, Side.debit)
  have h0' : boundaryProfile L0 (k, Side.debit) = 0 := by
    simp [boundaryProfile, ownerCount, L0]
  have h1' : boundaryProfile Ld (k, Side.debit) = 1 := by
    simpa [boundaryProfile, Ld] using hz.1
  omega

/-- C3 MODEL encoding on the owner-structured type: every committed unit is active. -/
def ownerReading {d : Nat} (L : LedgerState d) : OwnerChannel L → ZMod 2 :=
  fun _ => 1

What this page does not claim

The theorem does not claim that every assignment of counts is realizable as a ledger. The theorem does not claim a physical bridge from the owner-indexed carrier to pair-kernel source normalization. The theorem does not claim that the ownerReading encoding is derived rather than chosen.

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/OwnerIndexedHorizonCut.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: