math / data /lean /OAI /Combinatorics /FiniteCircle /ExcludedSeparation.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
20.1 kB
import OAI.Combinatorics.FiniteCircle.MaskSeparation
namespace OAI
namespace FiniteCircle
open scoped BigOperators List
noncomputable def excludedPhaseHom (m : β„•) (p : β„• β†’ β„• β†’ β„•) (M l : β„•)
(hd : βˆ€ k : Fin m, p l k ∣ M) : MaskResidues m p l β†’+ (Fin m β†’ ZMod M) where
toFun z i := βˆ‘ j ∈ Finset.univ.erase i, subcircle (hd j) (z j)
map_zero' := by ext i; simp
map_add' z w := by ext i; simp [Finset.sum_add_distrib]
theorem excludedPhaseHom_apply {m M l : β„•} {p : β„• β†’ β„• β†’ β„•}
(hd : βˆ€ k : Fin m, p l k ∣ M) (z : MaskResidues m p l) (i : Fin m) :
excludedPhaseHom m p M l hd z i = (βˆ‘ j, subcircle (hd j) (z j)) - subcircle (hd i) (z i) := by
change (βˆ‘ j ∈ Finset.univ.erase i, subcircle (hd j) (z j)) = _
exact (Finset.sum_erase_eq_sub (Finset.mem_univ i))
theorem excludedPhaseHom_natCast (m : β„•) (p : β„• β†’ β„• β†’ β„•) (M l a : β„•)
(hd : βˆ€ k : Fin m, p l k ∣ M) (hn : βˆ€ k : Fin m, 0 < p l k) :
excludedPhaseHom m p M l hd (fun k => (a : ZMod (p l k))) =
excludedTranslation m p M l a := by
ext i
change (βˆ‘ j ∈ Finset.univ.erase i, subcircle (hd j) (a : ZMod (p l j))) = _
unfold excludedTranslation
apply Finset.sum_congr rfl
intro j _
let : NeZero (p l j) := ⟨(hn j).ne'⟩
rw [subcircle_val, ZMod.val_natCast]
noncomputable def excludedCost (m : β„•) (p : β„• β†’ β„• β†’ β„•) (M : β„•)
(hd : βˆ€ l (k : Fin m), p l k ∣ M) (hn : βˆ€ l (k : Fin m), 0 < p l k) :
β„• β†’ PhaseCost (ZMod M)
| 0 => circlePhaseCost M
| l+1 => by
let : βˆ€ k : Fin m, NeZero (p (l+1) k) := fun k => ⟨(hn _ k).ne'⟩
exact (excludedCost m p M hd hn l).step (excludedPhaseHom m p M (l+1) (hd _))
theorem excludedCost_le_half {m M : β„•} {p : β„• β†’ β„• β†’ β„•} [NeZero M]
(hm : 0 < m) (hd : βˆ€ l (k : Fin m), p l k ∣ M) (hn : βˆ€ l (k : Fin m), 0 < p l k)
(l : β„•) (x : ZMod M) : excludedCost m p M hd hn l x ≀ 1/2 := by
induction l with
| zero => exact circleCost_le_half x
| succ l ih =>
let : βˆ€ k : Fin m, NeZero (p (l+1) k) := fun k => ⟨(hn _ k).ne'⟩
let : Nonempty (Fin m) := ⟨⟨0,hm⟩⟩
exact ((excludedCost m p M hd hn l).infAverage_le_self _ x).trans ih
theorem excluded_active_average_lower {m M l : β„•} {p : β„• β†’ β„• β†’ β„•}
(hm : 2 ≀ m) (hd : βˆ€ k : Fin m, p l k ∣ M)
(f : PhaseCost (ZMod M)) (x : ZMod M) (z : MaskResidues m p l)
(Q : ℝ) (hQ : 0 ≀ Q)
(hq : βˆ€ i j : Fin m, z i β‰  0 β†’ i β‰  j β†’
Q ≀ f (subcircle (hd i) (z i)-subcircle (hd j) (z j))) :
(((Finset.univ.filter (fun k : Fin m => z k β‰  0)).card : ℝ)/(4*m))*Q ≀
f.average (excludedPhaseHom m p M l hd) x z := by
classical
let A := Finset.univ.filter (fun k : Fin m => z k β‰  0)
let y (i : Fin m) := x+excludedPhaseHom m p M l hd z i
let B := βˆ‘ i : Fin m, f (y i)
have hB : 0 ≀ B := Finset.sum_nonneg (fun _ _ => f.nonneg _)
have hpair (i j : Fin m) (hi : i ∈ A) (hij : i β‰  j) : Q ≀ f (y i)+f (y j) := by
have he : subcircle (hd i) (z i)-subcircle (hd j) (z j) = y j-y i := by
dsimp only [y]
rw [excludedPhaseHom_apply, excludedPhaseHom_apply]
abel
exact (hq i j ((Finset.mem_filter.mp hi).2) hij).trans (by rw [he]; simpa [add_comm] using f.sub_le (y j) (y i))
have hper (i : Fin m) (hi : i ∈ A) : ((m : ℝ) - 1)*Q ≀ (m:ℝ)*f (y i)+B := by
have hh := Finset.sum_le_sum (s := Finset.univ.erase i) (fun j hj =>
hpair i j hi (Ne.symm (Finset.mem_erase.mp hj).1))
have hsum : (βˆ‘ j ∈ Finset.univ.erase i, (f (y i)+f (y j))) ≀
βˆ‘ j : Fin m, (f (y i)+f (y j)) := Finset.sum_le_sum_of_subset_of_nonneg
(Finset.erase_subset _ _) (fun j _ _ => add_nonneg (f.nonneg _) (f.nonneg _))
have hcard : (Finset.univ.erase i).card = m-1 := by simp
rw [Finset.sum_const, hcard, nsmul_eq_mul, Nat.cast_sub (by omega : 1 ≀ m), Nat.cast_one] at hh
simpa only [Finset.sum_add_distrib, Finset.sum_const, Finset.card_univ,
Fintype.card_fin, nsmul_eq_mul] using hh.trans hsum
have hs : A.card ≀ m := by simpa using Finset.card_le_card (Finset.subset_univ A)
have hsum := Finset.sum_le_sum (s := A) hper
simp only [Finset.sum_add_distrib, Finset.sum_const, nsmul_eq_mul, ← Finset.mul_sum] at hsum
have hpart : (βˆ‘ i ∈ A, f (y i)) ≀ B := Finset.sum_le_sum_of_subset_of_nonneg
(Finset.subset_univ _) (fun _ _ _ => f.nonneg _)
have hsreal : (A.card : ℝ) ≀ m := by exact_mod_cast hs
have hmreal : (2:ℝ) ≀ m := by exact_mod_cast hm
have ha0 : (0:ℝ) ≀ A.card := by positivity
have hsq : (A.card : ℝ)*Q ≀ 4*B := by
have hupper : (m:ℝ)*(βˆ‘ i ∈ A, f (y i))+(A.card:ℝ)*B ≀ 2*m*B := by
nlinarith [mul_le_mul_of_nonneg_left hpart (show (0 : ℝ) ≀ m by positivity),
mul_le_mul_of_nonneg_right hsreal hB]
have hbase : (A.card:ℝ)*((m : ℝ) - 1)*Q ≀ 2*m*B := by nlinarith
have hnon : 0 ≀ (A.card:ℝ)*Q := mul_nonneg ha0 hQ
nlinarith [mul_nonneg hnon (show (0:ℝ)≀(m : ℝ) - 2 by linarith)]
change (A.card:ℝ)/(4*m)*Q ≀ B / Fintype.card (Fin m)
rw [Fintype.card_fin]
rw [le_div_iffβ‚€ (by positivity : (0 : ℝ) < m)]
calc
_ = (A.card:ℝ)*Q/4 := by field_simp
_ ≀ _ := by linarith
theorem excluded_inactive_average_lower {m M l : β„•} {p : β„• β†’ β„• β†’ β„•}
(hm : 0 < m) (hd : βˆ€ k : Fin m, p l k ∣ M)
(f : PhaseCost (ZMod M)) (x : ZMod M) (z : MaskResidues m p l)
(hs : 2*(Finset.univ.filter (fun k : Fin m => z k β‰  0)).card ≀ m) :
(1/4:ℝ)*f (x+βˆ‘ k,subcircle (hd k) (z k)) ≀
f.average (excludedPhaseHom m p M l hd) x z := by
classical
let A := Finset.univ.filter (fun k : Fin m => z k β‰  0)
let N := Finset.univ.filter (fun k : Fin m => z k = 0)
let Q := f (x+βˆ‘ k,subcircle (hd k) (z k))
have hQ : 0 ≀ Q := f.nonneg _
have hsum : (N.card:ℝ)*Q ≀ βˆ‘ k : Fin m, f (x+excludedPhaseHom m p M l hd z k) := by
calc
_ = βˆ‘ _k ∈ N, Q := by simp only [Finset.sum_const, nsmul_eq_mul]
_ = βˆ‘ k ∈ N, f (x+excludedPhaseHom m p M l hd z k) := by
apply Finset.sum_congr rfl
intro k hk
rw [excludedPhaseHom_apply, (Finset.mem_filter.mp hk).2, map_zero, sub_zero]
_ ≀ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (fun _ _ _ => f.nonneg _)
have hcard : A.card+N.card = m := by
simpa only [Finset.card_univ, Fintype.card_fin, not_not] using
Finset.card_filter_add_card_filter_not (s := Finset.univ) (p := fun k : Fin m => z k β‰  0)
change 2*A.card ≀ m at hs
have hN : (m:ℝ) ≀ 2*N.card := by exact_mod_cast (show m ≀ 2*N.card by omega)
rw [PhaseCost.average, Fintype.card_fin, le_div_iffβ‚€ (by exact_mod_cast hm : (0 : ℝ) < m)]
change (1/4:ℝ)*Q*m ≀ _
have hh := mul_le_mul_of_nonneg_right hN hQ
nlinarith
theorem excluded_minimizer_options {m M l : β„•} {p : β„• β†’ β„• β†’ β„•}
[βˆ€ k : Fin m, NeZero (p l k)]
(hm : 2 ≀ m) (hd : βˆ€ k : Fin m, p l k ∣ M) (hn : βˆ€ k : Fin m, 0 < p l k)
(f : PhaseCost (ZMod M)) (x : ZMod M) :
βˆƒ z : MaskResidues m p l,
(βˆ€ Q : ℝ, 0 ≀ Q β†’ (βˆ€ i j : Fin m, z i β‰  0 β†’ i β‰  j β†’
Q ≀ f (subcircle (hd i) (z i)-subcircle (hd j) (z j))) β†’
(((Finset.univ.filter (fun k : Fin m => z k β‰  0)).card : ℝ)/(4*m))*Q ≀
(f.step (excludedPhaseHom m p M l hd)) x) ∧
(2*(Finset.univ.filter (fun k : Fin m => z k β‰  0)).card ≀ m β†’
(1/4:ℝ)*f (x+βˆ‘ k,subcircle (hd k) (z k)) ≀
(f.step (excludedPhaseHom m p M l hd)) x) := by
let : βˆ€ k : Fin m, NeZero (p l k) := fun k => ⟨(hn k).ne'⟩
obtain ⟨z,hz⟩ := f.exists_average_eq (excludedPhaseHom m p M l hd) x
refine ⟨z,?_,?_⟩
Β· intro Q hQ hq
change _ ≀ f.infAverage _ _
rw [hz]
exact excluded_active_average_lower hm hd f x z Q hQ hq
Β· intro hs
change _ ≀ f.infAverage _ _
rw [hz]
exact excluded_inactive_average_lower (by omega) hd f x z hs
def excludedTags (m _l : β„•) : List (Fin m) := List.ofFn id
@[simp] theorem length_excludedTags (m l : β„•) : (excludedTags m l).length = m := by
simp [excludedTags]
theorem mem_excludedTags (m l : β„•) (j : Fin m) : j ∈ excludedTags m l := by
simp [excludedTags]
theorem nodup_excludedTags (m l : β„•) : (excludedTags m l).Nodup := by
apply List.nodup_ofFn.mpr
exact Function.injective_id
theorem excludedWord_succ (m : β„•) (p : β„• β†’ β„• β†’ β„•) (R M l : β„•)
(v : ExcludedState m M (l+1)) :
excludedWord m p R M (l+1) v = (List.range (R*period m p (l+1))).flatMap (fun a =>
taggedRow (excludedTags m (l+1)) (fun j => excludedWord m p R M l
(shiftExcludedState m M l (v j) (excludedTranslation m p M (l+1) a j)))) := by
have he := excludedWord.eq_2 m p R M l v
dsimp only [ExcludedAlphabet, ExcludedState] at he
refine he.trans ?_
unfold taggedRow excludedTags
simp only [List.flatMap_def, List.map_ofFn, Function.comp_id]
noncomputable def excludedLength (h : β„•) (p : β„• β†’ β„• β†’ β„•) (R M : β„•) : β„• β†’ β„•
| 0 => M
| l+1 => (R*period h p (l+1))*((excludedTags h (l+1)).length*excludedLength h p R M l)
@[simp] theorem length_excludedWord (h : β„•) (p : β„• β†’ β„• β†’ β„•) (R M l : β„•)
(v : ExcludedState h M l) : (excludedWord h p R M l v).length = excludedLength h p R M l := by
induction l with
| zero =>
have he := excludedWord.eq_1 h p R M v
dsimp only [ExcludedAlphabet, ExcludedState] at he
exact (congrArg List.length he).trans (List.length_ofFn)
| succ l ih =>
rw [excludedWord_succ]
change ((List.range (R*period h p (l+1))).flatMap (fun a =>
taggedRow (excludedTags h (l+1)) (fun j => excludedWord h p R M l
(shiftExcludedState h M l (v j) (excludedTranslation h p M (l+1) a j))))).length = _
rw [length_flatMap_uniform _ _ ((excludedTags h (l+1)).length*excludedLength h p R M l)]
Β· simp [excludedLength]
Β· intro a _
apply length_flatMap_uniform
intro j _
simp [ih]
@[simp] theorem shiftExcludedState_zero (h : β„•) (M l : β„•)
(v : ExcludedState h M l) : shiftExcludedState h M l v 0 = v := by
induction l with
| zero => change ZMod M at v; exact add_zero v
| succ l ih => funext j; exact ih (v j)
theorem shiftExcludedState_add (h : β„•) (M l : β„•)
(v : ExcludedState h M l) (a b : ZMod M) :
shiftExcludedState h M l (shiftExcludedState h M l v a) b =
shiftExcludedState h M l v (a+b) := by
induction l with
| zero => change ZMod M at v; exact add_assoc v a b
| succ l ih => funext j; exact ih (v j)
theorem shiftExcludedState_change_base (h : β„•) (M l : β„•)
(v : ExcludedState h M l) (ΞΈ a b : ZMod M) :
shiftExcludedState h M l (shiftExcludedState h M l v ΞΈ) b =
shiftExcludedState h M l (shiftExcludedState h M l v a) (ΞΈ+b-a) := by
rw [shiftExcludedState_add, shiftExcludedState_add]
congr 1
abel
def excludedRow (h : β„•) (p : β„• β†’ β„• β†’ β„•) (R M l : β„•)
(v : ExcludedState h M (l+1)) (a : β„•) : List (ExcludedAlphabet h M (l+1)) :=
taggedRow (excludedTags h (l+1)) (fun j => excludedWord h p R M l
(shiftExcludedState h M l (v j) (excludedTranslation h p M (l+1) a j)))
@[simp] theorem length_excludedRow (h : β„•) (p : β„• β†’ β„• β†’ β„•) (R M l : β„•)
(v : ExcludedState h M (l+1)) (a : β„•) :
(excludedRow h p R M l v a).length = (excludedTags h (l+1)).length*excludedLength h p R M l := by
change (Fin h β†’ ExcludedState h M l) at v
change (taggedRow (excludedTags h (l+1)) (fun j => excludedWord h p R M l
(shiftExcludedState h M l (v j) (excludedTranslation h p M (l+1) a j)))).length = _
unfold taggedRow
apply length_flatMap_uniform
intro j _
rw [List.length_map, length_excludedWord]
theorem segment_excludedWord (h : β„•) (p : β„• β†’ β„• β†’ β„•) (R M l : β„•)
(v : ExcludedState h M (l+1)) (a : Fin (R*period h p (l+1))) :
segment (excludedWord h p R M (l+1) v)
(a.val*((excludedTags h (l+1)).length*excludedLength h p R M l))
((excludedTags h (l+1)).length*excludedLength h p R M l) = excludedRow h p R M l v a := by
have he := segment_flatMap_uniform (List.range (R*period h p (l+1)))
(excludedRow h p R M l v) _ (fun a _ => length_excludedRow h p R M l v a)
⟨a.val, by simp⟩
rw [excludedWord_succ]
change segment ((List.range (R*period h p (l+1))).flatMap (excludedRow h p R M l v)) _ _ = _
simpa only [List.get_eq_getElem, List.getElem_range] using he
theorem tag_get_excludedWord (h : β„•) (p : β„• β†’ β„• β†’ β„•) (R M l : β„•)
(v : ExcludedState h M (l+1)) (hL : 0 < excludedLength h p R M l)
(ht : 0 < (excludedTags h (l+1)).length)
(k : Fin (excludedWord h p R M (l+1) v).length) :
(excludedTags h (l+1)).idxOf ((excludedWord h p R M (l+1) v).get k).1 =
(k.val/excludedLength h p R M l)%(excludedTags h (l+1)).length := by
classical
have hl := congrArg List.length (excludedWord_succ h p R M l v)
let k' := Fin.cast hl k
have he := tag_get_rows (excludedTags h (l+1)) (nodup_excludedTags h (l+1))
(fun a j => excludedWord h p R M l
(shiftExcludedState h M l (v j) (excludedTranslation h p M (l+1) a j)))
(N := R*period h p (l+1)) hL ht
(fun _ _ _ _ => length_excludedWord ..) k'
have hg : ((excludedWord h p R M (l+1) v).get k) =
(((List.range (R*period h p (l+1))).flatMap (fun a =>
taggedRow (excludedTags h (l+1)) (fun j => excludedWord h p R M l
(shiftExcludedState h M l (v j) (excludedTranslation h p M (l+1) a j))))).get k') := by
exact List.get_of_eq (excludedWord_succ h p R M l v) k
rw [hg]
exact he
theorem excludedLength_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 < excludedLength h p R M l := by
induction l with
| zero => exact hM
| succ l ih =>
unfold excludedLength
apply Nat.mul_pos (Nat.mul_pos hR (Finset.prod_pos (fun k _ => hn _ k)))
apply Nat.mul_pos _ ih
simpa using hh
theorem excluded_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 ≀ (excludedTags h l).length)
(l : β„•) (v : ExcludedState h M l) (ΞΈ : ZMod M) :
(1/((2:ℝ)^l*4))*(excludedLength h p R M l)*excludedCost h p M hd hn l ΞΈ ≀
(deficit (excludedWord h p R M l v)
(excludedWord h p R M l (shiftExcludedState h M l v ΞΈ)) : ℝ) := by
classical
induction l generalizing ΞΈ with
| zero =>
change ZMod M at v
change (1/((2:ℝ)^0*4))*M*circleCost ΞΈ ≀
(deficit (excludedWord h p R M 0 v) (excludedWord h p R M 0 (v+ΞΈ)) : ℝ)
have hbase (u : ZMod M) : (excludedWord h p R M 0 u).map Prod.snd =
List.ofFn (fun i : Fin M => halfBit u (i.val : ZMod M)) := by
change (List.ofFn (fun b : Fin M => (b,halfBit u (b.val : ZMod M)))).map Prod.snd = _
rw [List.map_ofFn]
rfl
have hlcs := lcs_map_ge Prod.snd (excludedWord h p R M 0 v) (excludedWord h p R M 0 (v+ΞΈ))
rw [hbase, hbase] at hlcs
have hdef : deficit (List.ofFn (fun i : Fin M => halfBit v (i.val : ZMod M)))
(List.ofFn (fun i : Fin M => halfBit (v+ΞΈ) (i.val : ZMod M))) ≀
deficit (excludedWord h p R M 0 v) (excludedWord h p R M 0 (v+ΞΈ)) := by
have hlen := length_excludedWord h p R M 0 v
change (excludedWord h p R M 0 v).length = M at hlen
rw [deficit, List.length_ofFn, deficit, hlen]
exact Nat.sub_le_sub_left hlcs M
calc
_ = (M:ℝ)*circleCost ΞΈ/4 := by norm_num; ring
_ ≀ _ := (halfCircle_separation he v ΞΈ).trans (by exact_mod_cast hdef)
| succ l ih =>
let : βˆ€ k : Fin h, NeZero (p (l+1) k) := fun k => ⟨(hn _ k).ne'⟩
let L := excludedLength h p R M l
let t := (excludedTags h (l+1)).length
let N := R*period h p (l+1)
let f := excludedCost h p M hd hn l
let Οƒ := excludedPhaseHom h p M (l+1) (hd _)
let ρ := (1/((2:ℝ)^l*4))*excludedCost h p M hd hn (l+1) ΞΈ
have hL : 0 < L := excludedLength_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 := excludedCost_le_half hh hd hn (l+1) ΞΈ
have hc0 := (excludedCost 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*excludedCost h p M hd hn (l+1) ΞΈ := mul_le_mul_of_nonneg_right hi hc0
_ ≀ _ := by simpa using hc
have hx : (excludedWord h p R M (l+1) v).length = (t*L)*N := by
rw [length_excludedWord h p R M (l+1) v]
change N*(t*L) = (t*L)*N
exact Nat.mul_comm _ _
have hy : (excludedWord h p R M (l+1) (shiftExcludedState h M (l+1) v ΞΈ)).length = (t*L)*N := by
rw [length_excludedWord]
change N*(t*L) = (t*L)*N
exact Nat.mul_comm _ _
have hr := row_separation hL (ht (l+1)) hx hy
(fun x => (excludedTags h (l+1)).idxOf x.1)
(tag_get_excludedWord h p R M l v hL (by have := ht (l+1); omega))
(tag_get_excludedWord h p R M l _ hL (by have := ht (l+1); omega)) ρ hρ
have hrows : βˆ€ i j : Fin N, ρ*(t*L) ≀
(deficit (segment (excludedWord h p R M (l+1) v) (i.val*(t*L)) (t*L))
(segment (excludedWord h p R M (l+1) (shiftExcludedState h M (l+1) v ΞΈ))
(j.val*(t*L)) (t*L)) : ℝ) := by
intro a b
rw [segment_excludedWord h p R M l v a, segment_excludedWord h p R M l _ b]
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 : Fin h) : Οƒ z j =
excludedTranslation h p M (l+1) b j - excludedTranslation 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 (excludedPhaseHom_natCast h p M (l+1) b (hd _) (hn _)) j)
(congrFun (excludedPhaseHom_natCast h p M (l+1) a (hd _) (hn _)) j)
have hind (j : Fin h) := ih
(shiftExcludedState h M l (v j) (excludedTranslation h p M (l+1) a j)) (ΞΈ+Οƒ z j)
have hstate (j : Fin h) :
shiftExcludedState h M l (shiftExcludedState h M l (v j) (excludedTranslation h p M (l+1) a j)) (ΞΈ+Οƒ z j) =
shiftExcludedState h M l (shiftExcludedState h M l (v j) ΞΈ) (excludedTranslation h p M (l+1) b j) := by
rw [shiftExcludedState_add, shiftExcludedState_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 (excludedTags h (l+1)) (nodup_excludedTags ..)
(mem_excludedTags h (l+1))
(fun j => excludedWord h p R M l (shiftExcludedState h M l (v j) (excludedTranslation h p M (l+1) a j)))
(fun j => excludedWord h p R M l (shiftExcludedState h M l (shiftExcludedState h M l (v j) ΞΈ) (excludedTranslation h p M (l+1) b j)))
apply le_trans _ (hsum.trans hdef)
rw [← Finset.mul_sum]
have hcost : excludedCost 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 (Fin h) : ℝ) = t := by simp [t]
rw [PhaseCost.average, hcard, le_div_iffβ‚€ htpos] at hcost
dsimp only [ρ]
calc
_ = ((1/((2:ℝ)^l*4))*(L:ℝ)) * ((excludedCost 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_excludedWord h p R M (l+1) v] at hfinal
dsimp only [ρ] at hfinal
calc
_ = ((1/((2:ℝ)^l*4))*excludedCost h p M hd hn (l+1) ΞΈ)/2 * excludedLength h p R M (l+1) := by rw [pow_succ]; ring
_ ≀ _ := hfinal
end FiniteCircle
end OAI