import Mathlib
import OAI.Combinatorics.IndependentSets.Reduction.OccurrenceTuple

namespace OAI

namespace LargeIndependentSets
open scoped Classical BigOperators

@[ext] structure SubchainView (U V L R : Type*) (n : ℕ) (I : Finset (Fin (n+1))) where
  question : ∀ j : I, MixedTuple U V n j.val.val
  projection : ∀ i j : I, i.val ≤ j.val →
    MixedTuple L R n i.val.val → MixedTuple L R n j.val.val

def chainView {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (I : Finset (Fin (n+1))) : SubchainView U V L R n I where
  question j := occurrenceTuple lc c j.val.val
  projection i j hij := chainComposite lc c i.val.val j.val.val hij

lemma occurrenceTuple_local_left {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} {c c' : Fin n → C} (h : Fin n)
    (hout : ∀ k, k ≠ h → c k = c' k) (hown : lc.left (c h) = lc.left (c' h))
    {i : ℕ} (hi : i ≤ h.val) : occurrenceTuple lc c i = occurrenceTuple lc c' i := by
  apply Subtype.ext; funext k
  by_cases hk : k = h
  · subst k; simp [occurrenceTuple, show ¬ h.val < i by omega, hown]
  · simp [occurrenceTuple, hout k hk]

lemma occurrenceTuple_local_right {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} {c c' : Fin n → C} (h : Fin n)
    (hout : ∀ k, k ≠ h → c k = c' k) (hown : lc.right (c h) = lc.right (c' h))
    {i : ℕ} (hi : h.val < i) : occurrenceTuple lc c i = occurrenceTuple lc c' i := by
  apply Subtype.ext; funext k
  by_cases hk : k = h
  · subst k; simp [occurrenceTuple, hi, hown]
  · simp [occurrenceTuple, hout k hk]

lemma chainComposite_local {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} {c c' : Fin n → C} (h : Fin n)
    (hout : ∀ k, k ≠ h → c k = c' k) {i j : ℕ} (hij : i ≤ j)
    (haway : j ≤ h.val ∨ h.val < i) :
    chainComposite lc c i j hij = chainComposite lc c' i j hij := by
  funext x; apply Subtype.ext; funext k
  by_cases hk : k = h
  · subst k
    have hh : ¬(i ≤ h.val ∧ h.val < j) := by omega
    simp [chainComposite, hh]
  · simp [chainComposite, hout k hk]

lemma chainView_local_left {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} {c c' : Fin n → C} (h : Fin n)
    (hout : ∀ k, k ≠ h → c k = c' k) (hown : lc.left (c h) = lc.left (c' h))
    (I : Finset (Fin (n+1))) (hI : ∀ i ∈ I, i.val ≤ h.val) :
    chainView lc c I = chainView lc c' I := by
  apply SubchainView.ext
  · funext i; exact occurrenceTuple_local_left lc h hout hown (hI i.val i.property)
  · funext i j hij
    exact chainComposite_local lc h hout hij (Or.inl (hI j.val j.property))

lemma chainView_local_right {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} {c c' : Fin n → C} (h : Fin n)
    (hout : ∀ k, k ≠ h → c k = c' k) (hown : lc.right (c h) = lc.right (c' h))
    (I : Finset (Fin (n+1))) (hI : ∀ i ∈ I, h.val < i.val) :
    chainView lc c I = chainView lc c' I := by
  apply SubchainView.ext
  · funext i; exact occurrenceTuple_local_right lc h hout hown (hI i.val i.property)
  · funext i j hij
    exact chainComposite_local lc h hout hij (Or.inr (hI i.val i.property))

abbrev SubchainCoord (L R : Type*) (n : ℕ) (I : Finset (Fin (n+1))) :=
  Σ j : I, MixedTuple L R n j.val.val

noncomputable def leftEntry {L R : Type*} [Nonempty L] {n i : ℕ}
    (h : Fin n) (x : MixedTuple L R n i) : L := (x.val h).elim (fun _ => Classical.arbitrary L) id
noncomputable def rightEntry {L R : Type*} [Nonempty R] {n i : ℕ}
    (h : Fin n) (x : MixedTuple L R n i) : R := (x.val h).elim id (fun _ => Classical.arbitrary R)

lemma leftEntry_spec {L R : Type*} [Nonempty L] {n i : ℕ}
    (h : Fin n) (x : MixedTuple L R n i) (hi : i ≤ h.val) :
    x.val h = Sum.inr (leftEntry h x) := by
  have hp := x.property h
  simp only [show ¬h.val < i by omega, decide_false] at hp
  unfold leftEntry
  cases he : x.val h <;> simp_all

lemma rightEntry_spec {L R : Type*} [Nonempty R] {n i : ℕ}
    (h : Fin n) (x : MixedTuple L R n i) (hi : h.val < i) :
    x.val h = Sum.inl (rightEntry h x) := by
  have hp := x.property h
  simp only [hi, decide_true] at hp
  unfold rightEntry
  cases he : x.val h <;> simp_all

noncomputable def terminalList {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (I : Finset (Fin (n+1)))
    (S : Finset (SubchainCoord L R n I)) : Finset (MixedTuple L R n n) :=
  S.image (fun x => chainComposite lc c x.1.val.val n (by have := x.1.val.isLt; omega) x.2)

lemma terminal_intersection_decodes {U V L R C : Type*} [Nonempty L] [Nonempty R]
    (lc : LabelCoverData U V L R C) {n : ℕ} (c : Fin n → C) (h : Fin n)
    (I J : Finset (Fin (n+1))) (hI : ∀ i ∈ I, i.val ≤ h.val)
    (hJ : ∀ j ∈ J, h.val < j.val)
    (S : Finset (SubchainCoord L R n I)) (S' : Finset (SubchainCoord L R n J))
    (hinter : ¬ Disjoint (terminalList lc c I S) (terminalList lc c J S')) :
    ∃ l ∈ S.image (fun x => leftEntry h x.2),
      ∃ r ∈ S'.image (fun x => rightEntry h x.2), lc.project (c h) l = r := by
  obtain ⟨z,hz,hz'⟩ := Finset.not_disjoint_iff.mp hinter
  obtain ⟨x,hx,he⟩ := Finset.mem_image.mp hz
  obtain ⟨y,hy,he'⟩ := Finset.mem_image.mp hz'
  refine ⟨leftEntry h x.2, Finset.mem_image.mpr ⟨x,hx,rfl⟩,
    rightEntry h y.2, Finset.mem_image.mpr ⟨y,hy,rfl⟩,?_⟩
  have hp := congrArg (fun z : MixedTuple L R n n => z.val h) (he.trans he'.symm)
  have hix := hI x.1.val x.1.property
  have hjy := hJ y.1.val y.1.property
  simp only [chainComposite, hix, h.isLt, and_self, ite_true,
    show ¬ y.1.val.val ≤ h.val by omega, false_and, ite_false,
    leftEntry_spec h x.2 hix, rightEntry_spec h y.2 hjy, Sum.elim_inr] at hp
  exact Sum.inl.inj hp

noncomputable def ownQuestionList {C U X : Type*} (q : C → U) (f : C → Finset X)
    (u : U) : Finset X :=
  if h : ∃ c, q c = u then f h.choose else ∅

lemma ownQuestionList_apply {C U X : Type*} (q : C → U) (f : C → Finset X)
    (hf : ∀ c c', q c = q c' → f c = f c') (c : C) :
    ownQuestionList q f (q c) = f c := by
  simp only [ownQuestionList, dite_eq_left (show ∃ c', q c' = q c from ⟨c,rfl⟩)]
  exact hf _ _ (Exists.choose_spec (show ∃ c', q c' = q c from ⟨c,rfl⟩))

lemma ownQuestionList_card {C U X : Type*} (q : C → U) (f : C → Finset X)
    {d : ℕ} (hf : ∀ c, (f c).card ≤ d) (u : U) :
    (ownQuestionList q f u).card ≤ d := by
  unfold ownQuestionList; split_ifs <;> simp_all

theorem separated_lists_conditioned {U V L R C : Type*}
    [Fintype C] [Nonempty L] [Nonempty R]
    (lc : LabelCoverData U V L R C) {σ : ℝ} (hsound : lc.Sound σ)
    {n : ℕ} (background : Fin n → C) (h : Fin n)
    (I J : Finset (Fin (n+1))) (hI : ∀ i ∈ I, i.val ≤ h.val)
    (hJ : ∀ j ∈ J, h.val < j.val) (d : ℕ)
    (ruleI : SubchainView U V L R n I → Finset (SubchainCoord L R n I))
    (ruleJ : SubchainView U V L R n J → Finset (SubchainCoord L R n J))
    (hcardI : ∀ v, (ruleI v).card ≤ d) (hcardJ : ∀ v, (ruleJ v).card ≤ d) :
    ((Finset.univ.filter (fun c : C =>
      let chain := Function.update background h c
      ¬ Disjoint (terminalList lc chain I (ruleI (chainView lc chain I)))
        (terminalList lc chain J (ruleJ (chainView lc chain J))))).card : ℝ) ≤
      (d : ℝ)^2 * σ * Fintype.card C := by
  let chain := fun c => Function.update background h c
  let lefts := fun c => (ruleI (chainView lc (chain c) I)).image (fun x => leftEntry h x.2)
  let rights := fun c => (ruleJ (chainView lc (chain c) J)).image (fun x => rightEntry h x.2)
  have hout (c c' : C) (k : Fin n) (hk : k ≠ h) : chain c k = chain c' k := by
    simp [chain, Function.update_of_ne hk]
  have hleft (c c' : C) (he : lc.left c = lc.left c') : lefts c = lefts c' := by
    have hv := chainView_local_left lc h (hout c c') (by simpa [chain] using he) I hI
    simp only [lefts, hv]
  have hright (c c' : C) (he : lc.right c = lc.right c') : rights c = rights c' := by
    have hv := chainView_local_right lc h (hout c c') (by simpa [chain] using he) J hJ
    simp only [rights, hv]
  let A := ownQuestionList lc.left lefts
  let B := ownQuestionList lc.right rights
  have hA (u) : (A u).card ≤ d :=
    ownQuestionList_card _ _ (fun c => Finset.card_image_le.trans (hcardI _)) u
  have hB (v) : (B v).card ≤ d :=
    ownQuestionList_card _ _ (fun c => Finset.card_image_le.trans (hcardJ _)) v
  have hcover : Finset.univ.filter (fun c : C =>
      ¬Disjoint (terminalList lc (chain c) I (ruleI (chainView lc (chain c) I)))
        (terminalList lc (chain c) J (ruleJ (chainView lc (chain c) J)))) ⊆
      Finset.univ.filter (fun c => ∃ l ∈ A (lc.left c), ∃ r ∈ B (lc.right c), lc.project c l = r) := by
    intro c hc
    have hd := terminal_intersection_decodes lc (chain c) h I J hI hJ _ _
      (Finset.mem_filter.mp hc).2
    apply Finset.mem_filter.mpr
    refine ⟨Finset.mem_univ _,?_⟩
    change ∃ l ∈ ownQuestionList lc.left lefts (lc.left c),
      ∃ r ∈ ownQuestionList lc.right rights (lc.right c), lc.project c l = r
    rw [ownQuestionList_apply _ _ hleft, ownQuestionList_apply _ _ hright]
    simpa only [chain, Function.update_self] using hd
  exact (show (_ : ℝ) ≤ _ from Nat.cast_le.mpr (Finset.card_le_card hcover)).trans
    (bounded_list_decoding lc hsound d A B hA hB)

end LargeIndependentSets

end OAI