Encyclopedia Foundation Foundation Recurrence Bridge

ARTICLE 4 claims 4 theorems

Foundation Recurrence Bridge

A single theorem shows when a ladder of values must follow the Fibonacci rule, and the plastic constant marks the exact boundary.

The recurrence bridge

A ladder, in the framework's language, is a sequence of ever-larger positive numbers, each rung built from the ones below it. The question behind the recurrence bridge is plain: when must such a ladder obey the adjacent recurrence, where each rung equals the sum of the two below it, s(n+2) = s(n+1) + s(n)? That recurrence is famous because its ratios converge to the golden ratio φ ≈ 1.618. The framework had already proved that any positive sequence obeying this recurrence has ratios tending to φ. The bridge theorem supplies the missing half: it states the exact conditions under which the recurrence itself is forced.

The forcing conditions are two. First, a ratio floor: each step up the ladder must multiply size by at least ρ, with ρ³ > ρ + 1. The number ρ here is the plastic constant, about 1.3247, the real root of x³ = x + 1. Second, adjacent closure: the composition of any two adjacent rungs must itself be a rung. Under these two premises, the framework's machine-checked library of formal theorems proves that the adjacent recurrence must hold. The proof is a short inequality argument: the composition s(n) + s(n+1) is a rung above s(n+1), and the ratio floor makes it too small to reach rung n+3, so it must be exactly rung n+2.

The plastic constant is not an arbitrary cutoff; it is the sharp threshold. The same library proves a sharpness theorem: at ρ = plastic, where ρ³ = ρ + 1 exactly, a ladder exists that satisfies the ratio floor with equality, satisfies adjacent closure, yet violates the recurrence. At that boundary, the composition lands at rung n+3, skipping n+2. The strict inequality in the bridge theorem cannot be relaxed to ≥. This is a precise, proved boundary, not a heuristic one.

The module also refutes a tempting shortcut. One might hope that closure plus generation plus an absolute minimum step would force the recurrence. The counterexample is the integer ladder s(n) = n+1: it is strictly increasing, every rung is the sum of two smaller rungs, the composition is ordinary addition, and each step increases by exactly 1. Yet the recurrence fails, and no ratio floor above 1 exists. This shows the ratio floor is genuine extra content, exactly what the integer ladder lacks.

In Recognition Science, the bridge matters because the golden ratio φ is not assumed; it is derived. The framework models a ledger of recognition events where each new rung is posted from adjacent ones, and the cost of recognition is forced by a proved uniqueness theorem. The recurrence bridge names the two physical premises that carry the derivation: a per-rung cost floor above the plastic threshold, and the completeness of the posting operation for adjacent rungs. The framework's library proves that these premises force the recurrence, hence force the golden ratio as the asymptotic inter-level ratio. Whether the framework's deeper machinery actually delivers that per-rung cost floor remains an open question, not a proved result.

THEOREM recurrence_of_floor_above_plastic · IndisputableMonolith/Foundation/RecurrenceBridge.lean
recurrence_of_floor_above_plastic · IndisputableMonolith/Foundation/RecurrenceBridge.lean:74
/-- **The recurrence bridge.** A ratio floor ρ above the plastic constant
(ρ³ > ρ + 1), together with adjacent closure (the composition of rungs n and
n+1 is always a rung), forces the adjacent recurrence: the composition
cannot reach rung n+3, so it is rung n+2. -/
theorem recurrence_of_floor_above_plastic (hpos : ∀ n, 0 < s n)
    {ρ : ℝ} (hρ : 1 < ρ) (hρ3 : ρ + 1 < ρ ^ 3)
    (hfloor : ∀ n, ρ * s n ≤ s (n + 1))
    (hclosure : ∀ n, ∃ m, m ≥ n + 2 ∧ s m = s n + s (n + 1)) :
    ∀ n, s (n + 2) = s (n + 1) + s n := by
  have hmono := monotone_of_floor hpos hρ hfloor
  have hρpos : 0 < ρ := by linarith
  intro n
  obtain ⟨m, hm, hsm⟩ := hclosure n
  have hmle : m ≤ n + 2 := by
    by_contra h
    push_neg at h
    have hm3 : n + 3 ≤ m := by omega
    have hs3 : s (n + 3) ≤ s m := hmono hm3
    have hf2 : ρ ^ 2 * s (n + 1) ≤ s (n + 3) :=
      calc ρ ^ 2 * s (n + 1) = ρ * (ρ * s (n + 1)) := by ring
        _ ≤ ρ * s (n + 2) :=
          mul_le_mul_of_nonneg_left (hfloor (n + 1)) (le_of_lt hρpos)
        _ ≤ s (n + 3) := hfloor (n + 2)
    have hsn : s n ≤ s (n + 1) / ρ := by
      rw [le_div_iff₀ hρpos, mul_comm]
      exact hfloor n
    have hsp : 0 < s (n + 1) := hpos (n + 1)
    have h1 : ρ ^ 2 * s (n + 1) ≤ s n + s (n + 1) := by
      linarith [hs3, hf2, hsm]
    have h2 : s n + s (n + 1) ≤ s (n + 1) / ρ + s (n + 1) := by
      linarith [hsn]
    have h3 : ρ ^ 2 * s (n + 1) ≤ (1 / ρ + 1) * s (n + 1) := by
      have e : s (n + 1) / ρ + s (n + 1) = (1 / ρ + 1) * s (n + 1) := by ring
      rw [e] at h2
      exact le_trans h1 h2
    have h4 : ρ ^ 2 ≤ 1 / ρ + 1 := le_of_mul_le_mul_right h3 hsp
    have h5 : ρ ^ 2 * ρ ≤ (1 / ρ + 1) * ρ :=
      mul_le_mul_of_nonneg_right h4 (le_of_lt hρpos)
    have h6 : (1 / ρ + 1) * ρ = 1 + ρ := by field_simp [hρpos.ne']
    have h7 : ρ ^ 2 * ρ = ρ ^ 3 := by ring
    rw [h7] at h5
    rw [h6] at h5
    linarith [h5, hρ3]
  have hmeq : m = n + 2 := by omega
  subst hmeq
  linarith [hsm]
THEOREM plastic_sharpness · IndisputableMonolith/Foundation/RecurrenceBridge.lean
/-- The threshold is exact: at ρ = plastic (ρ³ = ρ + 1, the non-strict
boundary), the plastic ladder satisfies the ratio floor with equality,
satisfies adjacent closure (its composition lands at rung n+3, skipping
rung n+2), and violates the adjacent recurrence. The strict inequality
ρ³ > ρ + 1 in the bridge theorem cannot be relaxed to ≥. -/
theorem plastic_sharpness :
    ∃ (s : ℕ → ℝ) (ρ : ℝ), (∀ n, 0 < s n) ∧ 1 < ρ ∧ ρ ^ 3 = ρ + 1 ∧
      (∀ n, ρ * s n ≤ s (n + 1)) ∧
      (∀ n, ∃ m, m ≥ n + 2 ∧ s m = s n + s (n + 1)) ∧
      ¬ (∀ n, s (n + 2) = s (n + 1) + s n) := by
  obtain ⟨r, hr1, hr3⟩ := PhiClosureSelection.plastic_ladder_exists
  have hr0 : 0 < r := by linarith
  refine ⟨fun n => r ^ n, r, (fun n => pow_pos hr0 n), hr1, by linarith [hr3],
    ?_, ?_, ?_⟩
  · intro n
    exact le_of_eq (pow_succ' r n).symm
  · intro n
    refine ⟨n + 3, by omega, ?_⟩
    show r ^ (n + 3) = r ^ n + r ^ (n + 1)
    rw [pow_add, mul_comm, ← hr3, pow_succ']
    ring
  · intro hall
    have h0 := hall 0
    dsimp only at h0
    norm_num at h0
    have e : r ^ 3 = 2 * r + 1 := by
      calc r ^ 3 = r ^ 2 * r := by ring
        _ = (r + 1) * r := by rw [h0]
        _ = r ^ 2 + r := by ring
        _ = 2 * r + 1 := by rw [h0]; ring
    linarith [e, hr3, hr1]
THEOREM closure_generation_tick_insufficient · IndisputableMonolith/Foundation/RecurrenceBridge.lean
closure_generation_tick_insufficient · IndisputableMonolith/Foundation/RecurrenceBridge.lean:252
/-- The countermodel, packaged: strict monotonicity, adjacent closure, full
generation, ledger additivity (composition is addition), and an absolute
minimum step of 1 all hold for the integer ladder, yet the adjacent
recurrence fails and no ratio floor above 1 exists. Closure + generation +
absolute tick (the banked tick's form) do not force the recurrence. -/
theorem closure_generation_tick_insufficient :
    ∃ s : ℕ → ℝ, StrictMono s ∧
      (∀ n, ∃ m, m ≥ n + 2 ∧ s m = s n + s (n + 1)) ∧
      (∀ n, n ≥ 2 → ∃ a b, a ≤ b ∧ b < n ∧ s n = s a + s b) ∧
      (∀ n, s (n + 1) - s n = 1) ∧
      ¬ (∀ n, s (n + 2) = s (n + 1) + s n) ∧
      (∀ ρ : ℝ, 1 < ρ → ∃ n, s (n + 1) < ρ * s n) :=
  ⟨intLadder, intLadder_strictMono, intLadder_adjacent_closure,
    intLadder_generation, intLadder_tick, intLadder_recurrence_fails,
    intLadder_no_ratio_floor⟩
THEOREM phi_of_floor_above_plastic · IndisputableMonolith/Foundation/RecurrenceBridge.lean
/-- **T6 assembly, bridge form.** A ratio floor above the plastic constant
plus adjacent closure forces the recurrence (this module), hence the
asymptotic inter-level ratio is φ (PhiForcingUnconditional). No geometric
ladder, no uniform ratio, no minimality posture. -/
theorem phi_of_floor_above_plastic (hpos : ∀ n, 0 < s n)
    {ρ : ℝ} (hρ : 1 < ρ) (hρ3 : ρ + 1 < ρ ^ 3)
    (hfloor : ∀ n, ρ * s n ≤ s (n + 1))
    (hclosure : ∀ n, ∃ m, m ≥ n + 2 ∧ s m = s n + s (n + 1)) :
    Tendsto (fun n => s (n + 1) / s n) atTop (nhds phi) :=
  ratio_tendsto_phi hpos
    (recurrence_of_floor_above_plastic hpos hρ hρ3 hfloor hclosure)

What this page does not claim

The framework proves that the per-rung cost floor actually holds in its full model; that remains an open question. Closure and generation alone force the recurrence; the integer ladder is a counterexample. The recurrence bridge derives the golden ratio without any ratio floor premise.

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/RecurrenceBridge.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