AFTD Auto-Formalizing Theoretical Domains

cycle_power_dyadic_fold_model

theoremverified

The fold of a tight dyadic class model. If x is a tight, exactly dyadically covered, fully covered integer Boolean class model at exponent t+1 (t ≥ 1) with t+2 active classes per vertex, and the left count A(v) = Σ_{a<2^t} x(v-a, a) is 2^t-periodic, then the fold y(p, a) = x(p, a) or x(p, a+2^t) is such a model at exponent t with t+1 active classes per vertex.

Statement

theorem cycle_power_dyadic_fold_model (t : ℕ) (ht : 1 ≤ t) (x : ℤ → ℕ → Bool)
    (htight : ∀ p, cycle_power_dyadic_class_weight (t+1) (x p) =
      (Finset.range (2^(t+1))).sum (fun a => (x p a).toNat))
    (hexact : ∀ j < t+1, ∀ v : ℤ, (Finset.range (2^j)).sum (fun a =>
      (x (v-(a : ℤ)) a && x (v-(a : ℤ)) (a+2^(t+1)-2^j)).toNat) = 1)
    (hcover : ∀ d : ℕ, 1 ≤ d → d < 2^(t+1) → ∀ v : ℤ,
      ∃ a : ℕ, a < 2^(t+1)-d ∧ x (v-(a : ℤ)) a = true ∧
        x (v-(a : ℤ)) (a+d) = true)
    (hcount : ∀ v : ℤ, (Finset.range (2^(t+1))).sum (fun a =>
      (x (v-(a : ℤ)) a).toNat) = (t+1)+1)
    (hfold : ∀ v : ℤ, (Finset.range (2^t)).sum (fun a => (x (v-(a : ℤ)) a).toNat) =
      (Finset.range (2^t)).sum (fun a => (x (v+(2:ℤ)^t-(a : ℤ)) a).toNat)) :
    let y : ℤ → ℕ → Bool := fun p a => x p a || x p (a + 2^t)
    (∀ p, cycle_power_dyadic_class_weight t (y p) =
      (Finset.range (2^t)).sum (fun a => (y p a).toNat)) ∧
    (∀ j < t, ∀ v : ℤ, (Finset.range (2^j)).sum (fun a =>
      (y (v-(a : ℤ)) a && y (v-(a : ℤ)) (a+2^t-2^j)).toNat) = 1) ∧
    (∀ d : ℕ, 1 ≤ d → d < 2^t → ∀ v : ℤ,
      ∃ a : ℕ, a < 2^t-d ∧ y (v-(a : ℤ)) a = true ∧
        y (v-(a : ℤ)) (a+d) = true) ∧
    (∀ v : ℤ, (Finset.range (2^t)).sum (fun a =>
      (y (v-(a : ℤ)) a).toNat) = t+1)
Source
RT-1 / OP-205 (arXiv:2610.15635, Theorems 1.3-1.4: eq(C_n^k) for k+1 = 2^m, n even, (k+1) not dividing n). Session 2026-11-09: folding offsets modulo 2^t (experiment 19407).
Verified
09 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 2
Used by 2

The proof, explained

The proof constructs the folded model y(p, a) = x(p, a) || x(p, a+2^t) and verifies its four defining properties at exponent t. Three preliminary lemmas show that tightness at exponent t+1 forces child-parent implications at scale t, which collapse folded dyadic pairs to original dyadic pairs and preserve tightness under folding. In the main theorem, tightness transfers fiberwise; exact dyadic covering follows term-by-term from the folded pair identity; full covering for distance d lifts to covering in x at distance d + 2^t; and the active class count is t+1 by combining the degree at v+2^t with periodicity and subtracting the unique scale-t overlap.

  1. In a tight class b at exponent t+1, b(a+2^t) implies b(a) for a < 2^(t-1), and b(a) implies b(a+2^t) for 2^(t-1) ≤ a < 2^t

    We specialize cycle_power_dyadic_tight_class_parent to exponent m = t+1 and scale j = t. Using the identity a + 2^(t+1) - 2^t = a + 2^t and the bound 2^(t-1) ≤ 2^t, the parent-child implications directly establish the forward and backward implications between a and a + 2^t.

    lines 6–15

    uses cycle_power_dyadic_tight_class_parent, pow_succ, Nat.pow_le_pow_right, lt_of_lt_of_le

      have P := cycle_power_dyadic_tight_class_parent (t+1) t ht (by omega) b htight
      have e : ∀ a : ℕ, a + 2^(t+1) - 2^t = a + 2^t := by
        intro a; rw [pow_succ]; omega
      have hle : (2:ℕ)^(t-1) ≤ 2^t := Nat.pow_le_pow_right (by norm_num) (by omega)
      constructor
      · intro a ha h
        exact (P a (lt_of_lt_of_le ha hle)).1 ha (by rw [e]; exact h)
      · intro a ha hlt h
        have := (P a hlt).2 ha h
        rwa [e] at this
  2. For any scale j < t and index i < 2^j, the folded dyadic conjunction equals the original dyadic conjunction at exponent t+1

    Since i < 2^j ≤ 2^(t-1), cycle_power_dyadic_fold_parents gives b(i + 2^t) → b(i), simplifying the first disjunction to b(i). The shifted index i + 2^t - 2^j lies in [2^(t-1), 2^t), so b(i + 2^t - 2^j) implies b(i + 2^(t+1) - 2^j), simplifying the second disjunction to b(i + 2^(t+1) - 2^j). Exhaustive case analysis over the truth values of the four boolean terms confirms that the conjunction of disjunctions reduces to b(i) && b(i + 2^(t+1) - 2^j).

    lines 23–38

    uses cycle_power_dyadic_fold_parents, Nat.pow_le_pow_right, pow_succ'

      obtain ⟨P1, P2⟩ := cycle_power_dyadic_fold_parents t ht b htight
      have hQ : (2:ℕ)^j ≤ 2^(t-1) := Nat.pow_le_pow_right (by norm_num) (by omega)
      have h2t : (2:ℕ)^t = 2 * 2^(t-1) := by
        rw [← pow_succ']; congr 1; omega
      have hs : (2:ℕ)^(t+1) = 2 * 2^t := by rw [pow_succ']
      have hc1 : 2^(t-1) ≤ i + 2^t - 2^j := by omega
      have hc2 : i + 2^t - 2^j < 2^t := by omega
      have hc3 : i + 2^t - 2^j + 2^t = i + 2^(t+1) - 2^j := by omega
      have h1 : b (i + 2^t) = true → b i = true := P1 i (by omega)
      have h2 : b (i + 2^t - 2^j) = true → b (i + 2^t - 2^j + 2^t) = true := P2 _ hc1 hc2
      rw [← hc3]
      generalize b (i + 2^t - 2^j + 2^t) = w at *
      generalize b (i + 2^t - 2^j) = u at *
      generalize b (i + 2^t) = y at *
      generalize b i = z at *
      cases z <;> cases y <;> cases u <;> cases w <;> simp_all
  3. The bit sum of b splits into the bit sum of the folded class plus the overlap conjunctions, and the boundary pair matches at j = 0

    Splitting the sum over range 2^(t+1) into two blocks of length 2^t and applying the boolean identity u + v = (u || v) + (u && v) decomposes the sum of bits of b into the folded bit sum plus the sum of overlaps b(a) && b(a + 2^t). Setting j = 0 and i = 0 in cycle_power_dyadic_fold_pair equates the boundary conjunction of the folded class to that of b.

    lines 45–54

    uses cycle_power_dyadic_fold_pair, pow_succ, mul_two, Finset.sum_range_add, Finset.sum_add_distrib, Finset.sum_congr, Nat.add_comm, Nat.zero_add, pow_zero

      have hpair := cycle_power_dyadic_fold_pair t ht b htight
      have hsize : (Finset.range (2^(t+1))).sum (fun a => (b a).toNat) =
          (Finset.range (2^t)).sum (fun a => (b a || b (a + 2^t)).toNat) +
          (Finset.range (2^t)).sum (fun a => (b a && b (a + 2^t)).toNat) := by
        rw [pow_succ, mul_two, Finset.sum_range_add, ← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
        refine Finset.sum_congr rfl fun a _ => ?_
        rw [Nat.add_comm (2^t) a]
        cases b a <;> cases b (a + 2^t) <;> rfl
      have h0 := hpair 0 0 (by omega) (by norm_num)
      simp only [Nat.zero_add, pow_zero] at h0
  4. The top-scale dyadic sum equals the overlap sum, and all lower-scale sums match term-by-term between the folded and original class

    At the top scale j = t, the dyadic conjunction term in the weight of b simplifies via 2^(t+1) - 2^t = 2^t to the overlap sum of b(a) && b(a + 2^t). At each lower scale 1 ≤ j < t, cycle_power_dyadic_fold_pair replaces each term in the dyadic sum for the folded class with the corresponding term for b.

    lines 55–71

    uses if_neg, Finset.sum_congr, pow_succ, cycle_power_dyadic_fold_pair, Finset.mem_range.mp

      have htop : (if t = 0 then 0 else (Finset.range (2^t)).sum
          (fun i => (b i && b (i + 2^(t+1) - 2^t)).toNat)) =
          (Finset.range (2^t)).sum (fun a => (b a && b (a + 2^t)).toNat) := by
        rw [if_neg (by omega)]
        refine Finset.sum_congr rfl fun a _ => ?_
        have : a + 2^(t+1) - 2^t = a + 2^t := by rw [pow_succ]; omega
        rw [this]
      have hrest : (Finset.range t).sum (fun j => if j = 0 then 0 else
          (Finset.range (2^j)).sum (fun i =>
            ((b i || b (i + 2^t)) && (b (i + 2^t - 2^j) || b (i + 2^t - 2^j + 2^t))).toNat)) =
          (Finset.range t).sum (fun j => if j = 0 then 0 else
          (Finset.range (2^j)).sum (fun i => (b i && b (i + 2^(t+1) - 2^j)).toNat)) := by
        refine Finset.sum_congr rfl fun j hj => ?_
        split_ifs
        · rfl
        · refine Finset.sum_congr rfl fun i hi => ?_
          rw [hpair j i (Finset.mem_range.mp hj) (Finset.mem_range.mp hi)]
  5. The folded class y(a) = b(a) || b(a + 2^t) is tight at exponent t

    We unfold cycle_power_dyadic_class_weight at both exponents. In the tightness equation for b at exponent t+1, we isolate the top scale j = t (which equals the overlap sum) and substitute the decomposed Hamming weight. Canceling the overlap sum from both sides leaves the tightness equation for the folded class at exponent t.

    lines 72–76

    uses cycle_power_dyadic_class_weight, Finset.sum_range_succ, Nat.zero_add

      unfold cycle_power_dyadic_class_weight at htight ⊢
      rw [Finset.sum_range_succ, htop, hsize] at htight
      simp only []
      rw [hrest, show (0 + 2^t : ℕ) = 2^t from Nat.zero_add _, h0]
      omega
  6. The folded model y has tight classes at every position p

    We introduce y(p, a) = x(p, a) || x(p, a + 2^t) and expand 2^(t+1) = 2^t + 2^t. Fiberwise tightness of x at exponent t+1 implies fiberwise tightness of y at exponent t by cycle_power_dyadic_fold_tight.

    lines 100–102

    uses pow_succ, mul_two, cycle_power_dyadic_fold_tight

      intro y
      have hs : (2:ℕ)^(t+1) = 2^t + 2^t := by rw [pow_succ, mul_two]
      refine ⟨fun p => cycle_power_dyadic_fold_tight t ht (x p) (htight p), ?_, ?_, ?_⟩
  7. The folded model satisfies exact dyadic covering at every scale j < t

    For any scale j < t and vertex v, each term in the dyadic sum for y is a folded pair conjunction. By cycle_power_dyadic_fold_pair, this term equals the original term for x at scale j < t+1, so the sum equals 1 by exact dyadic covering of x.

    lines 103–108

    uses Finset.sum_congr, cycle_power_dyadic_fold_pair, Finset.mem_range.mp

      · intro j hj v
        rw [← hexact j (by omega) v]
        refine Finset.sum_congr rfl fun a ha => ?_
        show (((x (v-(a:ℤ)) a || x (v-(a:ℤ)) (a+2^t)) &&
          (x (v-(a:ℤ)) (a+2^t-2^j) || x (v-(a:ℤ)) (a+2^t-2^j+2^t))).toNat) = _
        rw [cycle_power_dyadic_fold_pair t ht (x (v-(a:ℤ))) (htight _) j a hj (Finset.mem_range.mp ha)]
  8. The folded model satisfies full covering for every distance 1 ≤ d < 2^t

    Given 1 ≤ d < 2^t, full covering for x applied to distance d + 2^t < 2^(t+1) produces an offset a < 2^t - d with x(v-a, a) = true and x(v-a, a + d + 2^t) = true. Since x implies y, both y(v-a, a) and y(v-a, a+d) hold.

    lines 109–115

      · intro d hd1 hd2 v
        obtain ⟨a, ha, h1, h2⟩ := hcover (d + 2^t) (by omega) (by omega) v
        refine ⟨a, by omega, ?_, ?_⟩
        · simp [y, h1]
        · have e : a + (d + 2^t) = a + d + 2^t := by ring
          rw [e] at h2
          simp [y, h2]
  9. Each vertex in the folded model has exactly t+1 active classes

    Exact covering of x at scale t shows that the overlap sum of x(v-a, a) && x(v-a, a+2^t) equals 1. Total vertex degree at v + 2^t is t+2; splitting the sum at 2^t and using 2^t-periodicity of the left count shows that the sum of x(v-a, a) plus x(v-a, a+2^t) is t+2. Using (u || v) + (u && v) = u + v, the folded sum plus the overlap (which is 1) equals t+2, leaving t+1 active classes.

    lines 116–141

    uses Finset.sum_congr, pow_succ, Finset.sum_range_add, Nat.add_comm, Finset.sum_add_distrib

      · intro v
        have hP : (Finset.range (2^t)).sum (fun a =>
            (x (v-(a : ℤ)) a && x (v-(a : ℤ)) (a+2^t)).toNat) = 1 := by
          rw [← hexact t (by omega) v]
          refine Finset.sum_congr rfl fun a _ => ?_
          have : a + 2^(t+1) - 2^t = a + 2^t := by rw [pow_succ]; omega
          rw [this]
        have hC := hcount (v + (2:ℤ)^t)
        rw [hs, Finset.sum_range_add] at hC
        have hB : (Finset.range (2^t)).sum (fun i =>
            (x (v + (2:ℤ)^t - ((2^t + i : ℕ) : ℤ)) (2^t + i)).toNat) =
            (Finset.range (2^t)).sum (fun a => (x (v-(a : ℤ)) (a+2^t)).toNat) := by
          refine Finset.sum_congr rfl fun i _ => ?_
          have e1 : v + (2:ℤ)^t - ((2^t + i : ℕ) : ℤ) = v - (i : ℤ) := by push_cast; ring
          rw [e1, Nat.add_comm (2^t) i]
        rw [hB, ← hfold v] at hC
        have hF : (Finset.range (2^t)).sum (fun a => (y (v-(a : ℤ)) a).toNat) +
            (Finset.range (2^t)).sum (fun a =>
              (x (v-(a : ℤ)) a && x (v-(a : ℤ)) (a+2^t)).toNat) =
            (Finset.range (2^t)).sum (fun a => (x (v-(a : ℤ)) a).toNat) +
            (Finset.range (2^t)).sum (fun a => (x (v-(a : ℤ)) (a+2^t)).toNat) := by
          rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib]
          refine Finset.sum_congr rfl fun a _ => ?_
          show (x (v-(a:ℤ)) a || x (v-(a:ℤ)) (a+2^t)).toNat + _ = _
          cases x (v-(a:ℤ)) a <;> cases x (v-(a:ℤ)) (a+2^t) <;> rfl
        omega
cycle_power_dyadic_tight_class_parent
In a tight class at exponent m, an active element in the lower half of a dyadic block at scale j < m is implied by its partner, and an active element in the upper half implies its partner.
pow_succ
Successor power identity: a^(n+1) = a^n * a.
Nat.pow_le_pow_right
Powers of a positive integer are monotonic in the exponent: if i ≤ j and n > 0 then n^i ≤ n^j.
lt_of_lt_of_le
Transitivity of strict inequality with non-strict inequality: if a < b and b ≤ c then a < c.
cycle_power_dyadic_fold_parents
For a tight class at exponent t+1, an active bit at a+2^t implies the bit at a for a < 2^(t-1), while an active bit at a implies the bit at a+2^t for 2^(t-1) ≤ a < 2^t.
pow_succ'
Successor power identity: a^(n+1) = a * a^n.
cycle_power_dyadic_fold_pair
The dyadic conjunction for folded classes at scale j < t equals the scale-(t+1) dyadic conjunction for the original class.
mul_two
Multiplying by two equals self-addition: n * 2 = n + n.
Finset.sum_range_add
Splitting a sum over range (n + m) into the sum over range n and the shifted sum over range m.
Finset.sum_add_distrib
Distributing summation over addition: the sum of f + g is the sum of f plus the sum of g.
Finset.sum_congr
Congruence for finite sums: equal functions on equal index sets have equal sums.
Nat.add_comm
Commutativity of addition: n + m = m + n.
Nat.zero_add
Zero is the left identity for natural addition: 0 + n = n.
pow_zero
Any element to the zeroth power is 1: a^0 = 1.
if_neg
An if-then-else evaluates to the else-branch when the condition is false.
Finset.mem_range.mp
An element belonging to Finset.range n is strictly less than n.
cycle_power_dyadic_class_weight
The dyadic weight of a boolean class b at exponent m: twice the boundary product plus the sum of dyadic conjunctions over scales 1 ≤ j < m.
Finset.sum_range_succ
Splitting the last term from a range sum: the sum over range (n+1) is the sum over range n plus the n-th term.
cycle_power_dyadic_fold_tight
Folding a tight class at exponent t+1 yields a tight class at exponent t.

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

theorem cycle_power_dyadic_fold_parents (t : ℕ) (ht : 1 ≤ t) (b : ℕ → Bool)    (htight : cycle_power_dyadic_class_weight (t+1) b =      (Finset.range (2^(t+1))).sum (fun a => (b a).toNat)) :    (∀ a, a < 2^(t-1) → b (a + 2^t) = true → b a = true) ∧    (∀ a, 2^(t-1) ≤ a → a < 2^t → b a = true → b (a + 2^t) = true) := by  have P := cycle_power_dyadic_tight_class_parent (t+1) t ht (by omega) b htight  have e : ∀ a : ℕ, a + 2^(t+1) - 2^t = a + 2^t := by    intro a; rw [pow_succ]; omega  have hle : (2:ℕ)^(t-1) ≤ 2^t := Nat.pow_le_pow_right (by norm_num) (by omega)  constructor  · intro a ha h    exact (P a (lt_of_lt_of_le ha hle)).1 ha (by rw [e]; exact h)  · intro a ha hlt h    have := (P a hlt).2 ha h    rwa [e] at thistheorem cycle_power_dyadic_fold_pair (t : ℕ) (ht : 1 ≤ t) (b : ℕ → Bool)    (htight : cycle_power_dyadic_class_weight (t+1) b =      (Finset.range (2^(t+1))).sum (fun a => (b a).toNat))    (j i : ℕ) (hj : j < t) (hi : i < 2^j) :    ((b i || b (i + 2^t)) && (b (i + 2^t - 2^j) || b (i + 2^t - 2^j + 2^t))) =      (b i && b (i + 2^(t+1) - 2^j)) := by  obtain ⟨P1, P2⟩ := cycle_power_dyadic_fold_parents t ht b htight  have hQ : (2:ℕ)^j ≤ 2^(t-1) := Nat.pow_le_pow_right (by norm_num) (by omega)  have h2t : (2:ℕ)^t = 2 * 2^(t-1) := by    rw [← pow_succ']; congr 1; omega  have hs : (2:ℕ)^(t+1) = 2 * 2^t := by rw [pow_succ']  have hc1 : 2^(t-1) ≤ i + 2^t - 2^j := by omega  have hc2 : i + 2^t - 2^j < 2^t := by omega  have hc3 : i + 2^t - 2^j + 2^t = i + 2^(t+1) - 2^j := by omega  have h1 : b (i + 2^t) = true → b i = true := P1 i (by omega)  have h2 : b (i + 2^t - 2^j) = true → b (i + 2^t - 2^j + 2^t) = true := P2 _ hc1 hc2  rw [← hc3]  generalize b (i + 2^t - 2^j + 2^t) = w at *  generalize b (i + 2^t - 2^j) = u at *  generalize b (i + 2^t) = y at *  generalize b i = z at *  cases z <;> cases y <;> cases u <;> cases w <;> simp_alltheorem cycle_power_dyadic_fold_tight (t : ℕ) (ht : 1 ≤ t) (b : ℕ → Bool)    (htight : cycle_power_dyadic_class_weight (t+1) b =      (Finset.range (2^(t+1))).sum (fun a => (b a).toNat)) :    cycle_power_dyadic_class_weight t (fun a => b a || b (a + 2^t)) =      (Finset.range (2^t)).sum (fun a => (b a || b (a + 2^t)).toNat) := by  have hpair := cycle_power_dyadic_fold_pair t ht b htight  have hsize : (Finset.range (2^(t+1))).sum (fun a => (b a).toNat) =      (Finset.range (2^t)).sum (fun a => (b a || b (a + 2^t)).toNat) +      (Finset.range (2^t)).sum (fun a => (b a && b (a + 2^t)).toNat) := by    rw [pow_succ, mul_two, Finset.sum_range_add, ← Finset.sum_add_distrib, ← Finset.sum_add_distrib]    refine Finset.sum_congr rfl fun a _ => ?_    rw [Nat.add_comm (2^t) a]    cases b a <;> cases b (a + 2^t) <;> rfl  have h0 := hpair 0 0 (by omega) (by norm_num)  simp only [Nat.zero_add, pow_zero] at h0  have htop : (if t = 0 then 0 else (Finset.range (2^t)).sum      (fun i => (b i && b (i + 2^(t+1) - 2^t)).toNat)) =      (Finset.range (2^t)).sum (fun a => (b a && b (a + 2^t)).toNat) := by    rw [if_neg (by omega)]    refine Finset.sum_congr rfl fun a _ => ?_    have : a + 2^(t+1) - 2^t = a + 2^t := by rw [pow_succ]; omega    rw [this]  have hrest : (Finset.range t).sum (fun j => if j = 0 then 0 else      (Finset.range (2^j)).sum (fun i =>        ((b i || b (i + 2^t)) && (b (i + 2^t - 2^j) || b (i + 2^t - 2^j + 2^t))).toNat)) =      (Finset.range t).sum (fun j => if j = 0 then 0 else      (Finset.range (2^j)).sum (fun i => (b i && b (i + 2^(t+1) - 2^j)).toNat)) := by    refine Finset.sum_congr rfl fun j hj => ?_    split_ifs    · rfl    · refine Finset.sum_congr rfl fun i hi => ?_      rw [hpair j i (Finset.mem_range.mp hj) (Finset.mem_range.mp hi)]  unfold cycle_power_dyadic_class_weight at htight ⊢  rw [Finset.sum_range_succ, htop, hsize] at htight  simp only []  rw [hrest, show (0 + 2^t : ℕ) = 2^t from Nat.zero_add _, h0]  omegatheorem cycle_power_dyadic_fold_model (t : ℕ) (ht : 1 ≤ t) (x : ℤ → ℕ → Bool)    (htight : ∀ p, cycle_power_dyadic_class_weight (t+1) (x p) =      (Finset.range (2^(t+1))).sum (fun a => (x p a).toNat))    (hexact : ∀ j < t+1, ∀ v : ℤ, (Finset.range (2^j)).sum (fun a =>      (x (v-(a : ℤ)) a && x (v-(a : ℤ)) (a+2^(t+1)-2^j)).toNat) = 1)    (hcover : ∀ d : ℕ, 1 ≤ d → d < 2^(t+1) → ∀ v : ℤ,      ∃ a : ℕ, a < 2^(t+1)-d ∧ x (v-(a : ℤ)) a = true ∧        x (v-(a : ℤ)) (a+d) = true)    (hcount : ∀ v : ℤ, (Finset.range (2^(t+1))).sum (fun a =>      (x (v-(a : ℤ)) a).toNat) = (t+1)+1)    (hfold : ∀ v : ℤ, (Finset.range (2^t)).sum (fun a => (x (v-(a : ℤ)) a).toNat) =      (Finset.range (2^t)).sum (fun a => (x (v+(2:ℤ)^t-(a : ℤ)) a).toNat)) :    let y : ℤ → ℕ → Bool := fun p a => x p a || x p (a + 2^t)    (∀ p, cycle_power_dyadic_class_weight t (y p) =      (Finset.range (2^t)).sum (fun a => (y p a).toNat)) ∧    (∀ j < t, ∀ v : ℤ, (Finset.range (2^j)).sum (fun a =>      (y (v-(a : ℤ)) a && y (v-(a : ℤ)) (a+2^t-2^j)).toNat) = 1) ∧    (∀ d : ℕ, 1 ≤ d → d < 2^t → ∀ v : ℤ,      ∃ a : ℕ, a < 2^t-d ∧ y (v-(a : ℤ)) a = true ∧        y (v-(a : ℤ)) (a+d) = true) ∧    (∀ v : ℤ, (Finset.range (2^t)).sum (fun a =>      (y (v-(a : ℤ)) a).toNat) = t+1) := by  intro y  have hs : (2:ℕ)^(t+1) = 2^t + 2^t := by rw [pow_succ, mul_two]  refine ⟨fun p => cycle_power_dyadic_fold_tight t ht (x p) (htight p), ?_, ?_, ?_⟩  · intro j hj v    rw [← hexact j (by omega) v]    refine Finset.sum_congr rfl fun a ha => ?_    show (((x (v-(a:ℤ)) a || x (v-(a:ℤ)) (a+2^t)) &&      (x (v-(a:ℤ)) (a+2^t-2^j) || x (v-(a:ℤ)) (a+2^t-2^j+2^t))).toNat) = _    rw [cycle_power_dyadic_fold_pair t ht (x (v-(a:ℤ))) (htight _) j a hj (Finset.mem_range.mp ha)]  · intro d hd1 hd2 v    obtain ⟨a, ha, h1, h2⟩ := hcover (d + 2^t) (by omega) (by omega) v    refine ⟨a, by omega, ?_, ?_⟩    · simp [y, h1]    · have e : a + (d + 2^t) = a + d + 2^t := by ring      rw [e] at h2      simp [y, h2]  · intro v    have hP : (Finset.range (2^t)).sum (fun a =>        (x (v-(a : ℤ)) a && x (v-(a : ℤ)) (a+2^t)).toNat) = 1 := by      rw [← hexact t (by omega) v]      refine Finset.sum_congr rfl fun a _ => ?_      have : a + 2^(t+1) - 2^t = a + 2^t := by rw [pow_succ]; omega      rw [this]    have hC := hcount (v + (2:ℤ)^t)    rw [hs, Finset.sum_range_add] at hC    have hB : (Finset.range (2^t)).sum (fun i =>        (x (v + (2:ℤ)^t - ((2^t + i : ℕ) : ℤ)) (2^t + i)).toNat) =        (Finset.range (2^t)).sum (fun a => (x (v-(a : ℤ)) (a+2^t)).toNat) := by      refine Finset.sum_congr rfl fun i _ => ?_      have e1 : v + (2:ℤ)^t - ((2^t + i : ℕ) : ℤ) = v - (i : ℤ) := by push_cast; ring      rw [e1, Nat.add_comm (2^t) i]    rw [hB, ← hfold v] at hC    have hF : (Finset.range (2^t)).sum (fun a => (y (v-(a : ℤ)) a).toNat) +        (Finset.range (2^t)).sum (fun a =>          (x (v-(a : ℤ)) a && x (v-(a : ℤ)) (a+2^t)).toNat) =        (Finset.range (2^t)).sum (fun a => (x (v-(a : ℤ)) a).toNat) +        (Finset.range (2^t)).sum (fun a => (x (v-(a : ℤ)) (a+2^t)).toNat) := by      rw [← Finset.sum_add_distrib, ← Finset.sum_add_distrib]      refine Finset.sum_congr rfl fun a _ => ?_      show (x (v-(a:ℤ)) a || x (v-(a:ℤ)) (a+2^t)).toNat + _ = _      cases x (v-(a:ℤ)) a <;> cases x (v-(a:ℤ)) (a+2^t) <;> rfl    omega
See it in the graphDiscuss this resultChallenge it