Cosmology Domain Coarsening Boundaries

The coarsest representation

Domain coarsening is a compression strategy: replace a long, finely detailed sequence with the shortest list of uniform blocks that still captures every change. Given a sequence of values, a boundary is any place where two neighboring values differ. A maximal run is a block of equal values that cannot be extended. The number of maximal runs is always exactly one more than the number of boundaries, for any nonempty sequence. This identity holds for every finite list, regardless of the values themselves or how long each run is. A sequence of a million identical entries has zero boundaries and is represented as one run; a sequence alternating between two values has many boundaries and needs many runs.

This elementary fact about lists is the content of a theorem named runs_eq in the Recognition Science framework's machine-checked library of formal theorems. The framework models a physical field as a discrete ledger, a record of events at distinct positions, where each position carries a charge value. The theorem proves that the number of coarse super-regions the framework's engine carries is exactly the number of forced distinctions plus one. A forced distinction is a boundary where the charge changes; within a uniform block there is no distinction, so the whole block is carried as a single item. The carried cost therefore tracks the active interface between different regions, not the total volume of the field.

In Recognition Science, this result is the formal core of a claim about computational cost: the engine's cost is sub-extensive in the volume. The theorem itself is conditional on the model, which is a definitional choice about how fields are represented. It does not by itself establish any physical law. The framework combines this theorem with separate results about how boundaries change over time and how uniform regions grow, but those dynamics are not part of the coarsening theorem. The theorem states a relationship between two counts on a list; it says nothing about what the values mean or how they evolve.

The practical consequence is a bound on representation size that is independent of domain sizes. If a field consists of two large uniform blocks, the engine carries exactly two super-regions no matter how large those blocks are. The theorem also proves that the number of runs never exceeds the length of the list, with equality only when every adjacent pair is a boundary. This gives a clean sense in which the coarsest lossless representation is optimal: no lossless cover can use fewer constant blocks than the number of runs, because each boundary forces a new block.

/-- **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 establish any physical law about how fields evolve. The theorem does not claim that the framework's model of charge fields is the correct physical description. The theorem does not prove that the engine cost is always sub-extensive; that requires additional dynamical assumptions.

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: