Cost Geometric Root No Cost Floor Under Refinement

Refinement and the cost floor

In the Recognition Science framework, a ledger, a discrete record of recognition events, assigns a cost to each distinction it records. The declaration no_cost_floor_under_refinement is a proved theorem about what happens when you subdivide one distinction into many smaller steps. It states that for any fixed distinction of size ε and any positive cost floor c, there exists a number of subdivisions n such that the total cost of n steps, n times the cost of one step of size ε/n, is less than c. In plain terms, the theorem proves that refinement can always make the total cost of a chain arbitrarily small, so no positive cost floor can survive infinite subdivision.

The proof rests on an exact identity for the cost function J(x) = (x-1)^2/(2x), which the framework derives from five plain conditions. The key bound is that n times J(exp(ε/n)) is at most ε² cosh(ε) / (2n), a quantity that tends to zero as n grows. Because the cost of each micro-step shrinks faster than the number of steps grows, the total cost collapses to zero. The theorem is kernel-checked in the framework's machine-checked library of formal theorems, with no framework-specific axioms.

The consequence is a forced discreteness: a ledger with an irreducible cost floor c > 0 cannot permit refinement past a bound of roughly n ≤ ε² cosh(ε) / (2c). This is how the framework derives the tick, its basic unit of recognition, as a regularizer rather than an assumption. The theorem does not claim that refinement is impossible, only that a positive floor makes unbounded refinement inconsistent. It also does not claim that any particular ledger has a cost floor; it proves a conditional statement about what follows if one exists.

/-- No positive cost floor survives refinement: for any `c > 0`, some
refinement level prices the `ε`-chain below `c`. -/
theorem no_cost_floor_under_refinement {ε : ℝ} {c : ℝ} (hc : 0 < c) :
    ∃ n : ℕ, (n : ℝ) * Jcost (Real.exp (ε / n)) < c := by
  have ht := jcost_subdivision_trivializes ε
  have hev : ∀ᶠ n : ℕ in Filter.atTop, (n : ℝ) * Jcost (Real.exp (ε / n)) < c :=
    ht.eventually (eventually_lt_nhds hc)
  exact hev.exists

/-- Per-refinement cost bound: splitting a distinction of log-size `ε` into
`n` equal micro-steps costs at most `ε²·cosh ε/(2n)`. -/
theorem subdivision_cost_bound (ε : ℝ) (n : ℕ) :
    (n : ℝ) * Jcost (Real.exp (ε / n))
      ≤ ε ^ 2 * Real.cosh ε / (2 * (n : ℝ)) := by
  rcases Nat.eq_zero_or_pos n with rfl | hn
  · simp [Jcost, Real.exp_zero, div_zero]
  · have hn' : (0 : ℝ) < (n : ℝ) := by exact_mod_cast hn
    have ht : Jcost (Real.exp (ε / n)) = Real.cosh (ε / n) - 1 := by
      have h := FunctionalEquation.Jcost_G_eq_cosh_sub_one (ε / (n : ℝ))
      simpa [FunctionalEquation.G] using h
    rw [ht]
    have hb := cosh_sub_one_le (ε / (n : ℝ))
    have hcosh_le : Real.cosh (ε / (n : ℝ)) ≤ Real.cosh ε := by
      have h1 : |ε / (n : ℝ)| ≤ |ε| := by
        rw [abs_div, abs_of_pos hn']
        exact div_le_self (abs_nonneg ε) (by exact_mod_cast hn)
      calc Real.cosh (ε / (n : ℝ)) = Real.cosh |ε / (n : ℝ)| := (Real.cosh_abs _).symm
        _ ≤ Real.cosh |ε| := cosh_mono_on_nonneg (abs_nonneg _) h1
        _ = Real.cosh ε := Real.cosh_abs _
    calc (n : ℝ) * (Real.cosh (ε / n) - 1)
        ≤ (n : ℝ) * ((ε / n) ^ 2 / 2 * Real.cosh (ε / n)) :=
          mul_le_mul_of_nonneg_left hb (le_of_lt hn')
      _ = ε ^ 2 / (2 * (n : ℝ)) * Real.cosh (ε / n) := by
          field_simp [hn'.ne']
      _ ≤ ε ^ 2 / (2 * (n : ℝ)) * Real.cosh ε := by
          apply mul_le_mul_of_nonneg_left hcosh_le
          positivity
      _ = ε ^ 2 * Real.cosh ε / (2 * (n : ℝ)) := by ring

/-- Positive reading: a ledger sustaining floor `c > 0` at refinement level
`n` must satisfy `n ≤ ε²·cosh ε/(2c)`; the tick is a regularizer forced by
cost-nontriviality, with an explicit bound. -/
theorem tick_bound {ε : ℝ} {c : ℝ} (hc : 0 < c) {n : ℕ} (hn : 0 < n)
    (hfloor : c ≤ (n : ℝ) * Jcost (Real.exp (ε / n))) :
    (n : ℝ) ≤ ε ^ 2 * Real.cosh ε / (2 * c) := by
  have hn' : (0 : ℝ) < (n : ℝ) := by exact_mod_cast hn
  have h1 : c ≤ ε ^ 2 * Real.cosh ε / (2 * (n : ℝ)) :=
    le_trans hfloor (subdivision_cost_bound ε n)
  rw [le_div_iff₀ (by positivity : (0 : ℝ) < 2 * (n : ℝ))] at h1
  rw [le_div_iff₀ (mul_pos (by norm_num : (0 : ℝ) < 2) hc)]
  have e : c * (2 * (n : ℝ)) = (n : ℝ) * (2 * c) := by ring
  linarith [h1, e]

What this page does not claim

The theorem does not prove that any actual ledger has a positive cost floor. It does not claim that refinement is physically impossible, only inconsistent with a floor. It does not derive the closure condition that would make the golden ratio forced.

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/Cost/GeometricRoot.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: