Foundation Recognition Lattice From Recognizer Every Cell Has Label

The labeled cells

A recognizer is an observer that sorts a collection of configurations into a finite set of outcomes. When two configurations produce the same outcome, the recognizer cannot tell them apart. The Recognition Science framework treats that indistinguishability as a grouping rule: all configurations sharing an outcome form one cell, and the full collection of cells is the recognition lattice. The declaration every_cell_has_label proves that this grouping is complete: for every cell in the lattice, there exists a label from the recognizer's finite outcome set that names it. The proof is direct: each cell is built from a configuration, and that configuration already carries an outcome, which becomes the cell's label.

The theorem is a machine-checked statement in the framework's library of formal theorems. It does not construct a new kind of space. The lattice it describes is pre-spatial: it is a quotient of configurations by the recognizer's kernel, not a metric or topological manifold. The result also does not claim that the recognizer's outcomes are infinite. The outcome set is a finite type, so the lattice can be finite, as with a two-outcome recognizer that produces exactly two cells. The theorem's force is organizational: any recognizer, however its outcomes are chosen, yields a lattice where every cell is addressable by an outcome label.

This labeling property is what lets the framework treat recognition as a discrete ledger. A ledger is a record of distinct events, and a label is the entry that makes an event findable. The theorem guarantees that no cell is orphaned: nothing in the recognizer's output falls outside the naming scheme. That completeness is the foundation for later claims about iteration and structure, because a process can only be studied cell by cell if every cell has a handle.

The declaration does not say that the recognizer's labels are unique to each cell. Two different cells can share a label if the recognizer cannot distinguish them, which is exactly the case the quotient captures. It also does not say that the lattice is infinite or that it embeds the natural numbers. The framework's iteration object maps into the lattice, but on a finite carrier that map may collapse distinct iteration steps into the same cell. The theorem establishes a labeling, not an injection.

/-- Every lattice cell has a finite-resolution label. -/
theorem every_cell_has_label {K : Type*} (I : PrimitiveInterface K)
    (c : RecognitionLattice I) :
    ∃ label : Fin I.n, c ∈ neighborhood I label := by
  refine ⟨cellLabel I c, ?_⟩
  simp [neighborhood]

/-- The **recognition lattice** generated by an interface: the quotient by
the interface kernel. -/
def RecognitionLattice {K : Type*} (I : PrimitiveInterface K) : Type _ :=
  Quotient (interfaceSetoid I)

/-- The finite event label of a recognition cell. This is well-defined because
the quotient identifies exactly configurations with equal observed labels. -/
def cellLabel {K : Type*} (I : PrimitiveInterface K) :
    RecognitionLattice I → Fin I.n :=
  Quotient.lift (fun x => I.observe x) (by
    intro x y h
    exact h)

What this page does not claim

The theorem does not claim that each cell has a unique label. It does not claim the recognition lattice is infinite or embeds the natural numbers. It does not establish that the lattice is a metric or topological manifold.

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