Foundation Ledger Field Write Head At Other

The untouched voxel

A ledger, in the plainest sense, is a discrete record of events that only ever grows by appending. In the Recognition Science framework, the universe keeps one such record at each point of space, and each record is called a voxel, a portmanteau of "volume" and "pixel" meaning a single cell of a spatial grid. The entire collection of these per-point records is a recognition field, an assignment of an independent append-only ledger to every voxel. The framework's library, a machine-checked collection of formal results, proves that this field obeys a strict locality rule: a commit, an act of appending one new entry to one voxel's record, changes only that voxel and leaves all others untouched.

The specific declaration named writeHeadAt_other pins down one consequence of that locality. Each voxel's ledger has a write-head, the present index at that voxel, which marks how many entries have been committed so far. The declaration states that when a new entry is committed at voxel v, the write-head at any other voxel w, where w is not equal to v, remains exactly what it was before. In symbols: writeHeadAt (commitAt F v e) w = writeHeadAt F w. This is not a separate assumption; it is a proved consequence of the definition of a commit as a local update, and it holds for every voxel other than the one written.

This declaration is the second half of a pair. Its companion, writeHeadAt_advances, proves that the write-head at the written voxel moves forward by exactly one. Taken together, the two declarations form a complete account of how the field's present index changes under a single commit: one step forward at the written voxel, zero steps everywhere else. The framework's library packages these results into a single certificate, fieldLedgerCert, which bundles five properties: local writes, an immutable past, head advance, head constancy elsewhere, and addressable readout of past entries. This certificate is what later results about content-emptiness and widening cones build upon.

What the declaration does not claim is just as important as what it proves. It says nothing about which voxels exist, how many there are, or what physical meaning they carry. The identification of the abstract index set V with physical voxels, and of the entry type E with recognition events, is a modeling choice argued in a companion document, not a result in the library. The declaration also does not say that commits are the only way the field changes, nor does it describe any dynamics, forces, or causes. It is a purely structural statement about one operation and its effect on one counter at one point.

The practical consequence is a guarantee of independence. If two voxels are distinct, no commit at one can ever move the write-head of the other, no matter how many entries are appended. That makes the field a collection of genuinely separate histories, each addressable on its own. For a reader, the takeaway is simple: in this framework, space is built from records that cannot reach across and edit one another, and that fact is not assumed but proved from the definition of a commit.

/-- **Write-head unchanged (other voxels).** No other voxel's present index moves. -/
theorem writeHeadAt_other (F : LedgerField V E) (v : V) (e : E) (w : V) (hw : w ≠ v) :
    writeHeadAt (commitAt F v e) w = writeHeadAt F w := by
  unfold writeHeadAt
  rw [commitAt_local F v e w hw]

/-- **Write-head unchanged (other voxels).** No other voxel's present index moves. -/
theorem writeHeadAt_other (F : LedgerField V E) (v : V) (e : E) (w : V) (hw : w ≠ v) :
    writeHeadAt (commitAt F v e) w = writeHeadAt F w := by
  unfold writeHeadAt
  rw [commitAt_local F v e w hw]

theorem fieldLedgerCert : FieldLedgerCert where
  local_write := fun F v e w hw => commitAt_local F v e w hw
  past_immutable := fun F v e => past_immutable_at F v e
  head_advances := fun F v e => writeHeadAt_advances F v e
  head_other := fun F v e w hw => writeHeadAt_other F v e w hw
  addressable := fun F v e i hi => past_addressable_at F v e i hi

/-- A recognition field: an independent append-only ledger at each voxel. -/
def LedgerField (V E : Type*) : Type _ := V → List E

What this page does not claim

The declaration does not specify how many voxels exist or what physical meaning they carry. The declaration does not describe any dynamics, forces, or causes that drive commits. The declaration does not claim that commits are the only operation that can change a field.

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