import OAI.Combinatorics.CycleDecomposition.UniformLayers

namespace OAI

section
open Filter Asymptotics Real
open scoped Topology
noncomputable section
open MeasureTheory ProbabilityTheory Finset
section

namespace ErdosGallai.Scale
noncomputable section
open Finset SimpleGraph Real
attribute [local instance] Classical.propDecidable
variable {V : Type} [Fintype V] [DecidableEq V]

lemma assigned_union_edges (L : List (AssignedPiece V)) :
    (⋃ i : Fin L.length, (L.get i).graph.edgeSet) = (graphUnion (L.map AssignedPiece.graph)).edgeSet := by
  ext e
  induction e using Sym2.ind with
  | _ x y =>
    simp only [Set.mem_iUnion,SimpleGraph.mem_edgeSet]

    rw [graphUnion_adj]
    constructor
    · rintro ⟨i,hi⟩
      exact ⟨_,List.mem_map.mpr ⟨_,L.get_mem i,rfl⟩,hi⟩
    · rintro ⟨G,hG,hxy⟩
      obtain ⟨Q,hQ,rfl⟩ := List.mem_map.mp hG
      obtain ⟨i,rfl⟩ := List.mem_iff_get.mp hQ
      exact ⟨i,hxy⟩

lemma box_coupled_partition {B R : AssignedPiece V} (A : List (AssignedPiece V))
    (hBR : GraphPartition B.graph (R.graph :: A.map AssignedPiece.graph))
    (s : SplitSystem V) (j k : ℕ) :
    GraphPartition (graphUnion ((advance s j k [R]).map AssignedPiece.graph ++ A.map AssignedPiece.graph))
      ((advance s j k [R]).map AssignedPiece.graph ++ A.map AssignedPiece.graph) := by
  apply graphPartition_of_le_one
  intro x y
  have hb := hBR x y
  have hr := past_partition s j k R x y
  simp only [edgeOccurrences_cons,edgeOccurrences_append] at hb hr ⊢
  split_ifs at hb hr <;> omega

theorem uniform_local_box_cost : ∃ D₀ : ℝ, 1 < D₀ ∧ ∀ D ≥ D₀, ∀ wmin : ℝ,
    ErdosGallai.MainScaleReady wmin D →
    ∀ (V : Type) [Fintype V] (L A : List (AssignedPiece V)) (Y : Finset V),
    GraphPartition (graphUnion (L.map AssignedPiece.graph ++ A.map AssignedPiece.graph))
      (L.map AssignedPiece.graph ++ A.map AssignedPiece.graph) →
    A.Pairwise (fun R S => Disjoint R.vertices S.vertices) →
    (∀ R ∈ A, R.vertices ⊆ Y) →
    (∀ Q ∈ L, Q.vertices ⊆ Y) →
    (∀ v ∈ Y, ∃ Q ∈ L, v ∈ Q.vertices) →
    (∀ Q ∈ L, Q.vertices.Nonempty ∧ (Q.vertices.card:ℝ) ≤ D^(1/1000:ℝ) ∧
      2*(edgeCount Q.graph:ℝ)/Q.vertices.card ≤ D^(1/1000:ℝ)) →
    (∀ R ∈ A, D^(9/10:ℝ) ≤ (R.vertices.card:ℝ) ∧ (R.vertices.card:ℝ) ≤ D^(51/50:ℝ) ∧
      CutExpansionOn R.graph R.vertices (D^(9/10:ℝ))) →
    (Y.card:ℝ) ≤ D^(51/50:ℝ) → vertexMass L ≤ 2*Y.card →
    ∀ (n : ℕ) (C t : ℝ), 0 ≤ C → 0 ≤ t → Y.card ≤ n → D^(3/10:ℝ) < n →
    (∀ (Q : Type) [Fintype Q] (H : SimpleGraph Q), Fintype.card Q < n →
      (ErdosGallai.decompositionCost H:ℝ) ≤ C*Fintype.card Q) →
    (∀ (Q : Type) [Fintype Q] (H : SimpleGraph Q), Fintype.card Q < n →
      (Fintype.card Q:ℝ) ≤ D^(3/10:ℝ) → (Batch.decompositionCost H:ℝ) ≤ t*Fintype.card Q) →
    (decompositionCost (graphUnion (L.map AssignedPiece.graph ++ A.map AssignedPiece.graph)):ℝ) ≤
      (9+C*ErdosGallai.mainEta)*vertexMass A + (t+8)*vertexMass L +
      (8-t/3)*vertexMass A + ((2/3)*t/logb 2 D-8)*Y.card := by
  obtain ⟨D₀,hD₀,hbox⟩ := ErdosGallai.uniform_box_cost
  refine ⟨D₀,hD₀,?_⟩
  intro D hD wmin hready V _ L A Y hpart hAd hAY hLY hcover hL hA hY hmass
    n C t hC ht hYn hsmall ih ihq
  let F := graphUnion (L.map AssignedPiece.graph)
  let G := graphUnion (L.map AssignedPiece.graph ++ A.map AssignedPiece.graph)
  let R (r : Fin A.length) := (A.get r).graph
  let U (r : Fin A.length) := (A.get r).vertices
  have hp := List.pairwise_append.mp (graphPartition_pairwise hpart)
  have hLL := list_pairwise_get (List.pairwise_map.mp hp.1) (fun _ _ h => h.symm)
  have hRR : Pairwise (fun r s => Disjoint (R r).edgeSet (R s).edgeSet) :=
    list_pairwise_get (List.pairwise_map.mp hp.2.1) (fun _ _ h => h.symm)
  have hUU : Pairwise (fun r s => Disjoint (U r) (U s)) :=
    list_pairwise_get hAd (fun _ _ h => h.symm)
  have hFR (r) : Disjoint F.edgeSet (R r).edgeSet := by
    rw [← assigned_union_edges]
    exact Set.disjoint_iUnion_left.mpr (fun i => hp.2.2 _ (List.mem_map.mpr ⟨_,L.get_mem i,rfl⟩)
      _ (List.mem_map.mpr ⟨_,A.get_mem r,rfl⟩))
  have hFG : F ≤ G := graphUnion_sublist (List.sublist_append_left _ _)
  have hRG (r) : R r ≤ G := by
    intro x y hxy
    exact (graphUnion_adj _ _ _).mpr ⟨_,List.mem_append_right _ (List.mem_map.mpr ⟨_,A.get_mem r,rfl⟩),hxy⟩
  have hcov : F.edgeSet ∪ (⋃ r, (R r).edgeSet) = G.edgeSet := by
    change F.edgeSet ∪ (⋃ r : Fin A.length, (A.get r).graph.edgeSet) = _
    rw [assigned_union_edges]
    ext e
    induction e using Sym2.ind with
    | _ x y => simp only [Set.mem_union,SimpleGraph.mem_edgeSet,G,graphUnion_append,SimpleGraph.sup_adj,F]
  have hB : 0 < D^(3/10:ℝ) := Real.rpow_pos_of_pos (by linarith [hready.gt_one]) _
  obtain ⟨b⟩ := Indexing.materialize_batches F Y (fun i : Fin L.length => (L.get i).graph)
    (fun i => (L.get i).vertices) hLL (assigned_union_edges L)
    (fun i x y hxy => (L.get i).supported hxy) (fun i => hLY _ (L.get_mem i))
    (by
      intro v hv
      obtain ⟨Q,hQ,hvQ⟩ := hcover v hv
      obtain ⟨i,rfl⟩ := List.mem_iff_get.mp hQ
      exact Finset.mem_biUnion.mpr ⟨i,mem_univ _,hvQ⟩)
    (D^(3/10:ℝ)) hB (fun i => ((hL _ (L.get_mem i)).2.1).trans hready.batch_power)
  have hsum : (∑ i : Fin L.length, ((L.get i).vertices.card:ℝ)) = vertexMass L := list_sum_get L (fun Q => (Q.vertices.card:ℝ))
  have hAsum : (∑ i : Fin A.length, ((U i).card:ℝ)) = vertexMass A := list_sum_get A (fun Q => (Q.vertices.card:ℝ))
  have hF : 2*(F.edgeFinset.card:ℝ) ≤ 2*Y.card*D^(1/1000:ℝ) := by
    have hh := (Nat.cast_le.mpr (edgeCount_union_le (L.map AssignedPiece.graph)) : (_:ℝ) ≤ _)
    have hdeg : (L.map (fun Q => 2*(edgeCount Q.graph:ℝ))).sum ≤ vertexMass L * D^(1/1000:ℝ) := by
      unfold vertexMass
      rw [← List.sum_map_mul_right]
      apply List.sum_le_sum
      intro Q hQ
      have hc : (0:ℝ) < Q.vertices.card := by exact_mod_cast Finset.card_pos.mpr (hL Q hQ).1
      simpa only [mul_comm] using (div_le_iff₀ hc).mp (hL Q hQ).2.2
    simp only [Nat.cast_list_sum,List.map_map,Function.comp_def] at hh
    rw [List.sum_map_mul_left] at hdeg
    have hx := mul_le_mul_of_nonneg_right hmass (Real.rpow_nonneg (show (0:ℝ) ≤ D by linarith [hready.gt_one]) (1/1000:ℝ))
    change 2*(edgeCount F:ℝ) ≤ _
    linarith
  have hcost := hbox D hD wmin hready V (Fin A.length) G F R U Y hFG hRG hRR hUU
    (fun r => hAY _ (A.get_mem r)) (fun r x y hxy => (A.get r).supported hxy) hFR hcov
    (fun r => (hA _ (A.get_mem r)).2.2)
    (fun r => ⟨(hA _ (A.get_mem r)).1,(hA _ (A.get_mem r)).2.1⟩)
    hY hF (∑ i : Fin L.length, ((L.get i).vertices.card:ℝ)) (by simpa only [hsum] using hmass)
    b n C t hC ht hYn hsmall ih ihq
  rw [hsum,hAsum] at hcost
  change (decompositionCost G:ℝ) ≤ _
  convert hcost using 1 <;> first | rfl | ring

end
end ErdosGallai.Scale

end

section

namespace ErdosGallai.Scale
noncomputable section
open Finset SimpleGraph Real
attribute [local instance] Classical.propDecidable
variable {V : Type} [Fintype V] [DecidableEq V]

lemma pastPieces_mem (s : SplitSystem V) (j k : ℕ) (L : List (AssignedPiece V))
    {R : AssignedPiece V} (hR : R ∈ pastPieces s j k L) :
    ∃ l < k, R ∈ levelPieces s (j+l) (advance s j l L) := by
  induction k with
  | zero => simp [pastPieces] at hR
  | succ k ih =>
    rcases List.mem_append.mp hR with h | h
    · obtain ⟨l,hl,hR⟩ := ih h
      exact ⟨l,by omega,hR⟩
    · exact ⟨k,by omega,h⟩

theorem uniform_committed_piece_cost : ∃ D₀ : ℝ, 1 < D₀ ∧ ∀ Dstar ≥ D₀,
    ∀ (V : Type) [Fintype V] [DecidableEq V] (P : AssignedPiece V) (H : Layers P Dstar),
    ∀ (C : ℝ), 0 ≤ C →
    (∀ (Q : Type) [Fintype Q] (G : SimpleGraph Q), Fintype.card Q < P.vertices.card →
      (ErdosGallai.decompositionCost G:ℝ) ≤ C*Fintype.card Q) →
    ∀ k ≤ H.count, ∀ R ∈ pastPieces H.system 0 k [P],
      (decompositionCost R.graph:ℝ) ≤ (9+C*ErdosGallai.mainEta)*R.vertices.card := by
  obtain ⟨D₀,hD₀,hpc⟩ := ErdosGallai.uniform_piece_cost_on 1 ErdosGallai.mainEta (by norm_num) ErdosGallai.mainEta_pos
  refine ⟨D₀,hD₀,?_⟩
  intro Dstar hD V _ _ P H C hC ih k hk R hR
  obtain ⟨j,hjk,hR⟩ := pastPieces_mem H.system 0 k [P] hR
  simp only [Nat.zero_add] at hR
  obtain ⟨Q,hQ,B,hB,hR⟩ := (by simpa [levelPieces,List.mem_flatMap] using hR :
    ∃ Q ∈ H.frontier j, ∃ B ∈ (H.system j Q).boxes, R ∈ (H.system j Q).pieces B)
  have hj : j < H.count := by omega
  have hb := (H.bounded j hj Q hQ).2.2.2.1 B hB R hR
  have hsub := ((H.system j Q).piece_subset B hB R hR).trans (H.box_subset j hQ hB)
  exact hpc (H.scale j) (hD.trans (H.cutoff j hj)) P.vertices.card C hC ih V R.graph R.graph R.vertices
    le_rfl (Finset.card_le_card hsub) R.supported hb.1 hb.2.1 (by
      simpa only [one_mul,ErdosGallai.CutExpansionOn,CutExpansionOn,cutCount,Layers.scale] using hb.2.2)

theorem uniform_gap_prefix_cost : ∃ D₀ : ℝ, 1 < D₀ ∧ ∀ Dstar ≥ D₀,
    ∀ (V : Type) [Fintype V] (P : AssignedPiece V) (H : Layers P Dstar),
    1 < (P.vertices.card:ℝ) →
    (∀ j < H.count, ErdosGallai.MainScaleReady 80 (H.scale j)) →
    ∀ i, i+200 < H.count → ∀ C t : ℝ, 0 ≤ C → 0 ≤ t →
    (∀ (Q : Type) [Fintype Q] (G : SimpleGraph Q), Fintype.card Q < P.vertices.card →
      (ErdosGallai.decompositionCost G:ℝ) ≤ C*Fintype.card Q) →
    (∀ (Q : Type) [Fintype Q] (G : SimpleGraph Q), Fintype.card Q < P.vertices.card →
      (Fintype.card Q:ℝ) ≤ (H.scale i)^(3/10:ℝ) →
      (Batch.decompositionCost G:ℝ) ≤ t*Fintype.card Q) →
    (∀ R ∈ pastPieces H.system 0 (i+201) [P],
      (decompositionCost R.graph:ℝ) ≤ (9+C*ErdosGallai.mainEta)*R.vertices.card) →
    (decompositionCost P.graph:ℝ) ≤ ((pastCycles H.system 0 (i+201) [P]).length:ℝ) +
      (9+C*ErdosGallai.mainEta)*vertexMass (pastPieces H.system 0 (i+201) [P]) +
      (t+8)*H.mass (i+201) + (8-t/3)*H.pieceMass i +
      ((2/3)*t/logb 2 (H.scale i)-8)*H.mass (i+1) := by
  obtain ⟨D₀,hD₀,hlocal⟩ := uniform_local_box_cost
  refine ⟨D₀,hD₀,?_⟩
  intro Dstar hD V _ P H hn hready i hik C t hC ht ih ihq hp
  have hi : i < H.count := by omega
  have hne : P.vertices.Nonempty := Finset.card_pos.mp (by exact_mod_cast (by linarith : (0:ℝ) < P.vertices.card))
  have hsmall : (H.scale i)^(3/10:ℝ) < (P.vertices.card:ℝ) := by
    apply lt_of_lt_of_le _ (inductionScale_le P.vertices.card hn.le i)
    have hd := inductionScale_gt_one P.vertices.card hn i
    simpa only [Real.rpow_one] using Real.rpow_lt_rpow_of_exponent_lt hd (by norm_num : (3/10:ℝ) < 1)
  apply selected_prefix_cost H.system i 200 P (9+C*ErdosGallai.mainEta)
    (t+8) (8-t/3) ((2/3)*t/logb 2 (H.scale i)-8) hp
  intro Q hQ B hB
  have hQne := advance_nonempty H.system 0 i [P] (by simpa using hne) Q hQ
  have hBne := (H.system i Q).box_nonempty hQne B hB
  have hrest : ((H.system i Q).rest B).vertices.Nonempty := by simpa only [StageSplit.rest_vertices] using hBne
  exact hlocal (H.scale i) (hD.trans (H.cutoff i hi)) 80 (hready i hi) V
    (advance H.system (i+1) 200 [(H.system i Q).rest B]) ((H.system i Q).pieces B) B.vertices
    (box_coupled_partition _ (by simpa only [StageSplit.rest_graph _ hB] using (H.system i Q).box_partition B hB) _ _ _)
    ((H.system i Q).piece_disjoint B hB) ((H.system i Q).piece_subset B hB)
    (advance_subset H.system (i+1) 200 [(H.system i Q).rest B] B.vertices (by simp))
    (fun v hv => advance_cover H.system (i+1) 200 [(H.system i Q).rest B] ((H.system i Q).rest B) (by simp) v (by simpa only [StageSplit.rest_vertices] using hv))
    (fun R hR => ⟨advance_nonempty H.system (i+1) 200 [(H.system i Q).rest B] (by simpa using hrest) R hR,
      H.gap_order hn i hik hQ hB hR⟩)
    ((H.bounded i hi Q hQ).2.2.2.1 B hB) ((H.bounded i hi Q hQ).2.2.1 B hB)
    (H.local_mass_two hn (fun j hj => (hready j hj).log_large) i 200 hik hQ hB)
    P.vertices.card C t hC ht (Finset.card_le_card (H.box_subset i hQ hB)) hsmall ih ihq

end
end ErdosGallai.Scale

end

section

namespace ErdosGallai
noncomputable section
open Real

lemma main_gap_scalar (q n S M L Nt Ni C t w : ℝ)
    (hn : 0 ≤ n) (hS : 0 ≤ S) (hC : 0 ≤ C) (ht : 0 ≤ t) (hw : 0 < w)
    (hM : M ≤ mainP*S) (hL : L ≤ mainH*n/w)
    (hNt : Nt ≤ n+mainH*n/w) (hNilo : n ≤ Ni) (hNihi : Ni ≤ 2*n)
    (hq : q ≤ L+(9+C*mainEta)*M+(t+8)*Nt+(8-t/3)*S+((2/3)*t/w-8)*Ni) :
    q ≤ mainA₂*(S+n/w)+(C/100)*S+t*(n-S/3+mainA₁*n/w) := by
  have hη := mainEta_pos
  have hc := mul_le_mul_of_nonneg_left hM (by positivity : 0 ≤ 9+C*mainEta)
  have hT := mul_le_mul_of_nonneg_left hNt (by linarith : 0 ≤ t+8)
  have hI := mul_le_mul_of_nonneg_left hNihi (by positivity : 0 ≤ (2/3)*t/w)
  have hI' : -8*Ni ≤ -8*n := by linarith
  have hA := mul_le_mul_of_nonneg_right (le_max_left (9*mainP+8) (9*mainH)) hS
  have hB := mul_le_mul_of_nonneg_right (le_max_right (9*mainP+8) (9*mainH)) (div_nonneg hn hw.le)
  change (9*mainP+8)*S ≤ mainA₂*S at hA
  change 9*mainH*(n/w) ≤ mainA₂*(n/w) at hB
  simp only [mainEta,mainP,mainA₁,div_eq_mul_inv] at hc hT hI hI' hA hB hq hL ⊢
  nlinarith only [hc,hT,hI,hI',hA,hB,hq,hL]

lemma main_terminal_scalar (q n M C Dstar : ℝ) (hn : 0 ≤ n) (hC : 0 ≤ C)
    (hCbig : 4*(20+Dstar+18*mainP) ≤ C) (hM : M ≤ 2*mainP*n)
    (hq : q ≤ (20+Dstar)*n+(9+C*mainEta)*M) :
    q ≤ C*Batch.inductionPhi n*n := by
  have hη := mainEta_pos
  have hc := mul_le_mul_of_nonneg_left hM (by positivity : 0 ≤ 9+C*mainEta)
  have hbig := mul_le_mul_of_nonneg_right hCbig hn
  have hphi := mul_le_mul_of_nonneg_left (Batch.inductionPhi_bounds n).1 (mul_nonneg hC hn)
  have hCn : 0 ≤ C*n := mul_nonneg hC hn
  simp only [mainEta,mainP] at hc hbig hq
  nlinarith only [hq,hc,hbig,hphi,hCn]

end
end ErdosGallai

namespace ErdosGallai.Scale
noncomputable section
open Finset SimpleGraph Real
attribute [local instance] Classical.propDecidable
variable {V : Type} [Fintype V] [DecidableEq V] {P : AssignedPiece V} {Dstar : ℝ}

lemma Layers.gap_log (H : Layers P Dstar) (hn : 1 < (P.vertices.card:ℝ)) (i) :
    logb 2 (H.scale (i+200)) = scaleTheta^200 * logb 2 (H.scale i) := by
  dsimp only [Layers.scale]
  rw [inductionScale_add _ (by positivity)]
  exact Real.logb_rpow_eq_mul_logb_of_pos (inductionScale_pos _ (by linarith) _)

lemma Layers.gap_mass (H : Layers P Dstar) (hn : 1 < (P.vertices.card:ℝ))
    (hready : ∀ j < H.count, ErdosGallai.MainScaleReady 80 (H.scale j)) (i)
    (hik : i+200 < H.count) :
    H.mass (i+201) ≤ (P.vertices.card:ℝ) + ErdosGallai.mainH*P.vertices.card/logb 2 (H.scale i) := by
  have hh := H.mass_upper hn (fun j hj => (hready j hj).log_large) (i+200) hik
  rw [H.gap_log hn] at hh
  convert hh using 1 ; try omega
  unfold ErdosGallai.mainH
  simp only [div_eq_mul_inv,mul_inv_rev]
  ring

lemma Layers.gap_cycles (H : Layers P Dstar) (hn : 1 < (P.vertices.card:ℝ))
    (hready : ∀ j < H.count, ErdosGallai.MainScaleReady 80 (H.scale j)) (i)
    (hik : i+200 < H.count) :
    ((pastCycles H.system 0 (i+201) [P]).length:ℝ) ≤
      ErdosGallai.mainH*P.vertices.card/logb 2 (H.scale i) := by
  have hh := H.cycles_bound hn hready (i+200) hik
  rw [H.gap_log hn] at hh
  have hw : 0 < logb 2 (H.scale i) := inductionScale_log_pos _ hn i
  calc
    _ ≤ 20*P.vertices.card/(scaleTheta^200*logb 2 (H.scale i)) := hh
    _ ≤ 80*P.vertices.card/(scaleTheta^200*logb 2 (H.scale i)) :=
      div_le_div_of_nonneg_right (by nlinarith [(Nat.cast_nonneg P.vertices.card : (0:ℝ) ≤ _)]) (by positivity)
    _ = _ := by unfold ErdosGallai.mainH; simp only [div_eq_mul_inv,mul_inv_rev]; ring

lemma Layers.boundary_cost (H : Layers P Dstar) (hn : 1 < (P.vertices.card:ℝ))
    (hready : ∀ j < H.count, ErdosGallai.MainScaleReady 80 (H.scale j)) :
    costMass (H.frontier H.count) ≤ Dstar*P.vertices.card := by
  have hne : P.vertices.Nonempty := Finset.card_pos.mp (by exact_mod_cast (by linarith : (0:ℝ) < P.vertices.card))
  have hD : 0 ≤ Dstar := by
    have hh := H.last_lt
    have hd := inductionScale_pos P.vertices.card (by linarith) H.count
    linarith
  have hcost : ∀ Q ∈ H.frontier H.count, (decompositionCost Q.graph:ℝ) ≤ (Dstar/2)*Q.vertices.card := by
    intro Q hQ
    have hQne := advance_nonempty H.system 0 H.count [P] (by simpa using hne) Q hQ
    have hc : (0:ℝ) < Q.vertices.card := by exact_mod_cast Finset.card_pos.mpr hQne
    have hg := (div_le_iff₀ hc).mp (H.degree H.count le_rfl Q hQ)
    have hh := mul_le_mul_of_nonneg_right H.last_lt.le hc.le
    have he := (Nat.cast_le.mpr (decompositionCost_edgeCount Q.graph) : (_:ℝ) ≤ _)
    nlinarith only [hg,hh,he]
  have hh := piece_list_cost (H.frontier H.count) (Dstar/2) hcost
  have hm := mul_le_mul_of_nonneg_left (H.mass_two hn (fun j hj => (hready j hj).log_large) H.count le_rfl)
    (div_nonneg hD (by norm_num : (0:ℝ) ≤ 2))
  change costMass (H.frontier H.count) ≤ (Dstar/2)*H.mass H.count at hh
  nlinarith only [hh,hm]

lemma Layers.terminal_cost (H : Layers P Dstar) (hn : 1 < (P.vertices.card:ℝ))
    (hready : ∀ j < H.count, ErdosGallai.MainScaleReady 80 (H.scale j)) (c : ℝ)
    (hp : ∀ R ∈ pastPieces H.system 0 H.count [P], (decompositionCost R.graph:ℝ) ≤ c*R.vertices.card) :
    (decompositionCost P.graph:ℝ) ≤ (20+Dstar)*P.vertices.card + c*vertexMass (pastPieces H.system 0 H.count [P]) := by
  have hcost := past_cost H.system 0 H.count P c hp
  have he := H.boundary_cost hn hready
  obtain ⟨j,hj⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt H.positive)
  have hcy := H.cycles_bound hn hready j (by omega)
  have hw := (hready j (by omega)).log_large
  have hdiv : 20*(P.vertices.card:ℝ)/logb 2 (H.scale j) ≤ 20*P.vertices.card :=
    div_le_self (by positivity) (by linarith)
  rw [hj] at hcost he ⊢
  nlinarith only [hcost,he,hcy,hdiv]

end
end ErdosGallai.Scale

end
end
end

end OAI