Encyclopedia Information Information Phi Hierarchy Growth Fibonacci Ratio Recursion
ARTICLE 3 claims 3 theorems
Information Phi Hierarchy Growth Fibonacci Ratio Recursion
In any growing Fibonacci sequence, the ratio of consecutive terms obeys a simple rule that forces the golden ratio as its only stable endpoint.
The Fibonacci ratio recursion
The Fibonacci sequence is the one where each term is the sum of the two before it: 1, 1, 2, 3, 5, 8, and so on. A classical fact about this sequence is that the ratio of consecutive terms settles down. The ratio 5/3 is 1.666, then 8/5 is 1.6, then 13/8 is 1.625, and the values close in on a single number. That number is the golden ratio, usually written φ, equal to (1 + √5)/2, about 1.618034. The rule behind this convergence is simple: if r is the ratio of one pair of consecutive terms, the next ratio is 1 + 1/r. The golden ratio is the unique positive number that satisfies r = 1 + 1/r, which is the same as the defining equation r² = r + 1.
This rule is not a coincidence of the usual starting values. It holds for any sequence with positive terms that follows the Fibonacci recurrence. The machine-checked library of formal theorems in Recognition Science proves this in the declaration fibonacci_ratio_recursion: for any positive sequence K where K(n+2) = K(n+1) + K(n), the ratio K(n+2)/K(n+1) equals 1 + 1/(K(n+1)/K(n)). The proof is a short algebraic manipulation, and it is a proved theorem, not a conjecture.
The same library goes one step further. If a sequence has a constant ratio r and follows the Fibonacci recurrence, then r must be φ. This is the uniqueness result phi_hierarchy_is_unique_fixed_point. There is no other positive constant ratio that works. The framework uses this to model a cache hierarchy, a discrete record of storage levels where each level is larger than the last. When the cost of moving between levels is minimized under the Fibonacci constraint, the unavoidable result is a sequence where every level is φ times the previous one. The theorem phi_hierarchy_exponential_growth states that after N levels, the size is exactly K₀ · φ^N, which grows exponentially because φ is greater than 1.
What the declaration does not claim is just as important. The recursion rule is a property of any positive Fibonacci sequence, but it does not say that every such sequence converges to φ. A sequence like 1, 3, 4, 7, 11 has ratios that bounce around and never settle; the recursion rule describes how each ratio is computed from the previous one, not that the ratios must approach a limit. The uniqueness result requires the extra assumption of a constant ratio. Without that assumption, the golden ratio is not forced. The framework's claim is about the special case of constant-ratio hierarchies, not about all Fibonacci sequences.
For a reader, the practical takeaway is a clean picture: a growing Fibonacci system with a stable ratio has exactly one possible ratio, and that ratio is φ. The recursion rule is the engine, and the uniqueness theorem is the destination. The framework's library shows that this is not a numerical accident but a proved consequence of the recurrence and positivity.
THEOREM fibonacci_ratio_recursion · IndisputableMonolith/Information/PhiHierarchyGrowth.lean
/-- **FIBONACCI RATIO RECURSION LEMMA**
If K satisfies Fibonacci recurrence with positive terms,
the ratio r_{n+1} = 1 + 1/r_n where r_n = K(n+1)/K(n). -/
theorem fibonacci_ratio_recursion (K : ℕ → ℝ)
(hK_pos : ∀ n, 0 < K n)
(hfib : fibonacci_recurrence K) (n : ℕ) :
K (n + 2) / K (n + 1) = 1 + 1 / (K (n + 1) / K n) := by
have hKn1 : K (n + 1) ≠ 0 := ne_of_gt (hK_pos (n + 1))
have hKn : K n ≠ 0 := ne_of_gt (hK_pos n)
have hfib_n := hfib n
field_simp
linarith
THEOREM phi_hierarchy_is_unique_fixed_point · IndisputableMonolith/Information/PhiHierarchyGrowth.lean
/-- **φ-HIERARCHY IS THE UNIQUE FIBONACCI FIXED POINT**
The phi-hierarchy is the unique positive constant-ratio Fibonacci sequence.
Any Fibonacci sequence with constant positive ratio must be the phi-hierarchy.
This is the "gradient flow fixed point" result: the phi-hierarchy cannot be
improved by any J-cost-preserving Fibonacci-compatible transformation. -/
theorem phi_hierarchy_is_unique_fixed_point (K : ℕ → ℝ) (r : ℝ)
(hr_pos : 0 < r)
(hK_pos : ∀ ℓ, 0 < K ℓ)
(hfib : fibonacci_recurrence K)
(hratio : constant_ratio K r) :
r = phi ∧ ∀ n, K n = K 0 * phi ^ n := by
constructor
· exact fibonacci_partition_forces_phi K r hr_pos hK_pos hfib hratio
· intro n
induction n with
| zero => simp
| succ m ih =>
have := hratio m
rw [ih] at this
have hphi_eq := fibonacci_partition_forces_phi K r hr_pos hK_pos hfib hratio
rw [hphi_eq] at this
rw [this]
ring
THEOREM phi_hierarchy_exponential_growth · IndisputableMonolith/Information/PhiHierarchyGrowth.lean
/-- **φ-HIERARCHY EXPONENTIAL GROWTH**
After N levels of a φ-optimal cache hierarchy starting from K₀ > 0,
the total complexity at level N is exactly K₀ · φ^N.
Since φ > 1, this is exponential in N.
Since gradient flow converges to this hierarchy (Theorem above),
any J-cost-minimizing system necessarily builds exponentially
growing complexity over time. -/
theorem phi_hierarchy_exponential_growth (K₀ : ℝ) (hK₀ : 0 < K₀) (N : ℕ) (hN : 0 < N) :
phiHierarchy K₀ N = K₀ * phi ^ N ∧
K₀ * phi ^ N > K₀ := by
constructor
· exact phiHierarchy_value K₀ N
· have : 1 < phi ^ N := one_lt_pow₀ one_lt_phi (by omega)
nlinarith
What this page does not claim
The recursion rule does not imply that every Fibonacci sequence converges to φ; a sequence like 1, 3, 4, 7, 11 has ratios that never settle. The uniqueness theorem requires the constant-ratio assumption and does not apply to all Fibonacci sequences. The framework does not claim that actual computer caches are built this way; it models an idealized hierarchy.
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/Information/PhiHierarchyGrowth.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:
- What is the J-cost function and why does its minimization select the Fibonacci constraint?
- How does the framework connect a cache hierarchy to physical memory or computation?
- What happens to the ratio recursion when the sequence is allowed to have non-constant ratios?
MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND
THEOREM fibonacci_ratio_recursion · IndisputableMonolith/Information/PhiHierarchyGrowth.lean
/-- **FIBONACCI RATIO RECURSION LEMMA** If K satisfies Fibonacci recurrence with positive terms, the ratio r_{n+1} = 1 + 1/r_n where r_n = K(n+1)/K(n). -/ theorem fibonacci_ratio_recursion (K : ℕ → ℝ) (hK_pos : ∀ n, 0 < K n) (hfib : fibonacci_recurrence K) (n : ℕ) : K (n + 2) / K (n + 1) = 1 + 1 / (K (n + 1) / K n) := by have hKn1 : K (n + 1) ≠ 0 := ne_of_gt (hK_pos (n + 1)) have hKn : K n ≠ 0 := ne_of_gt (hK_pos n) have hfib_n := hfib n field_simp linarithfor any positive sequence K where K(n+2) = K(n+1) + K(n), the ratio K(n+2)/K(n+1) equals 1 + 1/(K(n+1)/K(n)) fibonacci_ratio_recursion · IndisputableMonolith/Information/PhiHierarchyGrowth.leanTHEOREM phi_hierarchy_is_unique_fixed_point · IndisputableMonolith/Information/PhiHierarchyGrowth.lean
/-- **φ-HIERARCHY IS THE UNIQUE FIBONACCI FIXED POINT** The phi-hierarchy is the unique positive constant-ratio Fibonacci sequence. Any Fibonacci sequence with constant positive ratio must be the phi-hierarchy. This is the "gradient flow fixed point" result: the phi-hierarchy cannot be improved by any J-cost-preserving Fibonacci-compatible transformation. -/ theorem phi_hierarchy_is_unique_fixed_point (K : ℕ → ℝ) (r : ℝ) (hr_pos : 0 < r) (hK_pos : ∀ ℓ, 0 < K ℓ) (hfib : fibonacci_recurrence K) (hratio : constant_ratio K r) : r = phi ∧ ∀ n, K n = K 0 * phi ^ n := by constructor · exact fibonacci_partition_forces_phi K r hr_pos hK_pos hfib hratio · intro n induction n with | zero => simp | succ m ih => have := hratio m rw [ih] at this have hphi_eq := fibonacci_partition_forces_phi K r hr_pos hK_pos hfib hratio rw [hphi_eq] at this rw [this] ringIf a sequence has a constant ratio r and follows the Fibonacci recurrence, then r must be φ phi_hierarchy_is_unique_fixed_point · IndisputableMonolith/Information/PhiHierarchyGrowth.leanTHEOREM phi_hierarchy_exponential_growth · IndisputableMonolith/Information/PhiHierarchyGrowth.lean
/-- **φ-HIERARCHY EXPONENTIAL GROWTH** After N levels of a φ-optimal cache hierarchy starting from K₀ > 0, the total complexity at level N is exactly K₀ · φ^N. Since φ > 1, this is exponential in N. Since gradient flow converges to this hierarchy (Theorem above), any J-cost-minimizing system necessarily builds exponentially growing complexity over time. -/ theorem phi_hierarchy_exponential_growth (K₀ : ℝ) (hK₀ : 0 < K₀) (N : ℕ) (hN : 0 < N) : phiHierarchy K₀ N = K₀ * phi ^ N ∧ K₀ * phi ^ N > K₀ := by constructor · exact phiHierarchy_value K₀ N · have : 1 < phi ^ N := one_lt_pow₀ one_lt_phi (by omega) nlinarithafter N levels, the size is exactly K₀ · φ^N phi_hierarchy_exponential_growth · IndisputableMonolith/Information/PhiHierarchyGrowth.lean