import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.Edge2

namespace OAI

namespace MatchingFPRAS.UnitRefresh

open Finset

variable {V W L : Type*} [Fintype V] [Fintype W] [Fintype L]
  [DecidableEq V] [DecidableEq W] [DecidableEq L]

noncomputable def assignmentEquiv (b : V → Finset L) (c : W → Finset L)
    (e : V ≃ W) (he : ∀ x,c (e x)=b x) : Assignment b ≃ Assignment c where
  toFun f := ⟨fun y => f.val (e.symm y),fun y => by
    have hy : c y=b (e.symm y) := by simpa using he (e.symm y)
    rw [hy]; exact f.property (e.symm y)⟩
  invFun f := ⟨fun x => f.val (e x),fun x => by rw [←he]; exact f.property _⟩
  left_inv f := Subtype.ext (by funext x; simp)
  right_inv f := Subtype.ext (by funext x; simp)

omit [Fintype L] [DecidableEq V] [DecidableEq W] in
lemma fiberCount_equiv [Fintype L] [DecidableEq V] [DecidableEq W]
    (e : V ≃ W) (f : V → L) (g : W → L)
    (h : ∀ x,g (e x)=f x) (l : L) : fiberCount f l=fiberCount g l := by
  unfold fiberCount
  exact Fintype.card_congr (e.subtypeEquiv (fun x => by rw [h]))

lemma assignmentPartition_equiv (b : V → Finset L) (c : W → Finset L)
    (e : V ≃ W) (he : ∀ x,c (e x)=b x) (w : L → ℕ → ℕ) :
    assignmentPartition b w = assignmentPartition c w := by
  classical
  unfold assignmentPartition
  apply Fintype.sum_equiv (assignmentEquiv b c e he)
  intro f
  apply prod_congr rfl
  intro l hl
  congr 1
  apply fiberCount_equiv e
  intro x
  simp [assignmentEquiv]

abbrev Private (b : V → Finset L) (l : L) := {x : V // b x={l}}

abbrev Shared (b : V → Finset L) (l : L) := {x : V // l∈b x ∧ b x≠{l}}

abbrev Outside (b : V → Finset L) (l : L) := {x : V // l∉b x}

noncomputable def splitLeaf (b : V → Finset L) (l : L) :
    V ≃ Private b l ⊕ Shared b l ⊕ Outside b l where
  toFun x := if h : b x={l} then .inl ⟨x,h⟩ else
    if h' : l∈b x then .inr (.inl ⟨x,h',h⟩) else .inr (.inr ⟨x,h'⟩)
  invFun := Sum.elim Subtype.val (Sum.elim Subtype.val Subtype.val)
  left_inv x := by dsimp only; split_ifs <;> rfl
  right_inv x := by
    rcases x with x | (x | x)
    · simp [x.property]
    · simp [x.property.1,x.property.2]
    · have hx : b x.val≠{l} := by intro h; exact x.property (by simp [h])
      simp [hx,x.property]

def LeafAt (b : V → Finset L) (l p : L) : Prop :=
  ∀ x,l∈b x → b x={l} ∨ b x={l,p}

omit [Fintype V] [Fintype L] [DecidableEq V] in
lemma splitLeaf_bags [Fintype V] [Fintype L] [DecidableEq V]
    (b : V → Finset L) (l p : L) (h : LeafAt b l p) (x : V) :
    leafBags l p (fun y : Outside b l => b y.val) (splitLeaf b l x)=b x := by
  classical
  unfold splitLeaf
  simp only [Equiv.coe_fn_mk]
  split_ifs with he hm
  · exact he.symm
  · exact ((h x hm).resolve_left he).symm
  · rfl

theorem tree_leaf_elimination (b : V → Finset L) (l p : L) (hlp : l≠p)
    (h : LeafAt b l p) (w : L → ℕ → ℕ) :
    assignmentPartition b w =
      assignmentPartition (fun x : Outside b l => b x.val)
        (leafUpdate (Fintype.card (Private b l)) (Fintype.card (Shared b l)) l p w) := by
  classical
  rw [assignmentPartition_equiv b _ (splitLeaf b l) (splitLeaf_bags b l p h)]
  exact leaf_elimination l p hlp _ (fun x => x.property) w

def rootBags {U : Type*} (l : L) (b : W → Finset L) : U ⊕ W → Finset L :=
  Sum.elim (fun _ => {l}) b

noncomputable def rootAssignmentEquiv {U : Type*} [Fintype U] [DecidableEq U]
    (l : L) (b : W → Finset L) : Assignment (rootBags (U:=U) l b) ≃ Assignment b where
  toFun f := ⟨fun x => f.val (.inr x),fun x => f.property _⟩
  invFun f := ⟨Sum.elim (fun _ => l) f.val,by
    intro x; rcases x with x | x
    · simp [rootBags]
    · exact f.property x⟩
  left_inv f := by
    apply Subtype.ext
    funext x
    rcases x with x | x
    · have h := f.property (.inl x)
      have hx : f.val (.inl x)=l := by simpa [rootBags] using h
      exact hx.symm
    · rfl
  right_inv f := rfl

noncomputable def rootUpdate (u : ℕ) (l : L) (w : L → ℕ → ℕ) : L → ℕ → ℕ :=
  fun a r => if a=l then w l u else w a r

lemma root_elimination {U : Type*} [Fintype U] [DecidableEq U]
    (l : L) (b : W → Finset L) (hb : ∀ x,l∉b x) (w : L → ℕ → ℕ) :
    assignmentPartition (rootBags (U:=U) l b) w =
      assignmentPartition b (rootUpdate (Fintype.card U) l w) := by
  classical
  unfold assignmentPartition
  apply Fintype.sum_equiv (rootAssignmentEquiv l b)
  intro f
  have hl : fiberCount f.val l = Fintype.card U := by
    rw [fiberCount_sum]
    have he : (fun x : U => f.val (.inl x))=(fun _ => l) := by
      funext x; simpa [rootBags] using f.property (.inl x)
    rw [he,fiberCount_const,ite_eq_left rfl]
    have hz : fiberCount (fun x : W => f.val (.inr x)) l=0 := by
      apply fiberCount_zero
      intro x hx
      exact hb x (hx ▸ f.property (.inr x))
    omega
  apply prod_congr rfl
  intro a ha
  by_cases h : a=l
  · subst a; simp [rootUpdate,hl]
  · simp only [rootUpdate,ite_eq_right h]
    congr 1
    rw [fiberCount_sum]
    have he : (fun x : U => f.val (.inl x))=(fun _ => l) := by
      funext x; simpa [rootBags] using f.property (.inl x)
    rw [he,fiberCount_const,ite_eq_right (Ne.symm h),zero_add]
    rfl

noncomputable def splitRoot (b : V → Finset L) (l : L) :
    V ≃ {x : V // l∈b x} ⊕ Outside b l where
  toFun x := if h : l∈b x then .inl ⟨x,h⟩ else .inr ⟨x,h⟩
  invFun := Sum.elim Subtype.val Subtype.val
  left_inv x := by dsimp only; split_ifs <;> rfl
  right_inv x := by rcases x with x | x <;> simp [x.property]

theorem tree_root_elimination (b : V → Finset L) (l : L)
    (h : ∀ x,l∈b x → b x={l}) (w : L → ℕ → ℕ) :
    assignmentPartition b w =
      assignmentPartition (fun x : Outside b l => b x.val)
        (rootUpdate (Fintype.card {x : V // l∈b x}) l w) := by
  classical
  have he (x : V) : rootBags l (fun y : Outside b l => b y.val) (splitRoot b l x)=b x := by
    unfold splitRoot
    simp only [Equiv.coe_fn_mk]
    split_ifs with hx
    · exact (h x hx).symm
    · rfl
  rw [assignmentPartition_equiv b _ (splitRoot b l) he]
  exact root_elimination l _ (fun x => x.property) w

open Finset

variable {V L : Type*} [Fintype V] [Fintype L] [DecidableEq V] [DecidableEq L]

noncomputable def activePartition (b : V → Finset L) (R : Finset V) (w : L → ℕ → ℕ) : ℕ :=
  assignmentPartition (fun x : R => b x.val) w

def trim (b : V → Finset L) (R : Finset V) (l : L) : Finset V := R.filter fun x => l∉b x

def privateCount (b : V → Finset L) (R : Finset V) (l : L) : ℕ :=
  (R.filter fun x => b x={l}).card

def sharedCount (b : V → Finset L) (R : Finset V) (l : L) : ℕ :=
  (R.filter fun x => l∈b x ∧ b x≠{l}).card

noncomputable def activeFilterEquiv (R : Finset V) (P : V → Prop) [DecidablePred P] :
    {x : R // P x.val} ≃ (R.filter P) where
  toFun x := ⟨x.val.val,mem_filter.mpr ⟨x.val.property,x.property⟩⟩
  invFun x := ⟨⟨x.val,(mem_filter.mp x.property).1⟩,(mem_filter.mp x.property).2⟩
  left_inv _ := rfl
  right_inv _ := rfl

omit [Fintype V] [DecidableEq V] in
lemma active_card_filter [Fintype V] [DecidableEq V]
    (R : Finset V) (P : V → Prop) [DecidablePred P] :
    Fintype.card {x : R // P x.val}=(R.filter P).card := by
  rw [Fintype.card_congr (activeFilterEquiv R P),Fintype.card_coe]

omit [Fintype V] in
lemma active_outside [Fintype V]
    (b : V → Finset L) (R : Finset V) (l : L) (w : L → ℕ → ℕ) :
    assignmentPartition (fun x : Outside (fun y : R => b y.val) l => b x.val.val) w =
      activePartition b (trim b R l) w := by
  change assignmentPartition (fun x : {y : R // l∉b y.val} => b x.val.val) w =
    assignmentPartition (fun x : R.filter (fun y => l∉b y) => b x.val) w
  apply assignmentPartition_equiv _ _ (activeFilterEquiv R (fun x => l∉b x))
  intro x
  rfl

theorem active_leaf_elimination (b : V → Finset L) (R : Finset V) (l p : L) (hlp : l≠p)
    (h : LeafAt (fun x : R => b x.val) l p) (w : L → ℕ → ℕ) :
    activePartition b R w = activePartition b (trim b R l)
      (leafUpdate (privateCount b R l) (sharedCount b R l) l p w) := by
  unfold activePartition
  rw [tree_leaf_elimination _ l p hlp h,active_outside]
  rw [show Fintype.card (Private (fun x : R => b x.val) l)=privateCount b R l from
    active_card_filter R (fun x => b x={l}),
    show Fintype.card (Shared (fun x : R => b x.val) l)=sharedCount b R l from
    active_card_filter R (fun x => l∈b x ∧ b x≠{l})]
  rfl

lemma active_root_elimination (b : V → Finset L) (R : Finset V) (l : L)
    (h : ∀ x : R,l∈b x.val → b x.val={l}) (w : L → ℕ → ℕ) :
    activePartition b R w = activePartition b (trim b R l)
      (rootUpdate ((R.filter fun x => l∈b x).card) l w) := by
  unfold activePartition
  rw [tree_root_elimination _ l h,active_outside,active_card_filter R (fun x => l∈b x)]
  rfl

lemma partition_isEmpty {W : Type*} [Fintype W] [DecidableEq W] [IsEmpty W]
    (b : W → Finset L) (w : L → ℕ → ℕ) : assignmentPartition b w=∏ l,w l 0 := by
  classical
  let : Unique (Assignment b) :=
    { default := ⟨isEmptyElim,fun x => isEmptyElim x⟩
      uniq := fun f => Subtype.ext (by funext x; exact isEmptyElim x) }
  simp [assignmentPartition,fiberCount]

omit [Fintype V] in
lemma active_empty [Fintype V] (b : V → Finset L) (w : L → ℕ → ℕ) :
    activePartition b ∅ w=∏ l,w l 0 := partition_isEmpty _ _

def RankedBags (b : V → Finset L) (rank : L → ℕ) (parent : L → Option L) : Prop :=
  ∀ x a,a ∈ b x → ∀ a'∈b x,a≠a' →
    (rank a<rank a' ∧ parent a'=some a) ∨ (rank a'<rank a ∧ parent a=some a')

noncomputable def advanceTable (b : V → Finset L) (R : Finset V) (parent : L → Option L)
    (l : L) (w : L → ℕ → ℕ) : L → ℕ → ℕ :=
  match parent l with
  | some p => leafUpdate (privateCount b R l) (sharedCount b R l) l p w
  | none => rootUpdate ((R.filter fun x => l∈b x).card) l w

noncomputable def tableDP (b : V → Finset L) (parent : L → Option L) :
    List L → Finset V → (L → ℕ → ℕ) → (L → ℕ → ℕ)
  | [],_,w => w
  | l::ls,R,w => tableDP b parent ls (trim b R l) (advanceTable b R parent l w)

def LegalPlan (b : V → Finset L) (parent : L → Option L) : List L → Finset V → Prop
  | [],R => R=∅
  | l::ls,R =>
    (match parent l with
      | some p => l≠p ∧ LeafAt (fun x : R => b x.val) l p
      | none => ∀ x : R,l∈b x.val → b x.val={l}) ∧
    LegalPlan b parent ls (trim b R l)

theorem tableDP_correct (b : V → Finset L) (parent : L → Option L)
    (ls : List L) (R : Finset V) (hp : LegalPlan b parent ls R) (w : L → ℕ → ℕ) :
    activePartition b R w=∏ l,tableDP b parent ls R w l 0 := by
  induction ls generalizing R w with
  | nil =>
    have hR : R=∅ := hp
    subst R
    exact active_empty b w
  | cons l ls ih =>
    have ht : activePartition b R w =
        activePartition b (trim b R l) (advanceTable b R parent l w) := by
      cases hpar : parent l with
      | none =>
        unfold advanceTable; rw [hpar]
        exact active_root_elimination b R l (by simpa only [LegalPlan,hpar] using hp.1) w
      | some p =>
        have h := hp.1
        simp only [hpar] at h
        unfold advanceTable; rw [hpar]
        exact active_leaf_elimination b R l p h.1 h.2 w
    rw [ht]
    exact ih _ hp.2 _

omit [Fintype V] [Fintype L] [DecidableEq V] in
theorem rank_order_legal [Fintype V] [Fintype L] [DecidableEq V]
    (b : V → Finset L) (rank : L → ℕ) (parent : L → Option L)
    (hb : RankedBags b rank parent)
    (hp : ∀ l p,parent l=some p → rank p<rank l)
    (ls : List L) (hs : ls.Pairwise (fun a a' => rank a'≤rank a))
    (R : Finset V) (hne : ∀ x∈R,(b x).Nonempty)
    (hc : ∀ x∈R,∀ a∈b x,a∈ls) : LegalPlan b parent ls R := by
  induction ls generalizing R with
  | nil =>
    apply eq_empty_iff_forall_notMem.mpr
    intro x hx
    obtain ⟨a,ha⟩ := hne x hx
    exact List.not_mem_nil (hc x hx a ha)
  | cons l ls ih =>
    have hs' := List.pairwise_cons.mp hs
    have hmax (x : R) (a : L) (ha : a∈b x.val) : rank a≤rank l := by
      have h := hc x.val x.property a ha
      rcases List.mem_cons.mp h with h | h
      · exact h ▸ le_rfl
      · exact hs'.1 a h
    have hparent (x : R) (hl : l∈b x.val) (a : L) (ha : a∈b x.val) (hal : a≠l) :
        parent l=some a := by
      rcases hb x.val l hl a ha (Ne.symm hal) with h | h
      · exact (Nat.not_lt_of_ge (hmax x a ha) h.1).elim
      · exact h.2
    constructor
    · cases hpar : parent l with
      | none =>
        intro x hl
        apply eq_singleton_iff_unique_mem.mpr
        exact ⟨hl,fun a ha => by
          by_contra hal
          have h := hparent x hl a ha hal
          rw [hpar] at h
          cases h⟩
      | some p =>
        constructor
        · intro h; subst p
          exact Nat.lt_irrefl _ (hp l l hpar)
        · intro x hl
          by_cases h : b x.val={l}
          · exact Or.inl h
          · right
            apply Subset.antisymm
            · intro a ha
              by_cases hal : a=l
              · simp [hal]
              · have hpa : p=a := Option.some.inj (hpar.symm.trans (hparent x hl a ha hal))
                simp [hpa]
            · intro a ha
              simp only [mem_insert,mem_singleton] at ha
              rcases ha with ha | ha
              · simpa [ha] using hl
              · rw [ha]
                by_contra hpn
                apply h
                apply eq_singleton_iff_unique_mem.mpr
                refine ⟨hl,fun a ha => ?_⟩
                by_contra hal
                have hpa : p=a := Option.some.inj (hpar.symm.trans (hparent x hl a ha hal))
                exact hpn (hpa ▸ ha)
    · apply ih hs'.2
      · intro x hx
        exact hne x (mem_filter.mp hx).1
      · intro x hx a ha
        have hx' := mem_filter.mp hx
        have h := hc x hx'.1 a ha
        rcases List.mem_cons.mp h with hh | hh
        · exact (hx'.2 (hh ▸ ha)).elim
        · exact hh

end MatchingFPRAS.UnitRefresh

end OAI