Cosmology Domain Coarsening Carried Cost Tracks Distinctions

The coarsest lossless representation

A long strip of cells, each holding a value. Some neighboring cells differ; others match. The strip might be a million cells long with just two blocks of identical values, or it might alternate values at every step. The question is how many pieces you need to describe the strip without losing information. The answer, proved as a formal theorem in the framework's machine-checked library of formal theorems, is that the number of pieces equals the number of boundaries between differing cells, plus one.

This is the declaration carried_cost_tracks_distinctions. It establishes that the cost of carrying a field, measured as the number of coarse super-regions the engine holds, is set entirely by the forced distinctions: the adjacent positions carrying different charges. A field of length N made of two constant blocks is carried as two super-regions, no matter how large N is. The theorem states this exactly: for every nonempty field, the number of maximal equal-charge runs equals the number of adjacent unequal pairs plus one. It also proves the carried count never exceeds the volume, with equality only when every adjacent pair differs.

The result matters because it makes precise a claim about cost in a recognition ledger, a discrete record of events. The engine's carried cost is sub-extensive in the volume: it tracks the interface, the active boundary between different charges, not the linearly growing world. When the distinctions grow slowly while the volume grows fast, the engine carries few super-regions. This is the formal core of that claim, and it is optimal: each distinction forces a new block, so no lossless cover can use fewer pieces.

What the declaration does not claim is equally important. It does not say how fast the distinctions grow. That is a separate result about cadence and open-system dynamics. It does not claim anything about the physical universe directly; it is a theorem about lists of values with decidable equality. It does not prove that the engine is efficient in practice, only that the carried count is bounded by the distinctions. And it does not say anything about the values themselves, only about their equality pattern.

/-- **The coarsest lossless representation has size = forced distinctions + 1.** For every nonempty
charge field, the number of coarse super-regions the engine carries (`runs`) is exactly the number of
forced distinctions (`boundaries`) plus one. The right side depends only on the distinctions, not on
the run lengths, so two constant blocks of any size are carried as two super-regions. -/
theorem runs_eq (a : α) (l : List α) : runs (a :: l) = boundaries (a :: l) + 1 := by
  induction l generalizing a with
  | nil => simp
  | cons b l ih =>
    show (if a = b then 0 else 1) + runs (b :: l)
        = ((if a = b then 0 else 1) + boundaries (b :: l)) + 1
    rw [ih b]
    by_cases h : a = b
    · simp only [if_pos h]; omega
    · simp only [if_neg h]; omega

/-- The carried super-region count never exceeds the volume: a field of length `n+1` is carried as at
most `n+1` super-regions, with equality only when every adjacent pair is a distinction. -/
theorem runs_le_length (l : List α) : runs l ≤ l.length := by
  match l with
  | [] => simp
  | [a] => simp
  | a :: b :: t =>
    have ih := runs_le_length (b :: t)
    show (if a = b then 0 else 1) + runs (b :: t) ≤ (a :: b :: t).length
    rw [show (a :: b :: t).length = (b :: t).length + 1 from rfl]
    by_cases h : a = b
    · rw [if_pos h]; omega
    · rw [if_neg h]; omega

/-- **The carried cost is bounded by the distinctions, independent of domain sizes.** Restated from
`runs_eq`: the number of coarse super-regions equals the number of forced distinctions plus one. So
when the distinctions (the recognition-active interface) grow sub-extensively while the volume grows
linearly, the engine carries a sub-extensive number of super-regions. -/
theorem carried_cost_tracks_distinctions (a : α) (l : List α) :
    runs (a :: l) = boundaries (a :: l) + 1 ∧ runs (a :: l) ≤ (a :: l).length :=
  ⟨runs_eq a l, runs_le_length (a :: l)⟩

What this page does not claim

The theorem does not specify the growth rate of the distinctions over time. It does not make any claim about the physical universe, only about lists of values. It does not prove the engine is efficient in practice, only that the carried count is bounded by the distinctions.

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