Foundation Ledger Time Commit

The ledger and its commitments

A ledger, in the plainest sense, is a discrete record of events that can only be appended to. Once an entry is written, it is never edited or removed. The Recognition Science framework builds its model of time on exactly this structure. The framework's machine-checked library of formal theorems proves that this simple rule has sharp consequences: the past is immutable, the present moves forward by exactly one step per new entry, and the range of possible futures never shrinks.

The central operation is commit, which appends a new entry to the end of the list. From this one definition, three structural facts follow as theorems. First, past_immutable: if you take the ledger after a new commit and truncate it back to its previous length, you recover the old ledger exactly. Second, writeHead_advances: the present index, the number of committed entries, increases by exactly one with each commit. Third, past_addressable: every index in the committed past reads the same value after a new commit as it did before, so the past is read-only and addressable by position.

The framework also formalizes the future as a cone, the set of admissible continuations from the current frontier. Two theorems govern this cone. The cone never shrinks: the current frontier is always contained in its successor cone. And the count of admissible states is nondecreasing in horizon. Together these capture the lived asymmetry between a fixed, readable past and an open, widening future. The bare recognition tick, the smallest unit of time, is invertible and time-symmetric; the asymmetry enters only with the ledger.

In Recognition Science, the ledger is the structure that gives time its direction. The theorems about immutability and the growing cone are proved for any entry type and any successor relation, so they are structural facts about lists and finite sets. The identification of the entry type with recognition events, and of the cone step with the set of admissible continuations under the framework's cost function, is a modeling choice argued in the companion paper, not a theorem in the library. The framework proves the consequences of the ledger rule; it does not prove that reality must use this rule.

/-- **Past immutability.** Truncating the extended ledger back to the old length
returns the old ledger exactly: committing a new entry cannot alter the past.

Strategy: `unfold commit; exact List.take_left l [e]` (or
`simp [commit, List.take_left]`). -/
theorem past_immutable (l : List E) (e : E) :
    (commit l e).take l.length = l := by
  unfold commit; simp

/-- **Write-head advance.** The present index moves forward by exactly one per
commit.

Strategy: `simp [writeHead, commit, List.length_append]`. -/
theorem writeHead_advances (l : List E) (e : E) :
    writeHead (commit l e) = writeHead l + 1 := by
  unfold writeHead commit; simp

/-- **Past addressability.** Every committed past index reads the same value after
a new commit: the past is read-only and addressable by index.

Strategy: `unfold commit; exact List.getElem?_append_left hi` (find the exact
`getElem?_append` lemma for the index-in-left-segment case via the premises). -/
theorem past_addressable (l : List E) (e : E) (i : ℕ) (hi : i < l.length) :
    (commit l e)[i]? = l[i]? := by
  unfold commit; rw [List.getElem?_append_left hi]

/-- **The cone never shrinks.** The frontier is contained in its successor cone.

Strategy: `unfold coneStep; exact Finset.subset_union_left`. -/
theorem cone_grows (next : E → Finset E) (S : Finset E) :
    S ⊆ coneStep next S := by
  unfold coneStep; exact Finset.subset_union_left

/-- Commit a new entry to the ledger: append-only. -/
def commit (l : List E) (e : E) : List E := l ++ [e]

What this page does not claim

The ledger rule is not proved to be the only possible structure of time. The framework does not claim that the entry type E is physically realized as a specific particle or event. The cone theorems do not specify which continuations are admissible; that is determined by the cost function, not by the ledger structure itself.

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