cycle_power_dyadic_domain_wall_exact
Every dyadic long-distance edge has exactly one root owner in the explicit radius-eight model, at every integer vertex.
Statement
theorem cycle_power_dyadic_domain_wall_exact (j : ℕ) (hj : j < 3) (v : ℤ) : (range (2^j)).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (a+8-2^j)).toNat) = 1
- Source
- OP-205 / RT-1 structural-hypothesis audit following arXiv:2610.15635. A compact five-exception version of the previously computed nonperiodic domain wall6554 was independently audited in experiment7315. This formal countermodel addresses a stronger auxiliary statement without counts or periodicity; it is not a graph cover, a periodic model, an OP-205 refutation, or a research advance.
- Verified
- 28 Oct 2026
- Axioms
Classical.choiceQuot.soundpropext- Built on 3
- cycle_power_dyadic_domain_wallAn explicit radius-eight Boolean rooted-profile system on the integers: a two-periodic left tail and a four-periodic right tail, with…
- cycle_power_dyadic_domain_wall_leftFor roots at most-4, the explicit domain-wall profile equals its two-periodic left tail.
- cycle_power_dyadic_domain_wall_rightFor roots at least4, the explicit domain-wall profile equals its four-periodic right tail.
- Used by 2
- cycle_power_dyadic_count_free_boundary_endpoint_counterexampleThere exists a radius-eight Boolean integer class model with tight classes, exact dyadic ownership, full ordinary distance coverage, and…
- cycle_power_dyadic_count_free_nonperiodic_shape_counterexampleThere exists a genuinely nonperiodic tight radius-eight integer class system with exact dyadic edge ownership and coverage of every…
The proof, explained
The proof proceeds by case analysis on the dyadic scale parameter j < 3, splitting into j = 0, j = 1, and j = 2. For each scale, the vertex v is partitioned into three regions: the left asymptotic regime v ≤ -4, the right asymptotic regime v ≥ 11, and the intermediate interval -3 ≤ v ≤ 10. In both asymptotic regimes, domain wall asymptotic lemmas reduce the evaluation to periodic behavior modulo 2 and modulo 4, allowing the sum over a < 2^j to be verified by exhausting the residue of v modulo 4. In the intermediate interval, the finite set of 14 remaining integers is verified directly by decision-procedure computation.
It suffices to prove the identity for the three dyadic scales j = 0, j = 1, and j = 2.
Since j is a natural number with j < 3, the tactic `interval_cases` splits the goal into the three cases j = 0, j = 1, and j = 2.
interval_cases j
For j = 0 and v ≤ -4, the sum equals 1.
When v ≤ -4, every offset v - a for a < 8 satisfies v - a ≤ -4. By `cycle_power_dyadic_domain_wall_left`, the domain wall values depend only on (v - a) % 2. Setting r = v % 4, we have (v - a) % 2 = (r - a) % 2. Using `sum_congr` and `lt_of_lt_of_le`, the sum over range (2^0) is rewritten into a simplified boolean function f depending only on r and a. Exhausting the four residue classes r ∈ {0, 1, 2, 3} with `decide` verifies that the sum is 1 in every case.
uses
cycle_power_dyadic_domain_wall_left,sum_congr,lt_of_lt_of_le· by_cases hL : v ≤ -4 · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 2 = 0 then 129 else 243 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_left (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 2 = (r-(a : ℤ)) % 2 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^0) (by norm_num) (fun a => a+8-2^0)] dsimp only [f] interval_cases r <;> decide
For j = 0 and v ≥ 11, the sum equals 1.
When v ≥ 11, every offset v - a for a < 8 satisfies v - a ≥ 4. By `cycle_power_dyadic_domain_wall_right`, the domain wall values are periodic modulo 4, depending only on (v - a) % 4. Setting r = v % 4, we have (v - a) % 4 = (r - a) % 4. Rewriting the sum via `sum_congr` and `lt_of_lt_of_le` in terms of r, evaluating each residue r ∈ {0, 1, 2, 3} by `decide` shows the sum is 1.
uses
cycle_power_dyadic_domain_wall_right,sum_congr,lt_of_lt_of_le· by_cases hR : 11 ≤ v · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 4 = 1 then 195 else if (r-(a : ℤ)) % 4 = 3 then 255 else 129 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_right (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 4 = (r-(a : ℤ)) % 4 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^0) (by norm_num) (fun a => a+8-2^0)] dsimp only [f] interval_cases r <;> decide
For j = 0 and -3 ≤ v ≤ 10, the sum equals 1, completing the case j = 0.
The remaining integers satisfy -3 ≤ v ≤ 10 by linear arithmetic (`omega`). The tactic `interval_cases` iterates through all 14 individual integer values of v, and `decide` verifies the identity for each by direct computation.
· have hlo : -3 ≤ v := by omega have hhi : v ≤ 10 := by omega interval_cases v <;> decide
For j = 1 and v ≤ -4, the sum over a ∈ {0, 1} equals 1.
Since v ≤ -4 and a < 2^1 ≤ 8, we have v - a ≤ -4. By `cycle_power_dyadic_domain_wall_left`, the summand depends only on (v - a) % 2 = (r - a) % 2 where r = v % 4. We rewrite the sum using `sum_congr` and `lt_of_lt_of_le`, and check all four residue classes r ∈ {0, 1, 2, 3} using `decide`.
uses
cycle_power_dyadic_domain_wall_left,sum_congr,lt_of_lt_of_le· by_cases hL : v ≤ -4 · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 2 = 0 then 129 else 243 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_left (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 2 = (r-(a : ℤ)) % 2 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^1) (by norm_num) (fun a => a+8-2^1)] dsimp only [f] interval_cases r <;> decide
For j = 1 and v ≥ 11, the sum over a ∈ {0, 1} equals 1.
Since v ≥ 11 and a < 2^1 ≤ 8, we have v - a ≥ 4. By `cycle_power_dyadic_domain_wall_right`, the values depend only on (v - a) % 4 = (r - a) % 4 with r = v % 4. We rewrite the sum using `sum_congr` and `lt_of_lt_of_le`, and verify all four residues r ∈ {0, 1, 2, 3} using `decide`.
uses
cycle_power_dyadic_domain_wall_right,sum_congr,lt_of_lt_of_le· by_cases hR : 11 ≤ v · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 4 = 1 then 195 else if (r-(a : ℤ)) % 4 = 3 then 255 else 129 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_right (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 4 = (r-(a : ℤ)) % 4 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^1) (by norm_num) (fun a => a+8-2^1)] dsimp only [f] interval_cases r <;> decide
For j = 1 and -3 ≤ v ≤ 10, the sum equals 1, completing the case j = 1.
For the intermediate integers -3 ≤ v ≤ 10 established by `omega`, `interval_cases` and `decide` verify the identity by explicit computation for each of the 14 integer vertices.
· have hlo : -3 ≤ v := by omega have hhi : v ≤ 10 := by omega interval_cases v <;> decide
For j = 2 and v ≤ -4, the sum over a ∈ {0, 1, 2, 3} equals 1.
Since v ≤ -4 and a < 2^2 ≤ 8, each v - a ≤ -4. By `cycle_power_dyadic_domain_wall_left`, the terms depend only on (v - a) % 2 = (r - a) % 2 where r = v % 4. Using `sum_congr` and `lt_of_lt_of_le`, the sum over range (2^2) is reduced to a function of r and a, verified for all r ∈ {0, 1, 2, 3} by `decide`.
uses
cycle_power_dyadic_domain_wall_left,sum_congr,lt_of_lt_of_le· by_cases hL : v ≤ -4 · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 2 = 0 then 129 else 243 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_left (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 2 = (r-(a : ℤ)) % 2 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^2) (by norm_num) (fun a => a+8-2^2)] dsimp only [f] interval_cases r <;> decide
For j = 2 and v ≥ 11, the sum over a ∈ {0, 1, 2, 3} equals 1.
Since v ≥ 11 and a < 2^2 ≤ 8, we have v - a ≥ 4. By `cycle_power_dyadic_domain_wall_right`, the terms depend only on (v - a) % 4 = (r - a) % 4 with r = v % 4. Using `sum_congr` and `lt_of_lt_of_le`, the sum is reduced to the residue r, which `decide` verifies for each r ∈ {0, 1, 2, 3}.
uses
cycle_power_dyadic_domain_wall_right,sum_congr,lt_of_lt_of_le· by_cases hR : 11 ≤ v · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 4 = 1 then 195 else if (r-(a : ℤ)) % 4 = 3 then 255 else 129 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_right (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 4 = (r-(a : ℤ)) % 4 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^2) (by norm_num) (fun a => a+8-2^2)] dsimp only [f] interval_cases r <;> decide
For j = 2 and -3 ≤ v ≤ 10, the sum equals 1, completing the case j = 2 and the theorem.
For the remaining 14 integers in -3 ≤ v ≤ 10 bounded by `omega`, `interval_cases` and `decide` evaluate the sum for each vertex directly, concluding the proof.
· have hlo : -3 ≤ v := by omega have hhi : v ≤ 10 := by omega interval_cases v <;> decide
cycle_power_dyadic_domain_wall_left- For any position p ≤ -4 and bit index a, the domain wall value at (p, a) depends only on p % 2, given by bit a of 129 if p is even and 243 if p is odd.
cycle_power_dyadic_domain_wall_right- For any position p ≥ 4 and bit index a, the domain wall value at (p, a) depends only on p % 4, given by bit a of 195 if p ≡ 1 mod 4, 255 if p ≡ 3 mod 4, and 129 otherwise.
sum_congr- If two finite sets are equal and two functions agree on every element of the set, their sums over that set are equal.
lt_of_lt_of_le- In a preorder, if a < b and b ≤ c, then a < c.
- The bitmask constants (such as 129, 195, 243, 255) encode the explicit domain wall patterns of the radius-eight model. The residue cases modulo 4 and the intermediate values -3 ≤ v ≤ 10 are verified by Lean's computational evaluator (`decide`).
Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.
Lean source view module on GitHub
Choose a tactic — a marked line — to see the goals Lean had before and after it, as in Lean’s infoview. Step with ← → or j k.
open Finsetset_option maxHeartbeats 2000000set_option maxRecDepth 10000theorem cycle_power_dyadic_domain_wall_exact (j : ℕ) (hj : j < 3) (v : ℤ) : (range (2^j)).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (a+8-2^j)).toNat) = 1 := by interval_cases j · by_cases hL : v ≤ -4 · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 2 = 0 then 129 else 243 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_left (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 2 = (r-(a : ℤ)) % 2 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^0) (by norm_num) (fun a => a+8-2^0)] dsimp only [f] interval_cases r <;> decide · by_cases hR : 11 ≤ v · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 4 = 1 then 195 else if (r-(a : ℤ)) % 4 = 3 then 255 else 129 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_right (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 4 = (r-(a : ℤ)) % 4 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^0) (by norm_num) (fun a => a+8-2^0)] dsimp only [f] interval_cases r <;> decide · have hlo : -3 ≤ v := by omega have hhi : v ≤ 10 := by omega interval_cases v <;> decide · by_cases hL : v ≤ -4 · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 2 = 0 then 129 else 243 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_left (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 2 = (r-(a : ℤ)) % 2 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^1) (by norm_num) (fun a => a+8-2^1)] dsimp only [f] interval_cases r <;> decide · by_cases hR : 11 ≤ v · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 4 = 1 then 195 else if (r-(a : ℤ)) % 4 = 3 then 255 else 129 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_right (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 4 = (r-(a : ℤ)) % 4 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^1) (by norm_num) (fun a => a+8-2^1)] dsimp only [f] interval_cases r <;> decide · have hlo : -3 ≤ v := by omega have hhi : v ≤ 10 := by omega interval_cases v <;> decide · by_cases hL : v ≤ -4 · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 2 = 0 then 129 else 243 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_left (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 2 = (r-(a : ℤ)) % 2 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^2) (by norm_num) (fun a => a+8-2^2)] dsimp only [f] interval_cases r <;> decide · by_cases hR : 11 ≤ v · generalize hr : v % 4 = r have hr0 : 0 ≤ r := by omega have hr4 : r < 4 := by omega let f : ℕ → ℕ → Bool := fun a b => (if (r-(a : ℤ)) % 4 = 1 then 195 else if (r-(a : ℤ)) % 4 = 3 then 255 else 129 : ℕ).testBit b have hx (a : ℕ) (ha : a < 8) (b : ℕ) : cycle_power_dyadic_domain_wall (v-(a : ℤ)) b = f a b := by rw [cycle_power_dyadic_domain_wall_right (v-(a : ℤ)) (by omega) b] have he : (v-(a : ℤ)) % 4 = (r-(a : ℤ)) % 4 := by omega rw [he] have heq (N : ℕ) (hN : N ≤ 8) (g : ℕ → ℕ) : (range N).sum (fun a => (cycle_power_dyadic_domain_wall (v-(a : ℤ)) a && cycle_power_dyadic_domain_wall (v-(a : ℤ)) (g a)).toNat) = (range N).sum (fun a => (f a a && f a (g a)).toNat) := by apply sum_congr rfl intro a ha have ha8 : a < 8 := lt_of_lt_of_le (mem_range.mp ha) hN rw [hx a ha8 a, hx a ha8 (g a)] rw [heq (2^2) (by norm_num) (fun a => a+8-2^2)] dsimp only [f] interval_cases r <;> decide · have hlo : -3 ≤ v := by omega have hhi : v ≤ 10 := by omega interval_cases v <;> decide