Cosmology Domain Coarsening2 D Rowwise Cost Eq

The row-wise cost identity

In a two-dimensional grid, imagine compressing each row independently into contiguous blocks of equal charge, a process called coarsening. The declaration rowwise_cost_eq proves a clean identity: the total number of blocks across all rows equals the total number of horizontal boundaries between differing charges plus the number of rows. Written in symbols, for any grid with no empty rows, rowCost rows = rowInterface rows + rows.length. This is the exact two-dimensional analogue of the one-dimensional law that a line with b boundaries splits into b + 1 runs, summed across each row.

The identity is a theorem in the framework's machine-checked library of formal theorems, proved with no gaps and no extra axioms beyond the standard logical ones. Its force is that the cost of carrying coarse regions depends only on the interface and the row count, never on the row widths or the total area. A wide grid and a narrow grid with the same horizontal boundaries and same number of rows carry exactly the same number of super-regions. This is a structural fact about separable, row-by-row coarsening, not an empirical observation.

The true two-dimensional component coarsening also merges blocks vertically, so it never carries more regions than the row-wise version. Consequently, the identity provides a fully proved upper bound on the real 2D cost in terms of horizontal interface and row count. The framework's broader work bound then applies, so both the state and the computational work of the 2D engine are bounded by the interface, not the area. This is the payoff: in this model, the cost of recognizing structure in a plane scales with its perimeter, not its surface.

What the declaration does not claim is just as precise. It does not prove that the true 2D component count equals the row-wise count; that remains an inequality, with the exact count still open. It does not establish anything about vertical interfaces or diagonal structure, which are simply not part of the separable model. And it does not assert that real physical domains must coarsen this way; it proves an identity about a specific definitional choice, leaving the physical bridge to recognition as a separate, open question.

/-- **The separable coarsening cost = horizontal interface + number of rows.** For any 2D grid whose rows are
all nonempty, coarsening each row independently carries exactly (the total horizontal interface) plus (the
number of rows) super-regions. This is the exact per-axis generalization of the 1D law `runs = boundaries + 1`
summed over rows, and it depends only on the interface and the row count, never on the row widths (the area).
The true 2D component coarsening merges vertically as well, so it carries at most this many super-regions. -/
theorem rowwise_cost_eq (rows : List (List α)) (h : ∀ r ∈ rows, r ≠ []) :
    rowCost rows = rowInterface rows + rows.length := by
  induction rows with
  | nil => simp
  | cons r rs ih =>
    rw [rowCost_cons, rowInterface_cons, runs_eq_of_ne_nil r (h r (List.mem_cons.mpr (Or.inl rfl)))]
    rw [ih (fun row hrow => h row (List.mem_cons.mpr (Or.inr hrow)))]
    simp [List.length_cons]
    ring

/-- The carried cost is bounded by the interface, not the area: the separable coarsening cost is
`rowInterface + rows.length`, with no dependence on the row widths. -/
theorem rowwise_cost_independent_of_width (rows : List (List α)) (h : ∀ r ∈ rows, r ≠ []) :
    rowCost rows = rowInterface rows + rows.length :=
  rowwise_cost_eq rows h

/-- **The separable coarsening cost = horizontal interface + number of rows.** For any 2D grid whose rows are
all nonempty, coarsening each row independently carries exactly (the total horizontal interface) plus (the
number of rows) super-regions. This is the exact per-axis generalization of the 1D law `runs = boundaries + 1`
summed over rows, and it depends only on the interface and the row count, never on the row widths (the area).
The true 2D component coarsening merges vertically as well, so it carries at most this many super-regions. -/
theorem rowwise_cost_eq (rows : List (List α)) (h : ∀ r ∈ rows, r ≠ []) :
    rowCost rows = rowInterface rows + rows.length := by
  induction rows with
  | nil => simp
  | cons r rs ih =>
    rw [rowCost_cons, rowInterface_cons, runs_eq_of_ne_nil r (h r (List.mem_cons.mpr (Or.inl rfl)))]
    rw [ih (fun row hrow => h row (List.mem_cons.mpr (Or.inr hrow)))]
    simp [List.length_cons]
    ring

What this page does not claim

The exact 2D component count equals the row-wise count. Vertical interfaces are included in the separable model. Real physical domains must coarsen row by row.

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