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