import Mathlib
import OAI.Combinatorics.MatchingCount.Model
import OAI.Combinatorics.MatchingCount.Sampling.AssignmentEquiv

namespace OAI

namespace MatchingFPRAS.UnitRefresh

open Finset

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

noncomputable def rankOrder (rank : L → ℕ) : List L :=
  (univ : Finset L).toList.mergeSort (fun a a' => decide (rank a'≤rank a))

omit [DecidableEq L] in
lemma rankOrder_mem [DecidableEq L] (rank : L → ℕ) (a : L) : a∈rankOrder rank := by
  unfold rankOrder
  rw [(List.mergeSort_perm _ _).mem_iff]
  simp

omit [DecidableEq L] in
lemma rankOrder_length [DecidableEq L] (rank : L → ℕ) : (rankOrder rank).length=Fintype.card L := by
  unfold rankOrder
  rw [(List.mergeSort_perm _ _).length_eq]
  simp

omit [DecidableEq L] in
lemma rankOrder_sorted [DecidableEq L] (rank : L → ℕ) :
    (rankOrder rank).Pairwise (fun a a' => rank a'≤rank a) := by
  let r := fun a a' : L => rank a'≤rank a
  let : Std.Total r := ⟨fun a b => le_total (rank b) (rank a)⟩
  let : IsTrans L r := ⟨fun a b c hab hbc => hbc.trans hab⟩
  exact List.pairwise_mergeSort' r _

lemma rankOrder_legal (b : V → Finset L) (rank : L → ℕ) (parent : L → Option L)
    (hb : RankedBags b rank parent) (hne : ∀ x,(b x).Nonempty)
    (hp : ∀ l p,parent l=some p → rank p<rank l) :
    LegalPlan b parent (rankOrder rank) univ := by
  apply rank_order_legal b rank parent hb hp _ (rankOrder_sorted rank)
  · intro x _; exact hne x
  · intro x _ a _; exact rankOrder_mem rank a

lemma active_univ (b : V → Finset L) (w : L → ℕ → ℕ) :
    activePartition b univ w=assignmentPartition b w := by
  change assignmentPartition (fun x : (univ : Finset V) => b x.val) w=assignmentPartition b w
  let e : (univ : Finset V) ≃ V :=
    { toFun := Subtype.val
      invFun := fun x => ⟨x,mem_univ x⟩
      left_inv := fun x => rfl
      right_inv := fun x => rfl }
  apply assignmentPartition_equiv _ _ e
  intro x; rfl

theorem ranked_tableDP_correct (b : V → Finset L) (rank : L → ℕ) (parent : L → Option L)
    (hb : RankedBags b rank parent) (hne : ∀ x,(b x).Nonempty)
    (hp : ∀ l p,parent l=some p → rank p<rank l) (w : L → ℕ → ℕ) :
    assignmentPartition b w=∏ l,tableDP b parent (rankOrder rank) univ w l 0 := by
  rw [← active_univ b w]
  exact tableDP_correct b parent _ _ (rankOrder_legal b rank parent hb hne hp) w

omit [Fintype L] [DecidableEq V] in
lemma private_le_card [Fintype L] [DecidableEq V] (b : V → Finset L) (R : Finset V) (l : L) :
    privateCount b R l≤Fintype.card V := by
  exact (card_filter_le _ _).trans (card_le_univ R)

omit [Fintype L] [DecidableEq V] in
lemma shared_le_card [Fintype L] [DecidableEq V] (b : V → Finset L) (R : Finset V) (l : L) :
    sharedCount b R l≤Fintype.card V := by
  exact (card_filter_le _ _).trans (card_le_univ R)

omit [Fintype L] in
lemma private_add_shared [Fintype L] (b : V → Finset L) (R : Finset V) (l : L) :
    privateCount b R l+sharedCount b R l≤Fintype.card V := by
  classical
  have he : (R.filter fun x => b x={l}) ∪ (R.filter fun x => l∈b x ∧ b x≠{l}) =
      R.filter (fun x => l∈b x) := by
    ext x
    simp only [mem_union,mem_filter]
    constructor
    · rintro (⟨hx,hb⟩|⟨hx,hl,_⟩)
      · exact ⟨hx,by simp [hb]⟩
      · exact ⟨hx,hl⟩
    · rintro ⟨hx,hl⟩
      by_cases h : b x={l}
      · exact Or.inl ⟨hx,h⟩
      · exact Or.inr ⟨hx,hl,h⟩
  have hd : Disjoint (R.filter fun x => b x={l}) (R.filter fun x => l∈b x ∧ b x≠{l}) := by
    apply disjoint_left.mpr
    intro x hx hx'
    exact (mem_filter.mp hx').2.2 (mem_filter.mp hx).2
  unfold privateCount sharedCount
  rw [← card_union_of_disjoint hd,he]
  exact (card_filter_le _ _).trans (card_le_univ R)

lemma advanceTable_congr (b : V → Finset L) (R : Finset V) (parent : L → Option L)
    (l : L) (w z : L → ℕ → ℕ) (B : ℕ)
    (h : ∀ a r,r≤B+Fintype.card V → w a r=z a r) (a : L) (r : ℕ) (hr : r≤B) :
    advanceTable b R parent l w a r=advanceTable b R parent l z a r := by
  classical
  have hs := shared_le_card b R l
  have hu := private_add_shared b R l
  unfold advanceTable
  cases hpar : parent l with
  | some p =>
    simp only
    unfold leafUpdate
    split_ifs
    · rfl
    · apply sum_congr rfl
      intro k hk
      have hk' : k ≤ sharedCount b R l := by simpa using (mem_range.mp hk)
      rw [h l _ (by omega),h _ _ (by omega)]
    · exact h a r (by omega)
  | none =>
    simp only
    unfold rootUpdate
    split_ifs
    · apply h
      have ht := (card_filter_le (s:=R) (p:=fun x => l∈b x)).trans (card_le_univ R)
      omega
    · exact h a r (by omega)

noncomputable def capTable (B : ℕ) (w : L → ℕ → ℕ) : L → ℕ → ℕ :=
  fun a r => if r≤B then w a r else 0

noncomputable def finiteDP (b : V → Finset L) (parent : L → Option L) :
    List L → Finset V → (L → ℕ → ℕ) → (L → ℕ → ℕ)
  | [],_,w => w
  | l::ls,R,w => finiteDP b parent ls (trim b R l)
      (capTable (Fintype.card V*ls.length)
        (advanceTable b R parent l w))

lemma finiteDP_correct (b : V → Finset L) (parent : L → Option L) (ls : List L)
    (R : Finset V) (w z : L → ℕ → ℕ)
    (h : ∀ a r,r≤Fintype.card V*ls.length → w a r=z a r) (a : L) :
    finiteDP b parent ls R w a 0=tableDP b parent ls R z a 0 := by
  induction ls generalizing R w z with
  | nil => exact h a 0 (by simp)
  | cons l ls ih =>
    apply ih
    intro a r hr
    rw [capTable,ite_eq_left hr]
    apply advanceTable_congr b R parent l w z (Fintype.card V*ls.length)
    · intro a r hr
      apply h
      simpa only [List.length_cons,Nat.mul_add,Nat.mul_one] using hr
    · exact hr

theorem finite_ranked_count (b : V → Finset L) (rank : L → ℕ) (parent : L → Option L)
    (hb : RankedBags b rank parent) (hne : ∀ x,(b x).Nonempty)
    (hp : ∀ l p,parent l=some p → rank p<rank l) (w : L → ℕ → ℕ) :
    assignmentPartition b w=∏ l,finiteDP b parent (rankOrder rank) univ
      (capTable (Fintype.card V*Fintype.card L) w) l 0 := by
  rw [ranked_tableDP_correct b rank parent hb hne hp w]
  apply prod_congr rfl
  intro a _
  symm
  apply finiteDP_correct
  intro a r hr
  rw [rankOrder_length] at hr
  exact ite_eq_left hr




abbrev withoutPair (a b : V) := {x : V // x≠a ∧ x≠b}

abbrev residualBags (bags : V → Finset L) (a b : V) : withoutPair a b → Finset L :=
  fun x => bags x.val

abbrev Partner (bags : V → Finset L) (a : V) :=
  {bc : V × L // bc.1≠a ∧ bc.2∈bags a ∧ bc.2∈bags bc.1}

omit [Fintype V] [Fintype L] [DecidableEq V] [DecidableEq L] in
lemma ColoredPairing.subtype_hext [Fintype V] [Fintype L] [DecidableEq V] [DecidableEq L]
    {bags : V → Finset L} {P Q : V → Prop}
    [DecidablePred P] [DecidablePred Q]
    (p : ColoredPairing (fun x : {x // P x} => bags x.val))
    (q : ColoredPairing (fun x : {x // Q x} => bags x.val))
    (hPQ : ∀ x,P x ↔ Q x)
    (hm : ∀ (x : {x // P x}) (y : {x // Q x}),x.val=y.val →
      (p.pair.mate x).val=(q.pair.mate y).val)
    (hc : ∀ (x : {x // P x}) (y : {x // Q x}),x.val=y.val → p.color x=q.color y) :
    HEq p q := by
  have he : P=Q := funext fun x => propext (hPQ x)
  subst Q
  apply heq_of_eq
  apply ColoredPairing.ext
  · ext x; exact hm x x rfl
  · funext x; exact hc x x rfl

def ColoredPairing.remove {bags : V → Finset L} (p : ColoredPairing bags) (a : V) :
    ColoredPairing (residualBags bags a (p.pair.mate a)) where
  pair := p.pair.remove a
  color x := p.color x.val
  allowed x := p.allowed x.val
  same_color x := p.same_color x.val

def ColoredPairing.insert {bags : V → Finset L} (a : V) (c : Partner bags a)
    (p : ColoredPairing (residualBags bags a c.val.1)) : ColoredPairing bags where
  pair := p.pair.insert a c.val.1 c.property.1
  color x := if hx : x=a ∨ x=c.val.1 then c.val.2 else p.color ⟨x,by tauto⟩
  allowed x := by
    dsimp
    split_ifs with hx
    · rcases hx with rfl|rfl
      · exact c.property.2.1
      · exact c.property.2.2
    · exact p.allowed _
  same_color x := by
    by_cases ha : x=a
    · subst x
      simp [Pairing.insert,c.property.1]
    by_cases hb : x=c.val.1
    · subst x
      simp [Pairing.insert,c.property.1]
    simp only [Pairing.insert,dite_eq_right ha,dite_eq_right hb]
    rw [dite_eq_right (by exact not_or.mpr (p.pair.mate ⟨x,ha,hb⟩).property),
      dite_eq_right (not_or.mpr ⟨ha,hb⟩)]
    exact p.same_color ⟨x,ha,hb⟩

omit [Fintype V] [Fintype L] [DecidableEq L] in
@[simp] lemma ColoredPairing.insert_color [Fintype V] [Fintype L] [DecidableEq L]
    {bags : V → Finset L} (a : V) (c : Partner bags a)
    (p : ColoredPairing (residualBags bags a c.val.1)) :
    (p.insert a c).color a=c.val.2 := by simp [ColoredPairing.insert]

omit [Fintype V] [Fintype L] [DecidableEq L] in
@[simp] lemma ColoredPairing.insert_color_residual [Fintype V] [Fintype L] [DecidableEq L]
    {bags : V → Finset L} (a : V)
    (c : Partner bags a) (p : ColoredPairing (residualBags bags a c.val.1))
    (x : withoutPair a c.val.1) :
    (p.insert a c).color x.val=p.color x := by
  simp [ColoredPairing.insert,x.property.1,x.property.2]

noncomputable def ColoredPairing.split {bags : V → Finset L} (a : V) :
    ColoredPairing bags ≃ Σ c : Partner bags a,ColoredPairing (residualBags bags a c.val.1) where
  toFun p := ⟨⟨(p.pair.mate a,p.color a),p.pair.no_fixed a,p.allowed a,
    by rw [← p.same_color a]; exact p.allowed _⟩,p.remove a⟩
  invFun q := q.2.insert a q.1
  left_inv p := by
    apply ColoredPairing.ext
    · ext x
      by_cases ha : x=a
      · subst x; simp [ColoredPairing.insert,Pairing.insert]
      by_cases hb : x=p.pair.mate a
      · subst x; simp [ColoredPairing.insert,Pairing.insert,p.pair.no_fixed,p.pair.involutive a]
      simp [ColoredPairing.insert,Pairing.insert,ColoredPairing.remove,Pairing.remove,ha,hb]
    · funext x
      by_cases ha : x=a
      · subst x; simp [ColoredPairing.insert]
      by_cases hb : x=p.pair.mate a
      · subst x; simp [ColoredPairing.insert,p.same_color]
      simp [ColoredPairing.insert,ColoredPairing.remove,ha,hb]
  right_inv q := by
    rcases q with ⟨c,p⟩
    apply Sigma.ext
    · apply Subtype.ext
      exact Prod.ext (Pairing.insert_at a c.val.1 c.property.1 p.pair) (ColoredPairing.insert_color a c p)
    · apply ColoredPairing.subtype_hext
      · intro x; simp only [ColoredPairing.insert,Pairing.insert_at]
      · intro x y hxy
        change (p.pair.insert a c.val.1 c.property.1).mate x.val=(p.pair.mate y).val
        rw [hxy]
        exact Pairing.insert_other _ _ _ _ y
      · intro x y hxy
        change (p.insert a c).color x.val=p.color y
        rw [hxy]
        exact ColoredPairing.insert_color_residual _ _ _ y

lemma partner_card (bags : V → Finset L) (a : V) :
    Fintype.card (Partner bags a)≤Fintype.card V*Fintype.card L := by
  exact (Fintype.card_subtype_le _).trans_eq (Fintype.card_prod V L)

noncomputable def residualCount (bags : V → Finset L) (rank : L → ℕ)
    (parent : L → Option L) (a b : V) : ℕ :=
  ∏ l,finiteDP (residualBags bags a b) parent (rankOrder rank) univ
    (capTable (Fintype.card (withoutPair a b)*Fintype.card L) (fun _ => pairingCount)) l 0

lemma residualCount_eq (bags : V → Finset L) (rank : L → ℕ) (parent : L → Option L)
    (hb : RankedBags bags rank parent) (hne : ∀ x,(bags x).Nonempty)
    (hp : ∀ l p,parent l=some p → rank p<rank l) (a b : V) :
    residualCount bags rank parent a b=Fintype.card (ColoredPairing (residualBags bags a b)) := by
  rw [coloredPairing_card]
  symm
  apply finite_ranked_count
  · intro x c hc d hd
    exact hb x.val c hc d hd
  · intro x; exact hne x.val
  · exact hp

theorem unit_self_reduction (bags : V → Finset L) (rank : L → ℕ) (parent : L → Option L)
    (hb : RankedBags bags rank parent) (hne : ∀ x,(bags x).Nonempty)
    (hp : ∀ l p,parent l=some p → rank p<rank l) (a : V) :
    Fintype.card (ColoredPairing bags)=
      ∑ c : Partner bags a,residualCount bags rank parent a c.val.1 := by
  rw [Fintype.card_congr (ColoredPairing.split a),Fintype.card_sigma]
  apply sum_congr rfl
  intro c _
  exact (residualCount_eq bags rank parent hb hne hp a c.val.1).symm

end MatchingFPRAS.UnitRefresh

namespace MatchingFPRAS.UnitRefresh.Materialized

open Finset

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

abbrev Table := List (List ℕ)

def read (t : Table) (a r : ℕ) : ℕ := (t.getD a []).getD r 0

def tabulate (m B : ℕ) (f : Fin m → ℕ → ℕ) : Table :=
  List.ofFn fun a : Fin m => List.ofFn fun r : Fin (B+1) => f a r.val

lemma read_tabulate {m B : ℕ} (f : Fin m → ℕ → ℕ) (a : Fin m) (r : ℕ) :
    read (tabulate m B f) a.val r = if r≤B then f a r else 0 := by
  unfold read tabulate List.getD
  simp only [List.getElem?_ofFn, a.isLt, dite_eq_left, Option.getD_some]
  by_cases hr : r≤B
  · have h : r<B+1 := by omega
    simp [hr,h]
  · have h : ¬r<B+1 := by omega
    simp [hr,h]

lemma tabulate_length (m B : ℕ) (f : Fin m → ℕ → ℕ) :
    (tabulate m B f).length=m := by simp [tabulate]

lemma tabulate_rows {m B : ℕ} (f : Fin m → ℕ → ℕ) (row : List ℕ)
    (h : row ∈ tabulate m B f) : row.length=B+1 := by
  obtain ⟨a,rfl⟩ := List.mem_ofFn.mp h
  simp

lemma tabulate_cells (m B : ℕ) (f : Fin m → ℕ → ℕ) :
    ((tabulate m B f).map List.length).sum=m*(B+1) := by
  simp [tabulate,List.map_ofFn,List.sum_ofFn]

def entry {m : ℕ} (bags : V → Finset (Fin m)) (R : Finset V)
    (parent : Fin m → Option (Fin m)) (l a : Fin m) (t : Table) (r : ℕ) : ℕ :=
  match parent l with
  | none => if a=l then read t l.val ((R.filter fun x=>l∈bags x).card) else read t a.val r
  | some p => if a=l then 1 else if a=p then
      ∑ k∈range (sharedCount bags R l+1),
        (sharedCount bags R l).choose k * read t l.val (privateCount bags R l+k) *
          read t p.val (sharedCount bags R l-k+r)
      else read t a.val r

omit [Fintype V] [DecidableEq V] in
lemma entry_eq [Fintype V] [DecidableEq V] {m : ℕ} (bags : V → Finset (Fin m)) (R : Finset V)
    (parent : Fin m → Option (Fin m)) (l a : Fin m) (t : Table) (r : ℕ) :
    entry bags R parent l a t r =
      advanceTable bags R parent l (fun a r => read t a.val r) a r := by
  unfold entry advanceTable leafUpdate rootUpdate
  cases parent l <;> rfl

def update {m : ℕ} (bags : V → Finset (Fin m)) (R : Finset V)
    (parent : Fin m → Option (Fin m)) (l : Fin m) (B : ℕ) (t : Table) : Table :=
  tabulate m B (fun a r=>entry bags R parent l a t r)

lemma read_update {m : ℕ} (bags : V → Finset (Fin m)) (R : Finset V)
    (parent : Fin m → Option (Fin m)) (l a : Fin m) (B r : ℕ) (t : Table) :
    read (update bags R parent l B t) a.val r =
      capTable B (advanceTable bags R parent l (fun a r=>read t a.val r)) a r := by
  rw [update,read_tabulate]
  unfold capTable
  split_ifs <;> simp [entry_eq]

def run {m : ℕ} (bags : V → Finset (Fin m)) (parent : Fin m → Option (Fin m)) :
    List (Fin m) → Finset V → Table → Table
  | [],_,t => t
  | l::ls,R,t => run bags parent ls (trim bags R l)
      (update bags R parent l (Fintype.card V*ls.length) t)

lemma read_run {m : ℕ} (bags : V → Finset (Fin m)) (parent : Fin m → Option (Fin m))
    (ls : List (Fin m)) (R : Finset V) (t : Table) (a : Fin m) (r : ℕ) :
    read (run bags parent ls R t) a.val r =
      finiteDP bags parent ls R (fun a r=>read t a.val r) a r := by
  induction ls generalizing R t with
  | nil => rfl
  | cons l ls ih =>
    rw [run,finiteDP,ih]
    congr 2
    funext a r
    exact read_update bags R parent l a _ r t

def initial (m B : ℕ) : Table := tabulate m B (fun _=>pairingCount)

def count {m : ℕ} (bags : V → Finset (Fin m)) (parent : Fin m → Option (Fin m))
    (plan : List (Fin m)) : ℕ :=
  let t := run bags parent plan univ (initial m (Fintype.card V*m))
  ∏ a : Fin m,read t a.val 0

lemma count_eq {m : ℕ} (bags : V → Finset (Fin m)) (rank : Fin m → ℕ)
    (parent : Fin m → Option (Fin m))
    (hb : RankedBags bags rank parent) (hne : ∀ x,(bags x).Nonempty)
    (hp : ∀ l p,parent l=some p → rank p<rank l) :
    count bags parent (rankOrder rank)=Fintype.card (ColoredPairing bags) := by
  rw [coloredPairing_card]
  change count bags parent (rankOrder rank)=assignmentPartition bags (fun _=>pairingCount)
  rw [finite_ranked_count bags rank parent hb hne hp]
  unfold count
  apply prod_congr rfl
  intro a _
  rw [read_run]
  congr 2
  funext b r
  simp only [initial,read_tabulate,capTable,Fintype.card_fin]

def cellsWritten {m : ℕ} (bags : V → Finset (Fin m)) : List (Fin m) → ℕ
  | [] => 0
  | _::ls => m*(Fintype.card V*ls.length+1)+cellsWritten bags ls

omit [DecidableEq V] in
lemma cellsWritten_bound [DecidableEq V] {m : ℕ} (bags : V → Finset (Fin m)) (ls : List (Fin m)) :
    cellsWritten bags ls ≤ ls.length*m*(Fintype.card V*ls.length+1) := by
  induction ls with
  | nil => simp [cellsWritten]
  | cons l ls ih =>
    simp only [cellsWritten,List.length_cons]
    calc
      _ ≤ m*(Fintype.card V*ls.length+1)+ls.length*m*(Fintype.card V*ls.length+1) :=
        Nat.add_le_add_left ih _
      _ = (ls.length+1)*m*(Fintype.card V*ls.length+1) := by ring
      _ ≤ _ := Nat.mul_le_mul_left _ (Nat.add_le_add_right (Nat.mul_le_mul_left _ (Nat.le_succ _)) _)

end MatchingFPRAS.UnitRefresh.Materialized

end OAI