cycle_power_dyadic_fold_model
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
- cycle_power_dyadic_tight_class_parentEquality in the dyadic class weight bound forces all rooted-tree parent implications at every smaller dyadic scale, uniformly in the arc…
- cycle_power_dyadic_class_weightThe weighted number of pairs in a dyadic arc: the endpoint pair has weight two, and distances 2^m-2^j for 1≤j<m have weight one.
- Used by 2
- cycle_power_dyadic_fold_struct_stepInduction step through the fold. If every model at exponent t (t ≥ 2) has alternating bit 1 and endpoint-only classes without bit 1, then…
- cycle_power_dyadic_defective_fold_model_of_corrected_periodicityFor any zero-phase defective dyadic model of exponent t+1, if the lower-half active count plus the defect is 2^t-periodic, folding each…
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.
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.
uses
cycle_power_dyadic_tight_class_parent,pow_succ,Nat.pow_le_pow_right,lt_of_lt_of_lehave 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
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).
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
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.
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_zerohave 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
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.
uses
if_neg,Finset.sum_congr,pow_succ,cycle_power_dyadic_fold_pair,Finset.mem_range.mphave 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)]
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.
uses
cycle_power_dyadic_class_weight,Finset.sum_range_succ,Nat.zero_addunfold 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
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.
uses
pow_succ,mul_two,cycle_power_dyadic_fold_tightintro 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), ?_, ?_, ?_⟩
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.
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)]
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.
· 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]
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.
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.
- The boolean reduction in cycle_power_dyadic_fold_pair (line 38) is performed by an exhaustive case analysis over all 16 truth assignments to four boolean variables.
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.
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