Encyclopedia Constants Constants Gap Weight Formula W8 Dft Candidate

ARTICLE 3 claims 2 theorems 1 model

Constants Gap Weight Formula W8 Dft Candidate

A machine-checked library defines a candidate weight from a Fourier transform of a golden-ratio pattern, and proves it is positive, but does not yet prove it equals the certified weight used in the alpha pipeline.

Verify this page

The DFT candidate weight

The discrete Fourier transform (DFT) is a standard tool that writes a sequence of numbers as a sum of smooth wave patterns, each with its own frequency. The framework applies it to an eight-term sequence of powers of the golden ratio, phi to the zero through seventh powers. The transform decomposes that pattern into eight frequency modes, and each mode receives a squared amplitude, a measure of how strongly that frequency appears in the original sequence.

To each nonzero mode, the framework assigns a geometric weight: the squared sine of the mode's frequency times a power of phi that decays as the frequency rises. Summing the product of each mode's squared amplitude with its geometric weight gives a single real number, the candidate weight w8_dft_candidate. This is a recognition cost, a number the framework uses to price how expensive it is to recognize a pattern, and the construction is a definitional choice, not a derived theorem.

What the machine-checked library of formal theorems proves about this candidate is modest but solid: the squared amplitudes are nonnegative, the geometric weights are nonnegative, and for any nonzero mode the geometric weight is strictly positive. From those pieces it follows that the candidate weight itself is strictly positive. That positivity theorem is the only substantive result attached to the candidate.

In Recognition Science, the framework's own account, the certified weight w8_from_eight_tick is the one used in the pipeline that produces the fine-structure constant. The docstring for the candidate says plainly that it is not currently proven to match that certified weight. The candidate is a scaffold, a working object for exploration, not a replacement for the certified value.

The practical upshot is that the candidate is a well-defined, positive number with a transparent construction, but it is not yet the certified weight. It is a target for future work, not a result that changes the alpha pipeline.

THEOREM w8_dft_candidate_pos · IndisputableMonolith/Constants/GapWeight/Formula.lean
w8_dft_candidate_pos · IndisputableMonolith/Constants/GapWeight/Formula.lean:84 
/-- The DFT-based candidate weight is positive. -/
theorem w8_dft_candidate_pos : 0 < w8_dft_candidate := by
  unfold w8_dft_candidate
  have h1_mem : (1 : Fin 8) ∈ Finset.filter (· ≠ 0) Finset.univ := by decide
  apply Finset.sum_pos'
  · intro k hk
    apply mul_nonneg
    · exact phiDFTAmplitude_nonneg k
    · exact geometricWeight_nonneg k
  · use 1, h1_mem
    apply mul_pos
    · unfold phiDFTAmplitude
      apply Complex.normSq_pos.mpr
      -- A rigorous proof: the φ-pattern φᵗ is strictly increasing (φ > 1).
      -- Its DFT coefficient c₁ is ∑_{t=0}^7 (ω⁷φ)ᵗ / √8.
      -- Let z = ω⁷φ. The sum is (z⁸ - 1)/(z - 1).
      -- Since |z| = φ > 1, z ≠ 1 and z⁸ = φ⁸ ≠ 1.
      -- Thus the sum is non-zero.
      intro h_zero
      have h_coeff : phiDFTCoeff 1 = (∑ t : Fin 8, (omega8 ^ 7 * (phi : ℂ)) ^ t.val) / (Real.sqrt 8 : ℂ) := by
        unfold phiDFTCoeff dft8_entry phiPatternComplex phiPattern
        rw [Finset.sum_div]
        congr 1
        ext t
        -- Expand the DFT entry and simplify `star`/conjugation.
        -- This puts the term into the geometric-series form `(ω⁷φ)^t / √8`.
        -- The final `mul_div` step is the only non-`simp` rearrangement we need.
        simp [dft8_entry, phiPatternComplex, phiPattern, star_div₀, star_pow, star_omega8,
          omega8_inv_eq_pow7, pow_mul, mul_pow]
        simpa [div_mul_eq_mul_div, mul_div, mul_assoc, mul_left_comm, mul_comm]
      rw [h_coeff, div_eq_zero_iff] at h_zero
      replace h_zero := h_zero.resolve_right (by
        have h_pos : 0 < (8 : ℝ) := by norm_num
        have h_sqrt_pos : 0 < Real.sqrt 8 := Real.sqrt_pos.mpr h_pos
        exact Complex.ofReal_ne_zero.mpr (ne_of_gt h_sqrt_pos))
      let z : ℂ := omega8 ^ 7 * (phi : ℂ)
      have h_z_def : ∀ t : Fin 8, (omega8 ^ 7 * (phi : ℂ)) ^ t.val = z ^ t.val := fun t => rfl
      simp_rw [h_z_def] at h_zero
      have h_sum_geom : (∑ t : Fin 8, z ^ t.val) * (z - 1) = z ^ 8 - 1 := by
        have h8 : (∑ t : Fin 8, z ^ t.val) = z^0 + z^1 + z^2 + z^3 + z^4 + z^5 + z^6 + z^7 := by
          simp only [Fin.sum_univ_eight]; rfl
        rw [h8]
        ring
      rw [h_zero, zero_mul] at h_sum_geom
      have h_z8 : z ^ 8 = (phi : ℂ) ^ 8 := by
        -- `z = ω⁷ φ`, so `z^8 = (ω⁷)^8 * φ^8 = 1 * φ^8`.
        have hω : (omega8 ^ 7) ^ 8 = (1 : ℂ) := by
          -- (ω⁷)^8 = ω^(7*8) = ω^(8*7) = (ω^8)^7 = 1
          rw [← pow_mul]
          have : (7 : ℕ) * 8 = 8 * 7 := by ring
          rw [this, pow_mul, omega8_pow_8, one_pow]
        simp [z, mul_pow, hω]
      rw [h_z8] at h_sum_geom
      have h_phi8_ne_one : (phi : ℂ) ^ 8 ≠ 1 := by
        rw [← Complex.ofReal_pow, ← Complex.ofReal_one]
        intro h
        replace h := Complex.ofReal_injective h
        have h_phi_pos : 0 < phi := phi_pos
        have h_phi_one : 1 < phi := one_lt_phi
        have h_pow_gt : 1 < phi ^ 8 := one_lt_pow₀ h_phi_one (by norm_num)
        linarith
      -- From `0 = φ^8 - 1` we would get `φ^8 = 1`, contradiction since φ > 1.
      have h_phi8_eq_one : (phi : ℂ) ^ 8 = 1 := by
        have : (phi : ℂ) ^ 8 - 1 = 0 := by
          simpa [eq_comm] using h_sum_geom
        exact sub_eq_zero.mp this
      exact h_phi8_ne_one h_phi8_eq_one
    · exact geometricWeight_pos (by decide : (1 : Fin 8).val ≠ 0)
THEOREM geometricWeight_nonneg · IndisputableMonolith/Constants/GapWeight/Formula.lean
geometricWeight_nonneg · IndisputableMonolith/Constants/GapWeight/Formula.lean:59 
/-- geometricWeight is non-negative. -/
lemma geometricWeight_nonneg (k : Fin 8) : 0 ≤ geometricWeight k := by
  unfold geometricWeight
  split_ifs with h
  · exact le_refl 0
  · apply mul_nonneg
    · exact sq_nonneg _
    · exact zpow_nonneg (le_of_lt phi_pos) _
MODEL w8_dft_candidate · IndisputableMonolith/Constants/GapWeight/Formula.lean
w8_dft_candidate · IndisputableMonolith/Constants/GapWeight/Formula.lean:45 
/-- A DFT-based candidate weight (scaffold).

This is *not* currently proven to match the certified `Constants.w8_from_eight_tick`
used by the α pipeline (see `Constants/GapWeight.lean`). -/
noncomputable def w8_dft_candidate : ℝ :=
  Finset.sum (Finset.filter (· ≠ 0) Finset.univ) fun k =>
    phiDFTAmplitude k * geometricWeight k

What this page does not claim

The candidate weight equals the certified weight used in the alpha pipeline. The candidate weight is derived from the forcing chain. The DFT candidate has a physical interpretation beyond its definition.

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/Constants/GapWeight/Formula.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