import OAI.Combinatorics.CycleDecomposition.LayerCosts

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] {P : AssignedPiece V} {Dstar : ℝ}

def Layers.pieceSequence (H : Layers P Dstar) (j : ℕ) : ℝ :=
  if j < H.count then H.pieceMass j else 0

lemma Layers.pieceSequence_nonneg (H : Layers P Dstar) (j) : 0 ≤ H.pieceSequence j := by
  unfold Layers.pieceSequence
  split_ifs
  · exact vertexMass_nonneg _
  · rfl

lemma Layers.pieceSequence_zero (H : Layers P Dstar) (j) (hj : H.count ≤ j) :
    H.pieceSequence j = 0 := by simp only [Layers.pieceSequence,ite_eq_right (by omega : ¬ j < H.count)]

lemma Layers.past_mass_eq_sequence (H : Layers P Dstar) (k) (hk : k ≤ H.count) :
    vertexMass (pastPieces H.system 0 k [P]) = ∑ j ∈ range k, H.pieceSequence j := by
  rw [pastPieces_mass]
  apply Finset.sum_congr rfl
  intro j hj
  simp only [Nat.zero_add,Layers.pieceSequence,ite_eq_left (by have := Finset.mem_range.mp hj; omega : j < H.count)]

lemma Layers.prefix_choice (H : Layers P Dstar) :
    vertexMass (pastPieces H.system 0 H.count [P]) = 0 ∨
    ∃ i < H.count, 0 < H.pieceMass i ∧
      ∀ k ≤ H.count, k ≤ i+201 →
        vertexMass (pastPieces H.system 0 k [P]) ≤ ErdosGallai.mainP*H.pieceMass i := by
  by_cases he : ∃ j, 0 < H.pieceSequence j
  · right
    obtain ⟨i,hi,hpref⟩ := ErdosGallai.prefix_selection H.pieceSequence H.pieceSequence_nonneg
      200 H.count H.pieceSequence_zero he
    have hic : i < H.count := by
      by_contra hi'
      rw [H.pieceSequence_zero i (by omega)] at hi
      linarith
    simp only [Layers.pieceSequence,ite_eq_left hic] at hi
    refine ⟨i,hic,hi,?_⟩
    intro k hk hki
    rw [H.past_mass_eq_sequence k hk]
    have hh : (∑ j ∈ range k, H.pieceSequence j) ≤ ∑ j ∈ range (i+200+1), H.pieceSequence j :=
      Finset.sum_le_sum_of_subset_of_nonneg (Finset.range_mono (by omega)) (fun j _ _ => H.pieceSequence_nonneg j)
    apply hh.trans
    norm_num only [Layers.pieceSequence,ite_eq_left hic,ErdosGallai.mainP,Nat.cast_ofNat] at hpref ⊢
    exact hpref
  · left
    rw [H.past_mass_eq_sequence H.count le_rfl]
    apply Finset.sum_eq_zero
    intro j _
    exact le_antisymm (le_of_not_gt (fun h => he ⟨j,h⟩)) (H.pieceSequence_nonneg j)

end
end ErdosGallai.Scale

end

section

namespace ErdosGallai
noncomputable section
open Finset SimpleGraph Real
attribute [local instance] Classical.propDecidable

lemma main_edge_bound {V : Type} [Fintype V] (G : SimpleGraph V) :
    2*(Scale.edgeCount G:ℝ) ≤ (Fintype.card V:ℝ)^2 := by
  classical
  have h : (G.edgeFinset.card:ℝ) ≤ ((Fintype.card V).choose 2:ℝ) :=
    Nat.cast_le.mpr G.card_edgeFinset_le_card_choose_two
  rw [Nat.cast_choose_two] at h
  change 2*(G.edgeFinset.card:ℝ) ≤ _
  nlinarith [(Nat.cast_nonneg (Fintype.card V) : (0:ℝ) ≤ _)]

lemma main_cost_eq_scale {V : Type} [Fintype V] (G : SimpleGraph V) :
    decompositionCost G = Scale.decompositionCost G := by rfl
lemma main_cost_eq_batch {V : Type} [Fintype V] (G : SimpleGraph V) :
    decompositionCost G = Batch.decompositionCost G := by rfl

theorem main_cost_bound : ∃ C : ℝ, 0 < C ∧ ∀ (V : Type) [Fintype V] (G : SimpleGraph V),
    (decompositionCost G:ℝ) ≤ C*Batch.inductionPhi (Fintype.card V)*Fintype.card V := by
  classical
  let wmin : ℝ := max 80 (((mainA₁+1)/Batch.inductionDelta)^2)
  obtain ⟨Da,ha,hLayers⟩ := Scale.uniform_layers
  obtain ⟨Db,hb,hPiece⟩ := Scale.uniform_committed_piece_cost
  obtain ⟨Dc,hc,hGap⟩ := Scale.uniform_gap_prefix_cost
  obtain ⟨Dr,hr,hReady⟩ := main_scale_ready_cutoff wmin
  let Dstar : ℝ := max (max Da Db) (max Dc Dr)
  have hDa : Da ≤ Dstar := (le_max_left Da Db).trans (le_max_left _ _)
  have hDb : Db ≤ Dstar := (le_max_right Da Db).trans (le_max_left _ _)
  have hDc : Dc ≤ Dstar := (le_max_left Dc Dr).trans (le_max_right _ _)
  have hDr : Dr ≤ Dstar := (le_max_right Dc Dr).trans (le_max_right _ _)
  have hDstar : 1 < Dstar := ha.trans_le hDa
  let C : ℝ := max (4*(20+Dstar+18*mainP)) (7*mainA₂)
  have hCbig : 4*(20+Dstar+18*mainP) ≤ C := le_max_left _ _
  have hCA : 7*mainA₂ ≤ C := le_max_right _ _
  have hCpos : 0 < C := lt_of_lt_of_le (by linarith [mainP_pos]) hCbig
  have hC : 0 ≤ C := hCpos.le
  refine ⟨C,hCpos,?_⟩
  have hmain : ∀ n : ℕ, ∀ (V : Type) [Fintype V], Fintype.card V = n → ∀ (G : SimpleGraph V),
      (decompositionCost G:ℝ) ≤ C*Batch.inductionPhi (Fintype.card V)*Fintype.card V := by
    intro n
    induction n using Nat.strong_induction_on with
    | h n ih =>
      intro V _ hn G
      subst n
      have hn0 : (0:ℝ) ≤ Fintype.card V := Nat.cast_nonneg _
      by_cases hsmall : (Fintype.card V:ℝ) < Dstar
      · have he := main_edge_bound G
        have hq : (decompositionCost G:ℝ) ≤ Scale.edgeCount G :=
          Nat.cast_le.mpr (Scale.decompositionCost_edgeCount G)
        have hnD := mul_le_mul_of_nonneg_right hsmall.le hn0
        have hphi := mul_le_mul_of_nonneg_left (Batch.inductionPhi_bounds (Fintype.card V)).1
          (mul_nonneg hC hn0)
        have hbig := mul_le_mul_of_nonneg_right hCbig hn0
        have hP := mul_nonneg mainP_pos.le hn0
        nlinarith only [he,hq,hnD,hphi,hbig,hP]
      · have hnD : Dstar ≤ (Fintype.card V:ℝ) := le_of_not_gt hsmall
        have hn1 : 1 < (Fintype.card V:ℝ) := hDstar.trans_le hnD
        let P : Scale.AssignedPiece V := ⟨univ,G,fun _ _ _ => ⟨mem_univ _,mem_univ _⟩⟩
        have hpc : P.vertices.card = Fintype.card V := Finset.card_univ
        have hp1 : 1 < (P.vertices.card:ℝ) := by simpa only [hpc] using hn1
        have hdeg : 2*(Scale.edgeCount P.graph:ℝ)/P.vertices.card ≤ P.vertices.card := by
          apply (div_le_iff₀ (by linarith : (0:ℝ) < P.vertices.card)).mpr
          simpa only [hpc,P,pow_two] using main_edge_bound G
        obtain ⟨H⟩ := hLayers Dstar hDa V P (by simpa only [hpc] using hnD) hdeg
        have hready' : ∀ j < H.count, MainScaleReady wmin (H.scale j) := by
          intro j hj
          exact hReady _ (hDr.trans (H.cutoff j hj))
        have hready : ∀ j < H.count, MainScaleReady 80 (H.scale j) := by
          intro j hj
          have hh := hready' j hj
          exact ⟨hh.gt_one,(le_max_left _ _).trans hh.log_large,hh.cycle_power,hh.batch_power,
            hh.bad_power,hh.skip_power,hh.active_eight⟩
        have ihw : ∀ (Q : Type) [Fintype Q] (F : SimpleGraph Q), Fintype.card Q < P.vertices.card →
            (decompositionCost F:ℝ) ≤ C*Fintype.card Q := by
          intro Q _ F hQ
          have hh := ih (Fintype.card Q) (by simpa only [hpc] using hQ) Q rfl F
          have hp := mul_le_mul_of_nonneg_left (Batch.inductionPhi_bounds (Fintype.card Q)).2
            (mul_nonneg hC (Nat.cast_nonneg (Fintype.card Q) : (0:ℝ) ≤ _))
          nlinarith only [hh,hp]
        have hpieces := hPiece Dstar hDb V P H C hC ihw
        have terminal (hm : Scale.vertexMass (Scale.pastPieces H.system 0 H.count [P]) ≤
            2*mainP*P.vertices.card) :
            (decompositionCost G:ℝ) ≤ C*Batch.inductionPhi (Fintype.card V)*Fintype.card V := by
          have hh := H.terminal_cost hp1 hready (9+C*mainEta) (hpieces H.count le_rfl)
          have ht := main_terminal_scalar _ P.vertices.card _ C Dstar (Nat.cast_nonneg _) hC hCbig hm hh
          simpa only [hpc,P,← main_cost_eq_scale] using ht
        rcases H.prefix_choice with hz | ⟨i,hic,hi,hprefix⟩
        · apply terminal
          rw [hz]
          exact mul_nonneg (mul_nonneg (by norm_num) mainP_pos.le) (Nat.cast_nonneg _)
        · by_cases hgap : i+200 < H.count
          · let t := C*Batch.inductionPhi ((H.scale i)^(3/10:ℝ))
            have ht : 0 ≤ t := mul_nonneg hC (by linarith [(Batch.inductionPhi_bounds ((H.scale i)^(3/10:ℝ))).1])
            have ihq : ∀ (Q : Type) [Fintype Q] (F : SimpleGraph Q), Fintype.card Q < P.vertices.card →
                (Fintype.card Q:ℝ) ≤ (H.scale i)^(3/10:ℝ) →
                (Batch.decompositionCost F:ℝ) ≤ t*Fintype.card Q := by
              intro Q _ F hQ hQD
              have hh := ih (Fintype.card Q) (by simpa only [hpc] using hQ) Q rfl F
              by_cases h0 : Fintype.card Q = 0
              · simpa only [h0,Nat.cast_zero,mul_zero,← main_cost_eq_batch] using hh
              · have h1 : (1:ℝ) ≤ Fintype.card Q := by exact_mod_cast (by omega : 1 ≤ Fintype.card Q)
                have hp := Batch.inductionPhi_monotone h1 (h1.trans hQD) hQD
                have hp' := mul_le_mul_of_nonneg_left hp
                  (mul_nonneg hC (Nat.cast_nonneg (Fintype.card Q) : (0:ℝ) ≤ _))
                change (decompositionCost F:ℝ) ≤ C*Batch.inductionPhi ((H.scale i)^(3/10:ℝ))*Fintype.card Q
                nlinarith only [hh,hp']
            have hlocal := hGap Dstar hDc V P H hp1 hready i hgap C t hC ht ihw ihq
              (hpieces (i+201) (by omega))
            have hscalar := main_gap_scalar _ P.vertices.card (H.pieceMass i)
              (Scale.vertexMass (Scale.pastPieces H.system 0 (i+201) [P]))
              ((Scale.pastCycles H.system 0 (i+201) [P]).length:ℝ)
              (H.mass (i+201)) (H.mass (i+1)) C t (logb 2 (H.scale i))
              (Nat.cast_nonneg _) (Scale.vertexMass_nonneg _) hC ht
              (by linarith [(hready i hic).log_large])
              (hprefix (i+201) (by omega) le_rfl) (H.gap_cycles hp1 hready i hgap)
              (H.gap_mass hp1 hready i hgap) (H.mass_lower (i+1))
              (H.mass_two hp1 (fun j hj => (hready j hj).log_large) (i+1) (by omega)) hlocal
            have habs := Batch.induction_cost_absorbed (H.scale i) P.vertices.card (H.pieceMass i)
              C mainA₁ mainA₂ (hready i hic).gt_one (Scale.inductionScale_le _ hp1.le i)
              (Scale.vertexMass_nonneg _) hC mainA₁_nonneg mainA₂_nonneg hCA
              (by linarith [(hready i hic).log_large])
              ((le_max_right _ _).trans (hready' i hic).log_large)
            have hfinal := hscalar.trans habs
            simpa only [hpc,P,← main_cost_eq_scale] using hfinal
          · apply terminal
            calc
              _ ≤ mainP*H.pieceMass i := hprefix H.count le_rfl (by omega)
              _ ≤ mainP*(2*P.vertices.card) := mul_le_mul_of_nonneg_left
                (H.pieceMass_two hp1 (fun j hj => (hready j hj).log_large) i hic) mainP_pos.le
              _ = _ := by ring
  intro V _ G
  exact hmain (Fintype.card V) V rfl G

theorem erdos_gallai : MainStatement := by
  obtain ⟨C,hC,hcost⟩ := main_cost_bound
  refine ⟨C,hC,?_⟩
  intro n G
  refine ⟨decompositionCost G,decompositionCost_spec G,?_⟩
  have hh := hcost (Fin n) G
  simp only [Fintype.card_fin] at hh
  have hp := mul_le_mul_of_nonneg_left (Batch.inductionPhi_bounds n).2
    (mul_nonneg hC.le (Nat.cast_nonneg n : (0:ℝ) ≤ _))
  nlinarith only [hh,hp]

end
end ErdosGallai

end

end
end

end OAI