Cosmology Refine Trigger T3 Law Derived Refinement

The refinement trigger

In a simulation that builds structure from coarse to fine, a refiner must decide when to split a coarse cell into finer ones. A naive approach sets a tolerance: split a cell when some measure of activity exceeds a chosen value. The Recognition Science framework proves that no such choice is needed. Its machine-checked library of formal theorems establishes that the only lossless rule is to refine exactly the cells that carry a forced internal posting, a distinction the cell itself demands. The threshold is structurally zero, read off the ledger, a discrete record of events, with no knob to choose.

The result, named t3_law_derived_refinement, is a theorem in the framework's library. It states three facts. First, reconstructing a cell while refining only a chosen set of blocks is lossless if and only if that set covers every block that carries an internal posting. Second, the law-given rule, descend iff a block carries an internal posting, is lossless and minimal: any lossless decision must contain it. Third, no positive threshold is safe. A forced posting can have arbitrarily small positive J-cost, the recognition cost J(x) = (x + x⁻¹)/2 - 1, so for any ε > 0 there is a cell with an active block of demand below ε that an ε-rule skips, breaking losslessness.

The theorem builds on a cell model with events, internal and cross postings, and a cost function. The cost of a distinction is zero only when the ratio is one, and positive otherwise. The proof that a forced posting can have arbitrarily small cost uses ratios near one, where the cost approaches zero while remaining positive. This is why the zero threshold is unique: it is the only one that never misses a forced distinction.

Within the framework, this result removes a free parameter from the scale-adaptive Cosmogenesis engine. The refinement trigger is not a modeling choice but a consequence of the recognition cost law. The theorem holds for every cell and block map, making it a general statement about the framework's reconstruction semantics, not a special case.

The theorem does not claim that any particular physical simulation is correct, nor does it say how to implement the refinement in practice. It establishes a logical constraint on lossless refinement within the framework's model. It also does not claim that the J-cost function is the only possible cost; that uniqueness is a separate theorem. The result here takes the cost as given and derives the trigger rule from it.

/-- **The law-given rule is lossless.** Descending exactly the active blocks
reconstructs the cell with zero loss. -/
theorem lossless_law (block : ℕ → ℕ) (m : Multiset Event) :
    reconstructUnder block (descendLaw block m) m = m := by
  rw [lossless_iff]
  intro e he
  exact Multiset.mem_map.mpr ⟨e, he, rfl⟩

/-- **The law-given rule is minimal.** Any lossless decision must descend every active
block; you cannot skip a block that carries a posting. -/
theorem descendLaw_necessary (block : ℕ → ℕ) (D : ℕ → Prop) [DecidablePred D]
    (m : Multiset Event) (h : reconstructUnder block D m = m) :
    ∀ b, descendLaw block m b → D b := by
  intro b hb
  obtain ⟨e, he, hbe⟩ := Multiset.mem_map.mp hb
  have hD := (lossless_iff block D m).mp h e he
  rwa [hbe] at hD

/-- **No positive threshold is safe.** For every `ε > 0` there is a cell with a single
internal posting whose demand is positive but below `ε`. The threshold rule "descend
iff demand exceeds `ε`" therefore skips that active block, and the reconstruction is
lossy. Only the zero threshold (descend iff a distinction is forced) is law-given. -/
theorem epsilon_unsafe (ε : ℝ) (hε : 0 < ε) :
    ∃ (m : Multiset Event) (b : ℕ),
      0 < demand b01 m b ∧ demand b01 m b < ε
      ∧ reconstructUnder b01 (fun c => ε < demand b01 m c) m ≠ m := by
  obtain ⟨r, hr1, hrpos, hrlt⟩ := jcost_arbitrarily_small_positive ε hε
  refine ⟨{(⟨0, 1, r⟩ : Event)}, 0, ?_, ?_, ?_⟩
  · -- demand b01 {⟨0,1,r⟩} 0 = Jcost r
    have hd : demand b01 {(⟨0, 1, r⟩ : Event)} 0 = Jcost r := by
      unfold demand internalOf
      simp [sameBlock, b01, Multiset.filter_singleton, cost_singleton]
    rw [hd]; exact hrpos
  · have hd : demand b01 {(⟨0, 1, r⟩ : Event)} 0 = Jcost r := by
      unfold demand internalOf
      simp [sameBlock, b01, Multiset.filter_singleton, cost_singleton]
    rw [hd]; exact hrlt
  · -- the epsilon-rule skips block 0, so reconstruction drops the only posting
    have hd : demand b01 {(⟨0, 1, r⟩ : Event)} 0 = Jcost r := by
      unfold demand internalOf
      simp [sameBlock, b01, Multiset.filter_singleton, cost_singleton]
    have hnotsel : ¬ (ε < demand b01 {(⟨0, 1, r⟩ : Event)} 0) := by rw [hd]; linarith
    -- reconstructUnder = crossOf (empty) + internal filtered by a false predicate = 0
    have hrecon : reconstructUnder b01 (fun c => ε < demand b01 {(⟨0, 1, r⟩ : Event)} c)
        {(⟨0, 1, r⟩ : Event)} = 0 := by
      unfold reconstructUnder crossOf internalOf
      simp [sameBlock, b01, Multiset.filter_singleton, hnotsel]
    rw [hrecon]
    -- 0 ≠ {⟨0,1,r⟩}
    intro hcontra
    have : Multiset.card (0 : Multiset Event) = Multiset.card {(⟨0, 1, r⟩ : Event)} :=
      congrArg Multiset.card hcontra
    simp at this

/-- **The law-given trigger model holds for every cell and block map.** -/
theorem lawGivenTrigger (block : ℕ → ℕ) (m : Multiset Event) : LawGivenTrigger block m where
  threshold_forced := fun D => lossless_iff block D m
  law_lossless := lossless_law block m
  law_minimal := fun D => descendLaw_necessary block D m

What this page does not claim

The theorem does not prove that any particular physical simulation is correct. The theorem does not claim that J-cost is the only possible cost function. The theorem does not specify an implementation strategy for refinement.

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