lean/OAI/Combinatorics/MatchingCount/Sampling/LadderL.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.Evolve

namespace OAI

namespace MatchingFPRAS.Transport

section

open Finset MatchingFPRAS.Replica MatchingFPRAS.Replica.Ladder

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

variable {bags : V → Finset J} {G : SimpleGraph J}

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

omit [DecidableEq J] in
theorem ladder_minimum_mass
    (hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b)
    (hG : G.IsAcyclic) (D K : ℕ) (hD : 1 ≤ D) (hN : 2 ≤ Fintype.card V)
    (w : BagEdge bags → ℝ)
    (hw : ∀ e, (D:ℝ)⁻¹ ≤ w e ∧ w e ≤ 3*4^K) (T q : ℕ)
    (z : Slot T q → PM (BagEdge.Incident (bags := bags))) :
    Real.log ((ladderLaw w T q z)⁻¹) ≤
      (10*Fintype.card V*q*(T+1)*(K+Nat.clog 2 (Fintype.card V*D+2)+1):ℕ) := by
  have hl := ladderLaw_power_lower hbags hG D K hD hN w hw T q z
  have hp : 0 < ladderLaw w T q z := by
    apply Finset.prod_pos; intro x _; exact slotLaw_pos w x (z x)
  have hu := inv_anti₀ (by positivity : (0:ℝ) < ((2:ℝ)^(10*Fintype.card V*q*(T+1)*(K+Nat.clog 2 (Fintype.card V*D+2)+1)))⁻¹) hl
  rw [inv_inv] at hu
  have hh := Real.log_le_log (inv_pos.mpr hp) hu
  rw [Real.log_pow] at hh
  have hlog : Real.log 2 ≤ 1 := by
    have h := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<2)
    linarith
  have hΛ : (0:ℝ) ≤ (10*Fintype.card V*q*(T+1)*(K+Nat.clog 2 (Fintype.card V*D+2)+1):ℕ) := Nat.cast_nonneg _
  exact hh.trans (by simpa only [mul_one] using mul_le_mul_of_nonneg_left hlog hΛ)

end

def ladderL (N D : ℕ) : ℕ := (10^4*N*D)^100

def ladderQ (N D : ℕ) : ℕ := 32*ladderL N D

def ladderM (N D T : ℕ) : ℕ := T*(ladderQ N D)^2+ladderQ N D

def ladderLambda (N D K T : ℕ) : ℕ :=
  10*N*ladderQ N D*(T+1)*(K+Nat.clog 2 (N*D+2)+1)

noncomputable def ladderSteps (N D K T : ℕ) (ξ : ℝ) : ℕ :=
  20*ladderL N D*ladderM N D T*(ladderLambda N D K T+⌈Real.logb 2 ξ⁻¹⌉₊+1)

end MatchingFPRAS.Transport

namespace MatchingFPRAS.FiniteChain

lemma log_inv_le_ceil_logb {ξ : ℝ} (hξ : 0 < ξ) (hξ1 : ξ < 1) :
    -Real.log ξ ≤ (⌈Real.logb 2 ξ⁻¹⌉₊:ℝ) := by
  have hlog2 : 0 < Real.log 2 := Real.log_pos (by norm_num)
  have hlog21 : Real.log 2 ≤ 1 := by
    have h := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<2)
    linarith
  have hxi : 1 ≤ ξ⁻¹ := (one_le_inv₀ hξ).mpr hξ1.le
  have hlogxi : 0 ≤ Real.log ξ⁻¹ := Real.log_nonneg hxi
  have hb : 0 ≤ Real.logb 2 ξ⁻¹ := div_nonneg hlogxi hlog2.le
  have he : Real.logb 2 ξ⁻¹*Real.log 2 = -Real.log ξ := by
    rw [Real.logb,div_mul_cancel₀ _ hlog2.ne',Real.log_inv]
  exact (by nlinarith : -Real.log ξ ≤ Real.logb 2 ξ⁻¹).trans (Nat.le_ceil _)

lemma mixing_at_steps {a u γ Λ ξ : ℝ} {n b : ℕ}
    (ha : 0 ≤ a) (hu : 0 < u) (hγ : γ ≤ 1) (hΛ : 0 ≤ Λ)
    (hξ : 0 < ξ) (hb : -Real.log ξ ≤ (b:ℝ))
    (hmass : Real.log u⁻¹ ≤ Λ)
    (hsteps : 2*(Λ+(b:ℝ)+1) ≤ γ*n)
    (hmix : a^2 ≤ (1-γ)^n*(u⁻¹-1)) : a/2 ≤ ξ := by
  have hmass' : u⁻¹ ≤ Real.exp Λ := (Real.log_le_iff_le_exp (inv_pos.mpr hu)).mp hmass
  have hp : 0 ≤ 1-γ := by linarith
  have he : (1-γ)^n ≤ Real.exp (-γ*(n:ℝ)) := by
    calc
      _ ≤ (Real.exp (-γ))^n := pow_le_pow_left₀ hp (Real.one_sub_le_exp_neg γ) n
      _ = _ := by rw [← Real.exp_nat_mul]; congr 1; ring
  have hsq : a^2 ≤ ξ^2 := by
    calc
      _ ≤ (1-γ)^n*(u⁻¹-1) := hmix
      _ ≤ (1-γ)^n*Real.exp Λ := mul_le_mul_of_nonneg_left (by linarith) (pow_nonneg hp _)
      _ ≤ Real.exp (-γ*(n:ℝ))*Real.exp Λ := mul_le_mul_of_nonneg_right he (Real.exp_pos _).le
      _ = Real.exp (-γ*(n:ℝ)+Λ) := (Real.exp_add _ _).symm
      _ ≤ Real.exp (2*Real.log ξ) := Real.exp_le_exp.mpr (by linarith)
      _ = ξ^2 := by rw [show (2:ℝ)=(2:ℕ) by norm_num,Real.exp_nat_mul,Real.exp_log hξ]
  nlinarith

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} {G : SimpleGraph J}

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

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

theorem ideal_ladder_sampling
    (hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b)
    (hG : G.IsAcyclic) (height : J → ℝ) (hheight : ∀ l, 0 < height l)
    (hstep : ∀ a b, G.Adj a b → height a ≤ 2*height b)
    (D K : ℕ) (hD : 1 ≤ D) (hN : 2 ≤ Fintype.card V) (w : BagEdge bags → ℝ)
    (hw : ∀ e, height e.color / D ≤ w e ∧ w e ≤ 3*height e.color)
    (hglobal : ∀ e, (D:ℝ)⁻¹ ≤ w e ∧ w e ≤ 3*4^K)
    (M₀ : PM (BagEdge.Incident (bags := bags))) (T : ℕ)
    (z : Slot T (ladderQ (Fintype.card V) D) → PM (BagEdge.Incident (bags := bags)))
    (ξ : ℝ) (hξ : 0 < ξ) (hξ1 : ξ < 1) :
    let ν := ladderLaw w T (ladderQ (Fintype.card V) D)
    let C := ladderFlow hbags hG w T (ladderQ (Fintype.card V) D)
    (∑ s, |MatchingFPRAS.FiniteChain.walk ν C z (ladderSteps (Fintype.card V) D K T ξ) s-ν s|)/2 ≤ ξ := by
  classical
  dsimp only
  let N := Fintype.card V
  let L := ladderL N D
  let q := ladderQ N D
  let M := ladderM N D T
  let Λ := ladderLambda N D K T
  let b := ⌈Real.logb 2 ξ⁻¹⌉₊
  let ν := ladderLaw w T q
  let C := ladderFlow hbags hG w T q
  let n := ladderSteps N D K T ξ
  let γ : ℝ := 3/(8*(M:ℝ))
  have hL0 : 0 < L := by
    have hn : 0 < N := by dsimp [N]; omega
    have hd : 0 < D := by omega
    dsimp [L,ladderL]; positivity
  have hq0 : 0 < q := by dsimp [q,ladderQ]; exact Nat.mul_pos (by decide) hL0
  have hM0 : 0 < M := by dsimp [M,ladderM]; omega
  have hMr : (0:ℝ) < M := by exact_mod_cast hM0
  have hLr : (1:ℝ) ≤ L := by exact_mod_cast hL0
  have hΛr : (0:ℝ) ≤ Λ := Nat.cast_nonneg _
  have hγ : γ ≤ 1 := by
    dsimp [γ]
    apply (div_le_one (by positivity : (0:ℝ)<8*M)).mpr
    have hm : (1:ℝ) ≤ M := by exact_mod_cast hM0
    linarith
  have hsteps : 2*((Λ:ℝ)+(b:ℝ)+1) ≤ γ*(n:ℝ) := by
    have hb0 : (0:ℝ) ≤ b := Nat.cast_nonneg _
    have hfac : (0:ℝ) ≤ (Λ:ℝ)+(b:ℝ)+1 := by positivity
    calc
      _ ≤ ((15:ℝ)/2)*(L:ℝ)*((Λ:ℝ)+(b:ℝ)+1) :=
        mul_le_mul_of_nonneg_right (by linarith) hfac
      _ = _ := by
        dsimp [γ,n,ladderSteps,L,M,Λ,b]
        push_cast
        have hm0 : (ladderM N D T:ℝ) ≠ 0 := hMr.ne'
        field_simp [hm0]
        ring
  have hp : 0 < ν z := by
    apply Finset.prod_pos; intro i _; exact slotLaw_pos w i (z i)
  have hmass : Real.log ((ν z)⁻¹) ≤ (Λ:ℝ) :=
    ladder_minimum_mass hbags hG D K hD hN w hglobal T q z
  have hmix := concrete_ladder_mixing (hbags := hbags) (hG := hG)
    height hheight hstep D hD w hw hN M₀ T z n
  dsimp only at hmix
  have hmix' : (∑ s, |MatchingFPRAS.FiniteChain.walk ν C z n s-ν s|)^2 ≤
      (1-γ)^n*((ν z)⁻¹-1) := by
    simp only [γ,ν,C,q,M,ladderM,ladderQ,ladderL,N,Nat.cast_mul,Nat.cast_ofNat] at hmix ⊢
    convert hmix using 1
    congr 4
  exact MatchingFPRAS.FiniteChain.mixing_at_steps
    (Finset.sum_nonneg (fun _ _ => abs_nonneg _)) hp hγ hΛr hξ
    (MatchingFPRAS.FiniteChain.log_inv_le_ceil_logb hξ hξ1) hmass hsteps hmix'

end MatchingFPRAS.Transport

end OAI