lean/OAI/Combinatorics/MatchingCount/Sampling/Plan.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.RankOrder

namespace OAI

namespace MatchingFPRAS.UnitRefresh.Materialized

open Finset

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

def plan {m : ℕ} (rank : Fin m → ℕ) : List (Fin m) :=
  (List.ofFn (fun l : Fin m => l)).mergeSort (fun a b=>decide (rank b≤rank a))

lemma plan_mem {m : ℕ} (rank : Fin m → ℕ) (a : Fin m) : a∈plan rank := by
  unfold plan
  rw [(List.mergeSort_perm _ _).mem_iff]
  simp

lemma plan_length {m : ℕ} (rank : Fin m → ℕ) : (plan rank).length=m := by
  unfold plan
  rw [(List.mergeSort_perm _ _).length_eq]
  simp

lemma plan_sorted {m : ℕ} (rank : Fin m → ℕ) :
    (plan rank).Pairwise (fun a b=>rank b≤rank a) := by
  let r := fun a b : Fin m => rank b≤rank a
  let : Std.Total r := ⟨fun a b => le_total (rank b) (rank a)⟩
  let : IsTrans (Fin m) r := ⟨fun a b c hab hbc => hbc.trans hab⟩
  exact List.pairwise_mergeSort' r _

lemma plan_legal {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) :
    LegalPlan bags parent (plan rank) univ := by
  apply rank_order_legal bags rank parent hb hp _ (plan_sorted rank)
  · intro x _; exact hne x
  · intro x _ a _; exact plan_mem rank a

theorem computable_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 (plan rank)=Fintype.card (ColoredPairing bags) := by
  rw [coloredPairing_card]
  change count bags parent (plan rank)=assignmentPartition bags (fun _=>pairingCount)
  rw [←active_univ]
  rw [tableDP_correct bags parent _ _ (plan_legal bags rank parent hb hne hp)]
  unfold count
  apply prod_congr rfl
  intro a _
  rw [read_run]
  apply finiteDP_correct
  intro b r hr
  rw [plan_length] at hr
  simp [initial,read_tabulate,hr]

def branchCount {m : ℕ} (bags : V → Finset (Fin m)) (rank : Fin m → ℕ)
    (parent : Fin m → Option (Fin m)) (a b : V) : ℕ :=
  count (residualBags bags a b) parent (plan rank)

lemma branchCount_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)
    (a b : V) : branchCount bags rank parent a b=
      Fintype.card (ColoredPairing (residualBags bags a b)) := by
  apply computable_count_eq
  · intro x c hc d hd; exact hb x.val c hc d hd
  · intro x; exact hne x.val
  · exact hp

lemma branchCount_sum {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)
    (a : V) : (∑ c : Partner bags a,branchCount bags rank parent a c.val.1)=
      count bags parent (plan rank) := by
  rw [computable_count_eq bags rank parent hb hne hp,
    Fintype.card_congr (ColoredPairing.split a),Fintype.card_sigma]
  apply sum_congr rfl
  intro c _
  exact branchCount_eq bags rank parent hb hne hp a c.val.1



open Finset MatchingFPRAS.FiniteChoice

variable {n m : ℕ}

def validBranch (bags : Fin n → Finset (Fin m)) (a : Fin n) (bc : Fin n × Fin m) : Prop :=
  bc.1≠a ∧ bc.2∈bags a ∧ bc.2∈bags bc.1

instance (bags : Fin n → Finset (Fin m)) (a : Fin n) (bc : Fin n × Fin m) :
    Decidable (validBranch bags a bc) := inferInstanceAs (Decidable (_ ∧ _ ∧ _))

def edgeCount (bags : Fin n → Finset (Fin m)) (rank : Fin m → ℕ)
    (parent : Fin m → Option (Fin m)) (a : Fin n) (bc : Fin n × Fin m) : ℕ :=
  if validBranch bags a bc then branchCount bags rank parent a bc.1 else 0

lemma edgeCount_sum (bags : Fin n → 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)
    (a : Fin n) : (∑ bc,edgeCount bags rank parent a bc)=count bags parent (plan rank) := by
  rw [←branchCount_sum bags rank parent hb hne hp a]
  change (∑ bc,if validBranch bags a bc then branchCount bags rank parent a bc.1 else 0)=_
  rw [←Finset.sum_filter]
  exact Finset.sum_subtype _ (by intro bc; simp only [Finset.mem_filter,Finset.mem_univ,true_and]; rfl) _

def edgeProbability (bags : Fin n → Finset (Fin m)) (rank : Fin m → ℕ)
    (parent : Fin m → Option (Fin m)) (a : Fin n) (i : Fin (n*m)) : ℚ :=
  edgeCount bags rank parent a (finProdFinEquiv.symm i)/count bags parent (plan rank)

lemma edgeProbability_nonneg (bags : Fin n → Finset (Fin m)) (rank : Fin m → ℕ)
    (parent : Fin m → Option (Fin m)) (a : Fin n) (i : Fin (n*m)) :
    0≤edgeProbability bags rank parent a i := by unfold edgeProbability; positivity

lemma edgeProbability_sum (bags : Fin n → 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)
    (a : Fin n) (hz : 0<count bags parent (plan rank)) :
    ∑ i,edgeProbability bags rank parent a i=1 := by
  unfold edgeProbability
  rw [←Finset.sum_div,←Nat.cast_sum]
  rw [←finProdFinEquiv.sum_comp (fun i=>edgeCount bags rank parent a (finProdFinEquiv.symm i))]
  simp only [Equiv.symm_apply_apply]
  rw [edgeCount_sum bags rank parent hb hne hp a]
  exact div_self (by exact_mod_cast hz.ne')

def drawEdge (bags : Fin n → 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)
    (a : Fin n) (hz : 0<count bags parent (plan rank)) (k : ℕ) (bits : Fin k → Bool) :
    {c : Partner bags a // 0<branchCount bags rank parent a c.val.1} := by
  let p := edgeProbability bags rank parent a
  have hs := edgeProbability_sum bags rank parent hb hne hp a hz
  let i := chooseBits p hs k bits
  let bc := finProdFinEquiv.symm i
  have hh : 0<edgeCount bags rank parent a bc := by
    have h := chooseBits_pos p hs k bits
    change 0<(edgeCount bags rank parent a bc:ℚ)/(count bags parent (plan rank):ℚ) at h
    have := (div_pos_iff_of_pos_right (by exact_mod_cast hz : (0:ℚ)<count bags parent (plan rank))).mp h
    exact_mod_cast this
  have hv : validBranch bags a bc := by
    by_contra hv
    simp [edgeCount,hv] at hh
  exact ⟨⟨bc,hv⟩,by simpa [edgeCount,hv] using hh⟩

theorem drawEdge_tv (bags : Fin n → 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)
    (a : Fin n) (hz : 0<count bags parent (plan rank)) (k : ℕ) :
    let p := edgeProbability bags rank parent a
    let hs := edgeProbability_sum bags rank parent hb hne hp a hz
    (∑ i,|tapeLaw p hs k i-p i|)/2≤2*(n*m)/(2:ℚ)^k := by
  dsimp only
  rw [tapeLaw_eq]
  simpa only [Nat.cast_mul] using fixed_bit_choice _ (edgeProbability_nonneg bags rank parent a) _ k

end MatchingFPRAS.UnitRefresh.Materialized

namespace MatchingFPRAS.UnitRefresh

open Finset

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

def ColoredPairing.map (bags : V → Finset L) (e : U ≃ V)
    (p : ColoredPairing (fun x=>bags (e x))) : ColoredPairing bags where
  pair := p.pair.map e
  color x := p.color (e.symm x)
  allowed x := by simpa using p.allowed (e.symm x)
  same_color x := by simpa [Pairing.map] using p.same_color (e.symm x)

def ColoredPairing.comap (bags : V → Finset L) (e : U ≃ V)
    (p : ColoredPairing bags) : ColoredPairing (fun x=>bags (e x)) where
  pair := p.pair.map e.symm
  color x := p.color (e x)
  allowed x := p.allowed (e x)
  same_color x := by simpa [Pairing.map] using p.same_color (e x)

def ColoredPairing.equiv (bags : V → Finset L) (e : U ≃ V) :
    ColoredPairing (fun x=>bags (e x)) ≃ ColoredPairing bags where
  toFun := ColoredPairing.map bags e
  invFun := ColoredPairing.comap bags e
  left_inv p := by
    apply ColoredPairing.ext
    · ext x; simp [ColoredPairing.map,ColoredPairing.comap,Pairing.map]
    · funext x; simp [ColoredPairing.map,ColoredPairing.comap]
  right_inv p := by
    apply ColoredPairing.ext
    · ext x; simp [ColoredPairing.map,ColoredPairing.comap,Pairing.map]
    · funext x; simp [ColoredPairing.map,ColoredPairing.comap]

def gapEquiv {n : ℕ} (a : Fin (n+1)) : Fin n ≃ {x : Fin (n+1) // x≠a} :=
  Equiv.optionSubtype a ⟨(finSuccEquiv' a).symm,rfl⟩

def removePairEquiv {n : ℕ} (a b : Fin (n+2)) (hb : b≠a) :
    Fin n ≃ withoutPair a b := by
  let e := gapEquiv a
  let b' := e.symm ⟨b,hb⟩
  let f := gapEquiv b'
  refine {
    toFun := fun i=>⟨(e (f i).val).val,(e (f i).val).property,?_⟩
    invFun := fun x=>f.symm ⟨e.symm ⟨x.val,x.property.1⟩,?_⟩
    left_inv := ?_
    right_inv := ?_ }
  · intro h
    apply (f i).property
    apply e.injective
    apply Subtype.ext
    simpa [b'] using h
  · intro h
    have hh := congrArg (fun i=>(e i).val) h
    apply x.property.2
    simpa [b'] using hh
  · intro i
    apply f.injective
    simp
  · intro x
    apply Subtype.ext
    simp

end MatchingFPRAS.UnitRefresh

namespace MatchingFPRAS.UnitRefresh.Materialized

open Finset MatchingFPRAS.FiniteChoice

variable {m : ℕ}

lemma singleton_count_zero (bags : Fin 1 → 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 (plan rank)=0 := by
  rw [computable_count_eq bags rank parent hb hne hp]
  have : IsEmpty (ColoredPairing bags) := ⟨fun p=>p.pair.no_fixed 0 (Subsingleton.elim _ _)⟩
  exact Fintype.card_eq_zero

def sampleUnit (k : ℕ) : (n : ℕ) → (bags : Fin n → 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) →
    0<count bags parent (plan rank) → (Fin n → Fin k → Bool) → ColoredPairing bags
  | 0,bags,_,_,_,_,_,_,_ =>
    ⟨⟨fun x=>Fin.elim0 x,fun x=>Fin.elim0 x,fun x=>Fin.elim0 x⟩,
      (fun x=>Fin.elim0 x),(fun x=>Fin.elim0 x),(fun x=>Fin.elim0 x)⟩
  | 1,bags,rank,parent,hb,hne,hp,hz,_ =>
    False.elim (by rw [singleton_count_zero bags rank parent hb hne hp] at hz; omega)
  | n+2,bags,rank,parent,hb,hne,hp,hz,bits => by
    let a : Fin (n+2) := Fin.last (n+1)
    let c := drawEdge bags rank parent hb hne hp a hz k (bits a)
    let e := removePairEquiv a c.val.val.1 c.val.property.1
    let b' : Fin n → Finset (Fin m) := fun x=>bags (e x).val
    have hb' : RankedBags b' rank parent := by
      intro x l hl r hr; exact hb (e x).val l hl r hr
    have hne' : ∀ x,(b' x).Nonempty := fun x=>hne (e x).val
    have hz' : 0<count b' parent (plan rank) := by
      rw [computable_count_eq b' rank parent hb' hne' hp]
      rw [Fintype.card_congr (ColoredPairing.equiv (residualBags bags a c.val.val.1) e)]
      rw [←branchCount_eq bags rank parent hb hne hp]
      exact c.property
    let p := sampleUnit k n b' rank parent hb' hne' hp hz'
      (fun i=>bits i.castSucc.castSucc)
    exact (ColoredPairing.map (residualBags bags a c.val.val.1) e p).insert a c.val



open Finset MatchingFPRAS.FiniteChoice MatchingFPRAS.Variation
open scoped Classical

variable {n m : ℕ}

abbrev PositivePartner (bags : Fin n → Finset (Fin m)) (rank : Fin m → ℕ)
    (parent : Fin m → Option (Fin m)) (a : Fin n) :=
  {c : Partner bags a // 0<branchCount bags rank parent a c.val.1}

def partnerIndex (bags : Fin n → Finset (Fin m)) (rank : Fin m → ℕ)
    (parent : Fin m → Option (Fin m)) (a : Fin n)
    (c : PositivePartner bags rank parent a) : Fin (n*m) := finProdFinEquiv c.val.val

lemma partnerIndex_injective (bags : Fin n → Finset (Fin m)) (rank : Fin m → ℕ)
    (parent : Fin m → Option (Fin m)) (a : Fin n) :
    Function.Injective (partnerIndex bags rank parent a) := by
  intro c d h
  apply Subtype.ext
  apply Subtype.ext
  exact finProdFinEquiv.injective h

lemma drawEdge_index (bags : Fin n → 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)
    (a : Fin n) (hz : 0<count bags parent (plan rank)) (k : ℕ) (bits : Fin k → Bool) :
    partnerIndex bags rank parent a (drawEdge bags rank parent hb hne hp a hz k bits)=
      chooseBits (edgeProbability bags rank parent a) (edgeProbability_sum bags rank parent hb hne hp a hz) k bits := by
  exact finProdFinEquiv.apply_symm_apply _

lemma drawEdge_law (bags : Fin n → 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)
    (a : Fin n) (hz : 0<count bags parent (plan rank)) (k : ℕ)
    (c : PositivePartner bags rank parent a) :
    imageLaw (drawEdge bags rank parent hb hne hp a hz k) c=
      (tapeLaw (edgeProbability bags rank parent a) (edgeProbability_sum bags rank parent hb hne hp a hz) k
        (partnerIndex bags rank parent a c):ℝ) := by
  rw [imageLaw_eq_count]
  simp only [tapeLaw,Rat.cast_div,Rat.cast_natCast,Rat.cast_pow,Rat.cast_ofNat,
    Fintype.card_fun,Fintype.card_fin,Fintype.card_bool,Nat.cast_pow,Nat.cast_ofNat]
  congr 2
  apply congrArg Finset.card
  ext bits
  simp only [mem_filter,mem_univ,true_and]
  rw [←drawEdge_index]
  exact (partnerIndex_injective bags rank parent a).eq_iff.symm

theorem drawEdge_positive_tv (bags : Fin n → 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)
    (a : Fin n) (hz : 0<count bags parent (plan rank)) (k : ℕ) :
    tv (imageLaw (drawEdge bags rank parent hb hne hp a hz k))
      (fun c : PositivePartner bags rank parent a=>(branchCount bags rank parent a c.val.val.1:ℝ)/count bags parent (plan rank))
      ≤ 2*n*m/(2:ℝ)^k := by
  let idx := partnerIndex bags rank parent a
  let p := edgeProbability bags rank parent a
  let hs := edgeProbability_sum bags rank parent hb hne hp a hz
  have he (c : PositivePartner bags rank parent a) :
      (p (idx c):ℝ)=(branchCount bags rank parent a c.val.val.1:ℝ)/count bags parent (plan rank) := by
    have hv : validBranch bags a c.val.val := c.val.property
    simp [p,idx,partnerIndex,edgeProbability,edgeCount,hv]
  have hg : ∑ c : PositivePartner bags rank parent a,|(tapeLaw p hs k (idx c):ℝ)-(p (idx c):ℝ)| ≤
      ∑ i : Fin (n*m),|(tapeLaw p hs k i:ℝ)-(p i:ℝ)| := by
    change (∑ c,|(tapeLaw p hs k (partnerIndex bags rank parent a c):ℝ)-(p (partnerIndex bags rank parent a c):ℝ)|)≤_
    rw [←Finset.sum_image (s:=univ) (f:=fun i=>|(tapeLaw p hs k i:ℝ)-(p i:ℝ)|)
      (fun c _ d _ h=>(partnerIndex_injective bags rank parent a) h)]
    exact Finset.sum_le_univ_sum_of_nonneg (fun _=>abs_nonneg _)
  have ht : (∑ i : Fin (n*m),|(tapeLaw p hs k i:ℝ)-(p i:ℝ)|)/2 ≤ 2*(n*m)/(2:ℝ)^k := by
    have hh := drawEdge_tv bags rank parent hb hne hp a hz k
    have hcast := (Rat.cast_le (K:=ℝ)).mpr hh
    push_cast at hcast
    simpa only [p,hs,Nat.cast_mul] using hcast
  unfold tv
  have hg' : (∑ c : PositivePartner bags rank parent a,
      |imageLaw (drawEdge bags rank parent hb hne hp a hz k) c-
        (branchCount bags rank parent a c.val.val.1:ℝ)/count bags parent (plan rank)|)≤
      ∑ i : Fin (n*m),|(tapeLaw p hs k i:ℝ)-(p i:ℝ)| := by
    simpa only [drawEdge_law,he] using hg
  exact (div_le_div_of_nonneg_right hg' (by norm_num)).trans (by simpa only [mul_assoc] using ht)

noncomputable def positiveSplitEquiv (bags : Fin n → 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)
    (a : Fin n) :
    (Σ c : PositivePartner bags rank parent a,ColoredPairing (residualBags bags a c.val.val.1)) ≃ ColoredPairing bags := by
  let e : (Σ c : PositivePartner bags rank parent a,ColoredPairing (residualBags bags a c.val.val.1)) ≃
      (Σ c : Partner bags a,ColoredPairing (residualBags bags a c.val.1)) := {
    toFun := fun s=>⟨s.1.val,s.2⟩
    invFun := fun s=>⟨⟨s.1,by
      rw [branchCount_eq bags rank parent hb hne hp]
      exact Fintype.card_pos_iff.mpr ⟨s.2⟩⟩,s.2⟩
    left_inv := fun s=>by rcases s with ⟨⟨c,hc⟩,x⟩; rfl
    right_inv := fun s=>by cases s; rfl }
  exact e.trans (ColoredPairing.split a).symm

lemma positiveSplitEquiv_apply (bags : Fin n → 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)
    (a : Fin n) (c : PositivePartner bags rank parent a)
    (x : ColoredPairing (residualBags bags a c.val.val.1)) :
    positiveSplitEquiv bags rank parent hb hne hp a ⟨c,x⟩=x.insert a c.val := rfl

theorem unit_self_reduction_law (bags : Fin n → 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)
    (a : Fin n) (hz : 0<count bags parent (plan rank)) (z : ColoredPairing bags) :
    push (sigmaLift
      (fun c : PositivePartner bags rank parent a=>(branchCount bags rank parent a c.val.val.1:ℝ)/count bags parent (plan rank))
      (fun c=>uniform (ColoredPairing (residualBags bags a c.val.val.1))))
      (positiveSplitEquiv bags rank parent hb hne hp a) z=uniform (ColoredPairing bags) z := by
  let : Nonempty (ColoredPairing bags) := Fintype.card_pos_iff.mp (by
    rwa [←computable_count_eq bags rank parent hb hne hp])
  simp_rw [branchCount_eq bags rank parent hb hne hp,computable_count_eq bags rank parent hb hne hp]
  exact uniform_sigma (positiveSplitEquiv bags rank parent hb hne hp a) z

end MatchingFPRAS.UnitRefresh.Materialized

end OAI