Constants Gap Weight Projection Diff Energy8

The discrete difference energy

In signal processing and discrete mathematics, a difference operator measures how much a sequence changes from one step to the next. For a sequence arranged on a cycle of eight positions, the one-step difference at position t is simply the value at the next position minus the value at t. The quantity diffEnergy8 sums the squared magnitudes of these eight differences. It is a canonical, shift-invariant quadratic form: it assigns a nonnegative real number to any complex-valued function on the eight-point cycle, and it is zero exactly when the function is constant around the cycle.

The definition appears in the machine-checked library of formal theorems as part of the GapWeight.Projection module. The library proves two structural facts. First, diffEnergy8 is always nonnegative, a direct consequence of summing squared magnitudes. Second, when the input is a discrete Fourier mode of frequency k, the difference energy equals the squared magnitude of (ω^8^k − 1), where ω is the primitive eighth root of unity. This second lemma is the precise reason a factor of sin²(πk/8) appears in the geometric weights used elsewhere in the framework: it is the spectral footprint of the discrete derivative on the eight-tick cycle.

In Recognition Science, this operator appears in a specific role. The framework models an eight-tick recognition cycle, and the difference energy is a local, shift-invariant measure of change across that cycle. The module also defines a projection weight, w8_projected, which scales a dimensionless fraction by 64, the product of eight ticks and eight spatial vertices in a Q₃ cell. The library is explicit that this is claim hygiene: it makes the operator and measure choices visible so no hidden degree of freedom remains.

What diffEnergy8 does not claim is equally important. It is a definition, not a theorem about the physical world. The library does not prove that any particular physical pattern minimizes this energy, nor that the eight-tick cycle is the only possible clock. The projection weight w8_projected is a definition-level closure of what projection weight means; proving it equals the closed-form constant w8_from_eight_tick is tracked as a follow-up theorem, not yet established. The operator is a tool for measuring change, and the framework chooses to use it, but that choice is a modeling decision, not a forced consequence.

/-- Total squared energy of the discrete difference (a canonical local, shift-invariant quadratic form). -/
noncomputable def diffEnergy8 (v : Fin 8 → ℂ) : ℝ :=
  ∑ t : Fin 8, Complex.normSq (diff8 v t)

lemma diffEnergy8_nonneg (v : Fin 8 → ℂ) : 0 ≤ diffEnergy8 v := by
  unfold diffEnergy8
  exact Finset.sum_nonneg (fun _ _ => Complex.normSq_nonneg _)

/-- Discrete difference energy of a DFT mode is the squared magnitude of its shift eigenvalue minus 1.

This is the precise mathematical reason a `sin²(πk/8)` factor appears: it is (up to a fixed factor 4)
the spectrum of the 8-tick discrete derivative/Laplacian. -/
lemma diffEnergy8_mode (k : Fin 8) :
    diffEnergy8 (dft8_mode k) = Complex.normSq (omega8 ^ k.val - 1) := by
  unfold diffEnergy8 diff8
  -- Use that cyclic_shift (mode k) = ω^k • mode k.
  have hshift := dft8_shift_eigenvector k
  -- rewrite the difference pointwise
  have hpoint : ∀ t : Fin 8, cyclic_shift (dft8_mode k) t - dft8_mode k t =
      (omega8 ^ k.val - 1) * dft8_mode k t := by
    intro t
    have ht := congrArg (fun f => f t) hshift
    -- ht : cyclic_shift (dft8_mode k) t = (omega8 ^ k.val) • dft8_mode k t
    simp [Pi.smul_apply, smul_eq_mul] at ht
    -- subtract and factor
    calc
      cyclic_shift (dft8_mode k) t - dft8_mode k t
          = (omega8 ^ k.val) * dft8_mode k t - dft8_mode k t := by simpa [ht]
      _   = (omega8 ^ k.val - 1) * dft8_mode k t := by ring
  -- push through normSq and sum
  have hns : ∀ t : Fin 8, Complex.normSq (cyclic_shift (dft8_mode k) t - dft8_mode k t) =
      Complex.normSq (omega8 ^ k.val - 1) * Complex.normSq (dft8_mode k t) := by
    intro t
    -- use hpoint and normSq_mul
    simp [hpoint t, Complex.normSq_mul]
  simp_rw [hns]
  -- factor out the constant eigenvalue term
  have hfac :
      (∑ t : Fin 8, Complex.normSq (omega8 ^ k.val - 1) * Complex.normSq (dft8_mode k t)) =
        Complex.normSq (omega8 ^ k.val - 1) * (∑ t : Fin 8, Complex.normSq (dft8_mode k t)) := by
    -- `Finset.mul_sum` gives the reverse direction, so we use `.symm`.
    simpa using
      (Finset.mul_sum
        (s := (Finset.univ : Finset (Fin 8)))
        (f := fun t : Fin 8 => Complex.normSq (dft8_mode k t))
        (a := Complex.normSq (omega8 ^ k.val - 1))).symm
  rw [hfac, dft8_mode_normSq_sum]
  ring

/-- **Projection weight** of the φ-pattern onto the 8-tick basis:

`projectionScale * (rawWeightedNeutralEnergy / totalEnergy)`.

This makes the normalization and measure choice explicit. -/
noncomputable def w8_projected : ℝ :=
  projectionScale * (w8_dft_candidate / phiDFTEnergyTotal)

What this page does not claim

diffEnergy8 is not a physical law and does not by itself predict any measured quantity. The eight-tick cycle is not proven to be the only possible clock structure by this definition. The equality between w8_projected and the closed-form constant w8_from_eight_tick is not established in the library.

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/Projection.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: