import OAI.Combinatorics.FiniteCircle.WindowMatching

namespace OAI

namespace FiniteCircle

open scoped BigOperators List
open scoped ComplexConjugate
open RCLike Module

namespace WordMatching
variable {α : Type*} {x y : List α} {q : ℕ}

theorem common_offset_duplicate_loss (A : WordMatching x y q) {w i j t : ℕ} (hw : 0 < w)
    (hij : i < j) {k l : Fin q} (hk : k ∈ A.blockPair w i t) (hl : l ∈ A.blockPair w j t)
    (hmod : (A.left k).val%w = (A.left l).val%w) :
    (A.right k).val%w < A.sourceLoss w i + A.sourceLoss w j := by
  obtain ⟨hki, hkt⟩ := Finset.mem_inter.mp hk
  obtain ⟨hlj, hlt⟩ := Finset.mem_inter.mp hl
  let T := (A.sourceBlock w i).filter (fun v => k ≤ v)
  let U := (A.sourceBlock w j).filter (fun v => v ≤ l)
  have hdis : Disjoint T U := by
    apply Finset.disjoint_left.mpr
    intro v hv hu
    exact (lt_irrefl v) (A.sourceBlock_order hij (Finset.mem_filter.mp hv).1 (Finset.mem_filter.mp hu).1)
  have hmaps : Set.MapsTo A.right (↑(T ∪ U) : Set (Fin q))
      (↑(Finset.Icc (A.right k) (A.right l)) : Set (Fin y.length)) := by
    intro v hv
    change A.right v ∈ Finset.Icc (A.right k) (A.right l)
    rcases Finset.mem_union.mp hv with hv | hv
    · obtain ⟨hv, hkv⟩ := Finset.mem_filter.mp hv
      exact Finset.mem_Icc.mpr ⟨A.right.monotone hkv,
        A.right.monotone (A.sourceBlock_order hij hv hlj).le⟩
    · obtain ⟨hv, hvl⟩ := Finset.mem_filter.mp hv
      exact Finset.mem_Icc.mpr ⟨A.right.monotone (A.sourceBlock_order hij hki hv).le,
        A.right.monotone hvl⟩
  have hc := Finset.card_le_card_of_injOn A.right hmaps A.right.injective.injOn
  rw [Finset.card_union_of_disjoint hdis, Fin.card_Icc] at hc
  have hb := A.block_before_card_le hki
  have ha := A.block_after_card_le hw hlj
  have hTi : T.card + ((A.sourceBlock w i).filter (fun v => v < k)).card = (A.sourceBlock w i).card := by
    simpa only [not_le] using Finset.card_filter_add_card_filter_not (s := A.sourceBlock w i) (p := fun v => k ≤ v)
  have hUj : U.card + ((A.sourceBlock w j).filter (fun v => l < v)).card = (A.sourceBlock w j).card := by
    simpa only [not_le] using Finset.card_filter_add_card_filter_not (s := A.sourceBlock w j) (p := fun v => v ≤ l)
  have hXi : A.sourceLoss w i + (A.sourceBlock w i).card = w := Nat.sub_add_cancel (A.sourceBlock_card_le hw i)
  have hXj : A.sourceLoss w j + (A.sourceBlock w j).card = w := Nat.sub_add_cancel (A.sourceBlock_card_le hw j)
  have hrk := Nat.mod_add_div (A.right k).val w
  have hrl := Nat.mod_add_div (A.right l).val w
  have hkt' : (A.right k).val/w = t := (A.symm.mem_sourceBlock w t k).mp hkt
  have hlt' : (A.right l).val/w = t := (A.symm.mem_sourceBlock w t l).mp hlt
  rw [hkt'] at hrk
  rw [hlt'] at hrl
  have hklt := Nat.mod_lt (A.left k).val hw
  have hllt := Nat.mod_lt (A.left l).val hw
  have hrl_lt := Nat.mod_lt (A.right l).val hw
  have hkl : (A.right k).val ≤ (A.right l).val := A.right.monotone (A.sourceBlock_order hij hki hlj).le
  omega

theorem common_offset_duplicates_card (A : WordMatching x y q) {w i : ℕ}
    (hw : 0 < w) (hspan : (A.rightSpan (A.sourceBlock w i)).card ≤ 2*w) :
    ((A.sourceBlock w i).filter (fun k => ∃ l ∈ A.sourceBlock w (i+1),
      (A.left k).val%w = (A.left l).val%w ∧
      (A.right k).val/w = (A.right l).val/w)).card ≤
      3*(A.sourceLoss w i + A.sourceLoss w (i+1)) := by
  classical
  let S := (A.sourceBlock w i).filter (fun k => ∃ l ∈ A.sourceBlock w (i+1),
      (A.left k).val%w = (A.left l).val%w ∧
      (A.right k).val/w = (A.right l).val/w)
  let d := A.sourceLoss w i + A.sourceLoss w (i+1)
  let f : Fin q → ℕ × ℕ := fun k => ((A.right k).val/w,(A.right k).val%w)
  have hf : Function.Injective f := by
    intro k l h
    have h1 := congrArg Prod.fst h
    have h2 := congrArg Prod.snd h
    have hk := Nat.mod_add_div (A.right k).val w
    have hl := Nat.mod_add_div (A.right l).val w
    dsimp [f] at h1 h2
    rw [h1,h2] at hk
    exact A.right.injective (Fin.ext (by omega))
  have hmaps : S.image f ⊆ A.targetBlocks w (A.sourceBlock w i) ×ˢ Finset.range d := by
    intro v hv
    obtain ⟨k,hk,rfl⟩ := Finset.mem_image.mp hv
    obtain ⟨hki,l,hli,hmod,hdiv⟩ := Finset.mem_filter.mp hk
    apply Finset.mem_product.mpr
    refine ⟨Finset.mem_image.mpr ⟨k,hki,rfl⟩,Finset.mem_range.mpr ?_⟩
    have hkt : k ∈ A.blockPair w i ((A.right k).val/w) := Finset.mem_inter.mpr
      ⟨hki,(A.symm.mem_sourceBlock _ _ _).mpr rfl⟩
    have hlt : l ∈ A.blockPair w (i+1) ((A.right k).val/w) := Finset.mem_inter.mpr
      ⟨hli,(A.symm.mem_sourceBlock _ _ _).mpr hdiv.symm⟩
    exact A.common_offset_duplicate_loss hw (by omega) hkt hlt hmod
  have hh := Finset.card_le_card hmaps
  rw [Finset.card_image_of_injective S hf,Finset.card_product,Finset.card_range] at hh
  exact hh.trans (Nat.mul_le_mul_right d (A.targetBlocks_card_le_three hw hspan))

end WordMatching

namespace WordMatching
variable {α : Type*} {x y : List α} {q : ℕ}

def matchedAt (A : WordMatching x y q) (w i p : ℕ) : Prop :=
  ∃ k : Fin q, (A.left k).val = i*w+p

instance matchedAtDecidable (A : WordMatching x y q) (w i p : ℕ) :
    Decidable (A.matchedAt w i p) := inferInstanceAs (Decidable (∃ k : Fin q, (A.left k).val = i*w+p))

noncomputable def partnerAt (A : WordMatching x y q) (w i p : ℕ) : ℕ :=
  if h : A.matchedAt w i p then (A.right (Classical.choose h)).val/w else 0

theorem partnerAt_eq (A : WordMatching x y q) {w i p : ℕ} {k : Fin q}
    (hk : (A.left k).val = i*w+p) : A.partnerAt w i p = (A.right k).val/w := by
  have hh : A.matchedAt w i p := ⟨k,hk⟩
  rw [partnerAt,dite_eq_left hh]
  have he : Classical.choose hh = k := A.left.injective
    (Fin.ext ((Classical.choose_spec hh).trans hk.symm))
  rw [he]

theorem matchedAt_block (A : WordMatching x y q) {w i p : ℕ} {k : Fin q}
    (hp : p < w) (hk : (A.left k).val = i*w+p) :
    k ∈ A.sourceBlock w i ∧ (A.left k).val%w = p := by
  have hd : (A.left k).val/w = i :=
    Nat.div_eq_of_lt_le (by omega) (by rw [hk,Nat.add_mul,one_mul]; omega)
  refine ⟨(A.mem_sourceBlock w i k).mpr hd,?_⟩
  have hh := Nat.mod_add_div (A.left k).val w
  rw [hd,Nat.mul_comm w i] at hh
  omega

theorem unmatched_offsets_card_le (A : WordMatching x y q) {w i : ℕ}
    (hw : 0 < w) (I : Finset ℕ) (hI : I ⊆ Finset.range w) :
    (I.filter (fun p => ¬ A.matchedAt w i p)).card ≤ A.sourceLoss w i := by
  classical
  let T := (A.sourceBlock w i).image (fun k => (A.left k).val%w)
  have hT : T ⊆ Finset.range w := by
    intro p hp
    obtain ⟨k,_,rfl⟩ := Finset.mem_image.mp hp
    exact Finset.mem_range.mpr (Nat.mod_lt _ hw)
  have hTc : T.card = (A.sourceBlock w i).card :=
    Finset.card_image_of_injOn A.mod_injectiveOn
  have hs : I.filter (fun p => ¬ A.matchedAt w i p) ⊆ Finset.range w \ T := by
    intro p hp
    obtain ⟨hp,hn⟩ := Finset.mem_filter.mp hp
    refine Finset.mem_sdiff.mpr ⟨hI hp,?_⟩
    intro ht
    obtain ⟨k,hki,hkp⟩ := Finset.mem_image.mp ht
    apply hn
    refine ⟨k,?_⟩
    have hh := Nat.mod_add_div (A.left k).val w
    rw [(A.mem_sourceBlock w i k).mp hki,hkp,Nat.mul_comm w i] at hh
    omega
  have hh := Finset.card_le_card hs
  rwa [Finset.card_sdiff_of_subset hT,Finset.card_range,hTc] at hh

def duplicateAt (A : WordMatching x y q) (w i p : ℕ) : Prop :=
  ∃ k l : Fin q, (A.left k).val = i*w+p ∧ (A.left l).val = (i+1)*w+p ∧
    (A.right k).val/w = (A.right l).val/w

instance duplicateAtDecidable (A : WordMatching x y q) (w i p : ℕ) :
    Decidable (A.duplicateAt w i p) := inferInstanceAs (Decidable (∃ k l : Fin q,
      (A.left k).val = i*w+p ∧ (A.left l).val = (i+1)*w+p ∧
      (A.right k).val/w = (A.right l).val/w))

theorem duplicate_offsets_card_le (A : WordMatching x y q) {w i : ℕ}
    (hw : 0 < w) (I : Finset ℕ) (hI : I ⊆ Finset.range w)
    (hspan : (A.rightSpan (A.sourceBlock w i)).card ≤ 2*w) :
    (I.filter (A.duplicateAt w i)).card ≤ 3*(A.sourceLoss w i+A.sourceLoss w (i+1)) := by
  classical
  let T := (A.sourceBlock w i).filter (fun k => ∃ l ∈ A.sourceBlock w (i+1),
      (A.left k).val%w = (A.left l).val%w ∧
      (A.right k).val/w = (A.right l).val/w)
  have hs : I.filter (A.duplicateAt w i) ⊆ T.image (fun k => (A.left k).val%w) := by
    intro p hp
    obtain ⟨hp,k,l,hk,hl,hkl⟩ := Finset.mem_filter.mp hp
    have hpw := Finset.mem_range.mp (hI hp)
    obtain ⟨hki,hkp⟩ := A.matchedAt_block hpw hk
    obtain ⟨hli,hlp⟩ := A.matchedAt_block hpw hl
    exact Finset.mem_image.mpr ⟨k,Finset.mem_filter.mpr ⟨hki,l,hli,hkp.trans hlp.symm,hkl⟩,hkp⟩
  exact (Finset.card_le_card hs).trans ((Finset.card_image_le).trans
    (A.common_offset_duplicates_card hw hspan))

end WordMatching

theorem sum_card_filters_swap {α β : Type*} (S : Finset α) (T : Finset β)
    (R : α → β → Prop) [DecidableRel R] :
    ∑ a ∈ S, (T.filter (R a)).card = ∑ b ∈ T, (S.filter (fun a => R a b)).card := by
  simp only [Finset.card_eq_sum_ones,Finset.sum_filter]
  exact Finset.sum_comm

namespace WordMatching
variable {α : Type*} {x y : List α} {q : ℕ}

theorem sum_omitted_offsets_le (A : WordMatching x y q) {w L : ℕ}
    (hw : 0 < w) (I G : Finset ℕ) (hI : I ⊆ Finset.range w) (hG : G ⊆ Finset.range L) :
    (∑ p ∈ I, (L-(G.filter (fun i => A.matchedAt w i p)).card)) ≤
      I.card*(L-G.card) + ∑ i ∈ Finset.range L, A.sourceLoss w i := by
  classical
  have he (p : ℕ) : L-(G.filter (fun i => A.matchedAt w i p)).card =
      L-G.card + (G.filter (fun i => ¬ A.matchedAt w i p)).card := by
    have hh := Finset.card_filter_add_card_filter_not (s:=G) (p:=fun i => A.matchedAt w i p)
    have hg := Finset.card_le_card hG
    rw [Finset.card_range] at hg
    omega
  simp_rw [he]
  rw [Finset.sum_add_distrib]
  simp only [Finset.sum_const,smul_eq_mul]
  rw [sum_card_filters_swap]
  apply Nat.add_le_add_left
  exact (Finset.sum_le_sum (fun i _ => A.unmatched_offsets_card_le hw I hI)).trans
    (Finset.sum_le_sum_of_subset_of_nonneg hG (fun _ _ _ => Nat.zero_le _))

theorem sum_duplicate_offsets_le (A : WordMatching x y q) {w L : ℕ}
    (hw : 0 < w) (I G : Finset ℕ) (hI : I ⊆ Finset.range w) (hG : G ⊆ Finset.range L)
    (hspan : ∀ i ∈ G, (A.rightSpan (A.sourceBlock w i)).card ≤ 2*w) :
    (∑ p ∈ I, ((G.filter (fun i => i+1 < L)).filter (fun i => A.duplicateAt w i p)).card) ≤
      6 * ∑ i ∈ Finset.range L, A.sourceLoss w i := by
  classical
  let H := G.filter (fun i => i+1 < L)
  have hH : H ⊆ Finset.range L := (Finset.filter_subset _ _).trans hG
  have hsucc : H.image (fun i => i+1) ⊆ Finset.range L := by
    intro j hj
    obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp hj
    exact Finset.mem_range.mpr (Finset.mem_filter.mp hi).2
  have h1 : (∑ i ∈ H, A.sourceLoss w i) ≤ ∑ i ∈ Finset.range L, A.sourceLoss w i :=
    Finset.sum_le_sum_of_subset_of_nonneg hH (fun _ _ _ => Nat.zero_le _)
  have h2 : (∑ i ∈ H, A.sourceLoss w (i+1)) ≤ ∑ i ∈ Finset.range L, A.sourceLoss w i := by
    rw [← Finset.sum_image (g:=fun i => i+1) (by intro i _ j _ h; dsimp only at h; omega)]
    exact Finset.sum_le_sum_of_subset_of_nonneg hsucc (fun _ _ _ => Nat.zero_le _)
  rw [sum_card_filters_swap]
  have hh : (∑ i ∈ H, (I.filter (fun p => A.duplicateAt w i p)).card) ≤
      ∑ i ∈ H, 3*(A.sourceLoss w i+A.sourceLoss w (i+1)) := by
    apply Finset.sum_le_sum
    intro i hi
    exact A.duplicate_offsets_card_le hw I hI (hspan i (Finset.mem_filter.mp hi).1)
  change (∑ i ∈ H, _) ≤ _
  refine hh.trans ?_
  rw [← Finset.mul_sum,Finset.sum_add_distrib]
  omega

end WordMatching

namespace WordMatching
variable {α : Type*} {x y : List α} {w q : ℕ} {c : α → Fin w → Bool}

theorem offset_deficit_le (A : WordMatching (encode c x) (encode c y) q)
    (hw : 0 < w) (p : ℕ) (G : Finset ℕ) (hG : G ⊆ Finset.range x.length)
    (hlabels : ∀ i ∈ G, ∀ k : Fin q, (A.left k).val=i*w+p →
      x[i]? = y[(A.right k).val/w]?) :
    deficit x y ≤ 2*(x.length-(G.filter (fun i => A.matchedAt w i p)).card) +
      ((G.filter (fun i => i+1 < x.length)).filter (fun i => A.duplicateAt w i p)).card := by
  classical
  let S := G.filter (fun i => A.matchedAt w i p)
  let f := fun i => A.partnerAt w i p
  have hS : S ⊆ Finset.range x.length := (Finset.filter_subset _ _).trans hG
  have hf : ∀ i ∈ S, f i < y.length := by
    intro i hi
    obtain ⟨k,hk⟩ := (Finset.mem_filter.mp hi).2
    rw [show f i = (A.right k).val/w from A.partnerAt_eq hk]
    apply (Nat.div_lt_iff_lt_mul hw).mpr
    simpa only [length_encode,Nat.mul_comm] using (A.right k).isLt
  have hm : ∀ i ∈ S, ∀ j ∈ S, i ≤ j → f i ≤ f j := by
    intro i hi j hj hij
    obtain ⟨k,hk⟩ := (Finset.mem_filter.mp hi).2
    obtain ⟨l,hl⟩ := (Finset.mem_filter.mp hj).2
    rw [show f i = (A.right k).val/w from A.partnerAt_eq hk,
      show f j = (A.right l).val/w from A.partnerAt_eq hl]
    apply Nat.div_le_div_right
    apply A.right.monotone
    apply A.left.le_iff_le.mp
    change (A.left k).val ≤ (A.left l).val
    rw [hk,hl]
    exact Nat.add_le_add_right (Nat.mul_le_mul_right w hij) p
  have hl : ∀ i (hi : i ∈ S), x[i]'(Finset.mem_range.mp (hS hi)) = y[f i]'(hf i hi) := by
    intro i hi
    obtain ⟨k,hk⟩ := (Finset.mem_filter.mp hi).2
    have hh := hlabels i (Finset.mem_filter.mp hi).1 k hk
    rw [← A.partnerAt_eq hk] at hh
    change x[i]? = y[f i]? at hh
    simpa only [List.getElem?_eq_getElem (Finset.mem_range.mp (hS hi)),
      List.getElem?_eq_getElem (hf i hi),Option.some.injEq] using hh
  have hh := monotone_assignment_deficit S hS f hf hm hl
  have hs : S.filter (fun i => i+1 ∈ S ∧ f i=f (i+1)) ⊆
      (G.filter (fun i => i+1 < x.length)).filter (fun i => A.duplicateAt w i p) := by
    intro i hi
    obtain ⟨hi,hj,hfij⟩ := Finset.mem_filter.mp hi
    obtain ⟨k,hk⟩ := (Finset.mem_filter.mp hi).2
    obtain ⟨l,hl⟩ := (Finset.mem_filter.mp hj).2
    apply Finset.mem_filter.mpr
    refine ⟨Finset.mem_filter.mpr ⟨(Finset.mem_filter.mp hi).1,
      Finset.mem_range.mp (hS hj)⟩, k,l,hk,hl,?_⟩
    simpa only [f,A.partnerAt_eq hk,A.partnerAt_eq hl] using hfij
  exact hh.trans (Nat.add_le_add_left (Finset.card_le_card hs) _)

theorem averaged_offset_recovery (A : WordMatching (encode c x) (encode c y) q)
    (hw : 0 < w) (I G : Finset ℕ) (hI : I ⊆ Finset.range w) (hG : G ⊆ Finset.range x.length)
    (hspan : ∀ i ∈ G, (A.rightSpan (A.sourceBlock w i)).card ≤ 2*w)
    (hlabels : ∀ p ∈ I, ∀ i ∈ G, ∀ k : Fin q, (A.left k).val=i*w+p →
      x[i]? = y[(A.right k).val/w]?) :
    I.card * deficit x y ≤ 2*I.card*(x.length-G.card) +
      8*(w*x.length-q) := by
  have hsum : (∑ i ∈ Finset.range x.length, A.sourceLoss w i) = w*x.length-q := by
    have hh := A.sum_sourceLoss hw (length_encode c x)
    simpa only [Fin.sum_univ_eq_sum_range] using hh
  have hh := Finset.sum_le_sum (fun p (hp : p ∈ I) => A.offset_deficit_le hw p G hG (hlabels p hp))
  rw [Finset.sum_add_distrib,← Finset.mul_sum] at hh
  simp only [Finset.sum_const,smul_eq_mul] at hh
  have h1 := A.sum_omitted_offsets_le hw I G hI hG
  have h2 := A.sum_duplicate_offsets_le hw I G hI hG hspan
  rw [hsum] at h1 h2
  rw [Nat.mul_assoc]
  omega

end WordMatching

namespace WordMatching
variable {α : Type*} {x y : List α} {w q : ℕ} {c : α → Fin w → Bool}

noncomputable def offsetGood (A : WordMatching (encode c x) (encode c y) q) (w : ℕ) (η : ℝ) : Finset ℕ :=
  (Finset.range x.length).filter (fun i =>
    (A.sourceLoss w i : ℝ) ≤ η*w ∧ (A.spanLoss w i : ℝ) ≤ η*w)

theorem offsetGood_subset (A : WordMatching (encode c x) (encode c y) q) (w : ℕ) (η : ℝ) :
    A.offsetGood w η ⊆ Finset.range x.length := Finset.filter_subset _ _

theorem offsetGood_span (A : WordMatching (encode c x) (encode c y) q)
    (hw : 0 < w) {η : ℝ} (hη : η ≤ 1) {i : ℕ} (hi : i ∈ A.offsetGood w η) :
    (A.rightSpan (A.sourceBlock w i)).card ≤ 2*w := by
  have hv := (Finset.mem_filter.mp hi).2.2
  have hv' : (A.spanLoss w i : ℝ) ≤ w := hv.trans (by nlinarith only [hη,(show (0 : ℝ) ≤ w from Nat.cast_nonneg w)])
  have hvn : A.spanLoss w i ≤ w := by exact_mod_cast hv'
  have h1 := A.card_le_rightSpan (A.sourceBlock w i)
  have h2 := A.sourceBlock_card_le hw i
  dsimp only [spanLoss] at hvn
  omega

theorem offsetGood_bad_cost (A : WordMatching (encode c x) (encode c y) q)
    (hw : 0 < w) (hlen : x.length=y.length) (η : ℝ) :
    η*w*(x.length-(A.offsetGood w η).card : ℕ) ≤ 2*(w*x.length-q : ℕ) := by
  classical
  let G := A.offsetGood w η
  let B := Finset.range x.length \ G
  have hG : G ⊆ Finset.range x.length := A.offsetGood_subset w η
  have hBc : B.card=x.length-G.card := by rw [Finset.card_sdiff_of_subset hG,Finset.card_range]
  have hbad (i : ℕ) (hi : i ∈ B) : η*w ≤ (A.sourceLoss w i : ℝ)+A.spanLoss w i := by
    obtain ⟨hi,hn⟩ := Finset.mem_sdiff.mp hi
    have hn' : ¬ ((A.sourceLoss w i : ℝ) ≤ η*w ∧ (A.spanLoss w i : ℝ) ≤ η*w) := by
      intro hh
      exact hn (Finset.mem_filter.mpr ⟨hi,hh⟩)
    have hU : (0 : ℝ) ≤ A.sourceLoss w i := Nat.cast_nonneg _
    have hV : (0 : ℝ) ≤ A.spanLoss w i := Nat.cast_nonneg _
    push Not at hn'
    by_cases hh : (A.sourceLoss w i : ℝ) ≤ η*w
    · have hv := hn' hh
      linarith
    · push Not at hh
      linarith
  have hsumU : (∑ i ∈ Finset.range x.length, (A.sourceLoss w i : ℝ)) = (w*x.length-q : ℕ) := by
    have hh := A.sum_sourceLoss hw (length_encode c x)
    rw [Fin.sum_univ_eq_sum_range] at hh
    exact_mod_cast hh
  have hsumV : (∑ i ∈ Finset.range x.length, (A.spanLoss w i : ℝ)) ≤ (w*x.length-q : ℕ) := by
    have hh := A.sum_spanLoss_le hw (length_encode c x) (by rw [length_encode,hlen])
    rw [Fin.sum_univ_eq_sum_range] at hh
    exact_mod_cast hh
  have hcost : η*w*(B.card : ℝ) ≤ ∑ i ∈ Finset.range x.length,
      ((A.sourceLoss w i : ℝ)+A.spanLoss w i) := calc
    _ = ∑ _i ∈ B, η*w := by simp [mul_comm]
    _ ≤ ∑ i ∈ B, ((A.sourceLoss w i : ℝ)+A.spanLoss w i) := Finset.sum_le_sum hbad
    _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg Finset.sdiff_subset
      (fun _ _ _ => add_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _))
  rw [Finset.sum_add_distrib,hsumU,hBc] at hcost
  change η*w*(x.length-G.card : ℕ) ≤ _
  linarith only [hcost,hsumV]

end WordMatching

theorem offset_deficit_lower {α : Type*} {w : ℕ} (hw : 12 ≤ w) {δ η : ℝ}
    (hδ : δ ≤ 1) (hη0 : 0 ≤ η) (hη : η ≤ 1)
    (hfit : 2*η*w < δ*(w/8 : ℕ)) {c : α → Fin w → Bool} (hc : OffsetLocal δ c)
    (x y : List α) (hlen : x.length=y.length) :
    (η/(4+32*η))*w*deficit x y ≤ (deficit (encode c x) (encode c y) : ℝ) := by
  classical
  have hwp : 0 < w := by omega
  obtain ⟨A⟩ := exists_lcs_matching (encode c x) (encode c y)
  let G := A.offsetGood w η
  let I := Finset.Icc ((w+2)/3) (2*w/3)
  let E := deficit (encode c x) (encode c y)
  have hG : G ⊆ Finset.range x.length := A.offsetGood_subset w η
  have hI : I ⊆ Finset.range w := by
    intro p hp
    obtain ⟨h1,h2⟩ := Finset.mem_Icc.mp hp
    apply Finset.mem_range.mpr
    omega
  have hIp (p : ℕ) (hp : p ∈ I) : w/8 ≤ p ∧ p+w/8 ≤ w := by
    obtain ⟨h1,h2⟩ := Finset.mem_Icc.mp hp
    omega
  have hIc : w ≤ 4*I.card := by
    simp only [I,Nat.card_Icc]
    omega
  have hspan : ∀ i ∈ G, (A.rightSpan (A.sourceBlock w i)).card ≤ 2*w :=
    fun _ hi => A.offsetGood_span hwp hη hi
  have hlabels : ∀ p ∈ I, ∀ i ∈ G, ∀ k : Fin _, (A.left k).val=i*w+p →
      x[i]? = y[(A.right k).val/w]? := by
    intro p hp i hi k hk
    have hil := Finset.mem_range.mp (hG hi)
    have hjl : (A.right k).val/w < y.length := by
      apply (Nat.div_lt_iff_lt_mul hwp).mpr
      simpa only [length_encode,Nat.mul_comm] using (A.right k).isLt
    obtain ⟨hki,hkp⟩ := A.matchedAt_block (Finset.mem_range.mp (hI hp)) hk
    have hgood := (Finset.mem_filter.mp hi).2
    have hloss : (A.sourceLoss w i+A.spanLoss w i : ℕ) < δ*(w/8 : ℕ) := by
      push_cast
      linarith only [hgood.1,hgood.2,hfit]
    have hh := A.offset_interior_labels hwp hδ hc k ⟨i,hil⟩ ⟨(A.right k).val/w,hjl⟩
      ((A.mem_sourceBlock w i k).mp hki) rfl (by rw [hkp]; exact (hIp p hp).1)
      (by rw [hkp]; exact (hIp p hp).2) hloss
    simpa only [List.getElem?_eq_getElem hil,List.getElem?_eq_getElem hjl,
      List.get_eq_getElem,Option.some.injEq] using hh
  have hav := A.averaged_offset_recovery hwp I G hI hG hspan hlabels
  have he : w*x.length-lcs (encode c x) (encode c y) = E := by simp only [E,deficit,length_encode]
  rw [he] at hav
  have havr : (I.card : ℝ)*deficit x y ≤ 2*(I.card : ℝ)*(x.length-G.card : ℕ)+8*E := by exact_mod_cast hav
  have hbad := A.offsetGood_bad_cost hwp hlen η
  rw [he] at hbad
  have hbad' : η*w*(x.length-G.card : ℕ) ≤ 2*E := hbad
  have hicr : (w : ℝ) ≤ 4*I.card := by exact_mod_cast hIc
  have hip : (0 : ℝ) < I.card := by exact_mod_cast (show 0 < I.card by omega)
  have hmain : η*w*(deficit x y : ℝ) ≤ (4+32*η)*E := by
    apply (mul_le_mul_iff_right₀ hip).mp
    calc
      _ = η*w*((I.card : ℝ)*deficit x y) := by ring
      _ ≤ η*w*(2*(I.card : ℝ)*(x.length-G.card : ℕ)+8*E) :=
        mul_le_mul_of_nonneg_left havr (mul_nonneg hη0 (Nat.cast_nonneg w))
      _ = 2*(I.card : ℝ)*(η*w*(x.length-G.card : ℕ))+8*η*w*E := by ring
      _ ≤ 2*(I.card : ℝ)*(2*E)+8*η*(4*I.card)*E := add_le_add
        (mul_le_mul_of_nonneg_left hbad' (by positivity))
        (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hicr (by positivity)) (Nat.cast_nonneg E))
      _ = (I.card : ℝ)*((4+32*η)*E) := by ring
  have hden : 0 < 4+32*η := by linarith
  calc
    _ = (η*w*(deficit x y : ℝ))/(4+32*η) := by ring
    _ ≤ E := (div_le_iff₀ hden).mpr (by simpa only [mul_comm] using hmain)

end FiniteCircle

end OAI