Cosmology Domain Coarsening

Domain coarsening

Domain coarsening is a compression strategy for any system that tracks a sequence of values. The idea is to group adjacent positions that carry the same value into a single block, called a locked domain, a maximal run of equal charge with no internal distinction. Instead of remembering every position, the system remembers only the boundaries where the value changes. For a field of length N made of two constant blocks, this reduces the representation from N items to just two super-regions, no matter how large N is.

The classical picture comes from run-length encoding, a standard data compression technique. In 1967, Solomon W. Golomb described a form of it for transmitting information efficiently. The same principle appears across science: a crystal is described by its unit cell and defects, not by every atom; a digital image compresses well when large areas share a color. The key question is always the same: how much information is genuinely forced by the structure, and how much is redundant repetition?

In Recognition Science, the framework models the charge field along a ladder as a list of values. A forced distinction is an adjacent pair carrying different charges. The module proves a theorem about the coarsest lossless representation: for every nonempty field, the number of coarse super-regions carried equals the number of forced distinctions plus one. The formal statement is runs (a :: l) = boundaries (a :: l) + 1. The right side depends only on the distinctions, never on the run lengths. This is optimal: each distinction forces a new block, so no lossless cover can use fewer blocks.

This result is proved in a machine-checked library of formal theorems. The proof is a simple induction on the list, with no axioms beyond the standard three. The theorem also shows the carried super-region count never exceeds the volume, with equality only when every adjacent pair differs. When the number of distinctions grows slowly while the volume grows linearly, the engine carries a sub-extensive number of super-regions. The cost tracks the interface, not the world.

The consequence is practical. If the recognition-active interface grows diffusively while the world grows linearly, the engine's carried cost stays far below the volume. A field of length one million with two constant blocks is carried as two super-regions. This is what makes large-scale simulation tractable in the framework: the representation adapts to the structure, not the raw size.

/-- **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

What this page does not claim

The theorem does not specify the dynamics that make distinctions grow diffusively. The module does not prove that any particular physical field follows this model. The result applies to the list model, not to continuous fields without discretization.

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: