import OAI.Combinatorics.CycleDecomposition.Pairing

namespace OAI

universe cycleUniverse1 cycleUniverse2 cycleUniverse3 cycleUniverse4 cycleUniverse5 cycleUniverse6 cycleUniverse7 cycleUniverse8 cycleUniverse9 cycleUniverse10 cycleUniverse11 cycleUniverse12 cycleUniverse13 cycleUniverse14 cycleUniverse15 cycleUniverse16 cycleUniverse17 cycleUniverse18 cycleUniverse19 cycleUniverse20 cycleUniverse21 cycleUniverse22 cycleUniverse23 cycleUniverse24 cycleUniverse25 cycleUniverse26 cycleUniverse27 cycleUniverse28 cycleUniverse29 cycleUniverse30 cycleUniverse31

section
open Filter Asymptotics Real
open scoped Topology
noncomputable section
open MeasureTheory ProbabilityTheory Finset
section
namespace ErdosGallai.Batch
open Finset
noncomputable section
attribute [local instance] Classical.propDecidable
variable {V : Type cycleUniverse1} [Fintype V] (G : SimpleGraph V)

def neighborsIn (X : Finset V) (v : V) : ℕ :=
  (X.filter (G.Adj v)).card

def internalGraph (X : Finset V) : SimpleGraph V where
  Adj u v := G.Adj u v ∧ u ∈ X ∧ v ∈ X
  symm := ⟨fun _ _ h => ⟨h.1.symm,h.2.2,h.2.1⟩⟩
  loopless := ⟨fun _ h => G.irrefl h.1⟩

lemma neighborsIn_le_degree (X : Finset V) (v : V) :
    neighborsIn G X v ≤ G.degree v := by
  classical
  rw [← G.card_neighborFinset_eq_degree]
  apply Finset.card_le_card
  intro x hx
  exact (G.mem_neighborFinset v x).mpr (Finset.mem_filter.mp hx).2

lemma neighborsIn_eq_sum {V : Type cycleUniverse2} [_contextInstance1 : Fintype V] (G : SimpleGraph V) (X : Finset V) (v : V) :
    neighborsIn G X v = ∑ x ∈ X, if G.Adj v x then 1 else 0 := by
  classical
  simp only [neighborsIn,Finset.card_eq_sum_ones,Finset.sum_filter]

lemma sum_incidence_to_set (X : Finset V) :
    ∑ v, neighborsIn G X v = ∑ x ∈ X, G.degree x := by
  classical
  simp_rw [neighborsIn_eq_sum]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro x hx
  simp_rw [G.adj_comm (v:=x)]
  rw [← Finset.sum_filter]
  have he : Finset.univ.filter (G.Adj x) = G.neighborFinset x := by
    ext y
    simp
  simp [he]

lemma internalGraph_degree (X : Finset V) (v : V) :
    (internalGraph G X).degree v = if v ∈ X then neighborsIn G X v else 0 := by
  classical
  rw [← SimpleGraph.card_neighborFinset_eq_degree]
  by_cases hv : v ∈ X
  · simp only [hv,ite_true]
    congr 1
    ext x
    rw [SimpleGraph.mem_neighborFinset,Finset.mem_filter]
    change (G.Adj v x ∧ v ∈ X ∧ x ∈ X) ↔ _
    tauto
  · have he : (internalGraph G X).neighborFinset v = ∅ := by
      ext x
      simp only [SimpleGraph.mem_neighborFinset,Finset.notMem_empty]
      change (G.Adj v x ∧ v ∈ X ∧ x ∈ X) ↔ False
      tauto
    simp [he,hv]

lemma internalGraph_degree_sum (X : Finset V) :
    2 * (internalGraph G X).edgeFinset.card = ∑ x ∈ X, neighborsIn G X x := by
  classical
  rw [← SimpleGraph.sum_degrees_eq_twice_card_edges]
  simp_rw [internalGraph_degree]
  simp

lemma internal_edge_bound (X : Finset V) (a : ℝ)
    (ha : ∀ x ∈ X, (G.degree x : ℝ) ≤ a) :
    2 * ((internalGraph G X).edgeFinset.card : ℝ) ≤ a * X.card := by
  have hid := congrArg (fun n : ℕ => (n:ℝ)) (internalGraph_degree_sum G X)
  push_cast at hid
  rw [hid]
  calc
    _ ≤ ∑ x ∈ X, a := Finset.sum_le_sum fun x hx =>
      (Nat.cast_le.mpr (neighborsIn_le_degree G X x)).trans (ha x hx)
    _ = _ := by simp [mul_comm]

lemma incidence_bound (X : Finset V) (a : ℝ)
    (ha : ∀ x ∈ X, (G.degree x : ℝ) ≤ a) :
    (∑ v, neighborsIn G X v : ℝ) ≤ a * X.card := by
  have hid := congrArg (fun n : ℕ => (n:ℝ)) (sum_incidence_to_set G X)
  push_cast at hid
  rw [hid]
  simpa [mul_comm] using Finset.sum_le_sum (s:=X) (fun x hx => ha x hx)

lemma wedge_count_bound (X : Finset V) (a : ℝ) (ha : 1 ≤ a)
    (hdegree : ∀ x ∈ X, (G.degree x : ℝ) ≤ a)
    (hneighbor : ∀ v, (neighborsIn G X v : ℝ) ≤ a) :
    ((∑ v, (neighborsIn G X v).choose 2 : ℕ) : ℝ) ≤
      a*(a-1)*X.card/2 := by
  have hb (v : V) : ((neighborsIn G X v).choose 2 : ℝ) ≤
      (a-1)*(neighborsIn G X v)/2 := by
    rw [Nat.cast_choose_two]
    have hn : (0:ℝ) ≤ neighborsIn G X v := Nat.cast_nonneg _
    have hn' := hneighbor v
    nlinarith
  calc
    _ = ∑ v, ((neighborsIn G X v).choose 2 : ℝ) := by push_cast; rfl
    _ ≤ ∑ v, (a-1)*(neighborsIn G X v)/2 := Finset.sum_le_sum fun v _ => hb v
    _ = (a-1)/2 * ∑ v, (neighborsIn G X v : ℝ) := by
      rw [Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro v hv
      ring
    _ ≤ (a-1)/2 * (a*X.card) := mul_le_mul_of_nonneg_left
        (incidence_bound G X a hdegree) (by positivity)
    _ = _ := by ring

def betweenCount (X Y : Finset V) : ℕ := ∑ x ∈ X, neighborsIn G Y x

lemma betweenCount_comm (X Y : Finset V) :
    betweenCount G X Y = betweenCount G Y X := by
  classical
  simp only [betweenCount,neighborsIn_eq_sum]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro y hy
  apply Finset.sum_congr rfl
  intro x hx
  simp only [G.adj_comm]

lemma betweenCount_bound (X Y : Finset V) (a : ℝ)
    (hdegree : ∀ y ∈ Y, (G.degree y : ℝ) ≤ a) :
    (betweenCount G X Y : ℝ) ≤ a*Y.card := by
  rw [betweenCount_comm]
  simp only [betweenCount,Nat.cast_sum]
  calc
    _ ≤ ∑ y ∈ Y, a := Finset.sum_le_sum fun y hy =>
      (Nat.cast_le.mpr (neighborsIn_le_degree G X y)).trans (hdegree y hy)
    _ = _ := by simp [mul_comm]

lemma disjoint_neighbor_sum_le {I : Type cycleUniverse3} [Fintype I] (X : I → Finset V)
    (hd : Pairwise (fun i j => Disjoint (X i) (X j))) (v : V) :
    ∑ i, neighborsIn G (X i) v ≤ G.degree v := by
  classical
  have hb : ((Finset.univ : Finset I) : Set I).PairwiseDisjoint
      (fun i => (X i).filter (G.Adj v)) := by
    intro i hi j hj hij
    exact (hd hij).mono (Finset.filter_subset _ _) (Finset.filter_subset _ _)
  simp only [neighborsIn]
  rw [← Finset.card_biUnion hb,← G.card_neighborFinset_eq_degree]
  apply Finset.card_le_card
  intro x hx
  obtain ⟨i,hi,hx⟩ := Finset.mem_biUnion.mp hx
  exact (G.mem_neighborFinset v x).mpr (Finset.mem_filter.mp hx).2

lemma betweenCount_row_bound {I : Type cycleUniverse4} [Fintype I] (X : I → Finset V)
    (hd : Pairwise (fun i j => Disjoint (X i) (X j))) (i : I) (a : ℝ)
    (hdegree : ∀ x ∈ X i, (G.degree x : ℝ) ≤ a) :
    (∑ j, betweenCount G (X i) (X j) : ℝ) ≤ a*(X i).card := by
  simp only [betweenCount,Nat.cast_sum]
  rw [Finset.sum_comm]
  calc
    _ ≤ ∑ x ∈ X i, a := by
      apply Finset.sum_le_sum
      intro x hx
      have hn := disjoint_neighbor_sum_le G X hd x
      have hn' : (∑ j, (neighborsIn G (X j) x : ℝ)) ≤ G.degree x := by
        exact_mod_cast hn
      exact hn'.trans (hdegree x hx)
    _ = _ := by simp [mul_comm]

lemma cross_error_row {I : Type cycleUniverse5} [Fintype I] (X : I → Finset V)
    (hd : Pairwise (fun i j => Disjoint (X i) (X j))) (a : ℝ) (ha : 0 ≤ a)
    (hsize : ∀ i, 0 < (X i).card)
    (hdegree : ∀ i x, x ∈ X i → (G.degree x : ℝ) ≤ a) (i : I) :
    (∑ j, ((betweenCount G (X i) (X j) : ℝ)^2 /
      ((X i).card*(X j).card))) ≤ a^2 := by
  have hmi : (0:ℝ) < (X i).card := by exact_mod_cast hsize i
  calc
    _ ≤ ∑ j, a/(X i).card * (betweenCount G (X i) (X j) : ℝ) := by
      apply Finset.sum_le_sum
      intro j hj
      have hmj : (0:ℝ) < (X j).card := by exact_mod_cast hsize j
      have he := betweenCount_bound G (X i) (X j) a (hdegree j)
      have hn : (0:ℝ) ≤ betweenCount G (X i) (X j) := Nat.cast_nonneg _
      apply (div_le_iff₀ (mul_pos hmi hmj)).mpr
      field_simp
      nlinarith
    _ = a/(X i).card * ∑ j, (betweenCount G (X i) (X j) : ℝ) := by
      rw [Finset.mul_sum]
    _ ≤ a/(X i).card * (a*(X i).card) := mul_le_mul_of_nonneg_left
      (betweenCount_row_bound G X hd i a (hdegree i)) (by positivity)
    _ = a^2 := by field_simp

end
end ErdosGallai.Batch

namespace ErdosGallai.Batch
open Finset
noncomputable section

def CollisionPairs {α : Type cycleUniverse6} {β : Type cycleUniverse7} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Finset α) : Finset (Finset α) := by
  classical
  exact (s.powersetCard 2).filter (fun p => (p.image f).card = 1)

lemma mem_collisionPairs {α : Type cycleUniverse8} {β : Type cycleUniverse9} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Finset α) (p : Finset α) :
    p ∈ CollisionPairs f s ↔ p ⊆ s ∧ p.card = 2 ∧ (p.image f).card = 1 := by
  classical
  simp [CollisionPairs,and_assoc]

lemma collisionPairs_mono {α : Type cycleUniverse10} {β : Type cycleUniverse11} [DecidableEq α] [DecidableEq β] (f : α → β) {s t : Finset α} (h : s ⊆ t) :
    CollisionPairs f s ⊆ CollisionPairs f t := by
  classical
  intro p hp
  rw [mem_collisionPairs] at hp ⊢
  exact ⟨hp.1.trans h,hp.2⟩

lemma pair_mem_collisionPairs {α : Type cycleUniverse12} {β : Type cycleUniverse13} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Finset α)
    {a b : α} (ha : a ∈ s) (hb : b ∈ s) (hne : a ≠ b) (heq : f a = f b) :
    {a,b} ∈ CollisionPairs f s := by
  classical
  rw [mem_collisionPairs]
  refine ⟨?_,by simp [hne],by simp [heq]⟩
  intro x hx
  rcases Finset.mem_insert.mp hx with rfl | hx
  · exact ha
  · exact Finset.mem_singleton.mp hx ▸ hb

theorem prune_collisions {α : Type cycleUniverse14} {β : Type cycleUniverse15} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Finset α) :
    ∃ t ⊆ s, Set.InjOn f (t : Set α) ∧ t.image f = s.image f ∧
      s.card - t.card ≤ (CollisionPairs f s).card := by
  classical
  refine Finset.strongInductionOn s ?_
  intro s ih
  by_cases hinj : Set.InjOn f (s : Set α)
  · exact ⟨s,Subset.rfl,hinj,rfl,by simp⟩
  simp only [Set.InjOn,Finset.mem_coe,not_forall] at hinj
  obtain ⟨a,ha,b,hb,heq,hne⟩ := hinj
  have hsub : s.erase a ⊂ s := Finset.erase_ssubset ha
  obtain ⟨t,ht,hinj,himage,hcost⟩ := ih (s.erase a) hsub
  have hpair := pair_mem_collisionPairs f s ha hb hne heq
  have hnot : ({a,b}:Finset α) ∉ CollisionPairs f (s.erase a) := by
    intro hp
    have hh := (mem_collisionPairs f _ _).mp hp
    have := hh.1 (show a ∈ ({a,b}:Finset α) by simp)
    simp at this
  have hlt : (CollisionPairs f (s.erase a)).card < (CollisionPairs f s).card := by
    apply Finset.card_lt_card
    exact Finset.ssubset_iff_subset_ne.mpr ⟨collisionPairs_mono f (Finset.erase_subset _ _),
      fun he => hnot (he ▸ hpair)⟩
  have himage' : (s.erase a).image f = s.image f := by
    apply le_antisymm
    · exact Finset.image_subset_image (Finset.erase_subset _ _)
    · intro y hy
      obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy
      by_cases hxa : x = a
      · subst x
        exact Finset.mem_image.mpr ⟨b,by simp [hb,Ne.symm hne],heq.symm⟩
      · exact Finset.mem_image.mpr ⟨x,by simp [hx,hxa],rfl⟩
  refine ⟨t,ht.trans (Finset.erase_subset _ _),hinj,himage.trans himage',?_⟩
  have hcard := Finset.card_erase_of_mem ha
  have htt := Finset.card_le_card ht
  omega

theorem prune_bad_images {α : Type cycleUniverse16} {β : Type cycleUniverse17} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Finset α) (bad : β → Prop) [DecidablePred bad] :
    ∃ t ⊆ s, (∀ x ∈ t, ¬ bad (f x)) ∧ Set.InjOn f (t : Set α) ∧
      t.image f = (s.filter (fun x => ¬bad (f x))).image f ∧
      s.card-t.card ≤ (s.filter (fun x => bad (f x))).card +
        (CollisionPairs f (s.filter (fun x => ¬bad (f x)))).card := by
  classical
  obtain ⟨t,ht,hinj,himage,hcost⟩ := prune_collisions f (s.filter (fun x => ¬bad (f x)))
  refine ⟨t,ht.trans (Finset.filter_subset _ _),?_,hinj,himage,?_⟩
  · intro x hx
    exact (Finset.mem_filter.mp (ht hx)).2
  · have hpart := Finset.card_filter_add_card_filter_not (s:=s) (p:=fun x => bad (f x))
    have hle := Finset.card_le_card ht
    omega

end
end ErdosGallai.Batch
namespace ErdosGallai.Batch
open Finset
noncomputable section
attribute [local instance] Classical.propDecidable

def quotientDefect {V : Type cycleUniverse18} {W : Type cycleUniverse19} [Fintype V] (G : SimpleGraph V) (projMap : V → W) : ℕ := by
  classical
  let s := G.edgeFinset
  exact (s.filter (fun e => (Sym2.map projMap e).IsDiag)).card +
    (CollisionPairs (Sym2.map projMap) (s.filter (fun e => ¬(Sym2.map projMap e).IsDiag))).card

theorem simple_quotient_representatives {V : Type cycleUniverse20} {W : Type cycleUniverse21} [Fintype V]
    (G : SimpleGraph V) (projMap : V → W) :
    ∃ (retained : Finset (Sym2 V)) (Q : SimpleGraph W),
      retained ⊆ G.edgeFinset ∧
      (G.edgeFinset \ retained).card ≤ quotientDefect G projMap ∧
      Q.edgeSet = ((retained.image (Sym2.map projMap) : Finset (Sym2 W)) : Set (Sym2 W)) ∧
      (∀ e ∈ Q.edgeSet, ∃! f, f ∈ retained ∧ Sym2.map projMap f = e) := by
  classical
  obtain ⟨t,ht,hgood,hinj,himage,hcost⟩ :=
    prune_bad_images (Sym2.map projMap) G.edgeFinset Sym2.IsDiag
  let Q : SimpleGraph W := SimpleGraph.fromEdgeSet (t.image (Sym2.map projMap) : Set (Sym2 W))
  have hQ : Q.edgeSet = (t.image (Sym2.map projMap) : Set (Sym2 W)) := by
    rw [SimpleGraph.edgeSet_fromEdgeSet]
    ext e
    constructor
    · exact fun h => h.1
    · intro he
      refine ⟨he,?_⟩
      obtain ⟨f,hf,rfl⟩ := Finset.mem_image.mp he
      exact hgood f hf
  refine ⟨t,Q,ht,?_,hQ,?_⟩
  · rw [Finset.card_sdiff_of_subset ht]
    exact hcost
  · intro e he
    rw [hQ] at he
    obtain ⟨f,hf,hfe⟩ := Finset.mem_image.mp he
    refine ⟨f,⟨hf,hfe⟩,?_⟩
    intro g hg
    exact hinj hg.1 hf (hg.2.trans hfe.symm)

end
end ErdosGallai.Batch
namespace ErdosGallai.Batch
open Finset
noncomputable section
attribute [local instance] Classical.propDecidable
variable {V : Type cycleUniverse22} {I : Type cycleUniverse23} [Fintype V] [Fintype I] (X : I → Finset V)
  (hd : Pairwise (fun i j => Disjoint (X i) (X j)))

lemma familyPaired_symm {V : Type cycleUniverse24} {I : Type cycleUniverse25} [_contextInstance2 : Fintype V] [_contextInstance3 : Fintype I] (X : I → Finset V) (p : ∀ i, PairingSpace (X i)) {u v : V}
    (h : familyPaired X p u v) : familyPaired X p v u := by
  obtain ⟨i,hu,hv,hp⟩ := h
  exact ⟨i,hv,hu,paired_symm (p i) hp⟩

lemma familyPaired_local {V : Type cycleUniverse26} {I : Type cycleUniverse27} [_contextInstance2 : Fintype V] [_contextInstance3 : Fintype I] (X : I → Finset V) (hd : Pairwise fun i j => Disjoint (X i) (X j)) (p : ∀ i, PairingSpace (X i)) (i : I)
    (u v : X i) : familyPaired X p u v ↔ paired (p i) u v := by
  constructor
  · rintro ⟨j,hu,hv,hp⟩
    have hij : i = j := by
      by_contra hij
      exact Finset.disjoint_left.mp (hd hij) u.property hu
    subst j
    exact hp
  · intro hp
    exact ⟨i,u.property,v.property,hp⟩

lemma familyPaired_same_set {V : Type cycleUniverse28} {I : Type cycleUniverse29} [_contextInstance2 : Fintype V] [_contextInstance3 : Fintype I] (X : I → Finset V) (hd : Pairwise fun i j => Disjoint (X i) (X j)) (p : ∀ i, PairingSpace (X i)) (i : I)
    {u v : V} (hu : u ∈ X i) (hp : familyPaired X p u v) : v ∈ X i := by
  obtain ⟨j,hu',hv,hp⟩ := hp
  have hij : i = j := by
    by_contra hij
    exact Finset.disjoint_left.mp (hd hij) hu hu'
  exact hij.symm ▸ hv

def vertexPairEvent (p : ∀ i, PairingSpace (X i)) (s : Finset V) : Prop :=
  ∃ u ∈ s, ∃ v ∈ s, u ≠ v ∧ familyPaired X p u v

lemma vertexPairEvent_pair (p : ∀ i, PairingSpace (X i)) (u v : V) (huv : u ≠ v) :
    vertexPairEvent X p {u,v} ↔ familyPaired X p u v := by
  constructor
  · rintro ⟨a,ha,b,hb,hab,hp⟩
    simp only [Finset.mem_insert,Finset.mem_singleton] at ha hb
    rcases ha with rfl | rfl <;> rcases hb with rfl | rfl
    · exact False.elim (hab rfl)
    · exact hp
    · exact familyPaired_symm X p hp
    · exact False.elim (hab rfl)
  · intro hp
    exact ⟨u,by simp,v,by simp,huv,hp⟩

lemma finiteAverage_filter_card {Ω : Type cycleUniverse30} {A : Type cycleUniverse31} [Fintype Ω]
    (s : Finset A) (P : Ω → A → Prop) :
    finiteAverage (fun ω => ((s.filter (P ω)).card : ℝ)) =
      ∑ a ∈ s, finiteAverage (fun ω => if P ω a then 1 else 0) := by
  have hf (ω : Ω) : ((s.filter (P ω)).card : ℝ) =
      ∑ a ∈ s, if P ω a then 1 else 0 := by
    rw [Finset.card_eq_sum_ones, Nat.cast_sum]
    simp only [Nat.cast_one,Finset.sum_filter]
  simp_rw [hf]
  exact finiteAverage_sum s _

include hd in
lemma vertexPairEvent_average (i : I) (s : Finset V)
    (hs : s ⊆ X i) (hc : s.card = 2) (hm : 2 ≤ (X i).card) :
    finiteAverage (fun p : ∀ j, PairingSpace (X j) =>
      if vertexPairEvent X p s then 1 else 0) ≤ 1 / ((X i).card-1:ℝ) := by
  classical
  obtain ⟨u,v,huv,rfl⟩ := Finset.card_eq_two.mp hc
  have hu := hs (show u ∈ ({u,v}:Finset V) by simp)
  have hv := hs (show v ∈ ({u,v}:Finset V) by simp)
  have he (p : ∀ j, PairingSpace (X j)) :
      vertexPairEvent X p {u,v} ↔ paired (p i) ⟨u,hu⟩ ⟨v,hv⟩ :=
    (vertexPairEvent_pair X p u v huv).trans (familyPaired_local X hd p i ⟨u,hu⟩ ⟨v,hv⟩)
  simp_rw [he]
  rw [finiteAverage_pi_eval (Ω:=fun j => PairingSpace (X j)) i
    (fun p => if paired p ⟨u,hu⟩ ⟨v,hv⟩ then 1 else 0)]
  convert paired_first_bound (V:=(X i)) (by simpa using hm) ⟨u,hu⟩ ⟨v,hv⟩
    (fun h => huv (congrArg Subtype.val h)) using 1 ; simp

def wedgeErrors (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) (i : I) (v : V) :=
  (((X i).filter (G.Adj v)).powersetCard 2).filter (vertexPairEvent X p)

include hd in
lemma wedgeErrors_average (G : SimpleGraph V) (i : I) (v : V)
    (hm : 2 ≤ (X i).card) :
    finiteAverage (fun p : ∀ j, PairingSpace (X j) => ((wedgeErrors X G p i v).card : ℝ)) ≤
      ((neighborsIn G (X i) v).choose 2 : ℝ) / ((X i).card-1:ℝ) := by
  classical
  change finiteAverage (fun p => (((((X i).filter (G.Adj v)).powersetCard 2).filter
    (vertexPairEvent X p)).card : ℝ)) ≤ _
  rw [finiteAverage_filter_card]
  calc
    _ ≤ ∑ _s ∈ ((X i).filter (G.Adj v)).powersetCard 2,
        1 / ((X i).card-1:ℝ) := by
      apply Finset.sum_le_sum
      intro s hs
      obtain ⟨hs,hc⟩ := Finset.mem_powersetCard.mp hs
      exact vertexPairEvent_average X hd i s (hs.trans (Finset.filter_subset _ _)) hc hm
    _ = _ := by simp [Finset.card_powersetCard,neighborsIn,div_eq_mul_inv]

lemma mem_internalGraph {G : SimpleGraph V} {S : Finset V} {u v : V} :
    s(u,v) ∈ (internalGraph G S).edgeFinset ↔ G.Adj u v ∧ u ∈ S ∧ v ∈ S := by
  simp only [SimpleGraph.mem_edgeFinset,SimpleGraph.mem_edgeSet]
  rfl

def crossGraph (G : SimpleGraph V) (S T : Finset V) : SimpleGraph V where
  Adj u v := G.Adj u v ∧ ((u ∈ S ∧ v ∈ T) ∨ (u ∈ T ∧ v ∈ S))
  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⟩

lemma distinct_edge_cases (G : SimpleGraph V) {e f : Sym2 V}
    (he : e ∈ G.edgeFinset) (hf : f ∈ G.edgeFinset) (hef : e ≠ f) :
    (∃ v u w, v ≠ u ∧ v ≠ w ∧ u ≠ w ∧ e = s(v,u) ∧ f = s(v,w)) ∨
    (∃ u v x y, u ≠ v ∧ x ≠ y ∧ u ≠ x ∧ u ≠ y ∧ v ≠ x ∧ v ≠ y ∧
      e = s(u,v) ∧ f = s(x,y)) := by
  obtain ⟨a,b⟩ := e
  obtain ⟨c,d⟩ := f
  have hab : a ≠ b := (SimpleGraph.mem_edgeFinset.mp he).ne
  have hcd : c ≠ d := (SimpleGraph.mem_edgeFinset.mp hf).ne
  by_cases hac : a = c
  · subst c
    refine Or.inl ⟨a,b,d,hab,hcd,?_,rfl,rfl⟩
    intro hbd
    exact hef (hbd ▸ rfl)
  by_cases had : a = d
  · subst d
    refine Or.inl ⟨a,b,c,hab,hcd.symm,?_,rfl,Sym2.eq_swap⟩
    intro hbc
    subst c
    exact hef Sym2.eq_swap
  by_cases hbc : b = c
  · subst c
    refine Or.inl ⟨b,a,d,hab.symm,hcd,?_,Sym2.eq_swap,rfl⟩
    intro had
    subst d
    exact hef Sym2.eq_swap
  by_cases hbd : b = d
  · subst d
    refine Or.inl ⟨b,a,c,hab.symm,hcd.symm,?_,Sym2.eq_swap,Sym2.eq_swap⟩
    intro hac
    subst c
    exact hef rfl
  exact Or.inr ⟨a,b,c,d,hab,hcd,hac,had,hbc,hbd,rfl,rfl⟩

lemma internal_collision_average (i : I) (hm : 4 ≤ (X i).card)
    (u v x y : X i) (huv : u ≠ v) (hux : u ≠ x) (huy : u ≠ y)
    (hvx : v ≠ x) (hvy : v ≠ y) (hxy : x ≠ y) :
    finiteAverage (fun p : ∀ j, PairingSpace (X j) =>
      if Sym2.map (familyProject X hd p) s((u:V),(v:V)) =
         Sym2.map (familyProject X hd p) s((x:V),(y:V)) then 1 else 0) ≤
      2 / (((X i).card-1:ℝ)*((X i).card-3:ℝ)) := by
  classical
  have hmono : finiteAverage (fun p : ∀ j, PairingSpace (X j) =>
      if Sym2.map (familyProject X hd p) s((u:V),(v:V)) =
         Sym2.map (familyProject X hd p) s((x:V),(y:V)) then 1 else 0) ≤
      finiteAverage (fun p : ∀ j, PairingSpace (X j) =>
      if (paired (p i) u x ∧ paired (p i) v y) ∨
        (paired (p i) u y ∧ paired (p i) v x) then 1 else 0) := by
    apply finiteAverage_mono
    intro p
    by_cases hc : Sym2.map (familyProject X hd p) s((u:V),(v:V)) =
         Sym2.map (familyProject X hd p) s((x:V),(y:V))
    · have hh := four_endpoint_collision X hd p (fun h => hux (Subtype.ext h))
        (fun h => huy (Subtype.ext h)) (fun h => hvx (Subtype.ext h))
        (fun h => hvy (Subtype.ext h)) hc
      have he : (paired (p i) u x ∧ paired (p i) v y) ∨
          (paired (p i) u y ∧ paired (p i) v x) := by
        simpa only [familyPaired_local X hd p i] using hh
      simp only [ite_eq_left hc,ite_eq_left he,le_refl]
    · rw [ite_eq_right hc]
      split_ifs <;> norm_num
  apply hmono.trans
  rw [finiteAverage_pi_eval (Ω:=fun j => PairingSpace (X j)) i
    (fun p => if (paired p u x ∧ paired p v y) ∨ (paired p u y ∧ paired p v x)
      then 1 else 0)]
  simpa only [Fintype.card_coe] using pairing_patterns_internal
    (V:=(X i)) (by simpa using hm) u v x y huv hux huy hvx hvy hxy

lemma cross_collision_average (i j : I) (hij : i ≠ j)
    (hi : 2 ≤ (X i).card) (hj : 2 ≤ (X j).card)
    (u x : X i) (v y : X j) (hux : u ≠ x) (hvy : v ≠ y) :
    finiteAverage (fun p : ∀ k, PairingSpace (X k) =>
      if Sym2.map (familyProject X hd p) s((u:V),(v:V)) =
         Sym2.map (familyProject X hd p) s((x:V),(y:V)) then 1 else 0) ≤
      1 / (((X i).card-1:ℝ)*((X j).card-1:ℝ)) := by
  classical
  have huy : (u:V) ≠ y := by
    intro h
    exact Finset.disjoint_left.mp (hd hij) u.property (h ▸ y.property)
  have hvx : (v:V) ≠ x := by
    intro h
    exact Finset.disjoint_left.mp (hd hij) (h ▸ x.property) v.property
  have hmono : finiteAverage (fun p : ∀ k, PairingSpace (X k) =>
      if Sym2.map (familyProject X hd p) s((u:V),(v:V)) =
         Sym2.map (familyProject X hd p) s((x:V),(y:V)) then 1 else 0) ≤
      finiteAverage (fun p : ∀ k, PairingSpace (X k) =>
      if paired (p i) u x ∧ paired (p j) v y then 1 else 0) := by
    apply finiteAverage_mono
    intro p
    by_cases hc : Sym2.map (familyProject X hd p) s((u:V),(v:V)) =
         Sym2.map (familyProject X hd p) s((x:V),(y:V))
    · have hh := four_endpoint_collision X hd p (fun h => hux (Subtype.ext h))
        huy hvx (fun h => hvy (Subtype.ext h)) hc
      have he : paired (p i) u x ∧ paired (p j) v y := by
        rcases hh with hh | hh
        · exact ⟨(familyPaired_local X hd p i u x).mp hh.1,
            (familyPaired_local X hd p j v y).mp hh.2⟩
        · have hy := familyPaired_same_set X hd p i u.property hh.1
          exact False.elim (Finset.disjoint_left.mp (hd hij) hy y.property)
      simp only [ite_eq_left hc,ite_eq_left he,le_refl]
    · rw [ite_eq_right hc]
      split_ifs <;> norm_num
  apply hmono.trans
  simpa only [Fintype.card_coe] using pairing_patterns_cross_bound
    (V:=fun k => X k) i j hij (by simpa using hi) (by simpa using hj) u x hux v y hvy

end
end ErdosGallai.Batch
end
end
end

end OAI