Foundation Primitive Recognition Calculus Prccost On Field Jcost Iterate Mem T

The countable ledger

The declaration jcost_iterate_mem_T is a theorem in the framework's machine-checked library of formal theorems. It states that if a real number belongs to a certain countable subfield T of the real numbers, then applying the canonical cost function Cost.Jcost any finite number of times keeps the result inside T. The cost function is defined as J(x) = (x + x⁻¹)/2 − 1. The theorem is proved by induction: the base case is the hypothesis that the starting number is in T, and the induction step uses the fact that T is closed under addition, division, and the other field operations.

The substance is that the cost dynamics stay countable. The entire forward orbit of any T-element under repeated application of the cost function remains in T. Iterating recognition cost never escapes the countable field. The theorem needs no positivity or nonzero hypothesis because T is a subfield where inversion is total, with 0⁻¹ defined as 0. The proof is a short induction in the library, anchored by the companion theorem jcost_mem_T.

In Recognition Science, this closure is part of a larger claim. The framework proves there is one countable subfield T of the real numbers, strictly below the continuum, that is simultaneously closed under field operations, the exponential function, the logarithm, and the cost function, and that contains the seeds π and φ along with the derived constants e and α⁻¹. The cost function, the operations the constants are built from, and the constants themselves therefore share a single countable carrier. The headline is that a single primitive for physics runs on the countable field fed by the δ cost, and nowhere in the cost-and-constants loop is the uncountable continuum required.

What the theorem does not claim is just as precise. It does not assert that the cost function is bounded, convergent, or that any particular orbit reaches a fixed point. It only establishes membership in T for every finite iterate. It also does not claim that T is the smallest such field, nor that the closure property uniquely characterizes T. The theorem is a structural closure result, not a dynamical one. It tells you where the iterates live, not what they do there.

/-- **The cost dynamics stay countable.** The entire forward orbit of any
`T`-element under repeated application of the cost function remains in `T`. Iterating
recognition cost never escapes the countable field. -/
theorem jcost_iterate_mem_T {x : ℝ} (hx : x ∈ T) (n : ℕ) :
    (Cost.Jcost^[n] x) ∈ T := by
  induction n with
  | zero => simpa using hx
  | succ k ih =>
      rw [Function.iterate_succ_apply']
      exact jcost_mem_T ih

/-- **The cost dynamics stay countable.** The entire forward orbit of any
`T`-element under repeated application of the cost function remains in `T`. Iterating
recognition cost never escapes the countable field. -/
theorem jcost_iterate_mem_T {x : ℝ} (hx : x ∈ T) (n : ℕ) :
    (Cost.Jcost^[n] x) ∈ T := by
  induction n with
  | zero => simpa using hx
  | succ k ih =>
      rw [Function.iterate_succ_apply']
      exact jcost_mem_T ih

/-- The canonical cost `Cost.Jcost x = (x + x⁻¹)/2 − 1` maps the countable field `T`
into itself: it is a field expression, and `T` is a subfield (closed under `+`, `⁻¹`,
`/`, `−`, and containing `1` and `2`). No positivity or nonzero hypothesis is needed,
because `Subfield` inversion is total (`0⁻¹ = 0`). -/
theorem jcost_mem_T {x : ℝ} (hx : x ∈ T) : Cost.Jcost x ∈ T := by
  have h2 : (2 : ℝ) ∈ T := by exact_mod_cast natCast_mem T 2
  unfold Cost.Jcost
  exact sub_mem (div_mem (add_mem hx (inv_mem hx)) h2) (one_mem _)

/-- **The unified headline (Items 1 + 3).** There is ONE countable subfield `T` of ℝ,
strictly below the continuum, that simultaneously
  * is closed under field operations, `exp`, and `log`;
  * is closed under the canonical recognition cost `Cost.Jcost`;
  * contains the seeds π and φ and the derived constants `e` and `α⁻¹`.
The cost function, the operations the constants are built from, and the constants
themselves therefore share a single countable carrier. "A single primitive for
physics runs on the countable field fed by the δ cost" is literally true: nowhere in
the cost-and-constants loop is the uncountable continuum required. -/
theorem cost_and_constants_share_one_countable_field :
    ∃ K : Subfield ℝ,
      (K : Set ℝ).Countable
        ∧ (∀ x ∈ K, Real.exp x ∈ K)
        ∧ (∀ x ∈ K, Real.log x ∈ K)
        ∧ (∀ x ∈ K, Cost.Jcost x ∈ K)
        ∧ Real.pi ∈ K
        ∧ Real.goldenRatio ∈ K
        ∧ Real.exp 1 ∈ K
        ∧ MinimalField.alphaInv ∈ K
        ∧ (K : Set ℝ) ≠ Set.univ :=
  ⟨T, T_countable,
    fun _ hx => T_exp_closed hx,
    fun _ hx => T_log_closed hx,
    fun _ hx => jcost_mem_T hx,
    pi_mem_T, phi_mem_T, e_mem_T, alphaInv_mem_T, T_proper⟩

What this page does not claim

The theorem does not claim that any orbit converges or reaches a fixed point. The theorem does not claim that T is the unique or smallest countable field with these closure properties. The theorem does not claim that the cost function is bounded on T.

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/Foundation/PrimitiveRecognitionCalculus/PRCCostOnField.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: