Cosmology Domain Coarsening Runs

The coarsest lossless representation

In computer science, a run is a maximal sequence of identical values. The list [0, 0, 1, 1, 1, 0] has three runs: two zeros, three ones, and one zero. The recognition framework, which models reality as a discrete record of events, uses runs to measure the cost of carrying a field of values. Its machine-checked library of formal theorems proves a simple identity: for any nonempty list, the number of runs equals the number of adjacent unequal pairs, plus one. In the example, there are two adjacent unequal pairs (between the first 0 and the 1, and between the last 1 and the 0), so the formula gives 2 + 1 = 3 runs.

The theorem, named runs_eq, holds for every nonempty list of any type with decidable equality. Its proof is a short induction in the framework's library. The right side of the identity depends only on the boundaries, never on the lengths of the runs themselves. A field of length one million made of two constant blocks is carried as exactly two super-regions, no matter how large each block is. This is the formal core of a cost that is sub-extensive in the volume: the carried count tracks the interface, not the linearly growing world.

The framework models each maximal equal-charge run as a single coarse super-region, with zero internal cost because all members are equal. The theorem also proves this representation is optimal: the number of runs is the minimum number of constant contiguous blocks any lossless cover can use, since each distinction forces a new block. A companion theorem, runs_le_length, shows the carried count never exceeds the list length, with equality only when every adjacent pair is a distinction.

In Recognition Science, this result is the Phase-12 core behind a script that coarsens domains during cosmological simulation. The framework claims the engine's carried cost is set by forced distinctions, not by volume. It does not claim that the physical universe actually operates this way, nor that the dynamics of those distinctions are derived. The theorem is a statement about lists and counting, not about the cosmos itself.

/-- **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 prove that the physical universe is actually a discrete list of charges. The theorem does not derive the dynamics of how distinctions grow or shrink over time. The theorem does not claim that the framework's cosmological model is empirically verified.

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: