Cosmology Rung Coarsen T1 Coarsening Exact

The exact coarsening theorem

Coarsening is the act of grouping fine details into larger blocks. In cosmology simulations, a grid of fine cells is often merged into coarser cells to save memory. The theorem t1_coarsening_exact, proved in the Recognition Science framework's machine-checked library of formal theorems, establishes that this merging operation is exact: no information is lost when a fine record is grouped into a coarse one, and every conserved quantity is preserved.

The setting is a ledger, a discrete record of events. Each event is a directed posting from a source site to a target site, carrying a positive ratio. Coarsening groups sites into blocks. Events whose endpoints land in the same block are absorbed into that block's summary; events whose endpoints land in different blocks are promoted to coarse events between the blocks, with their ratios unchanged. The theorem proves that refining back, reassembling the coarse events and the block-internal events, returns exactly the original multiset of events. This round-trip identity is the core content.

Because the round-trip returns the identical multiset, any function of the multiset is unchanged. The theorem states this generically: event count, total cost for any ratio weight, the log-ratio spectrum, and net flow at every site are all preserved. It also proves that the coarse cost plus the internal cost partitions the fine cost exactly. The cost is stated for an arbitrary ratio weight, so it holds for the framework's recognition cost J and any other weight function.

The theorem also covers idle cells. A cell with no internal events keeps an empty refinement, so refinement memory scales with recognition activity, not with the number of sites. The proof is fully machine-checked with zero axioms beyond the standard three, and zero sorry.

The theorem does not claim that coarsening is lossless in any physical sense beyond the formal model. It does not claim that the coarsened ledger itself is identical to the fine ledger, only that the round-trip through refinement recovers the original. It does not claim that the framework's recognition cost J is the only valid cost, since the theorem holds for arbitrary ratio weights. It does not claim that the coarsening procedure is computationally efficient, only that it is exact in the formal sense.

/-- **T-1 round-trip.** Coarsening then refining returns the cell unchanged. The coarse
representation is lossless: it carries everything reality has determined with zero loss. -/
theorem roundtrip_eq (block : ℕ → ℕ) (m : Multiset Event) :
    roundtrip block m = m := by
  unfold roundtrip refineCell
  exact cross_add_internal block m

/-- Because the round-trip returns the identical multiset, ANY functional of the cell
is preserved. Sigma, totals, cost, and spectrum are all instances of this. -/
theorem conserved {X : Type*} (F : Multiset Event → X) (block : ℕ → ℕ) (m : Multiset Event) :
    F (roundtrip block m) = F m :=
  congrArg F (roundtrip_eq block m)

/-- **Cost partition.** Coarse cross-block cost plus block-internal cost equals the fine
cost. Cost is split exactly across the rung change, with no leakage. -/
theorem cost_partition (wr : ℝ → ℝ) (block : ℕ → ℕ) (m : Multiset Event) :
    cost wr (coarseLedger block m) + cost wr (internalOf block m) = cost wr m := by
  rw [cost_coarse_eq_cross, ← cost_add, cross_add_internal]

/-- **T-1 headline.** Coarsening one phi-rung and refining back is the identity, so a
region carried coarse loses nothing reality has determined: the event count, the total
cost, the log-ratio spectrum, and the (zero) net flow all come back identical, and the
cost partitions exactly across the rung change. This is the theorem that earns the word
"literal" for the scale-adaptive engine. -/
theorem t1_coarsening_exact (block : ℕ → ℕ) (m : Multiset Event) (wr : ℝ → ℝ) :
    (roundtrip block m = m)
    ∧ (count (roundtrip block m) = count m)
    ∧ (cost wr (roundtrip block m) = cost wr m)
    ∧ (spectrum (roundtrip block m) = spectrum m)
    ∧ (cost wr (coarseLedger block m) + cost wr (internalOf block m) = cost wr m)
    ∧ (∀ a, netFlow (roundtrip block m) a = netFlow m a) :=
  ⟨roundtrip_eq block m, count_preserved block m, cost_preserved wr block m,
   spectrum_preserved block m, cost_partition wr block m, sigma_preserved block m⟩

/-- **Idle carries nothing.** A cell with no internal events keeps an empty refinement,
so the round-trip is just the (already coarse) cross part, and refinement memory scales
with recognition activity rather than with the number of sites. -/
theorem idle_carries_nothing (block : ℕ → ℕ) (m : Multiset Event)
    (hidle : internalOf block m = 0) :
    roundtrip block m = crossOf block m := by
  unfold roundtrip refineCell
  rw [hidle, add_zero]

What this page does not claim

The coarsened ledger itself is identical to the fine ledger, only the round-trip through refinement is. The framework's recognition cost J is the only cost for which the theorem holds. The coarsening procedure is computationally efficient, only that it is formally exact.

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