lean/OAI/Combinatorics/MatchingCount/Probability/Tv.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.Marked

namespace OAI

namespace MatchingFPRAS.Variation

open Finset
open scoped Classical

variable {Ω Ψ : Type*} [Fintype Ω] [Fintype Ψ]

noncomputable def tv (p q : Ω → ℝ) : ℝ := (∑ s,|p s-q s|)/2

lemma tv_nonneg (p q : Ω → ℝ) : 0 ≤ tv p q := by
  unfold tv; positivity

lemma tv_symm (p q : Ω → ℝ) : tv p q=tv q p := by
  unfold tv
  simp_rw [abs_sub_comm]

lemma tv_triangle (p q r : Ω → ℝ) : tv p r ≤ tv p q+tv q r := by
  unfold tv
  rw [←add_div,←sum_add_distrib]
  exact div_le_div_of_nonneg_right (sum_le_sum (fun s _ => abs_sub_le _ _ _)) (by norm_num)

noncomputable def event (p : Ω → ℝ) (P : Ω → Prop) : ℝ := ∑ x,if P x then p x else 0

lemma event_nonneg (p : Ω → ℝ) (hp : ∀ x,0 ≤ p x) (P : Ω → Prop) : 0 ≤ event p P := by
  unfold event; apply sum_nonneg; intro x _; split_ifs
  · exact hp x
  · exact le_rfl

theorem event_sub_le (p q : Ω → ℝ) (hs : ∑ x,p x=∑ x,q x) (P : Ω → Prop) :
    |event p P-event q P| ≤ tv p q := by
  let A : Finset Ω := univ.filter P
  have hz : ∑ x,(p x-q x)=0 := by rw [sum_sub_distrib,hs,sub_self]
  have he : event p P-event q P=∑ x ∈ A,(p x-q x) := by
    simp only [event,←sum_sub_distrib,A,sum_filter]
    apply sum_congr rfl
    intro x _
    split_ifs <;> simp
  have hc : ∑ x ∈ Aᶜ,(p x-q x)= -(∑ x ∈ A,(p x-q x)) := by
    have h := Finset.sum_add_sum_compl A (fun x => p x-q x)
    rw [hz] at h
    linarith
  have ha := abs_sum_le_sum_abs (fun x => p x-q x) A
  have hb := abs_sum_le_sum_abs (fun x => p x-q x) Aᶜ
  rw [hc,abs_neg] at hb
  have hab := Finset.sum_add_sum_compl A (fun x => |p x-q x|)
  rw [he]
  unfold tv
  linarith

noncomputable def bind (p : Ω → ℝ) (k : Ω → Ψ → ℝ) (y : Ψ) : ℝ := ∑ x,p x*k x y

omit [Fintype Ψ] in
lemma bind_nonneg (p : Ω → ℝ) (k : Ω → Ψ → ℝ)
    (hp : ∀ x,0 ≤ p x) (hk : ∀ x y,0 ≤ k x y) (y : Ψ) : 0 ≤ bind p k y :=
  sum_nonneg fun x _ => mul_nonneg (hp x) (hk x y)

lemma bind_sum (p : Ω → ℝ) (k : Ω → Ψ → ℝ) (hs : ∑ x,p x=1)
    (hk : ∀ x,∑ y,k x y=1) : ∑ y,bind p k y=1 := by
  unfold bind
  rw [sum_comm]
  simp_rw [←mul_sum,hk,mul_one]
  exact hs

lemma bind_contraction (p q : Ω → ℝ) (k : Ω → Ψ → ℝ)
    (hk : ∀ x y,0 ≤ k x y) (hs : ∀ x,∑ y,k x y=1) :
    tv (bind p k) (bind q k) ≤ tv p q := by
  unfold tv bind
  apply div_le_div_of_nonneg_right _ (by norm_num)
  calc
    _ = ∑ y,|∑ x,(p x-q x)*k x y| := by simp only [sub_mul,sum_sub_distrib]
    _ ≤ ∑ y,∑ x,|(p x-q x)*k x y| := sum_le_sum (fun y _ => abs_sum_le_sum_abs _ _)
    _ = _ := by
      rw [sum_comm]
      simp_rw [abs_mul,abs_of_nonneg (hk _ _),←mul_sum,hs,mul_one]

lemma bind_perturbation (p : Ω → ℝ) (k l : Ω → Ψ → ℝ)
    (hp : ∀ x,0 ≤ p x) (hs : ∑ x,p x=1) (ε : ℝ) (he : ∀ x,tv (k x) (l x) ≤ ε) :
    tv (bind p k) (bind p l) ≤ ε := by
  unfold tv bind
  have h : ∑ y,|∑ x,p x*k x y-∑ x,p x*l x y| ≤ 2*ε := by
    calc
      _ = ∑ y,|∑ x,p x*(k x y-l x y)| := by simp only [mul_sub,sum_sub_distrib]
      _ ≤ ∑ y,∑ x,|p x*(k x y-l x y)| := sum_le_sum (fun y _ => abs_sum_le_sum_abs _ _)
      _ = ∑ x,p x*(∑ y,|k x y-l x y|) := by
        rw [sum_comm]; simp_rw [abs_mul,abs_of_nonneg (hp _),←mul_sum]
      _ ≤ ∑ x,p x*(2*ε) := by
        apply sum_le_sum
        intro x _
        apply mul_le_mul_of_nonneg_left _ (hp x)
        have hh := he x
        unfold tv at hh
        linarith
      _ = _ := by rw [←sum_mul,hs,one_mul]
  linarith

noncomputable def push (p : Ω → ℝ) (f : Ω → Ψ) (y : Ψ) : ℝ :=
  ∑ x,if f x=y then p x else 0

omit [Fintype Ψ] in
lemma push_nonneg (p : Ω → ℝ) (hp : ∀ x,0 ≤ p x) (f : Ω → Ψ) (y : Ψ) :
    0 ≤ push p f y := by
  unfold push; apply sum_nonneg; intro x _; split_ifs
  · exact hp x
  · exact le_rfl

lemma push_sum (p : Ω → ℝ) (hs : ∑ x,p x=1) (f : Ω → Ψ) : ∑ y,push p f y=1 := by
  unfold push; rw [sum_comm]; simpa using hs

lemma push_contraction (p q : Ω → ℝ) (f : Ω → Ψ) : tv (push p f) (push q f) ≤ tv p q := by
  have he (r : Ω → ℝ) : push r f=bind r (fun x y => if f x=y then 1 else 0) := by
    funext y
    simp only [push,bind,mul_ite,mul_one,mul_zero]
  rw [he p,he q]
  exact
    bind_contraction p q (fun x y => if f x=y then 1 else 0)
      (fun x y => by split_ifs <;> norm_num) (fun x => by simp)

noncomputable def tensor (p : Ω → ℝ) (q : Ψ → ℝ) (x : Ω×Ψ) : ℝ := p x.1*q x.2

lemma tensor_tv (p q : Ω → ℝ) (r s : Ψ → ℝ)
    (hp : ∀ x,0 ≤ p x) (hps : ∑ x,p x=1) (hs : ∀ y,0 ≤ s y) (hss : ∑ y,s y=1) :
    tv (tensor p r) (tensor q s) ≤ tv p q+tv r s := by
  have hv (x : Ω) (y : Ψ) : |p x*r y-q x*s y| ≤ p x*|r y-s y|+|p x-q x| *s y := by
    have he : p x*r y-q x*s y=p x*(r y-s y)+(p x-q x)*s y := by ring
    rw [he]
    simpa only [abs_mul,abs_of_nonneg (hp x),abs_of_nonneg (hs y)] using abs_add_le (p x*(r y-s y)) ((p x-q x)*s y)
  unfold tv tensor
  rw [←add_div]
  apply div_le_div_of_nonneg_right _ (by norm_num)
  rw [Fintype.sum_prod_type]
  calc
    _ ≤ ∑ x,∑ y,(p x*|r y-s y|+|p x-q x| *s y) := sum_le_sum (fun x _ => sum_le_sum (fun y _ => hv x y))
    _ = _ := by simp_rw [sum_add_distrib,←mul_sum,hss,mul_one,←sum_mul,hps,one_mul]; ring

lemma tv_equiv (e : Ω ≃ Ψ) (p q : Ψ → ℝ) : tv (p ∘ e) (q ∘ e)=tv p q := by
  unfold tv
  rw [←e.sum_comp (fun y => |p y-q y|)]
  rfl

noncomputable def iid (p : Ω → ℝ) (n : ℕ) (x : Fin n → Ω) : ℝ := ∏ i,p (x i)

omit [Fintype Ω] in
lemma iid_nonneg (p : Ω → ℝ) (hp : ∀ x,0 ≤ p x) (n : ℕ) (x : Fin n → Ω) : 0 ≤ iid p n x :=
  prod_nonneg fun _ _ => hp _

lemma iid_sum (p : Ω → ℝ) (hs : ∑ x,p x=1) (n : ℕ) : ∑ x,iid p n x=1 := by
  unfold iid
  rw [←Fintype.prod_sum]
  simp [hs]

theorem iid_tv (p q : Ω → ℝ) (hp : ∀ x,0 ≤ p x) (hps : ∑ x,p x=1)
    (hq : ∀ x,0 ≤ q x) (hqs : ∑ x,q x=1) (n : ℕ) :
    tv (iid p n) (iid q n) ≤ n*tv p q := by
  induction n with
  | zero => simp [tv,iid]
  | succ n ih =>
    let e : (Ω×(Fin n → Ω)) ≃ (Fin (n+1) → Ω) := Fin.consEquiv (fun _ : Fin (n+1) => Ω)
    have hpE : iid p (n+1) ∘ e=tensor p (iid p n) := by
      funext x
      simp [iid,tensor,e,Fin.prod_univ_succ]
    have hqE : iid q (n+1) ∘ e=tensor q (iid q n) := by
      funext x
      simp [iid,tensor,e,Fin.prod_univ_succ]
    rw [←tv_equiv e,hpE,hqE]
    have ht := tensor_tv p q (iid p n) (iid q n) hp hps (iid_nonneg q hq n) (iid_sum q hqs n)
    push_cast
    nlinarith

section Product

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

noncomputable def product (p : I → Ω → ℝ) (x : I → Ω) : ℝ := ∏ i,p i (x i)

lemma product_marginal (p : I → Ω → ℝ) (hs : ∀ i,∑ a,p i a=1) (j : I) :
    push (product p) (fun x => x j)=p j := by
  classical
  funext y
  let q : I → Ω → ℝ := fun i a => if i=j then (if a=y then p i a else 0) else p i a
  have he (x : I → Ω) : (if x j=y then product p x else 0)=∏ i,q i (x i) := by
    by_cases h : x j=y
    · simp only [ite_eq_left h,product]
      apply prod_congr rfl
      intro i _
      by_cases hi : i=j
      · subst i; simp [q,h]
      · simp [q,hi]
    · simp only [ite_eq_right h]
      symm
      apply prod_eq_zero (mem_univ j)
      simp [q,h]
  have hq (i : I) : ∑ a,q i a=if i=j then p j y else 1 := by
    by_cases h : i=j
    · subst i; simp [q]
    · simp [q,h,hs i]
  unfold push
  simp_rw [he]
  rw [←Fintype.prod_sum]
  simp_rw [hq]
  simp

end Product


variable {B : Ω → Type*} [∀ a,Fintype (B a)]

noncomputable def sigmaLift (p : Ω → ℝ) (k : ∀ a,B a → ℝ) (s : Sigma B) : ℝ :=
  p s.1*k s.1 s.2

omit [Fintype Ω] [∀ a,Fintype (B a)] in
lemma sigmaLift_nonneg (p : Ω → ℝ) (k : ∀ a,B a → ℝ)
    (hp : ∀ a,0 ≤ p a) (hk : ∀ a b,0 ≤ k a b) (s : Sigma B) : 0 ≤ sigmaLift p k s :=
  mul_nonneg (hp _) (hk _ _)

lemma sigmaLift_sum (p : Ω → ℝ) (k : ∀ a,B a → ℝ)
    (hs : ∑ a,p a=1) (hk : ∀ a,∑ b,k a b=1) : ∑ s,sigmaLift p k s=1 := by
  simp only [sigmaLift,Fintype.sum_sigma,←mul_sum,hk,mul_one,hs]

lemma sigmaLift_tv (p q : Ω → ℝ) (k : ∀ a,B a → ℝ)
    (hk : ∀ a b,0 ≤ k a b) (hs : ∀ a,∑ b,k a b=1) :
    tv (sigmaLift p k) (sigmaLift q k)=tv p q := by
  simp only [tv,sigmaLift,Fintype.sum_sigma,←sub_mul,abs_mul,abs_of_nonneg (hk _ _),←mul_sum,hs,mul_one]


end MatchingFPRAS.Variation

namespace MatchingFPRAS.Transport

def tierBound (N D K : ℕ) : ℕ := N^2*(Nat.clog 2 D+2*K+2)

lemma base_block (N : ℕ) (hN : 0<N) : 2 ≤ (1+((N:ℝ)^2)⁻¹)^(N^2) := by
  have hp : (0:ℝ)<N := by exact_mod_cast hN
  have ha : -(2:ℝ)≤((N:ℝ)^2)⁻¹ := by
    have : (0:ℝ)≤((N:ℝ)^2)⁻¹ := by positivity
    linarith
  have h := one_add_mul_le_pow (a:=((N:ℝ)^2)⁻¹) ha (N^2)
  norm_cast at h
  have he : (N^2:ℝ)*((N:ℝ)^2)⁻¹=1 := mul_inv_cancel₀ (by positivity)
  norm_num only [Nat.cast_pow, he] at h
  linarith

lemma tierBound_reaches (N D K : ℕ) (hN : 0<N) :
    max (D:ℝ) (3*4^K) ≤ (1+((N:ℝ)^2)⁻¹)^(tierBound N D K) := by
  have hb := base_block N hN
  have hp : 0≤(1+((N:ℝ)^2)⁻¹)^(N^2) := by positivity
  have hD : (D:ℝ) ≤ 2^(Nat.clog 2 D) := by exact_mod_cast Nat.le_pow_clog (by decide : 1<2) D
  have hk : (3:ℝ)*4^K ≤ 2^(2*K+2) := by
    rw [pow_add,pow_mul]
    norm_num
    nlinarith [pow_pos (by norm_num : (0:ℝ)<4) K]
  have eD : Nat.clog 2 D ≤ Nat.clog 2 D+2*K+2 := by omega
  have eK : 2*K+2 ≤ Nat.clog 2 D+2*K+2 := by omega
  calc
    max (D:ℝ) (3*4^K) ≤ 2^(Nat.clog 2 D+2*K+2) := max_le
      (hD.trans (pow_le_pow_right₀ (by norm_num) eD))
      (hk.trans (pow_le_pow_right₀ (by norm_num) eK))
    _ ≤ _ := by
      unfold tierBound
      rw [pow_mul]
      exact pow_le_pow_left₀ (by norm_num) hb _

noncomputable def ladderTier (N D K : ℕ) (hN : 0<N) : ℕ :=
  Nat.find (⟨tierBound N D K,tierBound_reaches N D K hN⟩ :
    ∃ t : ℕ,max (D:ℝ) (3*4^K) ≤ (1+((N:ℝ)^2)⁻¹)^t)

lemma ladderTier_spec (N D K : ℕ) (hN : 0<N) :
    max (D:ℝ) (3*4^K) ≤ (1+((N:ℝ)^2)⁻¹)^(ladderTier N D K hN) := by
  exact Nat.find_spec (p:=fun t : ℕ => max (D:ℝ) (3*4^K) ≤ (1+((N:ℝ)^2)⁻¹)^t)
    ⟨tierBound N D K,tierBound_reaches N D K hN⟩

lemma ladderTier_le (N D K : ℕ) (hN : 0<N) : ladderTier N D K hN ≤ tierBound N D K :=
  Nat.find_min' _ (tierBound_reaches N D K hN)

lemma ladderTier_min (N D K : ℕ) (hN : 0<N) {t : ℕ} (ht : t<ladderTier N D K hN) :
    (1+((N:ℝ)^2)⁻¹)^t < max (D:ℝ) (3*4^K) := lt_of_not_ge (Nat.find_min _ ht)

lemma topClamp_eq (N D K : ℕ) (hN : 0<N) (hD : 0<D) (w : ℝ)
    (hw : (D:ℝ)⁻¹ ≤ w ∧ w ≤ 3*4^K) :
    tierClamp (1+((N:ℝ)^2)⁻¹) (ladderTier N D K hN) w=w := by
  have ht := ladderTier_spec N D K hN
  have hlo : ((1+((N:ℝ)^2)⁻¹)^(ladderTier N D K hN))⁻¹ ≤ w :=
    (inv_anti₀ (by exact_mod_cast hD) ((le_max_left _ _).trans ht)).trans hw.1
  have hhi : w ≤ (1+((N:ℝ)^2)⁻¹)^(ladderTier N D K hN) := hw.2.trans ((le_max_right _ _).trans ht)
  simp only [tierClamp,min_eq_right hhi,max_eq_right hlo]

end MatchingFPRAS.Transport

namespace MatchingFPRAS.FiniteChain

open Finset
open scoped Classical

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

lemma walk_nonneg (π : Ω → ℝ) (hp : ∀ a,0<π a) (C : Ω → Ω → ℝ)
    (hC : ∀ a b,0≤C a b) (z a : Ω) (n : ℕ) : 0 ≤ walk π C z n a := by
  induction n generalizing a with
  | zero => simp only [walk]; split_ifs <;> norm_num
  | succ n ih => exact sum_nonneg fun b _ => mul_nonneg (ih b) (div_nonneg (hC b a) (hp b).le)

lemma walk_sum (π : Ω → ℝ) (hp : ∀ a,0<π a) (C : Ω → Ω → ℝ)
    (hC : ∀ a,∑ b,C a b=π a) (z : Ω) (n : ℕ) : ∑ a,walk π C z n a=1 := by
  induction n with
  | zero => simp [walk]
  | succ n ih =>
    simp only [walk,kernel]
    rw [sum_comm]
    simp_rw [←mul_sum,←sum_div,hC,div_self (hp _).ne',mul_one]
    exact ih

end MatchingFPRAS.FiniteChain

namespace MatchingFPRAS.Transport

open Finset MatchingFPRAS.Replica MatchingFPRAS.Replica.Ladder

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

variable {bags : V → Finset J}

noncomputable local instance : Fintype (BagEdge bags) := Fintype.ofFinite _

noncomputable local instance : DecidableEq (PM (BagEdge.Incident (bags := bags))) := Classical.decEq _

def topSlot (T q : ℕ) (hq : 0<q) : Slot T q := toLex (0,⟨0,hq⟩)

lemma topSlot_tier (T q : ℕ) (hq : 0<q) : tier (topSlot T q hq)=T := by simp [tier,rank,topSlot]

omit [DecidableEq V] [DecidableEq J] in
lemma ladder_top_marginal (w : BagEdge bags → ℝ) (T q : ℕ) (hq : 0<q)
    (M : PM (BagEdge.Incident (bags := bags))) :
    Variation.push (ladderLaw w T q) (fun x => x (topSlot T q hq))=slotLaw w (topSlot T q hq) := by
  exact Variation.product_marginal (slotLaw w) (fun i => slotLaw_sum w i M) _

omit [DecidableEq V] [Fintype J] [DecidableEq J] in
lemma slotWeight_top (w : BagEdge bags → ℝ) (D K T q : ℕ) (hD : 0<D) (hq : 0<q)
    (hw : ∀ e,(D:ℝ)⁻¹ ≤ w e ∧ w e ≤ 3*4^K)
    (hT : max (D:ℝ) (3*4^K) ≤ (tierBase V)^T) :
    slotWeight w (topSlot T q hq)=w := by
  funext e
  have hlo : ((tierBase V)^T)⁻¹ ≤ w e :=
    (inv_anti₀ (by exact_mod_cast hD) ((le_max_left _ _).trans hT)).trans (hw e).1
  have hhi : w e ≤ (tierBase V)^T := (hw e).2.trans ((le_max_right _ _).trans hT)
  simp only [slotWeight,topSlot_tier,tierClamp,min_eq_right hhi,max_eq_right hlo]

end MatchingFPRAS.Transport

namespace MatchingFPRAS.Enlargement

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

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 _

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

noncomputable def revealLaw (w : V → V → ℝ) (K D : ℕ) (p : SourcePM w K → ℝ) : SourceMarked w K → ℝ :=
  Variation.sigmaLift p (Marking.conditional BagEdge.Incident (sourcePortions w K D))

lemma sourceBagWeight_pos (w : V → V → ℝ) (hw : ∀ x y,0<w x y) (K D : ℕ) (hD : 0<D)
    (e : BagEdge (sourceBags w K)) : 0<sourceBagWeight w K D e := by
  unfold sourceBagWeight
  exact add_pos_of_nonneg_of_pos (sourceRealPortion_nonneg w hw K e) (div_pos (bagHeight_pos w K _) (by exact_mod_cast hD))

lemma revealLaw_ideal (w : V → V → ℝ) (hw : ∀ x y,0<w x y) (K D : ℕ) (hD : 0<D) :
    revealLaw w K D (gibbs (sourceBagWeight w K D))=sourceLaw w K D := by
  funext a
  have hc (e : BagEdge (sourceBags w K)) : Marking.collapse (sourcePortions w K D) e≠0 := by
    rw [sourcePortions_collapse]
    exact (sourceBagWeight_pos w hw K D hD e).ne'
  have h := Marking.law_from_reveal BagEdge.Incident (sourcePortions w K D) hc a
  have he : Marking.collapse (sourcePortions w K D)=sourceBagWeight w K D :=
    sourcePortions_collapse w K D
  rw [he] at h
  have hz : Transport.partition (inc:=BagEdge.Incident) (sourceBagWeight w K D)=
      partitionWeight BagEdge.Incident (sourceBagWeight w K D) univ := by
    unfold Transport.partition partitionWeight matchingWeight
    congr 1
    ext M
    simp
  exact (show revealLaw w K D (gibbs (sourceBagWeight w K D)) a=
    sourceLaw w K D a from by
      unfold revealLaw Variation.sigmaLift gibbs matchingWeight
      rw [hz]
      exact h)

lemma revealLaw_tv (w : V → V → ℝ) (hw : ∀ x y,0<w x y) (K D : ℕ) (hD : 0<D)
    (p q : SourcePM w K → ℝ) :
    Variation.tv (revealLaw w K D p) (revealLaw w K D q)=Variation.tv p q := by
  apply Variation.sigmaLift_tv
  · intro M a
    unfold Marking.conditional
    apply prod_nonneg
    intro e _
    apply div_nonneg (sourcePortions_nonneg w hw K D _ _)
    rw [sourcePortions_collapse]
    exact (sourceBagWeight_pos w hw K D hD e).le
  · intro M
    apply Marking.conditional_sum
    intro e
    rw [sourcePortions_collapse]
    exact (sourceBagWeight_pos w hw K D hD e).ne'

theorem source_marked_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 : ℕ)
    (hT : max (sourceD (V:=V) K:ℝ) (3*4^K) ≤ (tierBase (SourceVertex V 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 q := ladderQ N D
    ∃ hq : 0<q,
      let wt := sourceBagWeight w K D
      let ν := ladderLaw wt T q
      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 q
      let p := Variation.push (MatchingFPRAS.FiniteChain.walk ν C z (ladderSteps N D K T ξ))
        (fun a => a (topSlot T q hq))
      Variation.tv (revealLaw w K D p) (sourceLaw w K D) ≤ ξ := by
  dsimp only
  let D := sourceD (V:=V) K
  let N := Fintype.card (SourceVertex V K)
  have hd : 0<D := lt_of_lt_of_le (by decide) (sourceD_one K)
  have hn' : 0<N := lt_of_lt_of_le (by decide : 0<2) (hn.trans (sourceVertex_card_ge K))
  have hq : 0<ladderQ N D := by unfold ladderQ ladderL; positivity
  refine ⟨hq,?_⟩
  rw [←revealLaw_ideal w hw K D hd,revealLaw_tv w hw K D hd]
  have hm := ladder_top_marginal (sourceBagWeight w K D) T (ladderQ N D) hq M₀
  have he := slotWeight_top (sourceBagWeight w K D) D K T (ladderQ N D) hd hq
    (sourceBagWeight_global w K D (sourceD_one K) hw hK) hT
  unfold slotLaw at hm
  rw [he] at hm
  change Variation.push (ladderLaw (sourceBagWeight w K D) T (ladderQ N D))
    (fun a => a (topSlot T (ladderQ N D) hq))=gibbs (sourceBagWeight w K D) at hm
  rw [←hm]
  apply (Variation.push_contraction _ _ _).trans
  exact source_ladder_sampling hn w hw K hK M₀ T z ξ hξ hξ1

end MatchingFPRAS.Enlargement

end OAI