AFTD Auto-Formalizing Theoretical Domains

cycle_power_dyadic_domain_wall_exact

theoremverified

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
Used by 2

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.

  1. 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.

    line 10

      interval_cases j
  2. 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.

    lines 11–32

    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
  3. 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.

    lines 33–54

    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
  4. 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.

    lines 55–57

          · have hlo : -3 ≤ v := by omega
            have hhi : v ≤ 10 := by omega
            interval_cases v <;> decide
  5. 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`.

    lines 58–79

    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
  6. 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`.

    lines 80–101

    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
  7. 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.

    lines 102–104

          · have hlo : -3 ≤ v := by omega
            have hhi : v ≤ 10 := by omega
            interval_cases v <;> decide
  8. 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`.

    lines 105–126

    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
  9. 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}.

    lines 127–148

    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
  10. 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.

    lines 149–151

          · 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.

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

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
See it in the graphDiscuss this resultChallenge it