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