import OAI.Combinatorics.CycleDecomposition.DepthFirstSearch

namespace OAI

universe cycleUniverse1 cycleUniverse2 cycleUniverse3 cycleUniverse4 cycleUniverse5 cycleUniverse6 cycleUniverse7 cycleUniverse8 cycleUniverse9 cycleUniverse10 cycleUniverse11 cycleUniverse12 cycleUniverse13

section
open Filter Asymptotics Real
open scoped Topology
noncomputable section
open MeasureTheory ProbabilityTheory Finset
section
namespace ErdosGallai.Scale
open Finset SimpleGraph
variable {V : Type cycleUniverse1} [Fintype V] [DecidableEq V]
def avoidGraph (G : SimpleGraph V) (J : Finset V) : SimpleGraph V where
  Adj x y := G.Adj x y ∧ x ∉ J ∧ y ∉ J
  symm := ⟨fun _x _y h => ⟨h.1.symm,h.2.2,h.2.1⟩⟩
  loopless := ⟨fun _x h => G.irrefl h.1⟩

lemma chain_reachable {V : Type cycleUniverse2} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] {H : SimpleGraph V} {L : List V} (hL : L.IsChain H.Adj)
    {x y : V} (hx : x ∈ L) (hy : y ∈ L) : H.Reachable x y := by
  let : Trans H.Reachable H.Reachable H.Reachable := ⟨fun h₁ h₂ => h₁.trans h₂⟩
  cases L with
  | nil => simp at hx
  | cons a L =>
    have hC : (a::L).IsChain H.Reachable := hL.imp (fun _ _ h => h.reachable)
    have ha : ∀ b ∈ a::L, H.Reachable a b := by
      intro b hb
      rcases List.mem_cons.mp hb with rfl|hb
      · exact .refl _
      · exact hC.rel_cons hb
    exact (ha x hx).symm.trans (ha y hy)

theorem connector_exists (G : SimpleGraph V) [DecidableRel G.Adj]
    (α m : ℝ) (hα : 0 ≤ α) (hexp : VertexExpansion G α)
    (X Z J : Finset V) (hX : X.Nonempty) (hZ : Z.Nonempty)
    (hXJ : Disjoint X J) (hZJ : Disjoint Z J)
    (hconnX : ∀ x ∈ X, ∀ y ∈ X, (avoidGraph G J).Reachable x y)
    (_hconnZ : ∀ x ∈ Z, ∀ y ∈ Z, (avoidGraph G J).Reachable x y)
    (hmX : m ≤ (X.card : ℝ)) (hmZ : m ≤ (Z.card : ℝ))
    (hJ : (J.card : ℝ) < α*m) :
    ∃ x ∈ X, ∃ z ∈ Z, (avoidGraph G J).Reachable x z := by
  classical
  by_contra hn
  obtain ⟨x,hx⟩ := hX
  obtain ⟨z,hz⟩ := hZ
  let H := avoidGraph G J
  let A : Finset V := univ.filter (fun v => v ∉ J ∧ H.Reachable x v)
  let B : Finset V := univ \ (J ∪ A)
  have hXA : X ⊆ A := by
    intro y hy
    exact mem_filter.mpr ⟨mem_univ _,
      (Finset.disjoint_left.mp hXJ hy), hconnX x hx y hy⟩
  have hZA : ∀ y ∈ Z, ¬ H.Reachable x y := by
    intro y hy hr
    exact hn ⟨x,hx,y,hy,hr⟩
  have hZB : Z ⊆ B := by
    intro y hy
    simp only [B, Finset.mem_sdiff, mem_univ, true_and, mem_union, not_or]
    refine ⟨Finset.disjoint_left.mp hZJ hy, ?_⟩
    intro ha
    exact hZA y hy (mem_filter.mp ha).2.2
  have hAB : Disjoint A B := by
    apply Finset.disjoint_left.mpr
    intro y ha hb
    exact (mem_sdiff.mp hb).2 (mem_union_right J ha)
  have hc : A.card + B.card ≤ Fintype.card V := by
    rw [← card_union_of_disjoint hAB]
    exact card_le_univ _
  have hboundaryA : externalNeighbors G A ⊆ J := by
    intro v hv
    obtain ⟨_,hva,u,hu,hadj⟩ := mem_filter.mp hv
    by_contra hvj
    obtain ⟨_,huj,hru⟩ := mem_filter.mp hu
    have hadjH : H.Adj u v := ⟨hadj,huj,hvj⟩
    exact hva (mem_filter.mpr ⟨mem_univ _,hvj,hru.trans hadjH.reachable⟩)
  have hboundaryB : externalNeighbors G B ⊆ J := by
    intro v hv
    obtain ⟨_,hvb,u,hu,hadj⟩ := mem_filter.mp hv
    by_contra hvj
    have hva : v ∈ A := by
      by_contra hna
      exact hvb (mem_sdiff.mpr ⟨mem_univ _, by simpa using And.intro hvj hna⟩)
    obtain ⟨_,_,hrv⟩ := mem_filter.mp hva
    have huj : u ∉ J := fun h => (mem_sdiff.mp hu).2 (mem_union_left A h)
    have hadjH : H.Adj v u := ⟨hadj.symm,hvj,huj⟩
    have hua : u ∈ A := mem_filter.mpr ⟨mem_univ _,huj,hrv.trans hadjH.reachable⟩
    exact (mem_sdiff.mp hu).2 (mem_union_right J hua)
  have hcontr (Q : Finset V) (hne : Q.Nonempty) (hsmall : 2*Q.card ≤ Fintype.card V)
      (hm : m ≤ (Q.card : ℝ)) (hb : externalNeighbors G Q ⊆ J) : False := by
    have he := hexp Q hne hsmall
    have hc : ((externalNeighbors G Q).card : ℝ) ≤ J.card := by
      exact_mod_cast card_le_card hb
    have hh := mul_le_mul_of_nonneg_left hm hα
    linarith
  by_cases hsmall : 2*A.card ≤ Fintype.card V
  · exact hcontr A ⟨x,hXA hx⟩ hsmall
      (hmX.trans (by exact_mod_cast card_le_card hXA)) hboundaryA
  · exact hcontr B ⟨z,hZB hz⟩ (by omega)
      (hmZ.trans (by exact_mod_cast card_le_card hZB)) hboundaryB

lemma avoid_support {V : Type cycleUniverse3} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (G : SimpleGraph V) (J : Finset V) {x z : V}
    (p : (avoidGraph G J).Walk x z) (hx : x ∉ J) :
    ∀ w ∈ p.support, w ∉ J := by
  induction p with
  | nil => simpa using hx
  | @cons u v z hadj p ih =>
    intro w hw
    rcases List.mem_cons.mp hw with rfl|hw
    · exact hx
    · exact ih hadj.2.2 w hw

theorem shortest_set_connector (G : SimpleGraph V) (X Z J : Finset V)
    (hXJ : Disjoint X J)
    (hr : ∃ x ∈ X, ∃ z ∈ Z, (avoidGraph G J).Reachable x z) :
    ∃ x ∈ X, ∃ z ∈ Z, ∃ p : G.Walk x z,
      p.IsPath ∧ ∀ w ∈ p.support, w ∉ J ∧ (w ∈ X → w = x) ∧ (w ∈ Z → w = z) := by
  classical
  let H := avoidGraph G J
  let P : ℕ → Prop := fun k => ∃ x ∈ X, ∃ z ∈ Z, ∃ p : H.Walk x z,
    p.IsPath ∧ p.length = k
  have hP : ∃ k, P k := by
    obtain ⟨x,hx,z,hz,hr⟩ := hr
    obtain ⟨p,hp⟩ := hr.exists_isPath
    exact ⟨p.length,x,hx,z,hz,p,hp,rfl⟩
  obtain ⟨x,hx,z,hz,p,hp,hplen⟩ := Nat.find_spec hP
  have hmin : ∀ a ∈ X, ∀ b ∈ Z, ∀ q : H.Walk a b, q.IsPath → p.length ≤ q.length := by
    intro a ha b hb q hq
    rw [hplen]
    exact Nat.find_min' hP ⟨a,ha,b,hb,q,hq,rfl⟩
  have hsub : H ≤ G := fun _ _ h => h.1
  refine ⟨x,hx,z,hz,p.mapLe hsub,(hp.mapLe hsub),?_⟩
  intro w hw
  rw [Walk.support_mapLe_eq_support] at hw
  refine ⟨avoid_support G J p (Finset.disjoint_left.mp hXJ hx) w hw,?_,?_⟩
  · intro hwX
    by_contra hne
    have hlt := Walk.length_dropUntil_lt_length hw hne
    have hle := hmin w hwX z hz (p.dropUntil w hw) (hp.dropUntil hw)
    omega
  · intro hwZ
    by_contra hne
    have hlt := Walk.length_takeUntil_lt_length hw hne
    have hle := hmin x hx w hwZ (p.takeUntil w hw) (hp.takeUntil hw)
    omega

lemma path_cons_append {V : Type cycleUniverse4} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (G : SimpleGraph V) (x z : V) (B : List V)
    (hC : (x :: (B ++ [z])).IsChain G.Adj) :
    ∃ p : G.Walk x z, p.support = x :: (B ++ [z]) := by
  let L := x :: (B ++ [z])
  have hn : L ≠ [] := by simp [L]
  let p := Walk.ofSupport L hn hC
  have hx : L.head hn = x := rfl
  have hz : L.getLast hn = z := by simp [L]
  exact ⟨p.copy hx hz, by
    change ((Walk.ofSupport L hn hC).copy hx hz).support = L
    rw [Walk.support_copy, Walk.support_ofSupport]⟩

theorem cycle_across_middle (G : SimpleGraph V) (X J Z : List V)
    (hnd : (X ++ J ++ Z).Nodup) (hC : (X ++ J ++ Z).IsChain G.Adj)
    (hj : 1 ≤ J.length)
    (hc : ∃ x ∈ X, ∃ z ∈ Z, ∃ q : G.Walk x z,
      q.IsPath ∧ ∀ w ∈ q.support, w ∉ J ∧ (w ∈ X → w = x) ∧ (w ∈ Z → w = z)) :
    ∃ a : V, ∃ c : G.Walk a a, c.IsCycle ∧ J.length + 2 ≤ c.length := by
  obtain ⟨x,hx,z,hz,q,hq,havoid⟩ := hc
  obtain ⟨A,B,hX⟩ := List.mem_iff_append.mp hx
  obtain ⟨C,D,hZ⟩ := List.mem_iff_append.mp hz
  let M := x :: ((B ++ J ++ C) ++ [z])
  have heq : X ++ J ++ Z = A ++ (M ++ D) := by
    simp [hX,hZ,M,List.append_assoc]
  have hMC : M.IsChain G.Adj := by
    rw [heq] at hC
    exact hC.right_of_append.left_of_append
  have hMN : M.Nodup := by
    rw [heq] at hnd
    exact (List.nodup_append.mp (List.nodup_append.mp hnd).2.1).1
  obtain ⟨p,hpS⟩ := path_cons_append G x z (B ++ J ++ C) hMC
  have hp : p.IsPath := by
    rw [Walk.isPath_def,hpS]
    exact hMN
  have hlen : J.length + 1 ≤ p.length := by
    have ht := p.length_support
    rw [hpS] at ht
    simp only [List.length_cons,List.length_append] at ht
    omega
  have hxs : x ∉ p.support.tail := by
    have hn := hp.support_nodup
    rw [← p.cons_tail_support] at hn
    exact (List.nodup_cons.mp hn).1
  have hzs : z ∉ q.reverse.support.tail := by
    have hn := hq.reverse.support_nodup
    rw [← q.reverse.cons_tail_support] at hn
    exact (List.nodup_cons.mp hn).1
  have hdis : p.support.tail.Disjoint q.reverse.support.tail := by
    apply List.disjoint_left.mpr
    intro w hwP hwQ
    have hwq : w ∈ q.support := by
      simpa using List.mem_of_mem_tail hwQ
    obtain ⟨hwJ,hwX,hwZ⟩ := havoid w hwq
    have hwp : w ∈ X ++ J ++ Z := by
      rw [heq]
      have : w ∈ M := by
        change w ∈ x :: ((B ++ J ++ C) ++ [z])
        rw [← hpS]
        exact List.mem_of_mem_tail hwP
      simp only [List.mem_append]
      exact Or.inr (Or.inl this)
    simp only [List.mem_append] at hwp
    rcases hwp with (hw|hw)|hw
    · exact hxs (hwX hw ▸ hwP)
    · exact hwJ hw
    · exact hzs (hwZ hw ▸ hwQ)
  have hxz : x ≠ z := by
    intro he
    have hz : z ∈ p.support.tail := by simp [hpS]
    exact hxs (he ▸ hz)
  have hqlen : 1 ≤ q.length := by
    by_contra hh
    have : q.length = 0 := by omega
    exact hxz (Walk.eq_of_length_eq_zero this)
  refine ⟨x,p.append q.reverse,hp.isCycle_append hq.reverse hdis (Or.inl (by omega)),?_⟩
  simp only [Walk.length_append,Walk.length_reverse]
  omega

theorem long_cycle_of_vertex_expansion (G : SimpleGraph V) [DecidableRel G.Adj]
    (α : ℝ) (hα : 0 < α) (hα1 : α ≤ 1) (hexp : VertexExpansion G α)
    (hq : 1 ≤ α^2 * Fintype.card V / 100) :
    ∃ a : V, ∃ c : G.Walk a a, c.IsCycle ∧
      α^2 * Fintype.card V / 100 < (c.length : ℝ) := by
  classical
  obtain ⟨L,hnd,hchain,hL⟩ := exists_long_stack G α hα1 hexp
  let q := α^2 * Fintype.card V / 100
  let j := ⌊q⌋₊
  have hq0 : 0 ≤ q := by dsimp [q]; linarith
  have hjle : (j : ℝ) ≤ q := Nat.floor_le hq0
  have hjlt : q < (j : ℝ)+1 := Nat.lt_floor_add_one q
  have hj1 : 1 ≤ j := by exact (Nat.le_floor_iff hq0).mpr (by simpa [q] using hq)
  have hL0 : (0 : ℝ) ≤ L.length := Nat.cast_nonneg _
  have hu0 : (0 : ℝ) ≤ Fintype.card V := Nat.cast_nonneg _
  have haa : α^2 ≤ α := by nlinarith
  have hqq : 2*q ≤ α * Fintype.card V / 6 := by
    have hh := mul_le_mul_of_nonneg_right haa hu0
    dsimp [q]
    nlinarith [mul_nonneg (le_of_lt hα) hu0]
  have hround : 2*(j+1) ≤ L.length := by
    have hroundR : 2*((j:ℝ)+1) ≤ (L.length:ℝ) := by
      have hq1 : 1 ≤ q := hq
      linarith
    exact_mod_cast hroundR
  let k := (L.length-j)/2
  let X := L.take k
  let J := (L.drop k).take j
  let Z := (L.drop k).drop j
  have heq : L = X ++ J ++ Z := by
    dsimp [X,J,Z]
    rw [List.append_assoc,List.take_append_drop,List.take_append_drop]
  have hk : k ≤ L.length := by dsimp [k]; omega
  have hjdrop : j ≤ (L.drop k).length := by simp only [List.length_drop]; dsimp [k]; omega
  have hXlen : X.length = k := by simp [X,List.length_take, min_eq_left hk]
  have hJlen : J.length = j := by dsimp [J]; rw [List.length_take, min_eq_left hjdrop]
  have hZlen : Z.length = L.length-k-j := by simp only [Z,List.length_drop]
  have houterX : L.length ≤ 4*X.length := by rw [hXlen]; dsimp [k]; omega
  have houterZ : L.length ≤ 4*Z.length := by rw [hZlen]; dsimp [k]; omega
  rw [heq] at hnd hchain
  have hnX : X.Nodup := (List.nodup_append.mp (List.nodup_append.mp hnd).1).1
  have hnJ : J.Nodup := (List.nodup_append.mp (List.nodup_append.mp hnd).1).2.1
  have hnZ : Z.Nodup := (List.nodup_append.mp hnd).2.1
  have hXJ : X.Disjoint J := (List.nodup_append.mp hnd).1.disjoint
  have hZJ : Z.Disjoint J := by
    have hd := hnd.disjoint
    exact List.disjoint_left.mpr (fun w hwz hwj =>
      List.disjoint_left.mp hd (List.mem_append_right X hwj) hwz)
  have hXJf : Disjoint X.toFinset J.toFinset := by
    apply Finset.disjoint_left.mpr
    intro w hw hJw
    exact List.disjoint_left.mp hXJ (List.mem_toFinset.mp hw) (List.mem_toFinset.mp hJw)
  have hZJf : Disjoint Z.toFinset J.toFinset := by
    apply Finset.disjoint_left.mpr
    intro w hw hJw
    exact List.disjoint_left.mp hZJ (List.mem_toFinset.mp hw) (List.mem_toFinset.mp hJw)
  have hconnX : ∀ x ∈ X.toFinset, ∀ y ∈ X.toFinset,
      (avoidGraph G J.toFinset).Reachable x y := by
    intro x hx y hy
    apply chain_reachable (L := X) _ (List.mem_toFinset.mp hx) (List.mem_toFinset.mp hy)
    apply hchain.left_of_append.left_of_append.imp_of_mem_imp
    intro a b ha hb hab
    exact ⟨hab,fun hj => List.disjoint_left.mp hXJ ha (List.mem_toFinset.mp hj),
      fun hj => List.disjoint_left.mp hXJ hb (List.mem_toFinset.mp hj)⟩
  have hconnZ : ∀ x ∈ Z.toFinset, ∀ y ∈ Z.toFinset,
      (avoidGraph G J.toFinset).Reachable x y := by
    intro x hx y hy
    apply chain_reachable (L := Z) _ (List.mem_toFinset.mp hx) (List.mem_toFinset.mp hy)
    apply hchain.right_of_append.imp_of_mem_imp
    intro a b ha hb hab
    exact ⟨hab,fun hj => List.disjoint_left.mp hZJ ha (List.mem_toFinset.mp hj),
      fun hj => List.disjoint_left.mp hZJ hb (List.mem_toFinset.mp hj)⟩
  have hXne : X.toFinset.Nonempty := by
    rw [← Finset.card_pos,List.toFinset_card_of_nodup hnX]
    omega
  have hZne : Z.toFinset.Nonempty := by
    rw [← Finset.card_pos,List.toFinset_card_of_nodup hnZ]
    omega
  have hmX : (L.length : ℝ)/4 ≤ X.toFinset.card := by
    rw [List.toFinset_card_of_nodup hnX]
    have : (L.length : ℝ) ≤ 4*(X.length:ℝ) := by exact_mod_cast houterX
    linarith
  have hmZ : (L.length : ℝ)/4 ≤ Z.toFinset.card := by
    rw [List.toFinset_card_of_nodup hnZ]
    have : (L.length : ℝ) ≤ 4*(Z.length:ℝ) := by exact_mod_cast houterZ
    linarith
  have hsmallJ : (J.toFinset.card : ℝ) < α*((L.length:ℝ)/4) := by
    rw [List.toFinset_card_of_nodup hnJ,hJlen]
    have hmul := mul_le_mul_of_nonneg_left hL (le_of_lt hα)
    dsimp [q] at hjle
    nlinarith
  obtain ⟨x,hx,z,hz,p,hp,hpavoid⟩ := shortest_set_connector G X.toFinset Z.toFinset J.toFinset hXJf
    (connector_exists G α ((L.length:ℝ)/4) (le_of_lt hα) hexp
      X.toFinset Z.toFinset J.toFinset hXne hZne hXJf hZJf hconnX hconnZ hmX hmZ hsmallJ)
  obtain ⟨a,c,hc,hlen⟩ := cycle_across_middle G X J Z hnd hchain (by omega)
    ⟨x,List.mem_toFinset.mp hx,z,List.mem_toFinset.mp hz,p,hp,by simpa using hpavoid⟩
  refine ⟨a,c,hc,?_⟩
  rw [hJlen] at hlen
  have hlR : (j:ℝ)+2 ≤ c.length := by exact_mod_cast hlen
  change q < (c.length:ℝ)
  linarith

end ErdosGallai.Scale

namespace ErdosGallai.Scale
open Classical
end ErdosGallai.Scale
namespace ErdosGallai.Scale
open Finset SimpleGraph Classical
variable {V : Type cycleUniverse5} [Fintype V] [DecidableEq V]

def SupportedOn (G : SimpleGraph V) (A : Finset V) : Prop :=
  ∀ ⦃x y⦄, G.Adj x y → x ∈ A ∧ y ∈ A

structure AssignedPiece (V : Type cycleUniverse6) [DecidableEq V] where
  vertices : Finset V
  graph : SimpleGraph V
  supported : SupportedOn graph vertices

noncomputable def restrictGraph (G : SimpleGraph V) (A : Finset V) : SimpleGraph V where
  Adj x y := G.Adj x y ∧ x ∈ A ∧ y ∈ A
  symm := ⟨fun _ _ h => ⟨h.1.symm,h.2.2,h.2.1⟩⟩
  loopless := ⟨fun _ h => G.irrefl h.1⟩

noncomputable def crossingGraph (G : SimpleGraph V) (A B : Finset V) : SimpleGraph V where
  Adj x y := G.Adj x y ∧ ((x ∈ A ∧ y ∈ B) ∨ (x ∈ B ∧ y ∈ A))
  symm := ⟨fun _ _ h => ⟨h.1.symm, h.2.elim (fun h => Or.inr ⟨h.2,h.1⟩)
    (fun h => Or.inl ⟨h.2,h.1⟩)⟩⟩
  loopless := ⟨fun _ h => G.irrefl h.1⟩

noncomputable def edgeOccurrences (L : List (SimpleGraph V)) (x y : V) : ℕ := by
  classical
  exact L.countP (fun H => H.Adj x y)

def GraphPartition (G : SimpleGraph V) (L : List (SimpleGraph V)) : Prop :=
  ∀ x y, edgeOccurrences L x y = if G.Adj x y then 1 else 0

noncomputable def edgeCount (G : SimpleGraph V) : ℕ := by
  classical
  exact G.edgeFinset.card

noncomputable def cutCount (G : SimpleGraph V) (A B : Finset V) : ℕ := by
  classical
  exact (G.interedges A B).card

def CutExpansionOn (G : SimpleGraph V) (A : Finset V) (h : ℝ) : Prop :=
  ∀ U ⊆ A, h * min (U.card : ℝ) ((A \ U).card : ℝ) ≤ cutCount G U (A \ U)

@[simp] lemma edgeOccurrences_nil {V : Type cycleUniverse7} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (x y : V) : edgeOccurrences [] x y = 0 := by
  classical
  simp [edgeOccurrences]
@[simp] lemma edgeOccurrences_cons {V : Type cycleUniverse8} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (H : SimpleGraph V) (L) (x y : V) :
    edgeOccurrences (H::L) x y = (if H.Adj x y then 1 else 0) + edgeOccurrences L x y := by
  classical
  simp [edgeOccurrences, List.countP_cons, Nat.add_comm]
@[simp] lemma edgeOccurrences_append {V : Type cycleUniverse9} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (L M : List (SimpleGraph V)) (x y : V) :
    edgeOccurrences (L++M) x y = edgeOccurrences L x y + edgeOccurrences M x y := by
  classical
  simp [edgeOccurrences]

lemma restrictGraph_le {V : Type cycleUniverse10} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (G : SimpleGraph V) (A : Finset V) : restrictGraph G A ≤ G :=
  fun _ _ h => h.1
lemma restrictGraph_supported {V : Type cycleUniverse11} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (G : SimpleGraph V) (A : Finset V) :
    SupportedOn (restrictGraph G A) A := fun _ _ h => h.2

lemma partition_member_le {V : Type cycleUniverse12} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] {G : SimpleGraph V} {L : List (SimpleGraph V)}
    (h : GraphPartition G L) {H : SimpleGraph V} (hH : H ∈ L) : H ≤ G := by
  classical
  intro x y hxy
  by_contra hn
  have hc := h x y
  simp only [hn, ite_false] at hc
  have hp : 0 < edgeOccurrences L x y := by
    simpa [edgeOccurrences, List.countP_pos_iff] using (show ∃ K ∈ L, K.Adj x y from ⟨H,hH,hxy⟩)
  omega

@[simp] lemma edgeCount_bot {V : Type cycleUniverse13} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] : edgeCount (⊥ : SimpleGraph V) = 0 := by
  classical
  apply Finset.card_eq_zero.mpr
  apply Finset.eq_empty_iff_forall_notMem.mpr
  intro e he
  simp only [SimpleGraph.mem_edgeFinset, SimpleGraph.edgeSet_bot, Set.mem_empty_iff_false] at he

open Real

noncomputable def splitPotential (T x : ℝ) : ℝ :=
  1 + 1 / logb 2 (T/2) - 1 / logb 2 (max x (T/2))

lemma logb_four_thirds : (1/4:ℝ) ≤ logb 2 (4/3) := by
  have h := Real.logb_le_logb_of_le (b:=2) (x:=2) (y:=(4/3:ℝ)^4)
    (by norm_num) (by norm_num) (by norm_num)
  rw [Real.logb_pow] at h
  norm_num only [Real.logb_self_eq_one, Nat.cast_ofNat] at h
  have hlog : 0 < Real.log 2 := Real.log_pos (by norm_num)
  nlinarith

lemma splitPotential_bounds (T x : ℝ) (hT : 4 ≤ T) :
    1 ≤ splitPotential T x ∧ splitPotential T x ≤ 2 := by
  have hbase : 1 ≤ logb 2 (T/2) := by
    have hh := Real.logb_le_logb_of_le (b:=2) (x:=2) (y:=T/2)
      (by norm_num) (by norm_num) (by linarith)
    norm_num [Real.logb] at hh
    exact hh
  have hlog := Real.logb_le_logb_of_le (b:=2) (x:=T/2) (y:=max x (T/2))
    (by norm_num) (by linarith) (le_max_right _ _)
  have hsmall : 0 < logb 2 (T/2) := by linarith
  have hbig : 0 < logb 2 (max x (T/2)) := by linarith
  have hrecip : 1 / logb 2 (max x (T/2)) ≤ 1 / logb 2 (T/2) :=
    one_div_le_one_div_of_le hsmall hlog
  have hrecipone : 1/logb 2 (T/2) ≤ 1 := (div_le_one hsmall).mpr hbase
  dsimp [splitPotential]
  constructor
  · linarith
  · linarith [one_div_pos.mpr hbig]

lemma splitPotential_monotone (T : ℝ) (hT : 4 ≤ T) : Monotone (splitPotential T) := by
  intro x y hxy
  have hpos : 0 < T/2 := by linarith
  have hlogx : 0 < logb 2 (max x (T/2)) :=
    Real.logb_pos (by norm_num) (lt_of_lt_of_le (by linarith : 1 < T/2) (le_max_right _ _))
  have hlog := Real.logb_le_logb_of_le (b:=2) (by norm_num)
    (lt_of_lt_of_le hpos (le_max_right x (T/2))) (max_le_max hxy le_rfl)
  have hi := one_div_le_one_div_of_le hlogx hlog
  dsimp [splitPotential]
  linarith

lemma split_potential_decrement (T u u₁ : ℝ) (hT : 4 ≤ T) (hu : T < u)
    (h₁ : u₁ ≤ 3*u/4) :
    (1/4:ℝ)/(logb 2 u)^2 ≤ splitPotential T u - splitPotential T u₁ := by
  let M := max u₁ (T/2)
  have hu0 : 0 < u := by linarith
  have hM0 : 0 < M := lt_of_lt_of_le (by linarith : 0 < T/2) (le_max_right _ _)
  have hMu : M ≤ 3*u/4 := max_le h₁ (by linarith)
  have hMlt : M ≤ u := by linarith
  have hLu : 0 < logb 2 u := Real.logb_pos (by norm_num) (by linarith)
  have hLM : 0 < logb 2 M := Real.logb_pos (by norm_num)
    (lt_of_lt_of_le (by linarith : 1 < T/2) (le_max_right _ _))
  have hlle : logb 2 M ≤ logb 2 u :=
    Real.logb_le_logb_of_le (by norm_num) hM0 hMlt
  have hquot : (4/3:ℝ) ≤ u/M := (le_div_iff₀ hM0).mpr (by linarith)
  have hlogq := Real.logb_le_logb_of_le (b:=2) (x:=4/3) (y:=u/M)
    (by norm_num) (by norm_num) hquot
  rw [Real.logb_div hu0.ne' hM0.ne'] at hlogq
  have hgap : (1/4:ℝ) ≤ logb 2 u - logb 2 M := logb_four_thirds.trans hlogq
  have hmax : max u (T/2) = u := max_eq_left (by linarith)
  dsimp [splitPotential]
  rw [hmax]
  change (1/4:ℝ)/(logb 2 u)^2 ≤
    (1+1/logb 2 (T/2)-1/logb 2 u) - (1+1/logb 2 (T/2)-1/logb 2 M)
  have hid : (1+1/logb 2 (T/2)-1/logb 2 u) - (1+1/logb 2 (T/2)-1/logb 2 M) =
      (logb 2 u-logb 2 M)/(logb 2 M*logb 2 u) := by field_simp; ring
  rw [hid]
  apply (div_le_div_iff₀ (sq_pos_of_pos hLu) (mul_pos hLM hLu)).mpr
  have hm := mul_le_mul_of_nonneg_right hlle hLu.le
  nlinarith [sq_nonneg (logb 2 u)]

lemma split_potential_subadditive (T u u₁ u₂ : ℝ) (hT : 4 ≤ T) (hu : T < u)
    (hu₁ : 0 ≤ u₁) (hu₂ : 0 ≤ u₂) (h₁ : u₁ ≤ 3*u/4) (h₂ : u₂ ≤ u)
    (hsum : u₁+u₂ ≤ u+(1/32:ℝ)*u₁/(logb 2 u)^2) :
    u₁*splitPotential T u₁ + u₂*splitPotential T u₂ ≤ u*splitPotential T u := by
  have hdec := split_potential_decrement T u u₁ hT hu h₁
  have hmono := splitPotential_monotone T hT h₂
  obtain ⟨hfpos,hfhi⟩ := splitPotential_bounds T u hT
  have h₁cost := mul_le_mul_of_nonneg_left hdec hu₁
  have h₂cost := mul_le_mul_of_nonneg_left hmono hu₂
  have hLu : 0 < logb 2 u := Real.logb_pos (by norm_num) (by linarith)
  have hden : 0 < (logb 2 u)^2 := sq_pos_of_pos hLu
  have hsumcost := mul_le_mul_of_nonneg_right hsum (by linarith : 0 ≤ splitPotential T u)
  have hwt : 0 ≤ u₁/(logb 2 u)^2 := div_nonneg hu₁ hden.le
  have hratio : u₁*((1/4:ℝ)/(logb 2 u)^2) = (1/4:ℝ)*(u₁/(logb 2 u)^2) := by ring
  have hratio2 : ((1/32:ℝ)*u₁/(logb 2 u)^2)*splitPotential T u =
      (1/32:ℝ)*(u₁/(logb 2 u)^2)*splitPotential T u := by ring
  simp only [add_mul] at hsumcost
  rw [hratio2] at hsumcost
  rw [hratio] at h₁cost
  nlinarith

noncomputable def externalOn (G : SimpleGraph V) (U : Finset V) : Finset V :=
  univ.filter (fun v => v ∉ U ∧ ∃ u ∈ U, G.Adj u v)

lemma externalOn_subset {G : SimpleGraph V} {A U : Finset V} (hG : SupportedOn G A) :
    externalOn G U ⊆ A := by
  intro x hx
  obtain ⟨u,hu,hadj⟩ := (Finset.mem_filter.mp hx).2.2
  exact (hG hadj).2

lemma externalOn_disjoint (G : SimpleGraph V) (U : Finset V) :
    Disjoint U (externalOn G U) := by
  apply Finset.disjoint_left.mpr
  intro x hx hn
  exact (Finset.mem_filter.mp hn).2.1 hx

lemma overlap_child_supported {G : SimpleGraph V} {A U : Finset V}
    (hG : SupportedOn G A) (_hU : U ⊆ A) :
    SupportedOn (G \ restrictGraph G (U ∪ externalOn G U)) (A\U) := by
  intro x y hxy
  obtain ⟨hx,hy⟩ := hG hxy.1
  have hb (x y : V) (hxy : G.Adj x y) (hx : x ∈ U) : y ∈ U ∪ externalOn G U := by
    by_cases hy : y ∈ U
    · exact Finset.mem_union_left _ hy
    · exact Finset.mem_union_right _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hy,x,hx,hxy⟩)
  constructor
  · refine Finset.mem_sdiff.mpr ⟨hx,fun hxU => ?_⟩
    exact hxy.2 ⟨hxy.1,Finset.mem_union_left _ hxU,hb x y hxy.1 hxU⟩
  · refine Finset.mem_sdiff.mpr ⟨hy,fun hyU => ?_⟩
    exact hxy.2 ⟨hxy.1,hb y x hxy.1.symm hyU,Finset.mem_union_left _ hyU⟩

lemma overlap_child_sizes {G : SimpleGraph V} {A U : Finset V} {T : ℝ}
    (hT : 4 ≤ T) (hlarge : T < (A.card : ℝ)) (hU : U ⊆ A)
    (hne : U.Nonempty) (hhalf : 2*U.card ≤ A.card)
    (hsparse : ((externalOn G U).card : ℝ) < (1/32:ℝ)*U.card/(logb 2 A.card)^2) :
    (U ∪ externalOn G U).Nonempty ∧ (A\U).Nonempty ∧
    ((U ∪ externalOn G U).card : ℝ) ≤ 3*A.card/4 ∧
    (A\U).card < A.card ∧
    ((U ∪ externalOn G U).card : ℝ) + (A\U).card ≤
      A.card+(1/32:ℝ)*(U ∪ externalOn G U).card/(logb 2 A.card)^2 := by
  have hu : 0 < U.card := hne.card_pos
  have hlog : 1 ≤ logb 2 (A.card : ℝ) := by
    have h := Real.logb_le_logb_of_le (b:=2) (x:=2) (y:=A.card)
      (by norm_num) (by norm_num) (by linarith)
    norm_num [Real.logb] at h
    exact h
  have hd : 0 < (logb 2 (A.card : ℝ))^2 := by positivity
  have hquot : (1/32:ℝ)/(logb 2 (A.card : ℝ))^2 ≤ 1/2 := by
    apply (div_le_iff₀ hd).mpr
    nlinarith [sq_nonneg (logb 2 (A.card : ℝ)-1)]
  have hsmall : ((externalOn G U).card : ℝ) < (U.card : ℝ)/2 := by
    have hm := mul_le_mul_of_nonneg_right hquot (Nat.cast_nonneg U.card)
    have hid : (1/32:ℝ)/(logb 2 (A.card : ℝ))^2 * U.card =
        (1/32:ℝ)*U.card/(logb 2 (A.card : ℝ))^2 := by ring
    rw [hid] at hm
    linarith
  have hcard₁ := Finset.card_union_of_disjoint (externalOn_disjoint G U)
  have hcard₂ := Finset.card_sdiff_add_card_eq_card hU
  have hcard₁R : ((U ∪ externalOn G U).card : ℝ) = U.card+(externalOn G U).card := by
    exact_mod_cast hcard₁
  have hcard₂R : ((A\U).card : ℝ) + U.card = A.card := by exact_mod_cast hcard₂
  have hhalfR : 2*(U.card : ℝ) ≤ A.card := by exact_mod_cast hhalf
  have hmon : (1/32:ℝ)*U.card/(logb 2 A.card)^2 ≤
      (1/32:ℝ)*(U ∪ externalOn G U).card/(logb 2 A.card)^2 := by
    gcongr
    exact Finset.subset_union_left
  refine ⟨hne.mono Finset.subset_union_left,?_,?_,?_,?_⟩
  · exact Finset.card_pos.mp (by omega)
  · linarith
  · omega
  · linarith

lemma partition_split_append {G K : SimpleGraph V} {L M : List (SimpleGraph V)}
    (hle : K ≤ G) (hL : GraphPartition K L) (hM : GraphPartition (G\K) M) :
    GraphPartition G (L++M) := by
  intro x y
  have h₁ := hL x y
  have h₂ := hM x y
  have hk := @hle x y
  simp only [edgeOccurrences_append,SimpleGraph.sdiff_adj] at h₂ ⊢
  by_cases hK : K.Adj x y <;> by_cases hG : G.Adj x y <;> simp_all

theorem box_recursion (G : SimpleGraph V) (A : Finset V) (T : ℝ)
    (hT : 4 ≤ T) (hA : A.Nonempty) (hG : SupportedOn G A)
    (hsplit : ∀ B ⊆ A, ∀ H : SimpleGraph V, H ≤ G → SupportedOn H B → T < (B.card : ℝ) →
      ∃ U ⊆ B, U.Nonempty ∧ 2*U.card ≤ B.card ∧
        ((externalOn H U).card : ℝ) < (1/32:ℝ)*U.card/(logb 2 B.card)^2) :
    ∃ L : List (AssignedPiece V),
      (∀ P ∈ L, P.vertices ⊆ A ∧ P.vertices.Nonempty ∧ (P.vertices.card : ℝ) ≤ T) ∧
      (∀ x ∈ A, ∃ P ∈ L, x ∈ P.vertices) ∧
      GraphPartition G (L.map AssignedPiece.graph) ∧
      (L.map (fun P => (P.vertices.card : ℝ)*splitPotential T P.vertices.card)).sum ≤
        (A.card : ℝ)*splitPotential T A.card := by
  classical
  induction hn : A.card using Nat.strong_induction_on generalizing A G with
  | h n ih =>
    by_cases hsmall : (A.card : ℝ) ≤ T
    · let P : AssignedPiece V := ⟨A,G,hG⟩
      refine ⟨[P],?_,?_,?_,?_⟩
      · intro Q hQ; simp only [List.mem_singleton] at hQ; subst Q
        exact ⟨Finset.Subset.refl _,hA,hsmall⟩
      · intro x hx; exact ⟨P,by simp,hx⟩
      · intro x y; simp [P]
      · simp [P,← hn]
    · have hlarge : T < (A.card : ℝ) := lt_of_not_ge hsmall
      obtain ⟨U,hU,hne,hhalf,hsparse⟩ := hsplit A (Finset.Subset.refl _) G le_rfl hG hlarge
      let B := externalOn G U
      let A₁ := U ∪ B
      let A₂ := A\U
      let G₁ := restrictGraph G A₁
      let G₂ := G\G₁
      have hA₁ : A₁ ⊆ A := Finset.union_subset hU (externalOn_subset hG)
      have hA₂ : A₂ ⊆ A := Finset.sdiff_subset
      have hG₁ : G₁ ≤ G := restrictGraph_le G A₁
      have hG₂ : G₂ ≤ G := sdiff_le
      have hs₁ : SupportedOn G₁ A₁ := restrictGraph_supported G A₁
      have hs₂ : SupportedOn G₂ A₂ := overlap_child_supported hG hU
      obtain ⟨hn₁,hn₂,hsize₁,hsize₂,hsum⟩ := overlap_child_sizes hT hlarge hU hne hhalf hsparse
      have hlt₁ : A₁.card < n := by
        have hn0 : (0 : ℝ) < A.card := by linarith
        have hlt : (A₁.card : ℝ) < A.card := lt_of_le_of_lt hsize₁ (by linarith)
        exact hn ▸ (Nat.cast_lt.mp hlt)
      have hlt₂ : A₂.card < n := hn ▸ hsize₂
      have subprem (D : Finset V) (hD : D ⊆ A) (K : SimpleGraph V) (hK : K ≤ G) :
          ∀ C ⊆ D, ∀ H : SimpleGraph V, H ≤ K → SupportedOn H C → T < (C.card : ℝ) →
            ∃ U ⊆ C, U.Nonempty ∧ 2*U.card ≤ C.card ∧
              ((externalOn H U).card : ℝ) < (1/32:ℝ)*U.card/(logb 2 C.card)^2 := by
        intro C hC H hH hs hlarge
        exact hsplit C (hC.trans hD) H (hH.trans hK) hs hlarge
      obtain ⟨L,hL,hcovL,hpartL,hcostL⟩ := ih _ hlt₁ G₁ A₁ hn₁ hs₁
        (subprem A₁ hA₁ G₁ hG₁) rfl
      obtain ⟨M,hM,hcovM,hpartM,hcostM⟩ := ih _ hlt₂ G₂ A₂ hn₂ hs₂
        (subprem A₂ hA₂ G₂ hG₂) rfl
      refine ⟨L++M,?_,?_,?_,?_⟩
      · intro P hP
        rcases List.mem_append.mp hP with hP | hP
        · obtain ⟨hsub,hne,hbound⟩ := hL P hP; exact ⟨hsub.trans hA₁,hne,hbound⟩
        · obtain ⟨hsub,hne,hbound⟩ := hM P hP; exact ⟨hsub.trans hA₂,hne,hbound⟩
      · intro x hx
        by_cases hxU : x ∈ U
        · obtain ⟨P,hP,hxP⟩ := hcovL x (Finset.mem_union_left _ hxU)
          exact ⟨P,List.mem_append_left _ hP,hxP⟩
        · obtain ⟨P,hP,hxP⟩ := hcovM x (Finset.mem_sdiff.mpr ⟨hx,hxU⟩)
          exact ⟨P,List.mem_append_right _ hP,hxP⟩
      · simpa only [List.map_append] using partition_split_append hG₁ hpartL hpartM
      · simp only [List.map_append,List.sum_append]
        have hsub := split_potential_subadditive T A.card A₁.card A₂.card hT hlarge
          (Nat.cast_nonneg _) (Nat.cast_nonneg _) hsize₁ (by exact_mod_cast hsize₂.le) hsum
        rw [← hn]
        linarith

end ErdosGallai.Scale
end
end
end

end OAI