import Mathlib
import OAI.Combinatorics.IndependentSets.Reduction.ExtensionLaw

namespace OAI

namespace LargeIndependentSets

section
def Small {r : ℕ} (s : ℕ) (I : Finset (Fin r)) : Prop :=
  I.Nonempty ∧ I.card ≤ s

def Separated {r : ℕ} (I J : Finset (Fin r)) : Prop :=
  ∀ i ∈ I, ∀ j ∈ J, i < j

def Aligned {r : ℕ} {M : Type} (A : Finset (Fin r) → Finset M)
    (B : Finset (Fin r)) : Prop :=
  ∃ a : M → Fin r, (∀ x, a x ∈ B) ∧
    ∀ I, I.Nonempty → I ⊆ B → ∀ x ∈ A I, a x ∈ I

structure LayerLaw (r s : ℕ) where
  weight : Finset (Fin r) → ℚ
  nonneg : ∀ B, 0 ≤ weight B
  total : ∑ B, weight B = 1
  support : ∀ B, B.card ≠ s → weight B = 0

noncomputable def LayerLaw.badMass {r s : ℕ} (μ : LayerLaw r s)
    {M : Type} (A : Finset (Fin r) → Finset M) : ℚ := by
  classical
  exact ∑ B, if Aligned A B then 0 else μ.weight B

def DistributionalAlignment : Prop :=
  ∀ s d : ℕ, 1 ≤ s → 1 ≤ d → ∀ η : ℝ, 0 < η →
    ∃ r : ℕ, s ≤ r ∧ ∃ μ : LayerLaw r s,
      ∀ (M : Type) [DecidableEq M] (A : Finset (Fin r) → Finset M),
        (∀ I, Small s I → (A I).card ≤ d) →
        (∀ I J, Small s I → Small s J → Separated I J → Disjoint (A I) (A J)) →
        (μ.badMass A : ℝ) ≤ η

open scoped Classical BigOperators

noncomputable def actualSlot {s d r : ℕ} {M : Type*}
    (A : Finset (Fin r) → Finset M) (a : ListSlot s d (Fin r)) : Option M :=
  if h : a.2.val < (A a.1.val).card then
    some ((A a.1.val).equivFin.symm ⟨a.2.val, h⟩).val else none

lemma actualSlot_some_mem {s d r : ℕ} {M : Type*}
    (A : Finset (Fin r) → Finset M) (a : ListSlot s d (Fin r)) (x : M)
    (h : actualSlot A a = some x) : x ∈ A a.1.val := by
  unfold actualSlot at h
  split_ifs at h with ha
  · have he := Option.some.inj h
    exact he ▸ ((A a.1.val).equivFin.symm ⟨a.2.val, ha⟩).property

lemma actualSlot_unique {s d r : ℕ} {M : Type*}
    (A : Finset (Fin r) → Finset M) (a b : ListSlot s d (Fin r))
    (hI : a.1 = b.1) (he : actualSlot A a = actualSlot A b)
    (ha : actualSlot A a ≠ none) : a.2 = b.2 := by
  obtain ⟨I, i⟩ := a
  obtain ⟨J, j⟩ := b
  dsimp at hI
  subst J
  unfold actualSlot at he ha
  split_ifs at he with hi hj
  · apply Fin.ext
    have h := (A I.val).equivFin.symm.injective (Subtype.ext (Option.some.inj he))
    exact congrArg (fun z : Fin (A I.val).card => z.val) h
  · exact False.elim (ha (by simp [hi]))

lemma actualSlot_exists {s d r : ℕ} {M : Type*}
    (A : Finset (Fin r) → Finset M) (hbound : ∀ I, Small s I → (A I).card ≤ d)
    (I : ListIndex s (Fin r)) (x : M) (hx : x ∈ A I.val) :
    ∃ i : Fin d, actualSlot A (I, i) = some x := by
  let k := (A I.val).equivFin ⟨x, hx⟩
  have hk : k.val < d := k.isLt.trans_le (hbound I.val I.property)
  refine ⟨⟨k.val, hk⟩, ?_⟩
  simp only [actualSlot, k.isLt, dite_eq_left]
  exact congrArg (fun y : A I.val => some y.val) ((A I.val).equivFin.symm_apply_apply ⟨x, hx⟩)

noncomputable def actualPattern {s d r : ℕ} {M : Type*}
    (A : Finset (Fin r) → Finset M)
    (hsep : ∀ I J, Small s I → Small s J → Separated I J → Disjoint (A I) (A J)) :
    ListPattern s d (Fin r) :=
  ⟨fun a b => decide (actualSlot A a = actualSlot A b ∧ actualSlot A a ≠ none), by
    refine ⟨?_, ?_, ?_, ?_⟩
    · intro a b h
      have hh := of_decide_eq_true h
      exact decide_eq_true (And.intro hh.1.symm (hh.1 ▸ hh.2))
    · intro a b c hab hbc
      have hab' := of_decide_eq_true hab
      have hbc' := of_decide_eq_true hbc
      exact decide_eq_true ⟨hab'.1.trans hbc'.1, hab'.2⟩
    · intro a b h hab
      have hh := of_decide_eq_true h
      exact actualSlot_unique A a b hab hh.1 hh.2
    · intro a b hsep'
      apply decide_eq_false
      rintro ⟨he, hne⟩
      obtain ⟨x, hx⟩ := Option.ne_none_iff_exists'.mp hne
      have ha := actualSlot_some_mem A a x hx
      have hb := actualSlot_some_mem A b x (he.symm.trans hx)
      exact Finset.disjoint_left.mp (hsep a.1.val b.1.val a.1.property b.1.property hsep') ha hb⟩

lemma actualPattern_eq {s d r : ℕ} {M : Type*}
    (A : Finset (Fin r) → Finset M)
    (hsep : ∀ I J, Small s I → Small s J → Separated I J → Disjoint (A I) (A J))
    (a b : ListSlot s d (Fin r)) :
    (actualPattern A hsep).val a b = true ↔
      actualSlot A a = actualSlot A b ∧ actualSlot A a ≠ none := by
  exact decide_eq_true_iff

lemma actualPattern_good_aligned {s d r : ℕ} {M : Type}
    (A : Finset (Fin r) → Finset M) (hbound : ∀ I, Small s I → (A I).card ≤ d)
    (hsep : ∀ I J, Small s I → Small s J → Separated I J → Disjoint (A I) (A J))
    (B : Finset (Fin r)) (hB : B.Nonempty) (hBs : B.card ≤ s)
    (hgood : GoodPatternOn (actualPattern (d := d) A hsep) B) : Aligned A B := by
  classical
  have hchoice (x : M) : ∃ i ∈ B, ∀ I, I.Nonempty → I ⊆ B → x ∈ A I → i ∈ I := by
    by_cases hx : ∃ I, I.Nonempty ∧ I ⊆ B ∧ x ∈ A I
    · obtain ⟨I, hI, hIB, hxI⟩ := hx
      let I' : ListIndex s (Fin r) := ⟨I, hI, (Finset.card_le_card hIB).trans hBs⟩
      obtain ⟨j, hj⟩ := actualSlot_exists A hbound I' x hxI
      have haa : (actualPattern A hsep).val (I', j) (I', j) = true :=
        (actualPattern_eq _ _ _ _).mpr ⟨rfl, by rw [hj]; exact Option.some_ne_none _⟩
      obtain ⟨i, hiB, hi⟩ := hgood (I', j) hIB haa
      refine ⟨i, hiB, ?_⟩
      intro J hJ hJB hxJ
      let J' : ListIndex s (Fin r) := ⟨J, hJ, (Finset.card_le_card hJB).trans hBs⟩
      obtain ⟨k, hk⟩ := actualSlot_exists A hbound J' x hxJ
      apply hi (J', k) hJB
      exact (actualPattern_eq _ _ _ _).mpr ⟨hj.trans hk.symm, by rw [hj]; exact Option.some_ne_none _⟩
    · obtain ⟨i, hi⟩ := hB
      exact ⟨i, hi, fun I hI hIB hxI => False.elim (hx ⟨I, hI, hIB, hxI⟩)⟩
  choose a ha harest using hchoice
  exact ⟨a, ha, fun I hI hIB x hx => harest x I hI hIB hx⟩

end

noncomputable def ListSlot.pullbackFin {s d n : ℕ} {X : Type*} [LinearOrder X]
    (B : Finset X) (hB : B.card = n) (a : ListSlot s d X) (ha : a.1.val ⊆ B) :
    ListSlot s d (Fin n) :=
  ListSlot.map (B.orderIsoOfFin hB).symm.toEmbedding (a.inside B ha)

lemma ListSlot.map_pullbackFin {s d n : ℕ} {X : Type*} [LinearOrder X]
    (B : Finset X) (hB : B.card = n) (a : ListSlot s d X) (ha : a.1.val ⊆ B) :
    ListSlot.map (B.orderEmbOfFin hB).toEmbedding (a.pullbackFin B hB ha) = a := by
  unfold pullbackFin
  rw [ListSlot.map_comp]
  have he : (B.orderIsoOfFin hB).symm.toEmbedding.trans (B.orderEmbOfFin hB).toEmbedding =
      Function.Embedding.subtype (· ∈ B) := by
    ext x
    change ((B.orderIsoOfFin hB) ((B.orderIsoOfFin hB).symm x)).val = x.val
    rw [OrderIso.apply_symm_apply]
  rw [he, ListSlot.map_inside]

lemma good_full_restrict_goodOn {s d n : ℕ} {X : Type*} [LinearOrder X]
    (C : ListPattern s d X) (B : Finset X) (hB : B.card = n)
    (hgood : GoodPatternOn (C.restrict (B.orderEmbOfFin hB)) Finset.univ) :
    GoodPatternOn C B := by
  classical
  intro a ha haa
  have hsame : (C.restrict (B.orderEmbOfFin hB)).val
      (a.pullbackFin B hB ha) (a.pullbackFin B hB ha) = true := by
    change C.val (ListSlot.map _ _) (ListSlot.map _ _) = true
    rw [ListSlot.map_pullbackFin, haa]
  obtain ⟨i, _, hi⟩ := hgood (a.pullbackFin B hB ha) (Finset.subset_univ _) hsame
  refine ⟨B.orderEmbOfFin hB i, B.orderEmbOfFin_mem hB i, ?_⟩
  intro b hb hab
  have hrel : (C.restrict (B.orderEmbOfFin hB)).val
      (a.pullbackFin B hB ha) (b.pullbackFin B hB hb) = true := by
    change C.val (ListSlot.map _ _) (ListSlot.map _ _) = true
    rw [ListSlot.map_pullbackFin, ListSlot.map_pullbackFin, hab]
  have hm := hi (b.pullbackFin B hB hb) (Finset.subset_univ _) hrel
  have hm' : B.orderEmbOfFin hB i ∈
      (ListSlot.map (B.orderEmbOfFin hB).toEmbedding (b.pullbackFin B hB hb)).1.val :=
    Finset.mem_map.mpr ⟨i, hm, rfl⟩
  rwa [ListSlot.map_pullbackFin] at hm'

lemma good_embedding_restrict_goodOn {s d n : ℕ} {X : Type*} [LinearOrder X]
    (C : ListPattern s d X) (e : Fin n ↪o X)
    (hgood : GoodPatternOn (C.restrict e) Finset.univ) :
    GoodPatternOn C (Finset.univ.map e.toEmbedding) := by
  apply good_full_restrict_goodOn (n := n) C _ (by simp)
  simpa only [finite_embedding_sorted] using hgood

end LargeIndependentSets

end OAI