Encyclopedia Foundation Foundation Hierarchy Forcing Scale Perturbed Family Injective
ARTICLE 3 claims 2 theorems 1 model
Foundation Hierarchy Forcing Scale Perturbed Family Injective
A machine-checked theorem shows that distinct scaling parameters always produce distinct level sequences, a technical step in a larger argument about why hierarchical structures must be uniform.
The perturbation test
A hierarchy is a sequence of levels, each a positive real number. In the Recognition Science framework, a ledger (a discrete record of events) can carry such a hierarchy, and the framework asks which hierarchies are possible when no parameters are free to be tuned. The declaration scale_perturbed_family_injective is a machine-checked theorem that supports this inquiry by proving a precise fact about a specific kind of perturbation.
The perturbation in question is simple. Take any positive level sequence. Choose a position j and a real number t. The perturbed sequence leaves all levels at or below position j unchanged, and multiplies every level above position j by exp(t). This changes exactly one adjacent ratio, the ratio at position j, by the factor exp(t), while preserving all other ratios and leaving every level positive. The theorem states that different values of t always yield different perturbed sequences. The proof is short: at position j+1, the value is levels(j+1) times exp(t), and since the exponential function is injective, distinct t values cannot produce equal sequences. This is pure real arithmetic, with no additional axioms.
Why does this matter? The perturbation machinery exists to test a conjecture about hierarchies. The framework's broader goal is to show that a nontrivial hierarchy with no free scale parameters must have uniform adjacent ratios, meaning every level is a fixed multiple of the one below it. The injectivity result is a necessary technical ingredient for that argument: it ensures that the perturbation genuinely varies the level sequence, so that if the zero-parameter condition rules out all such variations, the conclusion about uniformity is not vacuous. The theorem itself does not establish uniformity; it establishes that the perturbation is a faithful probe, one that can distinguish different parameter choices.
In Recognition Science, this result is part of a chain leading to the golden ratio and to the framework's account of physical constants. But the declaration's own scope is narrow: it is a lemma about exponential scaling, not a statement about physics. It does not claim that any actual hierarchy is perturbed, nor that the golden ratio emerges from this theorem alone. It simply certifies that the perturbation family is injective, a fact that later theorems can rely on.
THEOREM scale_perturbed_family_injective · IndisputableMonolith/Foundation/HierarchyForcing.lean
/-- Different perturbation parameters give different level sequences.
The key step: at position `j + 1` the values are `levels(j+1) · exp(t)`,
and `exp` is injective. -/
theorem scale_perturbed_family_injective (levels : ℕ → ℝ) (j : ℕ)
(h_pos : 0 < levels (j + 1)) :
Function.Injective (ScalePerturbed levels j) := by
intro t₁ t₂ h
have h_eval := congr_fun h (j + 1)
unfold ScalePerturbed at h_eval
rw [if_neg (by omega : ¬(j + 1 ≤ j)), if_neg (by omega : ¬(j + 1 ≤ j))] at h_eval
have h_ne : levels (j + 1) ≠ 0 := ne_of_gt h_pos
exact Real.exp_injective (mul_left_cancel₀ h_ne h_eval)
MODEL ScalePerturbed · IndisputableMonolith/Foundation/HierarchyForcing.lean
/-- Perturbed level sequence: shift all levels above position `j` by the
factor `exp(t)`. This changes the ratio at position `j` to `r_j · exp(t)`
while preserving all other ratios and positivity for every `t ∈ ℝ`. -/
noncomputable def ScalePerturbed (levels : ℕ → ℝ) (j : ℕ) (t : ℝ) (k : ℕ) : ℝ :=
if k ≤ j then levels k else levels k * Real.exp t
THEOREM scale_perturbed_family_injective · IndisputableMonolith/Foundation/HierarchyForcing.lean
/-- Different perturbation parameters give different level sequences.
The key step: at position `j + 1` the values are `levels(j+1) · exp(t)`,
and `exp` is injective. -/
theorem scale_perturbed_family_injective (levels : ℕ → ℝ) (j : ℕ)
(h_pos : 0 < levels (j + 1)) :
Function.Injective (ScalePerturbed levels j) := by
intro t₁ t₂ h
have h_eval := congr_fun h (j + 1)
unfold ScalePerturbed at h_eval
rw [if_neg (by omega : ¬(j + 1 ≤ j)), if_neg (by omega : ¬(j + 1 ≤ j))] at h_eval
have h_ne : levels (j + 1) ≠ 0 := ne_of_gt h_pos
exact Real.exp_injective (mul_left_cancel₀ h_ne h_eval)
What this page does not claim
The theorem does not establish that uniform scaling is forced; it only proves injectivity of the perturbation family. The theorem does not claim that any actual physical hierarchy is perturbed; it is a mathematical lemma. The theorem does not derive the golden ratio; that requires additional hypotheses such as the additive composition condition.
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/HierarchyForcing.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 does the zero-parameter condition on a hierarchy mean in plain terms?
- How does the injectivity of the perturbation family support the proof that uniform scaling is forced?
- What role does the golden ratio play in the forced hierarchy theorem?
MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND
THEOREM scale_perturbed_family_injective · IndisputableMonolith/Foundation/HierarchyForcing.lean
/-- Different perturbation parameters give different level sequences. The key step: at position `j + 1` the values are `levels(j+1) · exp(t)`, and `exp` is injective. -/ theorem scale_perturbed_family_injective (levels : ℕ → ℝ) (j : ℕ) (h_pos : 0 < levels (j + 1)) : Function.Injective (ScalePerturbed levels j) := by intro t₁ t₂ h have h_eval := congr_fun h (j + 1) unfold ScalePerturbed at h_eval rw [if_neg (by omega : ¬(j + 1 ≤ j)), if_neg (by omega : ¬(j + 1 ≤ j))] at h_eval have h_ne : levels (j + 1) ≠ 0 := ne_of_gt h_pos exact Real.exp_injective (mul_left_cancel₀ h_ne h_eval)The theorem states that different values of t always yield different perturbed sequences. scale_perturbed_family_injective · IndisputableMonolith/Foundation/HierarchyForcing.leanMODEL ScalePerturbed · IndisputableMonolith/Foundation/HierarchyForcing.lean
/-- Perturbed level sequence: shift all levels above position `j` by the factor `exp(t)`. This changes the ratio at position `j` to `r_j · exp(t)` while preserving all other ratios and positivity for every `t ∈ ℝ`. -/ noncomputable def ScalePerturbed (levels : ℕ → ℝ) (j : ℕ) (t : ℝ) (k : ℕ) : ℝ := if k ≤ j then levels k else levels k * Real.exp tThe perturbed sequence leaves all levels at or below position j unchanged, and multiplies every level above position j by exp(t). ScalePerturbed · IndisputableMonolith/Foundation/HierarchyForcing.leanTHEOREM scale_perturbed_family_injective · IndisputableMonolith/Foundation/HierarchyForcing.lean
/-- Different perturbation parameters give different level sequences. The key step: at position `j + 1` the values are `levels(j+1) · exp(t)`, and `exp` is injective. -/ theorem scale_perturbed_family_injective (levels : ℕ → ℝ) (j : ℕ) (h_pos : 0 < levels (j + 1)) : Function.Injective (ScalePerturbed levels j) := by intro t₁ t₂ h have h_eval := congr_fun h (j + 1) unfold ScalePerturbed at h_eval rw [if_neg (by omega : ¬(j + 1 ≤ j)), if_neg (by omega : ¬(j + 1 ≤ j))] at h_eval have h_ne : levels (j + 1) ≠ 0 := ne_of_gt h_pos exact Real.exp_injective (mul_left_cancel₀ h_ne h_eval)The proof is short: at position j+1, the value is levels(j+1) times exp(t), and since the exponential function is injective, distinct t values cannot produce equal sequences. scale_perturbed_family_injective · IndisputableMonolith/Foundation/HierarchyForcing.lean