Foundation Ledger Time Cone Grows

The growing cone of futures

In the Recognition Science framework, time is not a continuous river but a sequence of discrete recognition events, each one a moment where reality commits to a record of what happened. The framework calls this record the ledger, a discrete list of committed entries. A bare moment of recognition is reversible, so the framework needed a separate structure to explain why the past feels fixed while the future feels open. That structure is the ledger itself: it is append-only, meaning new entries can be added but old ones never change.

The declaration cone_grows proves a simple structural fact about this ledger. At any moment, there is a set of possible next entries, a frontier of admissible continuations. The proof shows that the frontier is always contained within the set of continuations one step further out, the cone. In plain terms, the set of possible futures never shrinks as you look further ahead. A companion proof, cone_card_monotone, shows the count of admissible futures is nondecreasing with the horizon. These are results about lists and finite sets, standard in mathematics, checked by a machine.

The framework's library of formal results proves these structural facts. The same library also proves that the past is immutable and addressable, and that the present index advances by exactly one per commit. These are the mechanical bones of an asymmetric time: a fixed, readable past and a widening cone of possible futures. The proof itself is elementary, a direct consequence of how a set union is defined, but its role in the framework is to anchor the lived asymmetry of time in a formal structure.

What the declaration does not claim is just as important. The proof treats the ledger abstractly, over any type of entry. The identification of that abstract entry type with actual recognition events, and the identification of the cone step with the specific set of continuations allowed by the framework's cost function, is a modeling choice argued in a companion document, not a result in the library. The proof establishes a property of lists and finite sets; it does not by itself establish that physical time behaves this way. That bridge, from the formal structure to the physical world, remains an open question.

/-- **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

/-- **Admissible count nondecreasing.** The number of admissible states is
nondecreasing in horizon.

Strategy: `exact Finset.card_le_card (cone_grows next S)`. -/
theorem cone_card_monotone (next : E → Finset E) (S : Finset E) :
    S.card ≤ (coneStep next S).card := by
  exact Finset.card_le_card (cone_grows next S)

/-- **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

/-- **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]

/-- **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

/-- One step of the admissible future cone: the current frontier together with all
its admissible successors under `next`. -/
def coneStep (next : E → Finset E) (S : Finset E) : Finset E :=
  S ∪ S.biUnion next

What this page does not claim

The proof does not claim that physical time is actually discrete or append-only. The proof does not claim that the set of possible futures grows in any specific way, only that it never shrinks. The proof does not establish that the framework's cost function governs real-world recognition events.

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: