import Mathlib
import OAI.Combinatorics.MatchingCount.Algorithm.SortedList

namespace OAI

namespace MatchingFPRAS.Trial
open Finset Switching Subdivision RealGeometry Hierarchy Transport Enlargement StageAnalysis BitArithmetic
open scoped Classical

variable {G : GraphInput} {j K S : ℕ} [Nontrivial (Fin G.n)]
def empiricalDenom (G : GraphInput) (K : ℕ) : ℕ := (G.n+1)^Fintype.card (SourceVertex (Fin G.n) K)
lemma empiricalDenom_pos (G : GraphInput) (K : ℕ) : 0<empiricalDenom G K := by unfold empiricalDenom; positivity
lemma ScaleState.observables_grid (hn : 0<G.n) (s : ScaleState G j) (a : SourceMarked s.activity K) :
    GridFraction (empiricalDenom G K) (observableA s.activity K a) ∧
    GridFraction (empiricalDenom G K) (observableD s.activity s.nextActivity K a) ∧
    ∀ e₀,GridFraction (empiricalDenom G K) (observableProbe s.activity s.nextActivity K e₀ a) := by
  have h := s.observable_power a
  refine ⟨?_,?_,?_⟩
  · rcases h.1 with he|he
    · rw [he]; exact GridFraction.zero _
    · rw [he]; exact GridFraction.one (empiricalDenom_pos G K)
  · rcases h.2.1 with he|⟨t,ht,he⟩
    · rw [he]; exact GridFraction.zero _
    · rw [he,cooling_fraction G.n hn]
      exact GridFraction.cooling_power G.n _ t ht
  · intro e₀
    rcases h.2.2 e₀ with he|⟨t,ht,he⟩
    · rw [he]; exact GridFraction.zero _
    · rw [he,cooling_fraction G.n hn]
      exact GridFraction.cooling_power G.n _ t ht
lemma ScaleState.means_bits (hn : 0<G.n) (s : ScaleState G j)
    (hS : 0<S) (x : Fin S → SourceMarked s.activity K) :
    FractionBound (S*empiricalDenom G K) (sampleAverage (observableA s.activity K) x) ∧
    FractionBound (S*empiricalDenom G K) (sampleAverage (observableD s.activity s.nextActivity K) x) ∧
    ∀ e₀,FractionBound (S*empiricalDenom G K) (sampleAverage (observableProbe s.activity s.nextActivity K e₀) x) := by
  have hpos := Nat.mul_pos hS (empiricalDenom_pos G K)
  refine ⟨?_,?_,?_⟩
  · exact (GridFraction.average _ x (fun i=>(s.observables_grid hn (x i)).1)).fractionBound hpos
  · exact (GridFraction.average _ x (fun i=>(s.observables_grid hn (x i)).2.1)).fractionBound hpos
  · intro e₀
    exact (GridFraction.average _ x (fun i=>(s.observables_grid hn (x i)).2.2 e₀)).fractionBound hpos
end MatchingFPRAS.Trial

namespace MatchingFPRAS.BitArithmetic
open Finset

lemma alpha_bits : FractionBound 100000 RealStage.alpha := by
  exact ⟨1,100000,by norm_num,by norm_num,le_rfl,by norm_num [RealStage.alpha]⟩
def matrixBound (D B : ℕ) : ℕ := 200000*(D+1)*B^2
lemma matrixBound_large (D B : ℕ) (hB : 1≤B) : 100000 ≤ matrixBound D B := by
  unfold matrixBound
  have hb2 : 1≤B^2 := one_le_pow₀ hB
  nlinarith
lemma ratioEstimate_bits {B : ℕ} {a d : ℝ} (hB : 1≤B)
    (ha : FractionBound B a) (hd : FractionBound B d) :
    FractionBound (B^2) (RealStage.ratioEstimate a d) := by
  unfold RealStage.ratioEstimate
  split_ifs with h
  · simpa [pow_two] using hd.div ha h
  · exact FractionBound.one (one_le_pow₀ hB)
lemma upperEstimate_bits (D : ℕ) {B : ℕ} {d z : ℝ} (hB : 1≤B)
    (hd : FractionBound B d) (hz : FractionBound B z) :
    FractionBound (matrixBound D B) (RealStage.upperEstimate D d z) := by
  have hlarge := matrixBound_large D B hB
  unfold RealStage.upperEstimate
  split_ifs with h
  · have ht : FractionBound (matrixBound D B) ((D:ℝ)*z/d+RealStage.alpha) := by
      convert (((FractionBound.nat D).mul hz).div hd h).add alpha_bits using 1
      unfold matrixBound
      ring
    exact (alpha_bits.mono hlarge).max
      ((FractionBound.nat 3 |>.mono (by omega)).min ht)
  · exact FractionBound.one (by omega)
lemma scalingTrace_bits {n : ℕ} (hn : 2≤n) (G : Fin n → Fin n → ℝ)
    (hsym : ∀ i j,G i j=G j i) (hG : ∀ i j,i≠j → RealStage.alpha≤G i j ∧ G i j≤3)
    (B : ℕ) (hB : 2≤B) (hb : ∀ i j,FractionBound B (G i j)) (k : ℕ) :
    ∀ i,FractionBound (B^(k+1)) (RealStage.scalingTrace hn G k i) := by
  have hB1 : 1≤B := by omega
  induction k with
  | zero =>
    intro i
    change FractionBound (B^(0+1)) 2
    simpa using (show FractionBound B (2:ℝ) from ⟨2,1,by omega,hB,hB1,by norm_num⟩)
  | succ k ih =>
    intro i
    have hmono : B^(k+1)≤B^(k+1+1) := Nat.pow_le_pow_right hB1 (by omega)
    dsimp only [RealStage.scalingTrace]
    split_ifs with hk
    · unfold RealStage.scaleUpdate
      by_cases hi : i=⟨k,hk⟩
      · subst i
        simp only [Function.update_self]
        unfold RealStage.rowMaximum
        have hpos := (RealStage.scalingTrace_invariant hn G hsym hG k).1.pos
        convert FractionBound.sup' (univ.erase (⟨k,hk⟩ : Fin n)) (RealStage.others_nonempty hn _)
          (fun j=>G ⟨k,hk⟩ j / RealStage.scalingTrace hn G k j) (B*B^(k+1))
          (fun j _=>(hb ⟨k,hk⟩ j).div (ih j) (hpos j)) using 1
        rw [pow_succ,Nat.mul_comm]
      · rw [Function.update_of_ne hi]
        exact (ih i).mono hmono
    · exact (ih i).mono hmono
end MatchingFPRAS.BitArithmetic

namespace MatchingFPRAS.Trial
open Finset Switching Subdivision RealGeometry Hierarchy Transport Enlargement StageAnalysis BitArithmetic
open scoped Classical

variable {G : GraphInput} {j K S : ℕ} [Nontrivial (Fin G.n)]
lemma ScaleState.ratioEstimate_bits (hn : 0<G.n) (s : ScaleState G j)
    (hS : 0<S) (x : Fin S → SourceMarked s.activity K) :
    FractionBound ((S*empiricalDenom G K)^2) (s.ratioEstimate x) := by
  have hb := s.means_bits hn hS x
  exact BitArithmetic.ratioEstimate_bits (Nat.mul_pos hS (empiricalDenom_pos G K)) hb.1 hb.2.1
lemma ScaleState.matrix_bits (hn : 0<G.n) (s : ScaleState G j)
    (hS : 0<S) (x : Fin S → SourceMarked s.activity K) (a b : Fin G.n) :
    FractionBound (matrixBound (sourceD (V:=Fin G.n) K) (S*empiricalDenom G K)) (s.matrix x a b) := by
  have hb := s.means_bits hn hS x
  unfold ScaleState.matrix estimateMatrix
  apply upperEstimate_bits _ (Nat.mul_pos hS (empiricalDenom_pos G K)) hb.2.1
  unfold probeMatrix
  split_ifs
  · exact FractionBound.zero (Nat.mul_pos hS (empiricalDenom_pos G K))
  · exact hb.2.2 _
lemma ScaleState.updateVector_bits (hn : 2≤G.n) (s : ScaleState G j)
    (hS : 0<S) (x : Fin S → SourceMarked s.activity K) (a : Fin G.n) :
    FractionBound ((matrixBound (sourceD (V:=Fin G.n) K) (S*empiricalDenom G K))^(G.n+1)) (s.updateVector hn x a) := by
  apply scalingTrace_bits hn (s.matrix x) (estimateMatrix_symm _ _ _)
    (fun a b _=>s.matrix_bounds x a b) _ _ (fun a b=>s.matrix_bits (by omega) hS x a b)
  have hh := matrixBound_large (sourceD (V:=Fin G.n) K) (S*empiricalDenom G K)
    (Nat.mul_pos hS (empiricalDenom_pos G K))
  omega
open Finset Switching Subdivision RealGeometry Hierarchy Transport Enlargement StageAnalysis BitArithmetic
open scoped Classical

variable {G : GraphInput} [Nontrivial (Fin G.n)]
omit [Nontrivial (Fin G.n)] in
lemma initial_scale_bits (hn : 2≤G.n) (a : Fin G.n) :
    FractionBound (G.n+1) ((initialScaleState G hn).scale a) := by
  refine ⟨1,Nat.sqrt (G.n-1),?_,by omega,?_,?_⟩
  · exact Nat.le_sqrt.mpr (by omega)
  · exact (Nat.sqrt_le_self _).trans (by omega)
  · change (Initializer.initialScale G.n:ℝ)=_
    simp [Initializer.initialScale]

noncomputable def Parameters.empiricalBound (p : Parameters G) : ℕ := p.S*empiricalDenom G p.K
noncomputable def Parameters.matrixBound (p : Parameters G) : ℕ := BitArithmetic.matrixBound p.D p.empiricalBound
lemma Parameters.empiricalBound_pos (p : Parameters G) : 0<p.empiricalBound :=
  Nat.mul_pos p.S_pos (empiricalDenom_pos G p.K)
lemma Parameters.matrixBound_large (p : Parameters G) : 100000≤p.matrixBound :=
  BitArithmetic.matrixBound_large p.D p.empiricalBound p.empiricalBound_pos
noncomputable def Parameters.scaleBound (p : Parameters G) (j : ℕ) : ℕ :=
  (G.n+1)*p.matrixBound^(j*(G.n+1))
lemma layers_scale_bits (p : Parameters G) (j : ℕ) (hj : j≤p.K)
    (x : (layers p j hj).Ω) (a : Fin G.n) :
    FractionBound (p.scaleBound j) ((layers p j hj).state x |>.scale a) := by
  induction j with
  | zero => simpa [layers,firstLayer,Parameters.scaleBound] using initial_scale_bits p.hn a
  | succ j ih =>
    change FractionBound _ (((layers p j (by omega)).state x.1).scale a *
      ((layers p j (by omega)).state x.1).updateVector p.hn x.2 a)
    have hv := ((layers p j (by omega)).state x.1).updateVector_bits p.hn p.S_pos x.2 a
    have hh := (ih (by omega) x.1).mul hv
    convert hh using 1
    change (G.n+1)*p.matrixBound^((j+1)*(G.n+1))=
      ((G.n+1)*p.matrixBound^(j*(G.n+1)))*p.matrixBound^(G.n+1)
    rw [add_mul, one_mul, pow_add]
    ring
lemma layers_ratio_bits (p : Parameters G) (j : ℕ) (hj : j≤p.K)
    (x : (layers p j hj).Ω) (i : Fin j) :
    FractionBound (p.empiricalBound^2) ((layers p j hj).ratios x i) := by
  induction j with
  | zero => exact Fin.elim0 i
  | succ j ih =>
    refine Fin.lastCases ?_ (fun i=>?_) i
    · simpa only [layers,Layer.append,Fin.snoc_last,Parameters.empiricalBound] using
        ((layers p j (by omega)).state x.1).ratioEstimate_bits (by have := p.hn; omega) p.S_pos x.2
    · simpa only [layers,Layer.append,Fin.snoc_castSucc] using ih (by omega) x.1 i
lemma output_bits (p : Parameters G) (x : (layers p p.K le_rfl).Ω) :
    FractionBound ((Z (completeGraph G.n)+1)*(p.empiricalBound^2)^p.K) (output p x) := by
  have h := FractionBound.prod univ ((layers p p.K le_rfl).ratios x) (p.empiricalBound^2)
    (fun i _=>layers_ratio_bits p p.K le_rfl x i)
  simpa [output] using (FractionBound.nat (Z (completeGraph G.n))).mul h

noncomputable def rationalOutput (p : Parameters G) (x : (layers p p.K le_rfl).Ω) : ℚ :=
  (output_bits p x).choose / (output_bits p x).choose_spec.choose
lemma rationalOutput_cast (p : Parameters G) (x : (layers p p.K le_rfl).Ω) :
    (rationalOutput p x:ℝ)=output p x := by
  have h := (output_bits p x).choose_spec.choose_spec.2.2.2
  simpa [rationalOutput] using h.symm
lemma rationalOutput_nonneg (p : Parameters G) (x : (layers p p.K le_rfl).Ω) :
    0≤rationalOutput p x := by
  exact_mod_cast (show (0:ℝ)≤(rationalOutput p x:ℝ) by rw [rationalOutput_cast]; exact output_nonneg p x)
lemma rationalOutput_accurate (p : Parameters G) (x : (layers p p.K le_rfl).Ω) :
    Accurate p (output p x) ↔
      (1-p.epsilon)*(Z G:ℚ)≤rationalOutput p x ∧ rationalOutput p x≤(1+p.epsilon)*(Z G:ℚ) := by
  rw [← rationalOutput_cast p x]
  unfold Accurate
  norm_cast
end MatchingFPRAS.Trial

namespace MatchingFPRAS.FiniteTrial
open Finset Enlargement Transport BitArithmetic
open scoped Classical

variable {G : GraphInput} {j K S : ℕ} [Nontrivial (Fin G.n)]
attribute [local instance] NumberedHierarchy.labelOrder sym2Order bagEdgeOrder bagEdgeFintype
attribute [local instance] UnitRefresh.Computable.allowedDec prodOrder sumOrder
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    DecidableEq (SourceLabel (fun x y=>(w x y:ℝ)) K) := Classical.decEq _
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    Fintype (BagEdge (sourceBags (fun x y=>(w x y:ℝ)) K)) := Fintype.ofFinite _
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    Fintype (SourceMarked (fun x y=>(w x y:ℝ)) K) := Fintype.ofFinite _
lemma ScaleState.ratioEstimate_bits (hn : 0<G.n) (s : ScaleState G j) (hS : 0<S)
    (x : Fin S → SourceMarked (fun a b=>(s.activity a b:ℝ)) K) :
    FractionBound ((S*Trial.empiricalDenom G K)^2)
      (s.ratioEstimate (RationalSource.sourceMarkedEquiv s.activity K ∘ x):ℝ) := by
  have hb := s.toReal.ratioEstimate_bits (K:=K) (S:=S) hn hS
  unfold Trial.ScaleState.ratioEstimate at hb
  rw [←s.activity_cast,←s.nextActivity_cast] at hb
  rw [s.ratioEstimate_cast]
  exact hb x
lemma ScaleState.matrix_bits (hn : 0<G.n) (s : ScaleState G j) (hS : 0<S)
    (x : Fin S → SourceMarked (fun a b=>(s.activity a b:ℝ)) K) (a b : Fin G.n) :
    FractionBound (matrixBound (Enlargement.sourceD (V:=Fin G.n) K) (S*Trial.empiricalDenom G K))
      (s.matrix (RationalSource.sourceMarkedEquiv s.activity K ∘ x) a b:ℝ) := by
  have hb := s.toReal.matrix_bits (K:=K) (S:=S) hn hS
  unfold Trial.ScaleState.matrix at hb
  rw [←s.activity_cast,←s.nextActivity_cast] at hb
  have he := congrFun (congrFun (s.matrix_cast x) a) b
  rw [he,sourceD_eq]
  exact hb x a b
lemma ScaleState.updateVector_bits (hn : 2≤G.n) (s : ScaleState G j) (hS : 0<S)
    (x : Fin S → SourceMarked (fun a b=>(s.activity a b:ℝ)) K) (a : Fin G.n) :
    FractionBound ((matrixBound (Enlargement.sourceD (V:=Fin G.n) K) (S*Trial.empiricalDenom G K))^(G.n+1))
      (s.updateVector hn (RationalSource.sourceMarkedEquiv s.activity K ∘ x) a:ℝ) := by
  rw [ScaleState.updateVector,Counting.scalingTrace_cast]
  apply scalingTrace_bits hn _ _ _ _ _ _ _ a
  · intro a b
    exact_mod_cast s.matrix_symm _ a b
  · intro a b _
    have h:=s.matrix_bounds (RationalSource.sourceMarkedEquiv s.activity K ∘ x) a b
    constructor
    · have hh : ((Counting.alpha:ℚ):ℝ) ≤ (s.matrix (RationalSource.sourceMarkedEquiv s.activity K ∘ x) a b:ℝ) := by exact_mod_cast h.1
      simpa [Counting.alpha,RealStage.alpha] using hh
    · exact_mod_cast h.2
  · have h:=matrixBound_large (Enlargement.sourceD (V:=Fin G.n) K) (S*Trial.empiricalDenom G K)
      (Nat.mul_pos hS (Trial.empiricalDenom_pos G K))
    omega
  · intro a b
    exact s.matrix_bits (by omega) hS x a b
omit [Nontrivial (Fin G.n)] in
lemma initial_scale_bits (hn : 2≤G.n) (a : Fin G.n) :
    FractionBound (G.n+1) ((initialScaleState G hn).scale a:ℝ) := by
  exact Trial.initial_scale_bits hn a
lemma layers_scale_bits (p : Trial.Parameters G) (j : ℕ) (hj : j≤p.K)
    (x : (layers p j hj).Ω) (a : Fin G.n) :
    FractionBound (p.scaleBound j) ((layers p j hj).state x |>.scale a:ℝ) := by
  induction j with
  | zero => simpa [layers,firstLayer,Trial.Parameters.scaleBound] using initial_scale_bits p.hn a
  | succ j ih =>
    change FractionBound _ ((((layers p j (by omega)).state x.1).scale a *
      ((layers p j (by omega)).state x.1).updateVector p.hn
        (RationalSource.sourceMarkedEquiv ((layers p j (by omega)).state x.1).activity p.K ∘ x.2) a:ℚ):ℝ)
    rw [Rat.cast_mul]
    have hv := ((layers p j (by omega)).state x.1).updateVector_bits p.hn p.S_pos x.2 a
    have hh := (ih (by omega) x.1).mul hv
    convert hh using 1
    change (G.n+1)*p.matrixBound^((j+1)*(G.n+1))=
      ((G.n+1)*p.matrixBound^(j*(G.n+1)))*p.matrixBound^(G.n+1)
    rw [add_mul,one_mul,pow_add]
    ring
lemma layers_ratio_bits (p : Trial.Parameters G) (j : ℕ) (hj : j≤p.K)
    (x : (layers p j hj).Ω) (i : Fin j) :
    FractionBound (p.empiricalBound^2) ((layers p j hj).ratios x i:ℝ) := by
  induction j with
  | zero => exact Fin.elim0 i
  | succ j ih =>
    refine Fin.lastCases ?_ (fun i=>?_) i
    · simpa only [layers,Layer.append,Fin.snoc_last,Trial.Parameters.empiricalBound] using
        ((layers p j (by omega)).state x.1).ratioEstimate_bits (by have := p.hn; omega) p.S_pos x.2
    · simpa only [layers,Layer.append,Fin.snoc_castSucc] using ih (by omega) x.1 i
lemma output_bits (p : Trial.Parameters G) (x : (layers p p.K le_rfl).Ω) :
    FractionBound ((Z (completeGraph G.n)+1)*(p.empiricalBound^2)^p.K) (output p x:ℝ) := by
  have h := FractionBound.prod univ (fun i=>((layers p p.K le_rfl).ratios x i:ℝ)) (p.empiricalBound^2)
    (fun i _=>layers_ratio_bits p p.K le_rfl x i)
  simpa [output,Rat.cast_mul,Rat.cast_prod] using (FractionBound.nat (Z (completeGraph G.n))).mul h
end MatchingFPRAS.FiniteTrial

namespace MatchingFPRAS.BitArithmetic
lemma FractionBound.num_den {B : ℕ} {q : ℚ} (h : FractionBound B (q:ℝ)) :
    q.num.natAbs≤B ∧ q.den≤B := by
  obtain ⟨a,b,hb,ha,hbb,he⟩:=h
  have hq : q=(a:ℚ)/b := by
    apply Rat.cast_injective (α:=ℝ)
    simpa only [Rat.cast_div,Rat.cast_natCast] using he
  have hq' : q=Rat.divInt (a:ℤ) (b:ℤ) := by simpa only [Rat.divInt_eq_div,Int.cast_natCast] using hq
  have hb0 : (b:ℤ)≠0 := by exact_mod_cast hb.ne'
  have hd : q.den∣b := by
    have hh:=Rat.den_dvd (a:ℤ) (b:ℤ)
    rw [←hq'] at hh
    exact_mod_cast hh
  refine ⟨?_,(Nat.le_of_dvd hb hd).trans hbb⟩
  by_cases ha0 : a=0
  · simp [ha0] at hq
    simp [hq]
  · have hh:=Rat.num_dvd (a:ℤ) hb0
    rw [←hq'] at hh
    have hn : q.num.natAbs∣a := by simpa using Int.natAbs_dvd_natAbs.mpr hh
    exact (Nat.le_of_dvd (Nat.pos_of_ne_zero ha0) hn).trans ha
lemma size_mul_le (a b : ℕ) : (a*b).size≤a.size+b.size := by
  apply Nat.size_le.mpr
  rw [pow_add]
  have h₁:=Nat.lt_size_self a
  have h₂:=Nat.lt_size_self b
  have h₃ : 0<(2:ℕ)^a.size := by positivity
  nlinarith
lemma size_pow_le (a k : ℕ) : (a^k).size≤k*a.size+1 := by
  induction k with
  | zero => simp
  | succ k ih =>
    rw [pow_succ]
    have h:=size_mul_le (a^k) a
    rw [Nat.succ_mul]
    omega
lemma FractionBound.encode_length {B : ℕ} {q : ℚ} (h : FractionBound B (q:ℝ)) :
    (encodeRat q).length≤2*B.size+3 := by
  have hd:=h.num_den
  have hn:=Nat.size_le_size hd.1
  have hb:=Nat.size_le_size hd.2
  have he : (encodeRat q).length=q.num.natAbs.size+q.den.size+3 := by
    unfold encodeRat encodeInt encodeNat
    split_ifs <;> simp [Nat.size_eq_bits_len] <;> omega
  rw [he]
  omega
lemma size_empiricalBound {G : GraphInput} (p : Trial.Parameters G) :
    p.empiricalBound.size≤p.S.size+Fintype.card (Enlargement.SourceVertex (Fin G.n) p.K)*(G.n+1).size+1 := by
  unfold Trial.Parameters.empiricalBound Trial.empiricalDenom
  exact (size_mul_le _ _).trans (by have h:=size_pow_le (G.n+1) (Fintype.card (Enlargement.SourceVertex (Fin G.n) p.K)); omega)
lemma size_matrixBound {G : GraphInput} (p : Trial.Parameters G) :
    p.matrixBound.size≤19+(p.D+1).size+2*p.empiricalBound.size := by
  unfold Trial.Parameters.matrixBound matrixBound
  have h₁:=size_mul_le (200000*(p.D+1)) (p.empiricalBound^2)
  have h₂:=size_mul_le 200000 (p.D+1)
  have h₃:=size_pow_le p.empiricalBound 2
  have h₄ : (200000:ℕ).size=18 := by decide
  omega
lemma size_scaleBound {G : GraphInput} (p : Trial.Parameters G) (j : ℕ) :
    (p.scaleBound j).size≤(G.n+1).size+j*(G.n+1)*p.matrixBound.size+1 := by
  unfold Trial.Parameters.scaleBound
  have h₁:=size_mul_le (G.n+1) (p.matrixBound^(j*(G.n+1)))
  have h₂:=size_pow_le p.matrixBound (j*(G.n+1))
  omega
end MatchingFPRAS.BitArithmetic
namespace MatchingFPRAS.FiniteTrial
open BitArithmetic

variable {G : GraphInput} [Nontrivial (Fin G.n)]
lemma scale_encode_length (p : Trial.Parameters G) (j : ℕ) (hj : j≤p.K)
    (x : (layers p j hj).Ω) (a : Fin G.n) :
    (encodeRat (((layers p j hj).state x).scale a)).length ≤
      2*((G.n+1).size+j*(G.n+1)*(19+(p.D+1).size+2*(p.S.size+
        Fintype.card (Enlargement.SourceVertex (Fin G.n) p.K)*(G.n+1).size+1))+1)+3 := by
  have h₁:=(layers_scale_bits p j hj x a).encode_length
  have h₂:=size_scaleBound p j
  have h₃:=size_matrixBound p
  have h₄:=size_empiricalBound p
  have hb : (p.scaleBound j).size≤
      (G.n+1).size+j*(G.n+1)*(19+(p.D+1).size+2*(p.S.size+
        Fintype.card (Enlargement.SourceVertex (Fin G.n) p.K)*(G.n+1).size+1))+1 := by
    calc
      _ ≤ (G.n+1).size+j*(G.n+1)*p.matrixBound.size+1 := h₂
      _ ≤ (G.n+1).size+j*(G.n+1)*(19+(p.D+1).size+2*p.empiricalBound.size)+1 := by gcongr
      _ ≤ _ := by gcongr
  omega
end MatchingFPRAS.FiniteTrial

namespace MatchingFPRAS.Counting

def schedulePolynomial (n : ℕ) (e : ℚ) : ℕ := n*(n*n+32*⌈e⁻¹⌉₊)
lemma polynomial_schedule (n : ℕ) (hn : 2≤n) (e : ℚ) (he : 0<e) :
    scheduleAdmissible n e (schedulePolynomial n e) := by
  have hn0 : (0:ℚ)<n := by exact_mod_cast (show 0<n by omega)
  have hnz : (n:ℚ)≠0 := ne_of_gt hn0
  have hb : (2:ℚ)≤(1+1/n)^n := by
    have hh:=one_add_mul_le_pow (a:=(1/(n:ℚ))) (le_trans (by norm_num : (-2:ℚ)≤0) (by positivity : (0:ℚ)≤1/n)) n
    norm_num [mul_inv_cancel₀ hnz] at hh
    simpa only [one_div] using hh
  have hec : e⁻¹≤(⌈e⁻¹⌉₊:ℚ) := Nat.le_ceil _
  have hecp : 0<⌈e⁻¹⌉₊ := by
    by_contra h
    have hz : ⌈e⁻¹⌉₊=0 := by omega
    rw [hz] at hec
    have hp : 0<e⁻¹ := inv_pos.mpr he
    norm_num at hec
    linarith
  have hnp : (n:ℚ)≤2^n := by exact_mod_cast (Nat.lt_two_pow_self (n:=n)).le
  have hp₁ : (n:ℚ)^(n/2)≤2^(n*n) := by
    calc
      _ ≤ (2^n:ℚ)^(n/2) := pow_le_pow_left₀ hn0.le hnp _
      _ = (2:ℚ)^(n*(n/2)) := (pow_mul _ _ _).symm
      _ ≤ _ := pow_le_pow_right₀ (by norm_num) (Nat.mul_le_mul_left n (Nat.div_le_self _ _))
  have hp₂ : (32:ℚ)/e≤2^(32*⌈e⁻¹⌉₊) := by
    calc
      _ = 32*e⁻¹ := by rw [div_eq_mul_inv]
      _ ≤ 32*(⌈e⁻¹⌉₊:ℚ) := mul_le_mul_of_nonneg_left hec (by norm_num)
      _ ≤ (2:ℚ)^(32*⌈e⁻¹⌉₊) := by exact_mod_cast (Nat.lt_two_pow_self (n:=32*⌈e⁻¹⌉₊)).le
  have hp : (n:ℚ)^(n/2)*(32/e) ≤ (1+1/n)^schedulePolynomial n e := by
    calc
      _ ≤ (2:ℚ)^(n*n)*2^(32*⌈e⁻¹⌉₊) := mul_le_mul hp₁ hp₂ (by positivity) (by positivity)
      _ = (2:ℚ)^(n*n+32*⌈e⁻¹⌉₊) := (pow_add _ _ _).symm
      _ ≤ ((1+1/n:ℚ)^n)^(n*n+32*⌈e⁻¹⌉₊) := pow_le_pow_left₀ (by norm_num) hb _
      _ = _ := by rw [←pow_mul]; rfl
  refine ⟨by unfold schedulePolynomial; have := Nat.mul_pos (show 0<n by omega) (show 0<n*n+32*⌈e⁻¹⌉₊ by positivity); omega,?_⟩
  have hbase : (0:ℚ)<1+1/n := by positivity
  apply (div_le_iff₀ (pow_pos hbase _)).mpr
  have hh := (div_le_iff₀ he).mp (show (n:ℚ)^(n/2)*32/e≤(1+1/n)^schedulePolynomial n e by simpa [mul_div_assoc] using hp)
  nlinarith
lemma leastSchedule_polynomial (n : ℕ) (hn : 2≤n) (e : ℚ) (he : 0<e) (he1 : e<1) :
    leastSchedule n hn e he he1 ≤ schedulePolynomial n e :=
  leastSchedule_le n hn e he he1 _ (polynomial_schedule n hn e he)
end MatchingFPRAS.Counting

end OAI