File size: 16,021 Bytes
e320e82
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
import OAI.Combinatorics.FiniteCircle.CircleWords

namespace OAI

namespace FiniteCircle

open scoped BigOperators List

abbrev MaskResidues (h : ℕ) (p : ℕ → ℕ → ℕ) (l : ℕ) := (k : Fin h) → ZMod (p l k)

noncomputable def maskPhaseHom (h : ℕ) (p : ℕ → ℕ → ℕ) (M l : ℕ)
    (hd : ∀ k : Fin h, p l k ∣ M) : MaskResidues h p l →+ (MaskTag h p l → ZMod M) where
  toFun z j := (∑ k, subcircle (hd k) (z k)) + j.2.val • subcircle (hd j.1) (z j.1)
  map_zero' := by funext j; simp
  map_add' z u := by
    funext j
    simp only [Pi.add_apply, map_add, Finset.sum_add_distrib, nsmul_add]
    abel

 theorem maskPhaseHom_natCast (h : ℕ) (p : ℕ → ℕ → ℕ) (M l a : ℕ)
    (hd : ∀ k : Fin h, p l k ∣ M) (hn : ∀ k : Fin h, 0 < p l k) :
    maskPhaseHom h p M l hd (fun k => (a : ZMod (p l k))) = maskGamma h p M l a := by
  funext j
  change (∑ k, subcircle (hd k) (a : ZMod (p l k))) +
    j.2.val • subcircle (hd j.1) (a : ZMod (p l j.1)) = _
  have he (k : Fin h) : subcircle (hd k) (a : ZMod (p l k)) =
    ((M/p l k*(a%p l k) : ℕ) : ZMod M) := by
    let : NeZero (p l k) := ⟨(hn k).ne'⟩
    rw [subcircle_val, ZMod.val_natCast]
  simp_rw [he]
  simp only [maskGamma, nsmul_eq_mul, Nat.cast_mul]
  ring

 theorem sum_fin_zmod {p : ℕ} [NeZero p] (g : ZMod p → ℝ) :
    ∑ b : Fin p, g (b.val : ZMod p) = ∑ b : ZMod p, g b := by
  refine Fintype.sum_equiv (ZMod.finEquiv p).toEquiv _ _ ?_
  intro b
  congr 1
  cases p with
  | zero => exact Fin.elim0 b
  | succ p =>
    change (b.val : ZMod (p+1)) = b
    exact ZMod.natCast_zmod_val (show ZMod (p+1) from b)

noncomputable def maskCost (h : ℕ) (p : ℕ → ℕ → ℕ) (M : ℕ)
    (hd : ∀ l (k : Fin h), p l k ∣ M) (hn : ∀ l (k : Fin h), 0 < p l k) :
    ℕ → PhaseCost (ZMod M)
  | 0 => circlePhaseCost M
  | l+1 => by
    let : ∀ k : Fin h, NeZero (p (l+1) k) := fun k => ⟨(hn _ k).ne'⟩
    exact (maskCost h p M hd hn l).step (maskPhaseHom h p M (l+1) (hd _))

 theorem maskCost_le_half {h M : ℕ} {p : ℕ → ℕ → ℕ} [NeZero M]
    (hh : 0 < h) (hd : ∀ l (k : Fin h), p l k ∣ M) (hn : ∀ l (k : Fin h), 0 < p l k)
    (l : ℕ) (x : ZMod M) : maskCost h p M hd hn l x ≤ 1/2 := by
  induction l with
  | zero => exact circleCost_le_half x
  | succ l ih =>
    let : ∀ k : Fin h, NeZero (p (l+1) k) := fun k => ⟨(hn _ k).ne'⟩
    let : Nonempty (MaskTag h p (l+1)) := ⟨⟨⟨0,hh⟩,⟨0,hn _ ⟨0,hh⟩⟩⟩⟩
    exact ((maskCost h p M hd hn l).infAverage_le_self _ x).trans ih

 theorem card_maskTag (h : ℕ) (p : ℕ → ℕ → ℕ) (l : ℕ) :
    Fintype.card (MaskTag h p l) = ∑ k : Fin h, p l k := by
  simp only [MaskTag, Fintype.card_sigma, Fintype.card_fin]

 theorem mask_average_formula {h M l : ℕ} {p : ℕ → ℕ → ℕ}
    (hd : ∀ k : Fin h, p l k ∣ M) (hn : ∀ k : Fin h, 0 < p l k)
    (f : PhaseCost (ZMod M)) (x : ZMod M) (z : MaskResidues h p l) :
    f.average (maskPhaseHom h p M l hd) x z =
      (∑ k : Fin h, ∑ b : Fin (p l k),
        f (x+(∑ k,subcircle (hd k) (z k))+b.val • subcircle (hd k) (z k))) /
          (∑ k : Fin h, (p l k : ℝ)) := by
  let : ∀ k : Fin h, NeZero (p l k) := fun k => ⟨(hn k).ne'⟩
  simp only [PhaseCost.average, card_maskTag, Nat.cast_sum, Fintype.sum_sigma]
  congr 1
  apply Finset.sum_congr rfl
  intro k _
  apply Finset.sum_congr rfl
  intro b _
  congr 1
  change x+((∑ k,subcircle (hd k) (z k))+b.val • subcircle (hd k) (z k)) = _
  abel

theorem mask_active_average_lower {h M l : ℕ} {p : ℕ → ℕ → ℕ}
    (hh : 0 < h) (hd : ∀ k : Fin h, p l k ∣ M)
    (hp : ∀ k : Fin h, (p l k).Prime)
    (hlo : ∀ k : Fin h, h^3 ≤ p l k) (hhi : ∀ k : Fin h, p l k ≤ 2*h^3)
    (f : PhaseCost (ZMod M)) (x : ZMod M) (z : MaskResidues h p l)
    (Q : ℝ) (hQ : 0 ≤ Q)
    (hq : ∀ k : Fin h, z k ≠ 0 → Q ≤ f (subcircle (hd k) 1)) :
    (((Finset.univ.filter (fun k : Fin h => z k ≠ 0)).card : ℝ)/(4*h))*Q ≤
      f.average (maskPhaseHom h p M l hd) x z := by
  classical
  let : ∀ k : Fin h, NeZero (p l k) := fun k => ⟨(hp k).ne_zero⟩
  let S := Finset.univ.filter (fun k : Fin h => z k ≠ 0)
  let T : ℝ := ∑ k : Fin h, (p l k : ℝ)
  let B (k : Fin h) : ℝ := ∑ b : Fin (p l k),
    f (x+(∑ j,subcircle (hd j) (z j))+b.val • subcircle (hd k) (z k))
  have hB (k : Fin h) : 0 ≤ B k := Finset.sum_nonneg (fun _ _ => f.nonneg _)
  have hT : 0 < T := by
    apply Finset.sum_pos
    · intro k _; exact_mod_cast (hp k).pos
    · exact Finset.univ_nonempty_iff.mpr ⟨⟨0,hh⟩⟩
  have hTu : T ≤ 2*(h:ℝ)^4 := by
    calc
      T ≤ ∑ _k : Fin h, (2:ℝ)*h^3 := Finset.sum_le_sum (fun k _ => by exact_mod_cast hhi k)
      _ = _ := by simp; ring
  have hkb (k : Fin h) (hk : k ∈ S) : (h:ℝ)^3*Q ≤ 2*B k := by
    have ha := f.prime_grid_bound (hp k) (subcircle (hd k))
      (x+∑ j,subcircle (hd j) (z j)) (z k) ((Finset.mem_filter.mp hk).2)
    have he : B k = ∑ b : ZMod (p l k),
        f (x+(∑ j,subcircle (hd j) (z j))+b.val • subcircle (hd k) (z k)) := by
      symm
      rw [← sum_fin_zmod]
      apply Finset.sum_congr rfl
      intro b _
      rw [ZMod.val_natCast, Nat.mod_eq_of_lt b.isLt]
    rw [← he] at ha
    calc
      (h:ℝ)^3*Q ≤ (p l k : ℝ)*Q := mul_le_mul_of_nonneg_right (by exact_mod_cast hlo k) hQ
      _ ≤ (p l k : ℝ)*f (subcircle (hd k) 1) := mul_le_mul_of_nonneg_left (hq k ((Finset.mem_filter.mp hk).2)) (by positivity)
      _ ≤ _ := ha
  have hsum : (S.card : ℝ)*(h:ℝ)^3*Q ≤ 2*∑ k : Fin h, B k := by
    calc
      _ = ∑ _k ∈ S, (h:ℝ)^3*Q := by simp; ring
      _ ≤ ∑ k ∈ S, 2*B k := Finset.sum_le_sum hkb
      _ ≤ ∑ k : Fin h, 2*B k := Finset.sum_le_sum_of_subset_of_nonneg
        (Finset.subset_univ _) (fun k _ _ => mul_nonneg (by norm_num) (hB k))
      _ = _ := (Finset.mul_sum ..).symm
  rw [mask_average_formula hd (fun k => (hp k).pos)]
  change (S.card : ℝ)/(4*h)*Q ≤ (∑ k : Fin h, B k)/T
  rw [le_div_iff₀ hT]
  have hh' : (0:ℝ) < h := by exact_mod_cast hh
  have hb : 0 ≤ (S.card : ℝ)/(4*h)*Q := by positivity
  calc
    _ ≤ ((S.card : ℝ)/(4*h)*Q)*(2*(h:ℝ)^4) := mul_le_mul_of_nonneg_left hTu hb
    _ = ((S.card : ℝ)*(h:ℝ)^3*Q)/2 := by field_simp; ring
    _ ≤ _ := by linarith

theorem mask_inactive_average_lower {h M l : ℕ} {p : ℕ → ℕ → ℕ}
    (hh : 0 < h) (hd : ∀ k : Fin h, p l k ∣ M)
    (hp : ∀ k : Fin h, (p l k).Prime)
    (hlo : ∀ k : Fin h, h^3 ≤ p l k) (hhi : ∀ k : Fin h, p l k ≤ 2*h^3)
    (f : PhaseCost (ZMod M)) (x : ZMod M) (z : MaskResidues h p l)
    (hs : 2*(Finset.univ.filter (fun k : Fin h => z k ≠ 0)).card ≤ h) :
    (1/4:ℝ)*f (x+∑ k,subcircle (hd k) (z k)) ≤
      f.average (maskPhaseHom h p M l hd) x z := by
  classical
  let N := Finset.univ.filter (fun k : Fin h => z k = 0)
  let T : ℝ := ∑ k : Fin h, (p l k : ℝ)
  let B (k : Fin h) : ℝ := ∑ b : Fin (p l k),
    f (x+(∑ j,subcircle (hd j) (z j))+b.val • subcircle (hd k) (z k))
  let Q := f (x+∑ k,subcircle (hd k) (z k))
  have hQ : 0 ≤ Q := f.nonneg _
  have hB (k : Fin h) : 0 ≤ B k := Finset.sum_nonneg (fun _ _ => f.nonneg _)
  have hT : 0 < T := by
    apply Finset.sum_pos
    · intro k _; exact_mod_cast (hp k).pos
    · exact Finset.univ_nonempty_iff.mpr ⟨⟨0,hh⟩⟩
  have hTu : T ≤ 2*(h:ℝ)^4 := by
    calc
      T ≤ ∑ _k : Fin h, (2:ℝ)*h^3 := Finset.sum_le_sum (fun k _ => by exact_mod_cast hhi k)
      _ = _ := by simp; ring
  have hN : (h:ℝ) ≤ 2*N.card := by
    have hc := Finset.card_filter_add_card_filter_not (s := Finset.univ) (fun k : Fin h => z k = 0)
    simp only [Finset.card_univ, Fintype.card_fin] at hc
    change N.card + (Finset.univ.filter (fun k : Fin h => z k ≠ 0)).card = h at hc
    exact_mod_cast (show h ≤ 2*N.card by omega)
  have hkb (k : Fin h) (hk : k ∈ N) : (h:ℝ)^3*Q ≤ B k := by
    have hz := (Finset.mem_filter.mp hk).2
    have he : B k = (p l k : ℝ)*Q := by
      simp [B, Q, hz]
    rw [he]
    exact mul_le_mul_of_nonneg_right (by exact_mod_cast hlo k) hQ
  have hsum : (N.card : ℝ)*(h:ℝ)^3*Q ≤ ∑ k : Fin h, B k := by
    calc
      _ = ∑ _k ∈ N, (h:ℝ)^3*Q := by simp; ring
      _ ≤ ∑ k ∈ N, B k := Finset.sum_le_sum hkb
      _ ≤ ∑ k : Fin h, B k := Finset.sum_le_sum_of_subset_of_nonneg
        (Finset.subset_univ _) (fun k _ _ => hB k)
  rw [mask_average_formula hd (fun k => (hp k).pos)]
  change (1/4:ℝ)*Q ≤ (∑ k : Fin h, B k)/T
  rw [le_div_iff₀ hT]
  calc
    _ ≤ ((1/4:ℝ)*Q)*(2*(h:ℝ)^4) := mul_le_mul_of_nonneg_left hTu (by positivity)
    _ = ((h:ℝ)/2)*h^3*Q := by ring
    _ ≤ (N.card : ℝ)*h^3*Q := by gcongr; linarith
    _ ≤ _ := hsum

theorem mask_minimizer_options {h M l : ℕ} {p : ℕ → ℕ → ℕ}
    [∀ k : Fin h, NeZero (p l k)]
    (hh : 0 < h) (hd : ∀ k : Fin h, p l k ∣ M)
    (hp : ∀ k : Fin h, (p l k).Prime)
    (hlo : ∀ k : Fin h, h^3 ≤ p l k) (hhi : ∀ k : Fin h, p l k ≤ 2*h^3)
    (f : PhaseCost (ZMod M)) (x : ZMod M) :
    ∃ z : MaskResidues h p l,
      (let S := Finset.univ.filter (fun k : Fin h => z k ≠ 0)
       (∀ Q : ℝ, 0 ≤ Q → (∀ k ∈ S, Q ≤ f (subcircle (hd k) 1)) →
        (S.card : ℝ)/(4*h)*Q ≤ f.infAverage (maskPhaseHom h p M l hd) x) ∧
       (2*S.card ≤ h → (1/4:ℝ)*f (x+∑ k,subcircle (hd k) (z k)) ≤
         f.infAverage (maskPhaseHom h p M l hd) x)) := by
  classical
  let : ∀ k : Fin h, NeZero (p l k) := fun k => ⟨(hp k).ne_zero⟩
  obtain ⟨z,hz⟩ := f.exists_average_eq (maskPhaseHom h p M l hd) x
  refine ⟨z, ?_⟩
  dsimp only
  rw [hz]
  constructor
  · intro Q hQ hq
    exact mask_active_average_lower hh hd hp hlo hhi f x z Q hQ
      (fun k hk => hq k (by simp [hk]))
  · exact mask_inactive_average_lower hh hd hp hlo hhi f x z

 theorem deficit_cast {β : Type*} (x y : List β) : (deficit x y : ℝ) = (x.length:ℝ) - lcs x y := by
  exact Nat.cast_sub (lcs_le_length_left x y)

 theorem deficit_taggedRow_lower {J β : Type*} [Fintype J] [DecidableEq J]
    (js : List J) (hn : js.Nodup) (hall : ∀ j, j ∈ js) (W U : J → List β) :
    (∑ j : J, (deficit (W j) (U j) : ℝ)) ≤
      deficit (taggedRow js W) (taggedRow js U) := by
  have hc := lcs_taggedRow_le js hn hall W U
  have hcr : (lcs (taggedRow js W) (taggedRow js U) : ℝ) ≤ ∑ j : J, (lcs (W j) (U j) : ℝ) := by exact_mod_cast hc
  simp_rw [deficit_cast]
  rw [Finset.sum_sub_distrib, length_taggedRow js hn hall W, Nat.cast_sum]
  linarith

 theorem maskLength_pos {h M R : ℕ} {p : ℕ → ℕ → ℕ}
    (hh : 0 < h) (hM : 0 < M) (hR : 0 < R) (hn : ∀ l (k : Fin h), 0 < p l k)
    (l : ℕ) : 0 < maskLength h p R M l := by
  induction l with
  | zero => exact hM
  | succ l ih =>
    unfold maskLength
    apply Nat.mul_pos (Nat.mul_pos hR (Finset.prod_pos (fun k _ => hn _ k)))
    apply Nat.mul_pos _ ih
    rw [length_maskTags]
    exact Finset.sum_pos (fun k _ => hn _ k) (Finset.univ_nonempty_iff.mpr ⟨⟨0,hh⟩⟩)

theorem mask_separation {h M R : ℕ} {p : ℕ → ℕ → ℕ} [NeZero M]
    (he : M = 2*(M/2)) (hh : 0 < h) (hR : 0 < R)
    (hd : ∀ l (k : Fin h), p l k ∣ M) (hn : ∀ l (k : Fin h), 0 < p l k)
    (ht : ∀ l, 4 ≤ (maskTags h p l).length)
    (l : ℕ) (v : MaskState h p M l) (θ : ZMod M) :
    (1/((2:ℝ)^l*4))*(maskLength h p R M l)*maskCost h p M hd hn l θ ≤
      (deficit (maskWord h p R M l v)
        (maskWord h p R M l (shiftMaskState h p M l v θ)) : ℝ) := by
  classical
  induction l generalizing θ with
  | zero =>
    change ZMod M at v
    change (1/((2:ℝ)^0*4))*M*circleCost θ ≤
      (deficit (maskWord h p R M 0 v) (maskWord h p R M 0 (v+θ)) : ℝ)
    rw [maskWord_zero_eq, maskWord_zero_eq]
    calc
      _ = (M:ℝ)*circleCost θ/4 := by norm_num; ring
      _ ≤ _ := halfCircle_separation he v θ
  | succ l ih =>
    let : ∀ k : Fin h, NeZero (p (l+1) k) := fun k => ⟨(hn _ k).ne'⟩
    let L := maskLength h p R M l
    let t := (maskTags h p (l+1)).length
    let N := R*period h p (l+1)
    let f := maskCost h p M hd hn l
    let σ := maskPhaseHom h p M (l+1) (hd _)
    let ρ := (1/((2:ℝ)^l*4))*maskCost h p M hd hn (l+1) θ
    have hL : 0 < L := maskLength_pos hh (NeZero.pos M) hR hn l
    have hp2 : 1 ≤ (2:ℝ)^l := one_le_pow₀ (by norm_num)
    have hρ : ρ ≤ 1/2 := by
      have hc := maskCost_le_half hh hd hn (l+1) θ
      have hc0 := (maskCost h p M hd hn (l+1)).nonneg θ
      dsimp [ρ]
      have hi : 1/((2:ℝ)^l*4) ≤ 1 := (div_le_one (by positivity)).mpr (by nlinarith)
      calc
        _ ≤ 1*maskCost h p M hd hn (l+1) θ := mul_le_mul_of_nonneg_right hi hc0
        _ ≤ _ := by simpa using hc
    have hx : (maskWord h p R M (l+1) v).length = (t*L)*N := by
      rw [length_maskWord]
      change N*(t*L) = (t*L)*N
      exact Nat.mul_comm _ _
    have hy : (maskWord h p R M (l+1) (shiftMaskState h p M (l+1) v θ)).length = (t*L)*N := by
      rw [length_maskWord]
      change N*(t*L) = (t*L)*N
      exact Nat.mul_comm _ _
    have hr := row_separation hL (ht (l+1)) hx hy
      (fun x => (maskTags h p (l+1)).idxOf x.1)
      (tag_get_maskWord h p R M l v hL (by have := ht (l+1); omega))
      (tag_get_maskWord h p R M l _ hL (by have := ht (l+1); omega)) ρ hρ
    have hrows : ∀ i j : Fin N, ρ*(t*L) ≤
        (deficit (segment (maskWord h p R M (l+1) v) (i.val*(t*L)) (t*L))
          (segment (maskWord h p R M (l+1) (shiftMaskState h p M (l+1) v θ))
            (j.val*(t*L)) (t*L)) : ℝ) := by
      intro a b
      rw [segment_maskWord, segment_maskWord]
      let z : MaskResidues h p (l+1) := fun k => (b.val : ZMod (p (l+1) k)) - (a.val : ZMod (p (l+1) k))
      have hz (j : MaskTag h p (l+1)) : σ z j =
          maskGamma h p M (l+1) b j - maskGamma h p M (l+1) a j := by
        change σ ((fun k : Fin h => (b.val : ZMod (p (l+1) k))) - (fun k : Fin h => (a.val : ZMod (p (l+1) k)))) j = _
        rw [map_sub, Pi.sub_apply]
        exact congrArg₂ (·-·) (congrFun (maskPhaseHom_natCast h p M (l+1) b (hd _) (hn _)) j)
          (congrFun (maskPhaseHom_natCast h p M (l+1) a (hd _) (hn _)) j)
      have hind (j : MaskTag h p (l+1)) := ih
        (shiftMaskState h p M l (v j) (maskGamma h p M (l+1) a j)) (θ+σ z j)
      have hstate (j : MaskTag h p (l+1)) :
          shiftMaskState h p M l (shiftMaskState h p M l (v j) (maskGamma h p M (l+1) a j)) (θ+σ z j) =
          shiftMaskState h p M l (shiftMaskState h p M l (v j) θ) (maskGamma h p M (l+1) b j) := by
        rw [shiftMaskState_add, shiftMaskState_add, hz]
        congr 1
        abel
      simp_rw [hstate] at hind
      have hsum := Finset.sum_le_sum (s := Finset.univ) (fun j _ => hind j)
      have hdef := deficit_taggedRow_lower (maskTags h p (l+1)) (nodup_maskTags ..)
        (mem_maskTags h p (l+1))
        (fun j => maskWord h p R M l (shiftMaskState h p M l (v j) (maskGamma h p M (l+1) a j)))
        (fun j => maskWord h p R M l (shiftMaskState h p M l (shiftMaskState h p M l (v j) θ) (maskGamma h p M (l+1) b j)))
      apply le_trans _ (hsum.trans hdef)
      rw [← Finset.mul_sum]
      have hcost : maskCost h p M hd hn (l+1) θ ≤ f.average σ θ z := f.infAverage_le σ θ z
      have htpos : (0:ℝ) < t := by exact_mod_cast (show 0 < t by have := ht (l+1); omega)
      have hcard : (Fintype.card (MaskTag h p (l+1)) : ℝ) = t := by rw [card_maskTag]; exact_mod_cast (length_maskTags h p (l+1)).symm
      rw [PhaseCost.average, hcard, le_div_iff₀ htpos] at hcost
      dsimp only [ρ]
      calc
        _ = ((1/((2:ℝ)^l*4))*(L:ℝ)) * ((maskCost h p M hd hn (l+1) θ)*t) := by ring
        _ ≤ _ := mul_le_mul_of_nonneg_left hcost (by positivity)
    have hfinal := hr hrows
    rw [length_maskWord] at hfinal
    dsimp only [ρ] at hfinal
    calc
      _ = ((1/((2:ℝ)^l*4))*maskCost h p M hd hn (l+1) θ)/2 * maskLength h p R M (l+1) := by rw [pow_succ]; ring
      _ ≤ _ := hfinal

end FiniteCircle

end OAI