Encyclopedia Masses Masses Mass Genesis T10 Counting Bridge Obstruction Phi Pow Div Two Pow Not Bloc

ARTICLE 3 claims 3 theorems

Masses Mass Genesis T10 Counting Bridge Obstruction Phi Pow Div Two Pow Not Bloc

A theorem in the Recognition Science library proves that certain candidate mass values can never be assembled from the framework's basic energy blocks, no matter how the counting is adjusted.

The permanent counting obstruction

The golden ratio φ, approximately 1.618, is an irrational number: it cannot be written as a fraction of two whole numbers. This single fact has a sharp consequence inside the Recognition Science framework, which models physical quantities as discrete records of events called a ledger. The framework's basic energy blocks are the negative powers of φ, and a candidate value is said to be representable if it can be written as a finite sum of these blocks, each multiplied by an integer (positive, negative, or zero). The theorem phiPow_div_twoPow_not_block_combination proves that no pure power of φ divided by a power of two, such as φ³/2 or φ⁵/4, can ever be so represented.

The proof is a congruence argument, not a numerical search. Every block energy φ⁻ⁿ can be rewritten as an integer combination of 1 and φ, so any finite combination of blocks reduces to the form A·φ + B with A and B integers. The target value φᵏ/2ʲ also reduces to a Fibonacci-number combination: it equals (F_k·φ + F_{k-1})/2ʲ. Since φ is irrational, the only way these can match is if the denominator divides both Fibonacci numbers F_k and F_{k-1}. But consecutive Fibonacci numbers are always coprime, so they cannot both be even. The denominator 2ʲ forces both to be even, a contradiction. The obstruction is permanent: no change of tick convention, window normalization, or amplitude convention can escape it, because it is a fact about divisibility, not about scale.

This result closes one proposed route for constructing particle masses in the framework. The route, called the counting bridge, tried to express a specific load value φ⁴²/4 as a combination of block energies. The theorem shows this is impossible, and the general version proves the same for every pure power with a binary denominator. The framework therefore turns to a different mechanism, a genesis-creation predicate that selects the ground orbit point without requiring integer counts at all. The counting bridge is not repaired arithmetically; it is abandoned for a different kind of construction.

The theorem does not claim that all mass values are unrepresentable. Integer multiples of pure powers of φ, such as 3·φ², are representable trivially. It does not claim that the framework's mass spectrum is wrong or incomplete; it identifies a specific algebraic obstruction that redirects the construction. It also does not claim that the conjugate-window mechanism, a separate algebraic tool, is generally useless; the companion theorem shows only that this particular load falls below that window's range.

THEOREM phiPow_div_twoPow_not_block_combination · IndisputableMonolith/Masses/MassGenesis/T10CountingBridgeObstruction.lean
/-- **B-1, general (THEOREM).** No pure ladder power with a power-of-two
denominator is a finite integer combination of block energies:
`phi^k / 2^j`, `j ≥ 1`, would force `2 ∣ F_k` and `2 ∣ F_{k-1}`, and
consecutive Fibonacci numbers are coprime. -/
theorem phiPow_div_twoPow_not_block_combination (s : Finset ℕ) (c : ℕ → ℤ)
    (k j : ℕ) (hj : 1 ≤ j) :
    (∑ n ∈ s, (c n : ℝ) * ((Constants.phi : ℝ)⁻¹) ^ n) ≠
      (Constants.phi : ℝ) ^ k / (2 ^ j : ℝ) := by
  obtain ⟨A, B, hAB⟩ := combo_reduce s c
  intro h
  rw [hAB] at h
  have hj0 : (2 : ℝ) ^ j ≠ 0 := by positivity
  have h2j : (2 ^ j : ℝ) * (((A : ℝ)) * Constants.phi + ((B : ℝ))) =
      (Constants.phi : ℝ) ^ k := by
    field_simp at h
    linear_combination h
  rw [phi_pow_fib] at h2j
  have key : ((((2 : ℤ) ^ j * A - (Nat.fib k : ℤ)) : ℤ) : ℝ) * Constants.phi +
      ((((2 : ℤ) ^ j * B - ((Nat.fib (k + 1) : ℤ) - (Nat.fib k : ℤ))) : ℤ) : ℝ)
      = 0 := by
    push_cast
    linear_combination h2j
  obtain ⟨h1, h2⟩ := int_combination_eq_zero key
  have d1 : (2 : ℤ) ^ j ∣ (Nat.fib k : ℤ) := ⟨A, by linear_combination -h1⟩
  have d2 : (2 : ℤ) ^ j ∣ ((Nat.fib (k + 1) : ℤ) - (Nat.fib k : ℤ)) :=
    ⟨B, by linear_combination -h2⟩
  have h2dvd : (2 : ℤ) ∣ (2 : ℤ) ^ j := dvd_pow_self 2 (by omega)
  have e1 : (2 : ℤ) ∣ (Nat.fib k : ℤ) := h2dvd.trans d1
  have e2 : (2 : ℤ) ∣ ((Nat.fib (k + 1) : ℤ) - (Nat.fib k : ℤ)) :=
    h2dvd.trans d2
  rcases Nat.eq_zero_or_pos k with rfl | hk
  · norm_num [Nat.fib] at e2
  · have hf : (Nat.fib (k + 1) : ℤ) - (Nat.fib k : ℤ) =
        (Nat.fib (k - 1) : ℤ) := by
      have h := Nat.fib_add_two (n := k - 1)
      rw [show k - 1 + 2 = k + 1 by omega, show k - 1 + 1 = k by omega] at h
      rw [h]
      push_cast
      ring
    rw [hf] at e2
    have e1' : 2 ∣ Nat.fib k := Int.ofNat_dvd.mp (by exact_mod_cast e1)
    have e2' : 2 ∣ Nat.fib (k - 1) := Int.ofNat_dvd.mp (by exact_mod_cast e2)
    have g : 2 ∣ Nat.gcd (Nat.fib k) (Nat.fib (k - 1)) := Nat.dvd_gcd e1' e2'
    rw [← Nat.fib_gcd] at g
    have hcop : Nat.gcd k (k - 1) = 1 := by
      have hd1 : Nat.gcd k (k - 1) ∣ k := Nat.gcd_dvd_left _ _
      have hd2 : Nat.gcd k (k - 1) ∣ (k - 1) := Nat.gcd_dvd_right _ _
      have hd3 : Nat.gcd k (k - 1) ∣ (k - (k - 1)) := Nat.dvd_sub hd1 hd2
      have hkk : k - (k - 1) = 1 := by omega
      rw [hkk] at hd3
      exact Nat.dvd_one.mp hd3
    rw [hcop] at g
    norm_num at g
THEOREM combo_reduce · IndisputableMonolith/Masses/MassGenesis/T10CountingBridgeObstruction.lean
/-- **Every finite block combination has integer coefficients:** a sum of
signed multiples of block energies is `A * phi + B` with `A, B` integers. -/
theorem combo_reduce (s : Finset ℕ) (c : ℕ → ℤ) :
    ∃ A B : ℤ, (∑ n ∈ s, (c n : ℝ) * ((Constants.phi : ℝ)⁻¹) ^ n) =
      ((A : ℝ)) * Constants.phi + ((B : ℝ)) := by
  classical
  refine s.induction_on ⟨0, 0, by simp⟩ ?_
  intro n s hn ih
  obtain ⟨A, B, hAB⟩ := ih
  refine ⟨A - (c n) * (-1) ^ n * (Nat.fib n : ℤ),
    B + (c n) * (-1) ^ n * (Nat.fib (n + 1) : ℤ), ?_⟩
  rw [Finset.sum_insert hn, hAB, phiInv_pow]
  push_cast
  ring
THEOREM irrational_phi · int_combination_eq_zero · IndisputableMonolith/Masses/MassGenesis/T10CountingBridgeObstruction.lean
theorem irrational_phi : Irrational Constants.phi := by
  rintro ⟨q, hq⟩
  have h5 : Real.sqrt 5 = (((2 * q - 1 : ℚ)) : ℝ) := by
    have h1 : Constants.phi = (1 + Real.sqrt 5) / 2 := rfl
    rw [h1] at hq
    have h2 : Real.sqrt 5 = 2 * (q : ℝ) - 1 := by linear_combination -2 * hq
    rw [h2]
    push_cast
    ring
  exact irrational_sqrt5 ⟨2 * q - 1, h5.symm⟩
/-- **`{1, phi}` is rationally independent** (integer form). -/
theorem int_combination_eq_zero {a b : ℤ}
    (h : ((a : ℝ)) * Constants.phi + ((b : ℝ)) = 0) : a = 0 ∧ b = 0 := by
  by_cases ha : a = 0
  · subst ha
    simp at h
    exact ⟨rfl, by exact_mod_cast h⟩
  · exfalso
    have hane : (a : ℝ) ≠ 0 := by exact_mod_cast ha
    have hphi : Constants.phi = (((-(b : ℚ) / (a : ℚ)) : ℚ) : ℝ) := by
      push_cast
      field_simp
      linear_combination h
    exact irrational_phi ⟨-(b : ℚ) / (a : ℚ), hphi.symm⟩

What this page does not claim

The theorem does not claim that all mass values are unrepresentable; integer multiples of pure powers remain trivially representable. The theorem does not claim the framework's mass spectrum is wrong or incomplete, only that one construction route is blocked. The theorem does not claim the conjugate-window mechanism is useless in general, only that it fails on this specific load.

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/Masses/MassGenesis/T10CountingBridgeObstruction.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