import Mathlib
import OAI.Combinatorics.IndependentSets.PCP.LabelCoverData

namespace OAI

namespace LargeIndependentSets

section
open scoped Classical

def occurrenceTuple {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (i : ℕ) : MixedTuple U V n i :=
  ⟨fun h => if h.val < i then Sum.inl (lc.right (c h)) else Sum.inr (lc.left (c h)), by
    intro h
    by_cases hh : h.val < i <;> simp [hh]⟩

def occurrenceQuestion {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (i : Fin (n+1)) : LayerQuestion U V n :=
  ⟨i, occurrenceTuple lc c i.val⟩

def chainComposite {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (i j : ℕ) (hij : i ≤ j) :
    MixedTuple L R n i → MixedTuple L R n j :=
  fun x => ⟨fun h => if i ≤ h.val ∧ h.val < j then
      Sum.inl ((x.val h).elim id (lc.project (c h))) else x.val h, by
    intro h
    by_cases hh : i ≤ h.val ∧ h.val < j
    · simp [hh]
    · have he : (h.val < i) = (h.val < j) := propext (by omega)
      simp [hh, x.property h, he]⟩

@[simp] lemma chainComposite_self {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (i : ℕ) (hi : i ≤ i) (x : MixedTuple L R n i) :
    chainComposite lc c i i hi x = x := by
  apply Subtype.ext
  funext h
  simp [chainComposite, show ¬(i ≤ h.val ∧ h.val < i) from by omega]

lemma chainComposite_comp {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (i j k : ℕ) (hij : i ≤ j) (hjk : j ≤ k)
    (x : MixedTuple L R n i) :
    chainComposite lc c j k hjk (chainComposite lc c i j hij x) =
      chainComposite lc c i k (hij.trans hjk) x := by
  apply Subtype.ext
  funext h
  dsimp [chainComposite]
  by_cases h₁ : h.val < i
  · simp [show ¬i ≤ h.val from by omega, show ¬j ≤ h.val from by omega]
  · by_cases h₂ : h.val < j
    · simp [show i ≤ h.val from by omega, h₂, show h.val < k from by omega,
        show ¬ j ≤ h.val from by omega]
    · by_cases h₃ : h.val < k
      · simp [show i ≤ h.val from by omega, show j ≤ h.val from by omega, h₂, h₃]
      · simp [h₂, h₃]

lemma chainComposite_adjacent {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (h : Fin n) :
    chainComposite lc c h.val (h.val+1) (by omega) = mixedProject h (lc.project (c h)) := by
  funext x
  apply Subtype.ext
  funext k
  have he : (h.val ≤ k.val ∧ k.val < h.val+1) ↔ k = h := by
    constructor
    · intro hk; apply Fin.ext; omega
    · intro hk; subst k; omega
  simp only [chainComposite, mixedProject, he]
  split_ifs with hk
  · subst k; rfl
  · rfl

lemma occurrence_chain_imposed {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) (h : Fin n) :
    (layeredSystem lc n).imposed (occurrenceQuestion lc c h.castSucc)
      (occurrenceQuestion lc c h.succ) (chainComposite lc c h.val (h.val+1) (by omega)) := by
  rw [chainComposite_adjacent]
  apply LayerImposed.adjacent h (occurrenceTuple lc c h.val)
    (occurrenceTuple lc c (h.val+1)) (c h)
  · simp [occurrenceTuple]
  · simp [occurrenceTuple]
  · intro k hk
    have hne : k.val ≠ h.val := fun he => hk (Fin.ext he)
    have he : (k.val < h.val) = (k.val < h.val+1) := propext (by omega)
    simp only [occurrenceTuple, he]

lemma imposed_path_zero {Q : Type*} {M : Q → Type*} (S : ProjectionSystem Q M)
    {D : ℕ} [NeZero D] {q q' : Q} (π : M q → M q') (hπ : S.imposed q q' π)
    (v : M q' → ZMod D) : pathDistance S.linkLength ⟨q, v ∘ π⟩ ⟨q', v⟩ = 0 := by
  apply le_antisymm _ bot_le
  apply (pathDistance_le_link _ _ _).trans
  have hz : S.ZeroLink D ⟨q, v ∘ π⟩ ⟨q', v⟩ := Or.inl (.link q q' π hπ v)
  simp only [ProjectionSystem.linkLength, ite_eq_left hz]
  exact le_rfl

theorem occurrence_chain_path_zero {U V L R C : Type*} (lc : LabelCoverData U V L R C)
    {n : ℕ} (c : Fin n → C) {D : ℕ} [NeZero D] (i j : ℕ) (hij : i ≤ j) (hjn : j ≤ n)
    (v : MixedTuple L R n j → ZMod D) :
    pathDistance (layeredSystem lc n).linkLength
      ⟨occurrenceQuestion lc c ⟨i, by omega⟩, v ∘ chainComposite lc c i j hij⟩
      ⟨occurrenceQuestion lc c ⟨j, by omega⟩, v⟩ = 0 := by
  induction j, hij using Nat.le_induction with
  | base =>
    have he : v ∘ chainComposite lc c i i (by omega) = v := by
      funext x; simp
    simp only [occurrenceQuestion] at ⊢
    rw [he]
    exact pathDistance_self _ (linkLength_self _) _
  | succ j hij ih =>
    let w : MixedTuple L R n j → ZMod D := v ∘ chainComposite lc c j (j+1) (by omega)
    have hleft := ih (by omega) w
    have hright := imposed_path_zero (layeredSystem lc n)
      (q := occurrenceQuestion lc c ⟨j, by omega⟩)
      (q' := occurrenceQuestion lc c ⟨j+1, by omega⟩)
      (chainComposite lc c j (j+1) (by omega))
      (occurrence_chain_imposed lc c ⟨j, by omega⟩) v
    have he : w ∘ chainComposite lc c i j hij = v ∘ chainComposite lc c i (j+1) (by omega) := by
      funext x
      exact congrArg v (chainComposite_comp lc c i j (j+1) hij (by omega) x)
    simp only [occurrenceQuestion] at hleft
    rw [he] at hleft
    apply le_antisymm _ bot_le
    exact (pathDistance_triangle _ _
      ⟨occurrenceQuestion lc c ⟨j, by omega⟩, w⟩ _).trans
      (by
        simp only [occurrenceQuestion] at hright ⊢
        rw [hleft, hright, add_zero]
        exact le_rfl)

end

open scoped Classical BigOperators
noncomputable def paddedList {X : Type*} (A : Finset X) (d : ℕ) (x₀ : X) (i : Fin d) : X :=
  if hi : i.val < A.card then (A.equivFin.symm ⟨i.val, hi⟩).val else x₀

lemma mem_paddedList {X : Type*} (A : Finset X) (d : ℕ) (x₀ x : X)
    (hd : A.card ≤ d) (hx : x ∈ A) : ∃ i : Fin d, paddedList A d x₀ i = x := by
  let j := A.equivFin ⟨x, hx⟩
  refine ⟨⟨j.val, j.isLt.trans_le hd⟩, ?_⟩
  simp only [paddedList, j.isLt, dite_eq_left]
  exact congrArg Subtype.val (A.equivFin.symm_apply_apply ⟨x, hx⟩)

def LabelCoverData.Sound {U V L R C : Type*} [Fintype C]
    (lc : LabelCoverData U V L R C) (σ : ℝ) : Prop :=
  ∀ (l : U → L) (r : V → R),
    ((Finset.univ.filter (fun c => lc.project c (l (lc.left c)) = r (lc.right c))).card : ℝ) ≤
      σ * Fintype.card C

theorem bounded_list_decoding {U V L R C : Type*} [Fintype C] [Nonempty L] [Nonempty R]
    (lc : LabelCoverData U V L R C) {σ : ℝ} (hsound : lc.Sound σ)
    (d : ℕ) (A : U → Finset L) (B : V → Finset R)
    (hA : ∀ u, (A u).card ≤ d) (hB : ∀ v, (B v).card ≤ d) :
    ((Finset.univ.filter (fun c => ∃ l ∈ A (lc.left c), ∃ r ∈ B (lc.right c),
      lc.project c l = r)).card : ℝ) ≤ (d : ℝ)^2 * σ * Fintype.card C := by
  classical
  let ls : Fin d → U → L := fun i u => paddedList (A u) d (Classical.arbitrary L) i
  let rs : Fin d → V → R := fun i v => paddedList (B v) d (Classical.arbitrary R) i
  let E : Fin d × Fin d → Finset C := fun ij => Finset.univ.filter
    (fun c => lc.project c (ls ij.1 (lc.left c)) = rs ij.2 (lc.right c))
  have hcover : Finset.univ.filter (fun c => ∃ l ∈ A (lc.left c), ∃ r ∈ B (lc.right c),
        lc.project c l = r) ⊆ Finset.univ.biUnion E := by
    intro c hc
    obtain ⟨l, hl, r, hr, he⟩ := (Finset.mem_filter.mp hc).2
    obtain ⟨i, hi⟩ := mem_paddedList (A (lc.left c)) d (Classical.arbitrary L) l (hA _) hl
    obtain ⟨j, hj⟩ := mem_paddedList (B (lc.right c)) d (Classical.arbitrary R) r (hB _) hr
    apply Finset.mem_biUnion.mpr
    refine ⟨(i,j), Finset.mem_univ _, ?_⟩
    apply Finset.mem_filter.mpr
    exact ⟨Finset.mem_univ _, by simpa only [ls, rs, hi, hj] using he⟩
  have hc := (Finset.card_le_card hcover).trans (Finset.card_biUnion_le)
  have hcr : ((Finset.univ.filter (fun c => ∃ l ∈ A (lc.left c), ∃ r ∈ B (lc.right c),
        lc.project c l = r)).card : ℝ) ≤ ∑ ij, ((E ij).card : ℝ) := by
    exact_mod_cast hc
  have he : ∑ ij, ((E ij).card : ℝ) ≤ ∑ _ij : Fin d × Fin d, σ * Fintype.card C := by
    apply Finset.sum_le_sum
    intro ij _
    exact hsound (ls ij.1) (rs ij.2)
  calc
    _ ≤ _ := hcr.trans he
    _ = (d : ℝ)^2 * σ * Fintype.card C := by
      simp [Finset.sum_const, nsmul_eq_mul, pow_two, mul_assoc]

theorem bounded_list_probability {U V L R C : Type*} [Fintype C] [Nonempty C]
    [Nonempty L] [Nonempty R] (lc : LabelCoverData U V L R C)
    {σ : ℝ} (hsound : lc.Sound σ) (d : ℕ) (A : U → Finset L) (B : V → Finset R)
    (hA : ∀ u, (A u).card ≤ d) (hB : ∀ v, (B v).card ≤ d) :
    ((Finset.univ.filter (fun c => ∃ l ∈ A (lc.left c), ∃ r ∈ B (lc.right c),
      lc.project c l = r)).card : ℝ) / Fintype.card C ≤ (d : ℝ)^2 * σ := by
  apply (div_le_iff₀ (by exact_mod_cast Fintype.card_pos : (0 : ℝ) < Fintype.card C)).mpr
  exact bounded_list_decoding lc hsound d A B hA hB

end LargeIndependentSets

end OAI