import Mathlib
import OAI.Combinatorics.MatchingCount.Probability.LocalVariance
import OAI.Combinatorics.MatchingCount.Sampling.Certify

namespace OAI

namespace MatchingFPRAS.Transport.Sparse

open Finset

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

variable (ends : E → Sym2 V)

instance decideOverlay (U : Finset E) :
    DecidableRel (overlayLineGraph (fun e v => v ∈ ends e) U).Adj := by
  intro e f
  change Decidable (e ≠ f ∧ e ∈ U ∧ f ∈ U ∧ ∃ v, v ∈ ends e ∧ v ∈ ends f)
  infer_instance

def component (U : Finset E) (a : E) : Finset E :=
  U ∩ ComputableReach.closure (overlayLineGraph (fun e v => v ∈ ends e) U) a

lemma component_eq (U : Finset E) (a : E) :
    component ends U a = componentEdges (inc:=fun e v => v ∈ ends e) U a := by
  ext e
  simp only [component,mem_inter,ComputableReach.mem_closure,mem_componentEdges]

def allComponents (U : Finset E) : Finset (Finset E) := U.image (component ends U)

lemma allComponents_eq (U : Finset E) :
    allComponents ends U = components (inc:=fun e v => v ∈ ends e) U := by
  simp only [allComponents,components]
  exact Finset.image_congr (fun a _ => component_eq ends U a)

def discrepancies (A B : PM (fun e v => v ∈ ends e)) : Finset (Finset E) :=
  (allComponents ends (A.val ∪ B.val)).filter (fun S => ¬S ⊆ A.val ∩ B.val)

lemma discrepancies_eq (A B : PM (fun e v => v ∈ ends e)) :
    discrepancies ends A B = discrepancyComponents A B := by
  rw [discrepancies,allComponents_eq]
  rfl

def cycle (p : PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e))
    (S : Finset E) : PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e) :=
  if h : S ∈ allComponents ends (p.1.val ∪ p.2.val) then
    (⟨exchange p.1.val p.2.val S,exchange_matching p.1.property p.2.property
        (component_exchange_compatible (by rwa [allComponents_eq] at h))⟩,
     ⟨exchange p.2.val p.1.val S,exchange_matching p.2.property p.1.property
        (component_exchange_compatible (by rwa [allComponents_eq] at h)).symm⟩)
  else p

lemma cycle_eq (p : PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e)) (S : Finset E) :
    cycle ends p S = cycleMove p S := by
  unfold cycle cycleMove
  simp only [allComponents_eq]

lemma discrepancies_card (A B : PM (fun e v => v ∈ ends e)) :
    (discrepancies ends A B).card ≤ A.val.card+B.val.card := by
  calc
    _ ≤ (allComponents ends (A.val ∪ B.val)).card := card_filter_le _ _
    _ ≤ (A.val ∪ B.val).card := card_image_le
    _ ≤ _ := card_union_le _ _

end MatchingFPRAS.Transport.Sparse

namespace MatchingFPRAS

structure WeightedOptions (Ω : Type*) where
  size : ℕ
  out : Fin size → Ω
  mass : Fin size → ℚ
  nonneg : ∀ i, 0 ≤ mass i
  total : ∑ i, mass i = 1

namespace WeightedOptions

open Finset

variable {Ω Ψ : Type*}

def pure (a : Ω) : WeightedOptions Ω where
  size := 1
  out := fun _ => a
  mass := fun _ => 1
  nonneg := by simp
  total := by simp

def map (f : Ω → Ψ) (c : WeightedOptions Ω) : WeightedOptions Ψ where
  size := c.size
  out := f ∘ c.out
  mass := c.mass
  nonneg := c.nonneg
  total := c.total

def mix (p : ℚ) (hp : 0 ≤ p) (hp1 : p ≤ 1)
    (a b : WeightedOptions Ω) : WeightedOptions Ω where
  size := a.size+b.size
  out := Fin.addCases a.out b.out
  mass := Fin.addCases (fun i => p*a.mass i) (fun i => (1-p)*b.mass i)
  nonneg i := by
    refine Fin.addCases (fun i => ?_) (fun i => ?_) i
    · simp only [Fin.addCases_left]
      exact mul_nonneg hp (a.nonneg i)
    · simp only [Fin.addCases_right]
      exact mul_nonneg (sub_nonneg.mpr hp1) (b.nonneg i)
  total := by
    simp only [Fin.sum_univ_add,Fin.addCases_left,Fin.addCases_right,←mul_sum,a.total,b.total]
    ring

variable [DecidableEq Ω]

def law (c : WeightedOptions Ω) (b : Ω) : ℚ := ∑ i, if c.out i=b then c.mass i else 0

lemma law_nonneg (c : WeightedOptions Ω) (b : Ω) : 0 ≤ c.law b := by
  apply sum_nonneg
  intro i _
  split_ifs <;> [exact c.nonneg i; exact le_rfl]

lemma law_sum [Fintype Ω] (c : WeightedOptions Ω) : ∑ b, c.law b=1 := by
  unfold law
  rw [sum_comm]
  simpa using c.total

@[simp] lemma pure_law (a b : Ω) : (pure a).law b=if a=b then 1 else 0  := by
  change (∑ _i : Fin 1, if a=b then (1:ℚ) else 0)=_
  simp

lemma mix_law (p : ℚ) (hp : 0 ≤ p) (hp1 : p ≤ 1) (a b : WeightedOptions Ω) (x : Ω) :
    (mix p hp hp1 a b).law x=p*a.law x+(1-p)*b.law x := by
  change (∑ i : Fin (a.size+b.size), if Fin.addCases a.out b.out i=x then
    Fin.addCases (fun i=>p*a.mass i) (fun i=>(1-p)*b.mass i) i else (0:ℚ))=_
  rw [Fin.sum_univ_add]
  simp only [Fin.addCases_left,Fin.addCases_right,law,mul_sum]
  congr 1 <;> apply sum_congr rfl <;> intro i _ <;> split_ifs <;> simp

lemma sum_law_mul [Fintype Ω] (c : WeightedOptions Ω) (f : Ω → ℚ) :
    ∑ b, c.law b*f b = ∑ i, c.mass i*f (c.out i) := by
  simp only [law,sum_mul]
  rw [sum_comm]
  apply sum_congr rfl
  intro i _
  simp only [ite_mul,zero_mul]
  simp

lemma map_law [Fintype Ω] [DecidableEq Ψ] (f : Ω → Ψ) (c : WeightedOptions Ω) (b : Ψ) :
    (c.map f).law b = ∑ a, if f a=b then c.law a else 0 := by
  change (∑ i : Fin c.size, if f (c.out i)=b then c.mass i else (0:ℚ))=_
  calc
    _ = ∑ i, c.mass i*(if f (c.out i)=b then 1 else 0) := by
      simp only [mul_ite,mul_one,mul_zero]
    _ = ∑ a, c.law a*(if f a=b then 1 else 0) :=
      (c.sum_law_mul (fun a => if f a=b then (1:ℚ) else 0)).symm
    _ = _ := by simp

lemma map_first_law [DecidableEq Ψ] (c : WeightedOptions Ω) (a : Ψ) (b : Ω × Ψ) :
    (c.map (fun x => (x,a))).law b = if a=b.2 then c.law b.1 else 0 := by
  change (∑ i : Fin c.size, if (c.out i,a)=b then c.mass i else (0:ℚ))=_
  rcases b with ⟨b,d⟩
  by_cases h : a=d
  · subst d
    simp [law]
  · simp [h]

def accept (c : WeightedOptions Ω) (hold : Ω) (p : Ω → ℚ)
    (hp : ∀ a, 0 ≤ p a) (hp1 : ∀ a, p a ≤ 1) : WeightedOptions Ω where
  size := c.size+c.size
  out := Fin.addCases c.out (fun _ => hold)
  mass := Fin.addCases (fun i => c.mass i*p (c.out i))
    (fun i => c.mass i*(1-p (c.out i)))
  nonneg i := by
    refine Fin.addCases (fun i => ?_) (fun i => ?_) i
    · simp only [Fin.addCases_left]
      exact mul_nonneg (c.nonneg i) (hp _)
    · simp only [Fin.addCases_right]
      exact mul_nonneg (c.nonneg i) (sub_nonneg.mpr (hp1 _))
  total := by
    simp only [Fin.sum_univ_add,Fin.addCases_left,Fin.addCases_right,←sum_add_distrib]
    simp only [←mul_add,add_sub_cancel,mul_one,c.total]

lemma accept_law (c : WeightedOptions Ω) (hold : Ω) (p : Ω → ℚ)
    (hp : ∀ a, 0 ≤ p a) (hp1 : ∀ a, p a ≤ 1) (b : Ω) :
    (c.accept hold p hp hp1).law b = c.law b*p b +
      if hold=b then ∑ i, c.mass i*(1-p (c.out i)) else 0 := by
  change (∑ i : Fin (c.size+c.size), if Fin.addCases c.out (fun _=>hold) i=b then
    Fin.addCases (fun i=>c.mass i*p (c.out i)) (fun i=>c.mass i*(1-p (c.out i))) i
    else (0:ℚ))=_
  rw [Fin.sum_univ_add]
  simp only [Fin.addCases_left,Fin.addCases_right]
  congr 1
  · rw [law,sum_mul]
    apply sum_congr rfl
    intro i _
    split_ifs with h
    · rw [h]
    · simp
  · split_ifs <;> simp_all

variable [LinearOrder Ω]

def numbering (s : Finset Ω) : Fin s.card ≃ ↥s := (s.orderIsoOfFin rfl).toEquiv

def uniform (s : Finset Ω) (hs : s.Nonempty) : WeightedOptions Ω where
  size := s.card
  out := fun i => (numbering s i).val
  mass := fun _ => (s.card:ℚ)⁻¹
  nonneg := by intro i; positivity
  total := by
    have h : (s.card:ℚ) ≠ 0 := by exact_mod_cast hs.card_pos.ne'
    simp [h]

lemma uniform_law (s : Finset Ω) (hs : s.Nonempty) (b : Ω) :
    (uniform s hs).law b=if b ∈ s then (s.card:ℚ)⁻¹ else 0 := by
  unfold law uniform
  change (∑ i, if (numbering s i).val=b then (s.card:ℚ)⁻¹ else 0)=_
  rw [(numbering s).sum_comp (fun i : ↥s => if i.val=b then (s.card:ℚ)⁻¹ else 0)]
  rw [Finset.sum_coe_sort s (fun x : Ω => if x=b then (s.card:ℚ)⁻¹ else 0)]
  simp

def neighbors (a : Ω) (s : Finset Ω) (d : ℕ) (hd : s.card ≤ d) : WeightedOptions Ω where
  size := s.card+1
  out := Fin.lastCases a (fun i => (numbering s i).val)
  mass := Fin.lastCases (1-(s.card:ℚ)/d) (fun _ => (d:ℚ)⁻¹)
  nonneg i := by
    refine Fin.lastCases ?_ (fun j => ?_) i
    · simp only [Fin.lastCases_last]
      by_cases h : d=0
      · simp [h]
      · have hh : (0:ℚ)<d := by exact_mod_cast Nat.pos_of_ne_zero h
        exact sub_nonneg.mpr ((div_le_one hh).mpr (by exact_mod_cast hd))
    · simp only [Fin.lastCases_castSucc]
      positivity
  total := by
    rw [Fin.sum_univ_castSucc]
    simp only [Fin.lastCases_castSucc,Fin.lastCases_last,sum_const,card_fin,nsmul_eq_mul]
    ring

lemma neighbors_law (a : Ω) (s : Finset Ω) (d : ℕ) (hd : s.card ≤ d) (b : Ω) :
    (neighbors a s d hd).law b=(if b ∈ s then (d:ℚ)⁻¹ else 0)+
      (if a=b then 1-(s.card:ℚ)/d else 0) := by
  unfold law neighbors
  rw [Fin.sum_univ_castSucc]
  simp only [Fin.lastCases_castSucc,Fin.lastCases_last]
  congr 1
  rw [(numbering s).sum_comp (fun i : ↥s => if i.val=b then (d:ℚ)⁻¹ else 0)]
  rw [Finset.sum_coe_sort s (fun x : Ω => if x=b then (d:ℚ)⁻¹ else 0)]
  simp

end WeightedOptions

end MatchingFPRAS

namespace MatchingFPRAS.Transport.Sparse

open Finset WeightedOptions

variable {Ω : Type*} [Fintype Ω] [LinearOrder Ω] [DecidableEq Ω]

omit [LinearOrder Ω] in
lemma erased_eq (R : Ω → Ω → Prop) (s : Finset Ω) (a : Ω)
    (hs : ∀ b, b ∈ s ↔ R a b) : s.erase a = relationDestinations R a := by
  classical
  ext b
  simp only [mem_erase,relationDestinations,mem_filter,mem_univ,true_and,hs,ne_comm]

lemma neighbors_real (R : Ω → Ω → Prop) (s : Finset Ω) (d : ℕ) (a b : Ω)
    (hs : s=relationDestinations R a) (hd : s.card ≤ d) :
    ((WeightedOptions.neighbors a s d hd).law b : ℝ) = relationProposal R d a b := by
  classical
  rw [WeightedOptions.neighbors_law]
  push_cast
  subst s
  rw [relationProposal,relationOff_sum]
  by_cases hab : a=b
  · subst b
    simp [relationDestinations]
  · simp only [hab,ite_false,relationOff]
    split_ifs <;> push_cast <;> simp

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

variable (ends : E → Sym2 V)

local instance finsetOrder : LinearOrder (Finset E) :=
  LinearOrder.lift' toColex toColex.injective

local instance pmOrder : LinearOrder (PM (fun e v => v ∈ ends e)) :=
  LinearOrder.lift' Subtype.val Subtype.val_injective

lemma color_degree (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (A : PM (fun e v => v ∈ ends e)) : ((colors ends A).erase A).card ≤ Fintype.card V :=
  (card_erase_le).trans ((colors_card ends hpar A).trans_eq (A.twice_card ends hloop))

lemma switch_degree (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (A : PM (fun e v => v ∈ ends e)) :
    ((switches ends A).erase A).card ≤ 8*(Fintype.card V/2).choose 2 := by
  have h : Fintype.card V/2=A.val.card := by have := A.twice_card ends hloop; omega
  rw [h]
  exact card_erase_le.trans (switches_card ends hpar A)

def colorTable (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (A : PM (fun e v => v ∈ ends e)) : WeightedOptions (PM (fun e v => v ∈ ends e)) :=
  WeightedOptions.neighbors A ((colors ends A).erase A) (Fintype.card V)
    (color_degree ends hloop hpar A)

def switchTable (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (A : PM (fun e v => v ∈ ends e)) : WeightedOptions (PM (fun e v => v ∈ ends e)) :=
  WeightedOptions.neighbors A ((switches ends A).erase A) (8*(Fintype.card V/2).choose 2)
    (switch_degree ends hloop hpar A)

lemma colorTable_law (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (A B : PM (fun e v => v ∈ ends e)) :
    ((colorTable ends hloop hpar A).law B : ℝ)=colorProposal ends A B := by
  exact neighbors_real (ColorChange ends) ((colors ends A).erase A) (Fintype.card V) A B
    (erased_eq _ _ _ (mem_colors ends A)) (color_degree ends hloop hpar A)

lemma switchTable_law (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (A B : PM (fun e v => v ∈ ends e)) :
    ((switchTable ends hloop hpar A).law B : ℝ)=switchProposal ends A B := by
  exact neighbors_real (fun A B => TwoEdgeSwitch A B) ((switches ends A).erase A)
    (8*(Fintype.card V/2).choose 2) A B
    (erased_eq _ _ _ (mem_switches ends A)) (switch_degree ends hloop hpar A)

def cycleTable (p : PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e)) :
    WeightedOptions (PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e)) :=
  if h : (discrepancies ends p.1 p.2).Nonempty then
    (WeightedOptions.uniform _ h).map (cycle ends p)
  else WeightedOptions.pure p

lemma cycleTable_law (p q : PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e)) :
    ((cycleTable ends p).law q : ℝ)=cycleProposal p q := by
  classical
  by_cases h : (discrepancies ends p.1 p.2).Nonempty
  · have h' : (discrepancyComponents p.1 p.2).Nonempty := by rwa [←discrepancies_eq]
    rw [cycleTable,dite_eq_left h,cycleProposal,ite_eq_left h',WeightedOptions.map_law]
    push_cast
    apply sum_congr rfl
    intro S _
    rw [WeightedOptions.uniform_law,cycle_eq,discrepancies_eq]
    unfold cycleTerm
    split_ifs <;> simp_all
  · have h' : ¬(discrepancyComponents p.1 p.2).Nonempty := by rwa [←discrepancies_eq]
    rw [cycleTable,dite_eq_right h,cycleProposal,ite_eq_right h',WeightedOptions.pure_law]
    split_ifs <;> norm_num

def pairTable (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (p : PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e)) :
    WeightedOptions (PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e)) :=
  WeightedOptions.mix (1/3) (by norm_num) (by norm_num)
    ((switchTable ends hloop hpar p.1).map (fun x => (x,p.2)))
    (WeightedOptions.mix (1/2) (by norm_num) (by norm_num)
      ((colorTable ends hloop hpar p.1).map (fun x => (x,p.2)))
      (cycleTable ends p))

lemma pairTable_law (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (p q : PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e)) :
    ((pairTable ends hloop hpar p).law q : ℝ)=pairProposalRaw ends p q := by
  unfold pairTable
  rw [WeightedOptions.mix_law,WeightedOptions.mix_law,
    WeightedOptions.map_first_law,WeightedOptions.map_first_law]
  push_cast
  unfold pairProposalRaw firstLift
  by_cases h : p.2=q.2
  · simp only [ite_eq_left h]
    rw [switchTable_law,colorTable_law,cycleTable_law]
    ring
  · simp only [ite_eq_right h]
    push_cast
    rw [cycleTable_law]
    ring

lemma pairTable_size (hloop : ∀ e, ¬(ends e).IsDiag)
    (hpar : ∀ e, (univ.filter (fun f => ends f = ends e)).card ≤ 2)
    (p : PM (fun e v => v ∈ ends e) × PM (fun e v => v ∈ ends e)) :
    (pairTable ends hloop hpar p).size ≤
      8*p.1.val.card.choose 2 + 2*p.1.val.card + (p.1.val.card+p.2.val.card)+3 := by
  have hs : ((switches ends p.1).erase p.1).card ≤ 8*p.1.val.card.choose 2 := card_erase_le.trans (switches_card ends hpar p.1)
  have hc : ((colors ends p.1).erase p.1).card ≤ 2*p.1.val.card := card_erase_le.trans (colors_card ends hpar p.1)
  have hy := discrepancies_card ends p.1 p.2
  simp only [pairTable,WeightedOptions.mix,WeightedOptions.map,switchTable,colorTable,
    WeightedOptions.neighbors]
  have hz : (cycleTable ends p).size ≤ p.1.val.card+p.2.val.card+1 := by
    unfold cycleTable
    split_ifs <;> simp only [WeightedOptions.map,WeightedOptions.uniform,WeightedOptions.pure]
    · omega
    · omega
  omega

end MatchingFPRAS.Transport.Sparse

end OAI