import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreePairProposal
import OAI.Combinatorics.MatchingCount.Graphs.PushedFlow

namespace OAI

namespace MatchingFPRAS.FiniteChain

open Finset MatchingFPRAS.Replica

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

noncomputable def evolve (π : Ω → ℝ) (C : Ω → Ω → ℝ) : ℕ → (Ω → ℝ) → (Ω → ℝ)
  | 0, f => f
  | n+1, f => stepDensity π C (evolve π C n f)

omit [DecidableEq Ω] in
lemma evolve_mean (π : Ω → ℝ) (hp : ∀ a, 0 < π a) (C : Ω → Ω → ℝ)
    (hrow : ∀ a, ∑ b, C a b = π a) (n : ℕ) (f : Ω → ℝ) :
    massMean π (evolve π C n f) = massMean π f := by
  induction n with
  | zero => rfl
  | succ n ih => rw [evolve,stepDensity_mean π hp C hrow,ih]

omit [DecidableEq Ω] in
lemma evolve_center (π : Ω → ℝ) (hp : ∀ a, 0 < π a) (C : Ω → Ω → ℝ)
    (hcol : ∀ b, ∑ a, C a b = π b) (n : ℕ) (f : Ω → ℝ) :
    evolve π C n (fun a => f a-1) = fun a => evolve π C n f a-1 := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [evolve,ih]
    have he : (fun a => evolve π C n f a-1) = fun a => 1*evolve π C n f a+(-1)*(1:ℝ) := by funext a; ring
    rw [he,stepDensity_linear,stepDensity_one π hp C hcol]
    funext a; ring

lemma lazy_decay (π : Ω → ℝ) (hp : ∀ a, 0 < π a) (C : Ω → Ω → ℝ)
    (hC : ∀ a b, 0 ≤ C a b) (hrow : ∀ a, ∑ b, C a b = π a)
    (hcol : ∀ b, ∑ a, C a b = π b) (hlazy : ∀ a, π a/2 ≤ C a a)
    (γ : ℝ) (hγ : γ ≤ 1)
    (hgap : ∀ f, massMean π f = 0 → γ*sqNorm π f ≤ localEnergy C f)
    (f : Ω → ℝ) (hf : massMean π f = 0) (n : ℕ) :
    sqNorm π (evolve π C n f) ≤ (1-γ)^n*sqNorm π f := by
  induction n with
  | zero => simp [evolve]
  | succ n ih =>
    have hm : massMean π (evolve π C n f) = 0 := (evolve_mean π hp C hrow n f).trans hf
    have hl := lazy_l2 π hp C hC hrow hcol hlazy (evolve π C n f)
    have hg := hgap (evolve π C n f) hm
    have hh := mul_le_mul_of_nonneg_left ih (sub_nonneg.mpr hγ)
    rw [evolve,pow_succ]
    nlinarith

noncomputable def deltaDensity (π : Ω → ℝ) (z a : Ω) : ℝ := if a=z then (π z)⁻¹ else 0

lemma deltaDensity_mean (π : Ω → ℝ) (hp : ∀ a, 0 < π a) (z : Ω) :
    massMean π (deltaDensity π z) = 1 := by
  simp [massMean,deltaDensity,mul_ite,ne_of_gt (hp z)]

omit [DecidableEq Ω] in
lemma sqNorm_center (π f : Ω → ℝ) (hs : ∑ a, π a = 1) :
    sqNorm π (fun a => f a-1) = sqNorm π f-2*massMean π f+1 := by
  have he (a : Ω) : π a*(f a-1)^2 = π a*(f a)^2-2*(π a*f a)+π a := by ring
  simp only [sqNorm,massMean,he,Finset.sum_add_distrib,Finset.sum_sub_distrib,← Finset.mul_sum,hs]

lemma deltaDensity_sqNorm (π : Ω → ℝ) (_hp : ∀ a, 0 < π a) (z : Ω) :
    sqNorm π (deltaDensity π z) = (π z)⁻¹ := by
  simp only [sqNorm,deltaDensity,ite_pow,zero_pow (by decide : (2:ℕ) ≠ 0),mul_ite,mul_zero,
    Finset.sum_ite_eq',Finset.mem_univ,ite_true]
  field_simp

lemma deltaDensity_center_norm (π : Ω → ℝ) (hp : ∀ a, 0 < π a) (hs : ∑ a, π a = 1) (z : Ω) :
    sqNorm π (fun a => deltaDensity π z a-1) = (π z)⁻¹-1 := by
  rw [sqNorm_center π _ hs,deltaDensity_sqNorm π hp,deltaDensity_mean π hp]
  ring

omit [DecidableEq Ω] in
lemma abs_sum_sq_le (π f : Ω → ℝ) (hp : ∀ a, 0 ≤ π a) (hs : ∑ a, π a = 1) :
    (∑ a, |π a*f a|)^2 ≤ sqNorm π f := by
  have hh := square_average π hp hs (fun a => |f a|)
  simpa only [abs_mul,abs_of_nonneg (hp _),sq_abs,sqNorm] using hh

noncomputable def kernel (π : Ω → ℝ) (C : Ω → Ω → ℝ) (a b : Ω) : ℝ := C a b/π a

noncomputable def walk (π : Ω → ℝ) (C : Ω → Ω → ℝ) (z : Ω) : ℕ → Ω → ℝ
  | 0, a => if a=z then 1 else 0
  | n+1, b => ∑ a, walk π C z n a*kernel π C a b

lemma walk_density (π : Ω → ℝ) (hp : ∀ a, 0 < π a) (C : Ω → Ω → ℝ) (z : Ω) (n : ℕ) (a : Ω) :
    walk π C z n a = π a*evolve π C n (deltaDensity π z) a := by
  induction n generalizing a with
  | zero =>
    by_cases h : a=z
    · subst a; simp [walk,evolve,deltaDensity,ne_of_gt (hp z)]
    · simp [walk,evolve,deltaDensity,h]
  | succ n ih =>
    simp only [walk,ih,kernel,evolve,stepDensity,mul_div_cancel₀ _ (ne_of_gt (hp a))]
    apply Finset.sum_congr rfl
    intro b _
    field_simp [ne_of_gt (hp b)]

lemma meeting_bound (π : Ω → ℝ) (hp : ∀ a, 0 < π a) (hs : ∑ a, π a = 1)
    (C : Ω → Ω → ℝ) (hC : ∀ a b, 0 ≤ C a b)
    (hrow : ∀ a, ∑ b, C a b = π a) (hcol : ∀ b, ∑ a, C a b = π b)
    (hlazy : ∀ a, π a/2 ≤ C a a) (γ : ℝ) (hγ : γ ≤ 1)
    (hgap : ∀ f, massMean π f = 0 → γ*sqNorm π f ≤ localEnergy C f)
    (z : Ω) (n : ℕ) :
    (∑ a, |walk π C z n a-π a|)^2 ≤ (1-γ)^n*((π z)⁻¹-1) := by
  let f : Ω → ℝ := fun a => deltaDensity π z a-1
  have hf : massMean π f = 0 := by
    simp only [f,massMean,mul_sub,mul_one,Finset.sum_sub_distrib,hs]
    change massMean π (deltaDensity π z)-1=0
    rw [deltaDensity_mean π hp]; ring
  have hb := lazy_decay π hp C hC hrow hcol hlazy γ hγ hgap f hf n
  have ha := abs_sum_sq_le π (evolve π C n f) (fun a => (hp a).le) hs
  have he : (fun a => π a*evolve π C n f a) = fun a => walk π C z n a-π a := by
    funext a
    dsimp only [f]
    rw [evolve_center π hp C hcol,walk_density π hp C z n]
    ring
  have hh : (∑ a, |π a*evolve π C n f a|) = ∑ a, |walk π C z n a-π a| := by
    exact congrArg (fun g : Ω → ℝ => ∑ a, |g a|) he
  rw [hh] at ha
  have hn : sqNorm π f = (π z)⁻¹-1 := deltaDensity_center_norm π hp hs z
  rw [hn] at hb
  exact ha.trans hb

end MatchingFPRAS.FiniteChain

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 _

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

noncomputable def ladderLaw (w : BagEdge bags → ℝ) (T q : ℕ) :
    (Slot T q → PM (BagEdge.Incident (bags := bags))) → ℝ := density (slotLaw w)

noncomputable def ladderFlow
    (hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b)
    (hG : G.IsAcyclic) (w : BagEdge bags → ℝ) (T q : ℕ) :
    (Slot T q → PM (BagEdge.Incident (bags := bags))) →
      (Slot T q → PM (BagEdge.Incident (bags := bags))) → ℝ :=
  scanFlow (slotLaw w) guides (base T q) (treeLadderCapacity hbags hG w)

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

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

variable {hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b}

variable {hG : G.IsAcyclic}

variable (height : J → ℝ) (hheight : ∀ l, 0 < height l)

variable (hstep : ∀ a b, G.Adj a b → height a ≤ 2 * height b)

variable (D : ℕ) (hD : 1 ≤ D) (w : BagEdge bags → ℝ)

variable (hw : ∀ e, height e.color / D ≤ w e ∧ w e ≤ 3 * height e.color)

include hheight hstep hD hw hbags hG

theorem concrete_ladder_mixing (hN : 2 ≤ Fintype.card V)
    (M₀ : PM (BagEdge.Incident (bags := bags))) (T : ℕ)
    (z : Slot T (32*(10^4*Fintype.card V*D)^100) → PM (BagEdge.Incident (bags := bags)))
    (n : ℕ) :
    let q := 32*(10^4*Fintype.card V*D)^100
    let ν := ladderLaw w T q
    let C := ladderFlow hbags hG w T q
    (∑ s, |MatchingFPRAS.FiniteChain.walk ν C z n s-ν s|)^2 ≤
      (1-3/((8*(T*q^2+q):ℕ):ℝ))^n*((ν z)⁻¹-1) := by
  classical
  dsimp only
  let q : ℕ := 32*(10^4*Fintype.card V*D)^100
  let ν := ladderLaw w T q
  let C := ladderFlow hbags hG w T q
  have hq : 0 < q := by
    have hV : 0 < Fintype.card V := lt_of_lt_of_le (by norm_num) hN
    have hd : 0 < D := lt_of_lt_of_le (by norm_num) hD
    dsimp [q]; positivity
  have hM : 0 < ((8*(T*q^2+q):ℕ):ℝ) := by exact_mod_cast (by omega : 0 < 8*(T*q^2+q))
  have hp (s) : 0 < ν s := by
    apply Finset.prod_pos; intro i _; exact slotLaw_pos w i (s i)
  have hs : (∑ s, ν s) = 1 := density_sum (slotLaw w) (fun i => slotLaw_sum w i M₀)
  have hbase : (base T q).Nonempty := Finset.card_pos.mp (by rw [base_card]; exact hq)
  have hC (s t) : 0 ≤ C s t := scanFlow_nonneg (slotLaw w) (fun i a => (slotLaw_pos w i a).le)
    guides (base T q) (treeLadderCapacity hbags hG w) s t
  have hrow (s) : (∑ t, C s t) = ν s := scanFlow_row (slotLaw w) (fun i => slotLaw_sum w i M₀)
    guides (base T q) hbase (treeLadderCapacity hbags hG w) s
  have hcol (t) : (∑ s, C s t) = ν t := scanFlow_col (slotLaw w) (fun i => slotLaw_sum w i M₀)
    guides (base T q) hbase (treeLadderCapacity hbags hG w) t
  have hlazy (s) : ν s/2 ≤ C s s := scanFlow_lazy (slotLaw w) (fun i a => (slotLaw_pos w i a).le)
    guides (base T q) (treeLadderCapacity hbags hG w) s
  have hγ : 3/((8*(T*q^2+q):ℕ):ℝ) ≤ 1 := by
    apply (div_le_one hM).mpr
    exact_mod_cast (by omega : 3 ≤ 8*(T*q^2+q))
  have hgap (f) (hf : MatchingFPRAS.FiniteChain.massMean ν f = 0) :
      (3/((8*(T*q^2+q):ℕ):ℝ))*MatchingFPRAS.FiniteChain.sqNorm ν f ≤ localEnergy C f := by
    have hh := concrete_ladder_poincare (hbags := hbags) (hG := hG) height hheight hstep D hD w hw hN M₀ T f
    dsimp only at hh
    have hv : MatchingFPRAS.Replica.variance (slotLaw w) f = MatchingFPRAS.FiniteChain.sqNorm ν f := by
      have hm : MatchingFPRAS.Replica.mean (slotLaw w) f = 0 := hf
      unfold MatchingFPRAS.Replica.variance MatchingFPRAS.Replica.dot
      simp only [hm,Pi.sub_apply,sub_zero]
      unfold MatchingFPRAS.FiniteChain.sqNorm
      apply Finset.sum_congr rfl
      intro s _; change ν s*f s*f s=ν s*(f s)^2; ring
    rw [hv] at hh
    have he : localEnergy C f = scanEnergy (slotLaw w) guides (base T q) (treeLadderCapacity hbags hG w) f :=
      scanFlow_energy (slotLaw w) (fun i => slotLaw_sum w i M₀) guides (base T q) (treeLadderCapacity hbags hG w) f
    rw [← he] at hh
    change MatchingFPRAS.FiniteChain.sqNorm ν f ≤ ((8*(T*q^2+q):ℕ):ℝ)/3*localEnergy C f at hh
    rw [div_mul_eq_mul_div]
    apply (div_le_iff₀ hM).mpr
    linarith

  exact MatchingFPRAS.FiniteChain.meeting_bound ν hp hs C hC hrow hcol hlazy
    (3/((8*(T*q^2+q):ℕ):ℝ)) hγ hgap z n

end

section

open Finset

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

variable {inc : E → V → Prop}

noncomputable def chosenEdge (A : PM inc) (v : V) : E :=
  Classical.choose (A.property.2 v (mem_univ v))

omit [DecidableEq V] [Fintype E] [DecidableEq E] in
lemma chosenEdge_mem (A : PM inc) (v : V) : chosenEdge A v ∈ A.val :=
  (Classical.choose_spec (A.property.2 v (mem_univ v))).1.1

omit [DecidableEq V] [Fintype E] [DecidableEq E] in
lemma chosenEdge_incident (A : PM inc) (v : V) : inc (chosenEdge A v) v :=
  (Classical.choose_spec (A.property.2 v (mem_univ v))).1.2

omit [DecidableEq V] [Fintype E] [DecidableEq E] in
lemma chosenEdge_injective (hinc : ∀ e, ∃ v, inc e v) :
    Function.Injective (chosenEdge (inc := inc)) := by
  intro A B h
  apply Subtype.ext; ext e
  have hh (A B : PM inc) (h : chosenEdge A = chosenEdge B) : e ∈ A.val → e ∈ B.val := by
    intro he
    obtain ⟨v,hv⟩ := hinc e
    have heq : e = chosenEdge A v := A.property.unique (mem_univ v) he hv
      (chosenEdge_mem A v) (chosenEdge_incident A v)
    rw [heq,congrFun h v]
    exact chosenEdge_mem B v
  exact ⟨hh A B h,hh B A h.symm⟩

omit [DecidableEq E] in
lemma pm_card_le (hinc : ∀ e, ∃ v, inc e v) :
    Fintype.card (PM inc) ≤ Fintype.card E ^ Fintype.card V := by
  classical
  simpa only [Fintype.card_fun] using Fintype.card_le_of_injective chosenEdge (chosenEdge_injective hinc)

omit [DecidableEq V] [DecidableEq E] in
lemma gibbs_mass_lower (hinc : ∀ e, ∃ v, inc e v) (w : E → ℝ)
    (D B : ℝ) (hD : 1 ≤ D) (hB : 1 ≤ B)
    (hw : ∀ e, D⁻¹ ≤ w e ∧ w e ≤ B) (A : PM inc) :
    (Fintype.card (PM inc)*(D*B)^Fintype.card V)⁻¹ ≤ gibbs w A := by
  classical
  have hD0 : 0 < D := by linarith
  have hB0 : 0 < B := by linarith
  have hw0 : ∀ e, 0 < w e := fun e => (inv_pos.mpr hD0).trans_le (hw e).1
  have lower (M : PM inc) : (D^Fintype.card V)⁻¹ ≤ matchingWeight w M := by
    have hh : (D⁻¹)^M.val.card ≤ matchingWeight w M := by
      simpa only [matchingWeight,Finset.prod_const] using Finset.prod_le_prod₀
        (fun e (_ : e ∈ M.val) => (inv_pos.mpr hD0).le) (fun e _ => (hw e).1)
    rw [inv_pow] at hh
    exact (inv_anti₀ (pow_pos hD0 _) (pow_le_pow_right₀ hD (PM.card_le_vertices hinc M))).trans hh
  have upper (M : PM inc) : matchingWeight w M ≤ B^Fintype.card V := by
    have hh : matchingWeight w M ≤ B^M.val.card := by
      simpa only [matchingWeight,Finset.prod_const] using Finset.prod_le_prod₀
        (fun e (_ : e ∈ M.val) => (hw0 e).le) (fun e _ => (hw e).2)
    exact hh.trans (pow_le_pow_right₀ hB (PM.card_le_vertices hinc M))
  have hc : 0 < (Fintype.card (PM inc):ℝ) := by
    have : Nonempty (PM inc) := ⟨A⟩
    exact_mod_cast Fintype.card_pos
  have hz : partition (inc := inc) w ≤ Fintype.card (PM inc)*B^Fintype.card V := by
    have he : partition (inc := inc) w = ∑ M : PM inc, matchingWeight w M := by
      unfold partition
      congr
      exact Subsingleton.elim _ _
    rw [he]
    calc
      _ ≤ ∑ _M : PM inc, B^Fintype.card V := Finset.sum_le_sum (fun M _ => upper M)
      _ = _ := by simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
  have hp := partition_pos w hw0 A
  have hden : 0 < (Fintype.card (PM inc):ℝ)*B^Fintype.card V := mul_pos hc (pow_pos hB0 _)
  calc
    _ = (D^Fintype.card V)⁻¹/(Fintype.card (PM inc)*B^Fintype.card V) := by
      rw [mul_pow]; field_simp
    _ ≤ matchingWeight w A/partition (inc := inc) w :=
      div_le_div₀ (matchingWeight_pos w hw0 A).le (lower A) hp hz
    _ = _ := rfl

end

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 _

lemma tierClamp_range {c lo hi w : ℝ} (hc : 1 ≤ c) (hlo : lo ≤ 1) (hhi : 1 ≤ hi)
    (hw : lo ≤ w ∧ w ≤ hi) (t : ℕ) : lo ≤ tierClamp c t w ∧ tierClamp c t w ≤ hi := by
  have hp : 1 ≤ c^t := one_le_pow₀ hc
  have hip : (c^t)⁻¹ ≤ 1 := inv_le_one_of_one_le₀ hp
  constructor
  · exact le_trans (le_min (hlo.trans hp) hw.1) (le_max_right _ _)
  · exact max_le (hip.trans hhi) ((min_le_right _ _).trans hw.2)

omit [DecidableEq V] [Fintype J] [DecidableEq J] in
lemma slotWeight_range (D K : ℕ) (hD : 1 ≤ D) (w : BagEdge bags → ℝ)
    (hw : ∀ e, (D:ℝ)⁻¹ ≤ w e ∧ w e ≤ 3*4^K) {T q : ℕ} (x : Slot T q) (e : BagEdge bags) :
    (D:ℝ)⁻¹ ≤ slotWeight w x e ∧ slotWeight w x e ≤ 3*4^K := by
  apply tierClamp_range
  · unfold tierBase; exact le_add_of_nonneg_right (by positivity)
  · apply inv_le_one_of_one_le₀; exact_mod_cast hD
  · have h : (1:ℝ) ≤ 4^K := one_le_pow₀ (by norm_num)
    linarith
  · exact hw e

omit [DecidableEq J] in
lemma bag_pm_card_le
    (hbags : ∀ v, ∀ a ∈ bags v, ∀ b ∈ bags v, a = b ∨ G.Adj a b)
    (hG : G.IsAcyclic) :
    Fintype.card (PM (BagEdge.Incident (bags := bags))) ≤ (2*Fintype.card V^2)^Fintype.card V := by
  apply (pm_card_le BagEdge.exists_incident).trans
  exact Nat.pow_le_pow_left (bag_edges_card_le hbags hG) _

lemma denominator_power_bound (N D K : ℕ) (hN : 2 ≤ N) (hD : 1 ≤ D) :
    ((2*(N:ℝ)^2)^N)*((D:ℝ)*(3*4^K))^N ≤
      (2:ℝ)^(10*N*(K+Nat.clog 2 (N*D+2)+1)) := by
  let a := Nat.clog 2 (N*D+2)
  have hp : (N*D+2:ℝ) ≤ (2:ℝ)^a := by exact_mod_cast Nat.le_pow_clog (by decide : 1 < 2) (N*D+2)
  have hn : (N:ℝ) ≤ 2^a := by
    have hd : (1:ℝ) ≤ D := by exact_mod_cast hD
    have hn0 : (0:ℝ) ≤ N := Nat.cast_nonneg N
    have hnd : (N:ℝ) ≤ N*D := by nlinarith
    exact hnd.trans (le_trans (by linarith) hp)
  have hd : (D:ℝ) ≤ 2^a := by
    have hn2 : (2:ℝ) ≤ N := by exact_mod_cast hN
    have hd0 : (0:ℝ) ≤ D := Nat.cast_nonneg D
    have hnd : (D:ℝ) ≤ N*D := by nlinarith
    exact hnd.trans (le_trans (by linarith) hp)
  have hfour : (4:ℝ)^K = 2^(2*K) := by rw [pow_mul]; norm_num
  have hb : 2*(N:ℝ)^2*((D:ℝ)*(3*4^K)) ≤ 2^(3+3*a+2*K) := by
    calc
      _ ≤ 2*(2^a)^2*((2^a)*(3*4^K)) := mul_le_mul
        (mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (Nat.cast_nonneg N) hn 2) (by norm_num))
        (mul_le_mul_of_nonneg_right hd (by positivity)) (by positivity) (by positivity)
      _ ≤ 2*(2^a)^2*((2^a)*(4*4^K)) := by
        apply mul_le_mul_of_nonneg_left _ (by positivity)
        apply mul_le_mul_of_nonneg_left _ (by positivity)
        exact mul_le_mul_of_nonneg_right (by norm_num : (3:ℝ) ≤ 4) (by positivity)
      _ = _ := by
        rw [hfour]
        calc
          _ = (2:ℝ)^3*2^(a*2)*2^a*2^(2*K) := by rw [pow_mul]; norm_num; ring
          _ = _ := by simp only [← pow_add]; congr 1; omega
  calc
    _ = (2*(N:ℝ)^2*((D:ℝ)*(3*4^K)))^N := (mul_pow _ _ _).symm
    _ ≤ (2^(3+3*a+2*K))^N := pow_le_pow_left₀ (by positivity) hb N
    _ = (2:ℝ)^((3+3*a+2*K)*N) := (pow_mul _ _ _).symm
    _ ≤ _ := pow_le_pow_right₀ (by norm_num) (by dsimp only [a]; nlinarith)

end

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
lemma slotLaw_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 : ℕ} (x : Slot T q) (A : PM (BagEdge.Incident (bags := bags))) :
    ((2:ℝ)^(10*Fintype.card V*(K+Nat.clog 2 (Fintype.card V*D+2)+1)))⁻¹ ≤ slotLaw w x A := by
  have hl := gibbs_mass_lower BagEdge.exists_incident (slotWeight w x) D (3*4^K)
    (by exact_mod_cast hD) (by
      have hh : (1:ℝ) ≤ 4^K := one_le_pow₀ (by norm_num)
      linarith)
    (slotWeight_range D K hD w hw x) A
  have hc : (Fintype.card (PM (BagEdge.Incident (bags := bags))):ℝ) ≤
      (2*Fintype.card V^2:ℝ)^Fintype.card V := by exact_mod_cast bag_pm_card_le hbags hG
  have hd := (mul_le_mul_of_nonneg_right hc (by positivity : (0:ℝ) ≤ ((D:ℝ)*(3*4^K))^Fintype.card V)).trans
    (denominator_power_bound (Fintype.card V) D K hN hD)
  have hp : 0 < (Fintype.card (PM (BagEdge.Incident (bags := bags))):ℝ)*
      ((D:ℝ)*(3*4^K))^Fintype.card V := by
    have : Nonempty (PM (BagEdge.Incident (bags := bags))) := ⟨A⟩
    have hc0 : (0:ℝ) < Fintype.card (PM (BagEdge.Incident (bags := bags))) := by exact_mod_cast Fintype.card_pos
    have hd0 : (0:ℝ) < D := by exact_mod_cast (by omega : 0 < D)
    positivity
  exact (inv_anti₀ hp hd).trans hl

omit [DecidableEq J] in
lemma ladderLaw_power_lower
    (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))) :
    ((2:ℝ)^(10*Fintype.card V*q*(T+1)*(K+Nat.clog 2 (Fintype.card V*D+2)+1)))⁻¹ ≤ ladderLaw w T q z := by
  have hh := Finset.prod_le_prod₀ (s := Finset.univ)
    (fun (x : Slot T q) _ => (by positivity : (0:ℝ) ≤ ((2:ℝ)^(10*Fintype.card V*(K+Nat.clog 2 (Fintype.card V*D+2)+1)))⁻¹))
    (fun x _ => slotLaw_minimum_mass hbags hG D K hD hN w hw x (z x))
  simp only [prod_const,card_univ,slots_card,← inv_pow,← pow_mul] at hh
  have he : 10*Fintype.card V*(K+Nat.clog 2 (Fintype.card V*D+2)+1)*((T+1)*q) =
      10*Fintype.card V*q*(T+1)*(K+Nat.clog 2 (Fintype.card V*D+2)+1) := by ring
  rw [he] at hh
  simpa only [inv_pow,ladderLaw,density] using hh

end MatchingFPRAS.Transport

end OAI