Encyclopedia Cosmology Cosmology Refine Trigger Law Given Trigger

ARTICLE 4 claims 4 theorems

Cosmology Refine Trigger Law Given Trigger

A machine-checked theorem shows why a cosmology simulation's refinement threshold must be exactly zero, with no free parameter to tune.

Verify this page

The refinement trigger

In a simulation that builds a universe from coarse to fine detail, something must decide when to refine a region. The naive answer is a tolerance: refine when some measure of error exceeds a chosen value ε. The Recognition Science framework's ledger, a discrete record of recognition events, removes that choice. Its machine-checked library of formal theorems proves that the only lossless refinement rule is to descend exactly where a distinction is forced, making the threshold structurally zero.

The framework models each cell as a collection of events, each with a recognition cost, the price the ledger pays to register a distinction. The cost function is J(x) = (x + x⁻¹)/2 − 1, which is zero when the ratio x equals one and positive otherwise. A block carries an internal posting when it holds an event whose ratio differs from one. The theorem lawGivenTrigger proves three facts about any cell and any block map: reconstruction is lossless if and only if the decision covers every block with an internal posting; the rule "descend iff a posting is forced" is both lossless and minimal; and no positive threshold is safe.

The third fact is the sharp one. For any ε > 0, there exists a cell with a single internal posting whose demand is positive but below ε. A rule that descends only when demand exceeds ε skips that active block, and the reconstruction is lossy. Because a forced distinction can have arbitrarily small positive cost, any ε-rule breaks losslessness. Zero is the unique law-given threshold, read off the ledger, with no knob to choose.

The theorem does not claim that this refinement rule describes any particular physical process. It establishes a formal property of a model: within the framework's cell and event structure, lossless reconstruction forces the descent set. The step from this formal result to a claim about actual cosmology, such as where galaxies form, remains a modeling choice, not a proved consequence.

THEOREM lawGivenTrigger · IndisputableMonolith/Cosmology/RefineTrigger.lean
lawGivenTrigger · IndisputableMonolith/Cosmology/RefineTrigger.lean:213 
/-- **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
THEOREM lossless_iff · IndisputableMonolith/Cosmology/RefineTrigger.lean
lossless_iff · IndisputableMonolith/Cosmology/RefineTrigger.lean:66 
/-- **The descent set is forced.** Refining only the blocks in `D` is lossless if and
only if `D` covers every block that carries an internal posting. There is no tunable
slack: lossless reconstruction requires descending exactly the active blocks. -/
theorem lossless_iff (block : ℕ → ℕ) (D : ℕ → Prop) [DecidablePred D] (m : Multiset Event) :
    reconstructUnder block D m = m ↔ ∀ e ∈ internalOf block m, D (block e.source) := by
  unfold reconstructUnder
  rw [← Multiset.filter_eq_self]
  constructor
  · intro h
    have h2 : crossOf block m + (internalOf block m).filter (fun e => D (block e.source))
            = crossOf block m + internalOf block m := by
      rw [h]; exact (cross_add_internal block m).symm
    exact add_left_cancel h2
  · intro h
    rw [h]
    exact cross_add_internal block m
THEOREM lossless_law · descendLaw_necessary · IndisputableMonolith/Cosmology/RefineTrigger.lean
lossless_law · IndisputableMonolith/Cosmology/RefineTrigger.lean:90 
/-- **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⟩
descendLaw_necessary · IndisputableMonolith/Cosmology/RefineTrigger.lean:98 
/-- **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
THEOREM epsilon_unsafe · IndisputableMonolith/Cosmology/RefineTrigger.lean
epsilon_unsafe · IndisputableMonolith/Cosmology/RefineTrigger.lean:159 
/-- **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

What this page does not claim

The theorem does not claim that any actual cosmological process follows this refinement rule. It does not claim that the framework derives the fine-structure constant or any specific coupling value. It does not claim that a positive threshold is ever safe for any cost function other than the specific J-cost.

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:

MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND