lean/OAI/Combinatorics/MatchingCount/Graphs/PM.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Sampling.LadderL
import OAI.Combinatorics.MatchingCount.Graphs.MatchingMap

namespace OAI

namespace MatchingFPRAS.Enlargement

open MatchingFPRAS.Switching MatchingFPRAS.Subdivision MatchingFPRAS.RealGeometry
open MatchingFPRAS.Hierarchy MatchingFPRAS.Transport Finset
open MatchingFPRAS.Replica MatchingFPRAS.Replica.Ladder

variable {V : Type*} [Fintype V] [LinearOrder V] [Nontrivial V]

noncomputable local instance (w : V → V → ℝ) (K : ℕ) : DecidableEq (SourceLabel w K) := Classical.decEq _

noncomputable local instance (w : V → V → ℝ) (K : ℕ) : Fintype (BagEdge (sourceBags w K)) := Fintype.ofFinite _

abbrev SourcePM (w : V → V → ℝ) (K : ℕ) := PM (BagEdge.Incident (bags:=sourceBags w K))

noncomputable local instance (w : V → V → ℝ) (K : ℕ) : DecidableEq (SourcePM w K) := Classical.decEq _

omit [Nontrivial V] in
lemma sourceVertex_card_ge (K : ℕ) : Fintype.card V ≤ Fintype.card (SourceVertex V K) := by
  exact Fintype.card_le_of_injective (Sum.inl : V → SourceVertex V K) Sum.inl_injective

theorem source_ladder_sampling (hn : 2 ≤ Fintype.card V)
    (w : V → V → ℝ) (hw : ∀ x y, 0 < w x y) (K : ℕ)
    (hK : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K)
    (M₀ : SourcePM w K) (T : ℕ)
    (z : Slot T (ladderQ (Fintype.card (SourceVertex V K)) (sourceD (V:=V) K)) → SourcePM w K)
    (ξ : ℝ) (hξ : 0 < ξ) (hξ1 : ξ < 1) :
    let D := sourceD (V:=V) K
    let N := Fintype.card (SourceVertex V K)
    let wt := sourceBagWeight w K D
    let ν := ladderLaw wt T (ladderQ N D)
    let C := ladderFlow (fun x a ha b hb => sourceBag_tree_adjacent w K hK x a b ha hb) (sourceTree_isTree w K).2 wt T (ladderQ N D)
    (∑ s, |MatchingFPRAS.FiniteChain.walk ν C z (ladderSteps N D K T ξ) s-ν s|)/2 ≤ ξ := by
  classical
  dsimp only
  apply ideal_ladder_sampling (fun x a ha b hb => sourceBag_tree_adjacent w K hK x a b ha hb) (sourceTree_isTree w K).2
    (bagHeight w K) (bagHeight_pos w K) (bagHeight_adjacent w K)
    (sourceD (V:=V) K) K (sourceD_one K) (hn.trans (sourceVertex_card_ge K))
    (sourceBagWeight w K (sourceD (V:=V) K))
    (sourceBagWeight_range w K _ (sourceD_one K) hw hK)
    (sourceBagWeight_global w K _ (sourceD_one K) hw hK) M₀ T z ξ hξ hξ1

end MatchingFPRAS.Enlargement

namespace MatchingFPRAS.Subdivision

open Finset

def probeHoles (p : ℕ) (hp : 1≤p) : Finset (Fin (4*p)) :=
  {⟨2*p-1,by omega⟩,⟨2*p,by omega⟩}

def probeWord (p : ℕ) : Selection (4*p) :=
  fun i => if i.val=2*p then false else alternating true i.val

lemma probeWord_valid (p : ℕ) (hp : 1≤p) : Valid (probeHoles p hp) (probeWord p) := by
  intro i
  by_cases h : i.val=2*p-1 ∨ i.val=2*p
  · have hm : i∈probeHoles p hp := by simpa [probeHoles,Fin.ext_iff] using h
    rw [ite_eq_left hm]
    rcases h with h | h
    · have _hm : i.val%2=1 := by omega
      simp [probeWord,Fin.val_castSucc,Fin.val_succ,h,show 2*p-1+1=2*p by omega,
        alternating,show (2*p-1)%2=1 by omega,show 2*p-1≠2*p by omega]
    · simp [probeWord,Fin.val_castSucc,Fin.val_succ,h,alternating,Nat.add_mod]
  · have hm : i∉probeHoles p hp := by simpa [probeHoles,Fin.ext_iff] using h
    rw [ite_eq_right hm]
    have h₁ : i.val≠2*p := by omega
    have h₂ : i.val+1≠2*p := by omega
    simp only [probeWord,Fin.val_castSucc,Fin.val_succ,ite_eq_right h₁,ite_eq_right h₂,alternating_succ]
    cases alternating true i.val <;> decide

@[simp] lemma probeWord_first (p : ℕ) (hp : 1≤p) : probeWord p 0=true := by
  simp [probeWord,show 0≠2*p by omega]

@[simp] lemma probeWord_last (p : ℕ) (hp : 1≤p) : probeWord p (Fin.last (4*p))=true := by
  simp [probeWord,show 4*p≠2*p by omega,alternating,Nat.mul_mod]

lemma probeHoles_nonempty (p : ℕ) (hp : 1≤p) : (probeHoles p hp).Nonempty := by
  simp [probeHoles]

lemma probeWord_unique (p : ℕ) (hp : 1≤p) (b : Selection (4*p))
    (hb : Valid (probeHoles p hp) b) : b=probeWord p :=
  broken_unique (probeHoles_nonempty p hp) hb (probeWord_valid p hp)

lemma probe_weight (p : ℕ) (B Hu Hv lam : ℝ) :
    selectedWeight (profileActivity p B Hu Hv lam) (probeWord p)=
      (∏ r : Fin p,max B (Hu/2^r.val))*(∏ r : Fin p,max B (Hv/2^r.val)) := by
  have he : selectedWeight (profileActivity p B Hu Hv lam) (probeWord p)=
      selectedWeight (profileActivity p B Hu Hv 1) (fun i => alternating true i.val) := by
    unfold selectedWeight
    apply Finset.prod_congr rfl
    intro i _
    by_cases hi : i.val=2*p
    · have hfi : i=⟨2*p,by omega⟩ := Fin.ext hi
      rw [hfi]
      simp [probeWord,alternating]
    · simp only [probeWord,ite_eq_right hi]
      congr 1
      rcases lt_or_gt_of_ne hi with h | h
      · rw [profile_left _ _ _ _ _ _ h,profile_left _ _ _ _ _ _ h]
      · rw [profile_right _ _ _ _ _ _ h,profile_right _ _ _ _ _ _ h]
  rw [he,exact_profile_weight]
  simp


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

variable (u v : E → V) (p : ℕ) (hp : 1≤p) (e₀ : E)

def singleProbeHoles (e : E) : Finset (Fin (4*p)) :=
  if e=e₀ then probeHoles p hp else ∅

@[simp] lemma broken_singleProbe : broken (singleProbeHoles p hp e₀)={e₀} := by
  ext e
  by_cases he : e=e₀ <;> simp [singleProbeHoles,he,probeHoles_nonempty]

omit [Fintype V] [Fintype E] [DecidableEq V] in
lemma singleProbe_word (b : E → Selection (4*p))
    (hb : FamilyHoles u v (4*p) ∅ (singleProbeHoles p hp e₀) b) : b e₀=probeWord p := by
  exact probeWord_unique p hp (b e₀) (by simpa [singleProbeHoles] using hb.1 e₀)

lemma residual_singleProbe (b : E → Selection (4*p))
    (hb : FamilyHoles u v (4*p) ∅ (singleProbeHoles p hp e₀) b) :
    residualHoles u v ∅ (singleProbeHoles p hp e₀) b={u e₀,v e₀} := by
  ext x
  simp only [mem_residualHoles,notMem_empty,broken_singleProbe,mem_singleton,
    exists_eq_left,false_or,Uses,singleProbe_word u v p hp e₀ b hb,
    probeWord_first p hp,probeWord_last p hp,true_and,mem_insert,mem_singleton]
  exact or_congr eq_comm eq_comm

def insertProbe (s : E → Bool) (e : E) : Selection (4*p) :=
  if e=e₀ then probeWord p else fun i => alternating (s e) i.val

include hp in
omit [Fintype V] [Fintype E] [DecidableEq V] in
lemma insertProbe_uses (s : E → Bool) (e : E) (x : V) :
    Uses u v (insertProbe p e₀ s) e x ↔
      if e=e₀ then u e₀=x ∨ v e₀=x else s e=true ∧ (u e=x ∨ v e=x) := by
  by_cases he : e=e₀
  · subst e; simp [Uses,insertProbe,probeWord_first p hp,probeWord_last p hp]
  · simp [Uses,insertProbe,he,alternating,and_or_left,Nat.mul_mod]

omit [Fintype V] [Fintype E] in
lemma insertProbe_family (_hne : u e₀≠v e₀) (s : E → Bool)
    (hs : LogicalHoles u v {u e₀,v e₀} {e₀} s) :
    FamilyHoles u v (4*p) ∅ (singleProbeHoles p hp e₀) (insertProbe p e₀ s) := by
  refine ⟨?_,by simp,?_⟩
  · intro e
    by_cases he : e=e₀
    · subst e; simpa [singleProbeHoles,insertProbe] using probeWord_valid p hp
    · simpa [singleProbeHoles,insertProbe,he] using alternating_valid (4*p) (s e)
  · intro x _
    by_cases hx : x∈({u e₀,v e₀} : Finset V)
    · refine ⟨e₀,?_,?_⟩
      · change Uses u v (insertProbe p e₀ s) e₀ x
        rw [insertProbe_uses u v p hp e₀,ite_eq_left rfl]
        simpa only [mem_insert,mem_singleton,eq_comm] using hx
      · intro e he
        by_contra hen
        rw [insertProbe_uses u v p hp e₀,ite_eq_right hen] at he
        exact hs.2.1 x hx e he
    · obtain ⟨e,he,hu⟩ := hs.2.2 x hx
      have he₀ : e≠e₀ := by
        intro h
        subst e
        exact (Bool.noConfusion (he.1.symm.trans (hs.1 e₀ (mem_singleton_self _))))
      refine ⟨e,(insertProbe_uses u v p hp e₀ s e x).mpr (by simpa [he₀] using he),?_⟩
      intro f hf
      by_cases hf₀ : f=e₀
      · subst f
        rw [insertProbe_uses u v p hp e₀,ite_eq_left rfl] at hf
        exact False.elim (hx (by simpa only [mem_insert,mem_singleton,eq_comm] using hf))
      · rw [insertProbe_uses u v p hp e₀,ite_eq_right hf₀] at hf
        exact hu f hf

omit [Fintype V] [DecidableEq V] in
lemma singleProbe_deletionConstant (b : E → Selection (4*p))
    (hb : FamilyHoles u v (4*p) ∅ (singleProbeHoles p hp e₀) b)
    (B Hu Hv lam : E → ℝ) :
    deletionConstant (singleProbeHoles p hp e₀) b
      (fun e => profileActivity p (B e) (Hu e) (Hv e) (lam e))
      (fun e => (∏ r : Fin p,max (B e) (Hu e/2^r.val))*(∏ r : Fin p,max (B e) (Hv e/2^r.val))) =
    ∏ e,(∏ r : Fin p,max (B e) (Hu e/2^r.val))*(∏ r : Fin p,max (B e) (Hv e/2^r.val)) := by
  unfold deletionConstant
  apply Finset.prod_congr rfl
  intro e _
  by_cases he : e=e₀
  · subst e
    simp only [singleProbeHoles,probeHoles_nonempty,ite_true,
      singleProbe_word u v p hp e₀ b hb,probe_weight]
  · simp [singleProbeHoles,he]

theorem singleProbe_partition (hne : u e₀≠v e₀) (B Hu Hv lam : E → ℝ) :
    realHolePartition u v (4*p) ∅ (singleProbeHoles p hp e₀)
      (fun e => profileActivity p (B e) (Hu e) (Hv e) (lam e)) =
    (∏ e,(∏ r : Fin p,max (B e) (Hu e/2^r.val))*(∏ r : Fin p,max (B e) (Hv e/2^r.val))) *
      logicalHolePartition u v {u e₀,v e₀} {e₀} lam := by
  classical
  by_cases h : ∃ b,FamilyHoles u v (4*p) ∅ (singleProbeHoles p hp e₀) b
  · obtain ⟨b,hb⟩ := h
    have hid := deletion_partition_identity (show Even (4*p) from ⟨2*p,by omega⟩)
      u v ∅ (singleProbeHoles p hp e₀) b hb
      (fun e => profileActivity p (B e) (Hu e) (Hv e) (lam e))
      (fun e => List.ofFn fun r : Fin p => max (B e) (Hu e/2^r.val))
      (fun e => (List.ofFn fun r : Fin p => max (B e) (Hv e/2^r.val)).reverse) lam
      (fun e => profileActivity_ofFn p (B e) (Hu e) (Hv e) (lam e))
    simp only [List.prod_reverse,List.prod_ofFn] at hid
    rw [singleProbe_deletionConstant u v p hp e₀ b hb,residual_singleProbe u v p hp e₀ b hb,
      broken_singleProbe] at hid
    exact hid
  · have hl : ¬∃ s,LogicalHoles u v {u e₀,v e₀} {e₀} s := by
      rintro ⟨s,hs⟩
      exact h ⟨insertProbe p e₀ s,insertProbe_family u v p hp e₀ hne s hs⟩
    have hz : realHolePartition u v (4*p) ∅ (singleProbeHoles p hp e₀)
        (fun e => profileActivity p (B e) (Hu e) (Hv e) (lam e))=0 := by
      unfold realHolePartition
      apply Finset.sum_eq_zero
      intro b _
      exact False.elim (h ⟨b.val,b.property⟩)
    have hz' : logicalHolePartition u v {u e₀,v e₀} {e₀} lam=0 := by
      unfold logicalHolePartition
      apply Finset.sum_eq_zero
      intro s _
      exact False.elim (hl ⟨s.val,s.property⟩)
    rw [hz,hz',mul_zero]


end MatchingFPRAS.Subdivision

namespace MatchingFPRAS.Representation

open MatchingFPRAS.Switching MatchingFPRAS.Subdivision MatchingFPRAS.Enlargement Finset

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

omit [Fintype V] in
lemma forbidden_endpoint_redundant (R : Finset V) (e₀ : LogicalEdge V)
    (he : source e₀∈R) (s : LogicalEdge V → Bool) :
    LogicalHoles source target R {e₀} s ↔ LogicalHoles source target R ∅ s := by
  constructor
  · intro h; exact ⟨by simp,h.2⟩
  · intro h
    refine ⟨?_,h.2⟩
    intro e hem
    have heq : e=e₀ := mem_singleton.mp hem
    subst e
    cases hs : s e₀ with
    | false => rfl
    | true => exact False.elim (h.2.1 (source e₀) he e₀ ⟨hs,Or.inl rfl⟩)

lemma logical_partition_redundant (w : V → V → ℝ) (R : Finset V) (e₀ : LogicalEdge V)
    (he : source e₀∈R) :
    logicalHolePartition source target R {e₀} (logicalActivity w)=partition w R := by
  classical
  let := Fintype.ofFinite {s : LogicalEdge V → Bool // LogicalHoles source target R {e₀} s}
  let := Fintype.ofFinite {s : LogicalEdge V → Bool // LogicalHoles source target R ∅ s}
  rw [← logical_partition_eq]
  unfold logicalHolePartition
  apply Fintype.sum_equiv (Equiv.subtypeEquivRight (forbidden_endpoint_redundant R e₀ he))
  intro s
  rfl

end MatchingFPRAS.Representation

namespace MatchingFPRAS.Enlargement

open MatchingFPRAS.Switching MatchingFPRAS.Subdivision MatchingFPRAS.RealGeometry
open MatchingFPRAS.Transport MatchingFPRAS.Representation Finset

variable {V : Type*} [Fintype V] [LinearOrder V] [Nontrivial V]

noncomputable local instance (w : V → V → ℝ) (K : ℕ) : Fintype (BagEdge (sourceBags w K)) := Fintype.ofFinite _

theorem source_probe_partition (w : V → V → ℝ) (K : ℕ) (e₀ : LogicalEdge V) :
    partitionWeight BagEdge.Incident (sourceRealPortion w K)
      (survivors (4*(2*K+2)) ∅ (singleProbeHoles (2*K+2) (by omega) e₀)) =
    (∏ e, pathConstant (2*K+2) (bottleneck w (source e) (target e))
      (sourceHeight w (source e)) (sourceHeight w (target e))) *
        partition w {source e₀,target e₀} := by
  rw [sourceRealPortion_partition]
  change realHolePartition source target (4*(2*K+2)) ∅
    (singleProbeHoles (2*K+2) (by omega) e₀)
    (fun e => profileActivity (2*K+2) (bottleneck w (source e) (target e))
      (sourceHeight w (source e)) (sourceHeight w (target e)) (logicalActivity w e)) = _
  rw [singleProbe_partition _ _ _ _ _ (source_ne_target e₀)]
  rw [logical_partition_redundant w _ e₀ (by simp)]
  rfl

theorem source_probe_ratio (w : V → V → ℝ) (hz : 0<partition w ∅) (K : ℕ)
    (e₀ : LogicalEdge V) (D I : ℝ) :
    (partitionWeight BagEdge.Incident (sourceRealPortion w K)
      (survivors (4*(2*K+2)) ∅ (singleProbeHoles (2*K+2) (by omega) e₀)) / D) /
      (I * partitionWeight BagEdge.Incident (sourceRealPortion w K) univ) =
        holeRatio w {source e₀,target e₀}/(D*I) := by
  rw [source_probe_partition,sourceRealPortion_full w hz]
  have hc : (∏ e : LogicalEdge V, pathConstant (2*K+2) (bottleneck w (source e) (target e))
      (sourceHeight w (source e)) (sourceHeight w (target e)))≠0 := by
    exact ne_of_gt (prod_pos fun e _ => pathConstant_pos _ _ _ _
      (zero_lt_one.trans_le (one_le_bottleneck w _ _)))
  unfold holeRatio
  field_simp

end MatchingFPRAS.Enlargement

end OAI