Cost Geometric Root Jcost Subdivision Trivializes

The refinement limit

In the Recognition Science framework, a ledger is a discrete record of recognition events, and each event carries a cost: a positive number measuring how much that recognition deviates from a perfect match. The cost function J(x) is defined for positive ratios x, and its exact form is J(x) = (x-1)^2/(2x). This is a proved theorem in the framework's machine-checked library of formal theorems, not an assumption.

The declaration jcost_subdivision_trivializes concerns what happens when you take a fixed distinction, say a ratio of e to 1, and split it into n equal micro-steps. The theorem proves that as n grows, the total cost of all n steps, n times J(e^(ε/n)), tends to zero. In plain terms, splitting a fixed distinction into arbitrarily fine micro-steps makes the total cost arbitrarily small. The proof uses the bound n · J(e^(ε/n)) ≤ ε² · cosh ε / (2n), which visibly shrinks as n grows.

The consequence is structural. If a ledger could be refined without limit, any positive cost floor would be destroyed: for any proposed floor c > 0, there exists a large enough n such that the total cost drops below c. Therefore a ledger with an irreducible cost floor c > 0 must forbid refinement past a finite bound, n ≤ ε² · cosh ε / (2c). Discreteness is not assumed; it is forced by the cost law itself. This result is one leg in the chain that leads to the golden ratio and the eight-tick cycle, but it does not by itself complete that chain.

The theorem does not claim that the golden ratio follows from this result alone. The assembly to φ requires an additional closure hypothesis, that a geometric scale sequence satisfies a self-similarity condition, which remains an assumed premise in the library, not a proved consequence. The theorem also does not claim that any actual physical ledger is discrete; it proves a conditional statement about any ledger that obeys the cost law and has a positive cost floor.

/-- The chordal form: `J(x) = (x-1)^2/(2x)`. On the upper half-plane this is
`cosh d(i, ix) - 1` with `d` the hyperbolic distance, via
`cosh d(z,w) - 1 = |z-w|^2/(2 Im z Im w)`. The geometric reading is the
docstring; the arithmetic content is this identity. -/
theorem jcost_eq_chordal {x : ℝ} (hx : 0 < x) :
    Jcost x = (x - 1) ^ 2 / (2 * x) := by
  unfold Jcost
  field_simp [hx.ne']
  ring

/-- **Subdivision trivializes.** The total cost of `n` equal micro-steps
spanning a fixed distinction of log-size `ε` tends to zero:
`n · J(e^{ε/n}) → 0`. A continuum (infinitely refinable) ledger prices every
finite chain arbitrarily low. -/
theorem jcost_subdivision_trivializes (ε : ℝ) :
    Filter.Tendsto (fun n : ℕ => (n : ℝ) * Jcost (Real.exp (ε / n)))
      Filter.atTop (nhds 0) := by
  have hC : Filter.Tendsto (fun n : ℕ => ε ^ 2 * Real.cosh ε / (2 * (n : ℝ)))
      Filter.atTop (nhds 0) := by
    have h := tendsto_const_div_atTop_nhds_zero_nat (ε ^ 2 * Real.cosh ε / 2)
    exact h.congr (fun n => by rw [div_div])
  exact squeeze_zero (subdivision_cost_nonneg ε) (subdivision_cost_bound ε) hC

/-- 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 golden ratio follows from subdivision trivialization alone. The closure hypothesis for the geometric ladder is proved. Any actual ledger in the physical world is discrete.

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: