Cosmology Interface Component Bound Mono Le Interface Of Descent

The interface bound

In graph theory, a classic fact governs how many separate pieces a network can have. If you start with a connected graph and delete some edges, each deletion can split at most one piece into two, so the number of pieces can never exceed the number of deleted edges plus one. The Recognition Science framework applies this idea to its cosmology engine, where a finite world is modeled as a graph of cells, each carrying a charge value. Cells with equal charge form locked domains, meaning uniform regions that the engine treats as a single unit. The edges where charges differ form the recognition-active interface, the boundary between those regions.

The declaration mono_components_le_bichromatic_succ proves the general theorem: in any finite, connected world, the number of locked domains is at most the number of interface edges plus one. The proof is dimension-free, working for any graph structure, and it is machine-checked in the framework's library of formal theorems. This closes a gap that previously relied only on numeric checks in the engine's live runs. The key insight is that adding the interface edges back to the monochromatic graph reconstructs the original connected world, and each added edge can merge at most two domains.

The theorem takes connectivity as a hypothesis, but the framework also proves that its specific lattices satisfy it. A finite world with a height function that has a unique zero and a descent edge from every other cell is connected. The 2D diamond lattice, the L1 ball with 4-neighbor adjacency, and the 3D octahedron lattice, the L1 ball with 6-neighbor adjacency, both satisfy this criterion using the L1 norm as height. This yields the concrete bound for the exact lattices the engine evolves, for any radius, with no fixed size. The result is a structural guarantee about the engine's representation, not a claim about physical space itself.

In Recognition Science, recognition, the cost of distinguishing states, drives the engine toward coarser descriptions. This theorem shows that coarsening cannot fragment a connected world beyond the number of distinctions it makes. The bound is tight in one dimension, where runs equal boundaries plus one, and becomes an inequality in higher dimensions where interfaces can be multiply connected. What this changes is the status of the engine's domain count: it is no longer an empirical observation but a proved consequence of the graph structure.

/-- **Locked domains are at most the interface plus one.** For a connected finite world with edge
list `E` and charge `c`, the number of monochromatic connected components (the locked domains the
engine carries) is at most the number of bichromatic edges (the recognition-active interface) plus
one. This is the dimension-free form of the 1D identity `runs = boundaries + 1`. -/
theorem mono_components_le_bichromatic_succ {β : Type*} [Finite V] [Nonempty V] [DecidableEq β]
    (E : List (V × V)) (c : V → β)
    (hconn : ∀ u v : V, clos E u v) :
    comp (E.filter (fun p => decide (c p.1 = c p.2)))
      ≤ (E.filter (fun p => decide (c p.1 ≠ c p.2))).length + 1 := by
  set mono := E.filter (fun p => decide (c p.1 = c p.2)) with hmono
  set bi := E.filter (fun p => decide (c p.1 ≠ c p.2)) with hbi
  have hsplit : ∀ p, p ∈ mono ++ bi ↔ p ∈ E := by
    intro p
    simp only [hmono, hbi, List.mem_append, List.mem_filter, decide_eq_true_eq]
    constructor
    · rintro (⟨hp, _⟩ | ⟨hp, _⟩) <;> exact hp
    · intro hp
      by_cases hc : c p.1 = c p.2
      · exact Or.inl ⟨hp, hc⟩
      · exact Or.inr ⟨hp, hc⟩
  have h1 : comp mono ≤ comp (mono ++ bi) + bi.length := comp_le_comp_append mono bi
  have h2 : comp (mono ++ bi) = comp E := comp_congr hsplit
  have h3 : comp E = 1 := comp_eq_one_of_connected E hconn
  rw [h2, h3] at h1
  omega

/-- From any off-centre diamond vertex there is a 4-neighbour edge to a strictly-lower cell: step the
larger-magnitude coordinate one unit toward the origin. -/
theorem descent (t : ℕ) :
    ∀ v : Vtx t, height t v ≠ 0 →
      ∃ u, ((v, u) ∈ edges t ∨ (u, v) ∈ edges t) ∧ height t u < height t v := by
  rintro ⟨⟨x, y⟩, hmem⟩ hv
  simp only [height] at hv
  rw [mem_ball_iff] at hmem
  rcases lt_trichotomy x 0 with hx | hx | hx
  · refine ⟨⟨(x + 1, y), ?_⟩, Or.inl ?_, ?_⟩
    · rw [mem_ball_iff]; omega
    · rw [mem_edges]; unfold adj; dsimp only; omega
    · simp only [height]; omega
  · subst hx
    rcases lt_trichotomy y 0 with hy | hy | hy
    · refine ⟨⟨(0, y + 1), ?_⟩, Or.inl ?_, ?_⟩
      · rw [mem_ball_iff]; omega
      · rw [mem_edges]; unfold adj; dsimp only; omega
      · simp only [height]; omega
    · exfalso; omega
    · refine ⟨⟨(0, y - 1), ?_⟩, Or.inl ?_, ?_⟩
      · rw [mem_ball_iff]; omega
      · rw [mem_edges]; unfold adj; dsimp only; omega
      · simp only [height]; omega
  · refine ⟨⟨(x - 1, y), ?_⟩, Or.inl ?_, ?_⟩
    · rw [mem_ball_iff]; omega
    · rw [mem_edges]; unfold adj; dsimp only; omega
    · simp only [height]; omega

What this page does not claim

The theorem does not claim that locked domains correspond to physical objects or regions in spacetime. It does not claim that the bound is tight in two or three dimensions, only that it holds as an inequality. It does not claim that the engine's coarsening process is the only way to produce such a bound.

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/Cosmology/InterfaceComponentBound.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: