Blame for lean/OAI/Combinatorics/CycleDecomposition/BatchIndexing.lean

import OAI.Combinatorics.CycleDecomposition.ScaleDecomposition

namespace OAI

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

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

namespace ErdosGallai.Indexing
noncomputable section
open Finset

variable {I : Type cycleUniverse1} [DecidableEq I]

def batchWeight (w : I → ℕ) (b : Finset I) : ℝ := ∑ i ∈ b, (w i : ℝ)

lemma batchWeight_nonneg {I : Type cycleUniverse2} [_contextInstance1 : DecidableEq I] (w : I → ℕ) (b : Finset I) : 0 ≤ batchWeight w b := by
  exact Finset.sum_nonneg (fun _ _ => Nat.cast_nonneg _)

lemma indexed_batch_construction (w : I → ℕ) (A : Finset I) (B : ℝ) (hB : 0 < B)
    (hw : ∀ i ∈ A, (w i : ℝ) ≤ B/2) :
    ∃ P : List (Finset I),
      P.Pairwise Disjoint ∧
      (∀ i, i ∈ A ↔ ∃ b ∈ P, i ∈ b) ∧
      (∀ b ∈ P, b.Nonempty ∧ batchWeight w b ≤ B) ∧
      (∀ b ∈ P.tail, B/2 < batchWeight w b) ∧
      (P.map (batchWeight w)).sum = batchWeight w A := by
  induction A using Finset.induction_on with
  | empty =>
    refine ⟨[], by simp, ?_, by simp, by simp, ?_⟩
    · simp
    · simp [batchWeight]
  | @insert a A ha ih =>
    obtain ⟨P, hdisj, hcover, hbins, hheavy, hmass⟩ := ih (fun i hi => hw i (by simp [hi]))
    have hwa := hw a (by simp)
    have haP : ∀ b ∈ P, a ∉ b := by
      intro b hb hab
      exact ha ((hcover a).mpr ⟨b,hb,hab⟩)
    cases P with
    | nil =>
      have hAz : A = ∅ := by
        apply Finset.eq_empty_iff_forall_notMem.mpr
        intro i hi
        simpa using (hcover i).mp hi
      subst A
      refine ⟨[{a}], by simp, ?_, ?_, by simp, ?_⟩
      · intro i; simp
      · intro b hb
        simp only [List.mem_singleton] at hb
        subst b
        exact ⟨by simp, by simp [batchWeight]; linarith⟩
      · simp
    | cons b bs =>
      have hab : a ∉ b := haP b (by simp)
      obtain ⟨hbne,hbB⟩ := hbins b (by simp)
      by_cases hlight : batchWeight w b ≤ B/2
      · refine ⟨insert a b :: bs, ?_, ?_, ?_, ?_, ?_⟩
        · rw [List.pairwise_cons]
          refine ⟨?_, (List.pairwise_cons.mp hdisj).2⟩
          intro d hd
          exact Finset.disjoint_insert_left.mpr ⟨haP d (by simp [hd]),
            (List.pairwise_cons.mp hdisj).1 d hd⟩
        · intro i
          constructor
          · intro hia
            rcases Finset.mem_insert.mp hia with hia | hi
            · exact ⟨insert a b, by simp, by simp [hia]⟩
            · obtain ⟨d,hd,hid⟩ := (hcover i).mp hi
              rcases List.mem_cons.mp hd with hd | hd
              · subst d
                exact ⟨insert a b, by simp, Finset.mem_insert_of_mem hid⟩
              · exact ⟨d, by simp [hd], hid⟩
          · rintro ⟨d,hd,hid⟩
            rcases List.mem_cons.mp hd with rfl | hd
            · rcases Finset.mem_insert.mp hid with rfl | hib
              · simp
              · exact Finset.mem_insert_of_mem ((hcover i).mpr ⟨b, by simp, hib⟩)
            · exact Finset.mem_insert_of_mem ((hcover i).mpr ⟨d, by simp [hd], hid⟩)
        · intro d hd
          rcases List.mem_cons.mp hd with rfl | hd
          · refine ⟨by simp, ?_⟩
            simp only [batchWeight, Finset.sum_insert hab]
            change (w a : ℝ) + batchWeight w b ≤ B
            linarith
          · exact hbins d (by simp [hd])
        · simpa using hheavy
        · simp only [List.map_cons, List.sum_cons] at hmass ⊢
          rw [show batchWeight w (insert a b) = (w a:ℝ)+batchWeight w b by
            simp [batchWeight, hab], show batchWeight w (insert a A) = (w a:ℝ)+batchWeight w A by
            simp [batchWeight, ha]]
          linarith
      · refine ⟨{a} :: b :: bs, ?_, ?_, ?_, ?_, ?_⟩
        · rw [List.pairwise_cons]
          exact ⟨fun d hd => Finset.disjoint_singleton_left.mpr (haP d hd), hdisj⟩
        · intro i
          constructor
          · intro hi
            rcases Finset.mem_insert.mp hi with hia | hi
            · exact ⟨{a}, by simp, by simp [hia]⟩
            · obtain ⟨d,hd,hid⟩ := (hcover i).mp hi
              exact ⟨d, List.mem_cons_of_mem _ hd, hid⟩
          · rintro ⟨d,hd,hid⟩
            rcases List.mem_cons.mp hd with rfl | hd
            · exact Finset.mem_insert.mpr (Or.inl (Finset.mem_singleton.mp hid))
            · exact Finset.mem_insert_of_mem ((hcover i).mpr ⟨d,hd,hid⟩)
        · intro d hd
          rcases List.mem_cons.mp hd with rfl | hd
          · exact ⟨by simp, by simp [batchWeight]; linarith⟩
          · exact hbins d hd
        · intro d hd
          rcases List.mem_cons.mp hd with rfl | hd
          · exact lt_of_not_ge hlight
          · exact hheavy d hd
        · simp only [List.map_cons, List.sum_cons] at hmass ⊢
          simp only [batchWeight, Finset.sum_singleton, Finset.sum_insert ha] at hmass ⊢
          linarith

lemma batch_tail_mass {I : Type cycleUniverse3} [_contextInstance1 : DecidableEq I] (w : I → ℕ) (P : List (Finset I)) (t : ℝ)
    (ht : ∀ b ∈ P, t ≤ batchWeight w b) :
    (P.length : ℝ)*t ≤ (P.map (batchWeight w)).sum := by
  induction P with
  | nil => simp
  | cons b bs ih =>
    have hb := ht b (by simp)
    have hbs := ih (fun d hd => ht d (by simp [hd]))
    simp only [List.length_cons, Nat.cast_add, Nat.cast_one, List.map_cons, List.sum_cons]
    nlinarith

theorem indexed_batch_partition (w : I → ℕ) (A : Finset I) (B : ℝ) (hB : 0 < B)
    (hw : ∀ i ∈ A, (w i : ℝ) ≤ B/2) :
    ∃ P : List (Finset I),
      P.Pairwise Disjoint ∧
      (∀ i, i ∈ A ↔ ∃ b ∈ P, i ∈ b) ∧
      (∀ b ∈ P, b.Nonempty ∧ batchWeight w b ≤ B) ∧
      (P.map (batchWeight w)).sum = batchWeight w A ∧
      (P.length : ℝ) ≤ 1 + 2*batchWeight w A/B := by
  obtain ⟨P,hd,hc,hb,ht,hm⟩ := indexed_batch_construction w A B hB hw
  refine ⟨P,hd,hc,hb,hm,?_⟩
  have htail := batch_tail_mass w P.tail (B/2) (fun b hb => (ht b hb).le)
  cases P with
  | nil =>
    simp only [List.length_nil, Nat.cast_zero]
    have hh := div_nonneg (mul_nonneg (by norm_num : (0:ℝ) ≤ 2) (batchWeight_nonneg w A)) hB.le
    linarith
  | cons b bs =>
    simp only [List.tail_cons, List.length_cons, Nat.cast_add, Nat.cast_one] at htail ⊢
    simp only [List.map_cons, List.sum_cons] at hm
    have hb0 := batchWeight_nonneg w b
    have hdv : (bs.length : ℝ) ≤ 2*batchWeight w A/B := by
      apply (le_div_iff₀ hB).mpr
      linarith
    linarith

end
end ErdosGallai.Indexing

namespace ErdosGallai.Indexing
noncomputable section
open scoped BigOperators

private theorem cover_card_le {V : Type cycleUniverse4} {I : Type cycleUniverse5} [DecidableEq V] [Fintype I]
    (S : Finset V) (W : I → Finset V)
    (h : S ⊆ Finset.univ.biUnion W) :
    S.card ≤ ∑ i, (W i).card :=
  (Finset.card_le_card h).trans Finset.card_biUnion_le

private theorem disjoint_piece_inter {V : Type cycleUniverse6} {J : Type cycleUniverse7} [DecidableEq V] [Fintype J]
    (R : J → Finset V) (hR : Pairwise fun i j => Disjoint (R i) (R j))
    (S : Finset V) :
    (S ∩ Finset.univ.biUnion R).card = ∑ j, (S ∩ R j).card := by
  rw [Finset.inter_biUnion]
  apply Finset.card_biUnion
  intro i _ j _ hij
  exact (hR hij).mono Finset.inter_subset_right Finset.inter_subset_right

theorem active_occurrences {V : Type cycleUniverse8} {I : Type cycleUniverse9} {J : Type cycleUniverse10} [DecidableEq V]
    [Fintype I] [Fintype J]
    (Y good : Finset V) (W : I → Finset V) (R : J → Finset V)
    (_hW : ∀ i, W i ⊆ Y) (hRsub : ∀ j, R j ⊆ Y)
    (hcover : Y ⊆ Finset.univ.biUnion W)
    (hR : Pairwise fun i j => Disjoint (R i) (R j))
    (keep : I → J → Prop) [∀ i j, Decidable (keep i j)] :
    let active := ∑ i, ∑ j, if keep i j then (W i ∩ R j ∩ good).card else 0
    let skipped := ∑ i, ∑ j, if keep i j then 0 else (W i ∩ R j ∩ good).card
    (∑ j, (R j).card) ≤ active + skipped + (Y \ good).card ∧
    active + Y.card ≤ (∑ j, (R j).card) + ∑ i, (W i).card := by
  classical
  dsimp only
  let U := Finset.univ.biUnion R
  have hU : U ⊆ Y := by
    intro v hv
    obtain ⟨j, _, hj⟩ := Finset.mem_biUnion.mp hv
    exact hRsub j hj
  have hcard : U.card = ∑ j, (R j).card := by
    apply Finset.card_biUnion
    intro i _ j _ hij
    exact hR hij
  let mass := ∑ i, ∑ j, (W i ∩ R j ∩ good).card
  let whole := ∑ i, (W i ∩ U).card
  have hsplit :
      (∑ i, ∑ j, if keep i j then (W i ∩ R j ∩ good).card else 0) +
      (∑ i, ∑ j, if keep i j then 0 else (W i ∩ R j ∩ good).card) = mass := by
    dsimp [mass]
    rw [← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro i _
    rw [← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro j _
    split_ifs <;> omega
  have hgood : (U ∩ good).card ≤ mass := by
    have hc : U ∩ good ⊆ Finset.univ.biUnion (fun i => W i ∩ U ∩ good) := by
      intro v hv
      obtain ⟨i, hi, hvi⟩ := Finset.mem_biUnion.mp (hcover (hU (Finset.mem_inter.mp hv).1))
      exact Finset.mem_biUnion.mpr ⟨i, hi, Finset.mem_inter.mpr
        ⟨Finset.mem_inter.mpr ⟨hvi, (Finset.mem_inter.mp hv).1⟩,
          (Finset.mem_inter.mp hv).2⟩⟩
    apply (cover_card_le (U ∩ good) _ hc).trans
    apply le_of_eq
    apply Finset.sum_congr rfl
    intro i _
    have heq : W i ∩ U ∩ good = (W i ∩ good) ∩ U := by ext v; simp only [Finset.mem_inter]; tauto
    rw [heq, disjoint_piece_inter R hR]
    apply Finset.sum_congr rfl
    intro j _
    congr 1
    ext v
    simp only [Finset.mem_inter]
    tauto
  have hbad : (U \ good).card ≤ (Y \ good).card := by
    apply Finset.card_le_card
    intro v hv
    exact Finset.mem_sdiff.mpr ⟨hU (Finset.mem_sdiff.mp hv).1, (Finset.mem_sdiff.mp hv).2⟩
  have hmass : mass ≤ whole := by
    apply Finset.sum_le_sum
    intro i _
    rw [disjoint_piece_inter R hR]
    exact Finset.sum_le_sum fun j _ => Finset.card_le_card Finset.inter_subset_left
  have houtside : (Y \ U).card ≤ ∑ i, (W i \ U).card := by
    apply cover_card_le
    intro v hv
    obtain ⟨i, hi, hvi⟩ := Finset.mem_biUnion.mp (hcover (Finset.mem_sdiff.mp hv).1)
    exact Finset.mem_biUnion.mpr ⟨i, hi, Finset.mem_sdiff.mpr ⟨hvi, (Finset.mem_sdiff.mp hv).2⟩⟩
  have hY : U.card + (Y \ U).card = Y.card := by
    simpa only [Finset.inter_eq_right.mpr hU] using Finset.card_inter_add_card_sdiff Y U
  have hWsum : whole + (∑ i, (W i \ U).card) = ∑ i, (W i).card := by
    dsimp [whole]
    rw [← Finset.sum_add_distrib]
    exact Finset.sum_congr rfl fun i _ => Finset.card_inter_add_card_sdiff (W i) U
  have hUgood := Finset.card_inter_add_card_sdiff U good
  constructor <;> omega

theorem skipped_occurrences_bound {V : Type cycleUniverse11} {I : Type cycleUniverse12} {J : Type cycleUniverse13} [DecidableEq V]
    [Fintype I] [Fintype J] (W : I → Finset V) (R : J → Finset V)
    (good : Finset V) (L : ℕ) :
    (∑ i, ∑ j, if L ≤ (W i ∩ R j ∩ good).card then 0
      else (W i ∩ R j ∩ good).card) ≤ L * Fintype.card I * Fintype.card J := by
  classical
  calc
    _ ≤ ∑ _i : I, ∑ _j : J, L := by
      apply Finset.sum_le_sum
      intro i _
      apply Finset.sum_le_sum
      intro j _
      split_ifs <;> omega
    _ = _ := by simp only [Finset.sum_const, Finset.card_univ, smul_eq_mul]; ring

end
end ErdosGallai.Indexing

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

lemma list_pairwise_get {A : Type cycleUniverse14} {R : A → A → Prop} {L : List A}
    (h : L.Pairwise R) (hs : (∀ ⦃left right⦄, R left right → R right left)) : Pairwise fun i j : Fin L.length => R (L.get i) (L.get j) := by
  intro i j hij
  rcases lt_or_gt_of_ne (show i.val ≠ j.val from fun he => hij (Fin.ext he)) with hlt | hgt
  · exact List.pairwise_iff_getElem.mp h i.val j.val i.isLt j.isLt hlt
  · exact hs (List.pairwise_iff_getElem.mp h j.val i.val j.isLt i.isLt hgt)

lemma list_sum_get {A : Type cycleUniverse15} {M : Type cycleUniverse16} [AddCommMonoid M] (L : List A) (f : A → M) :
    (∑ i : Fin L.length, f (L.get i)) = (L.map f).sum := by
  rw [← List.sum_ofFn]
  calc
    _ = (List.map f (List.ofFn L.get)).sum := by rw [List.map_ofFn]; rfl
    _ = _ := by rw [List.ofFn_get]

structure GraphBatches {V : Type} (F : SimpleGraph V) (Y : Finset V) (B T : ℝ) where
  Index : Type
  finite : Fintype Index
  graph : Index → SimpleGraph V
  vertices : Index → Finset V
  graph_le : ∀ i, graph i ≤ F
  disjoint : Pairwise fun i j => Disjoint (graph i).edgeSet (graph j).edgeSet
  edge_cover : (⋃ i, (graph i).edgeSet) = F.edgeSet
  supported : ∀ i, ∀ ⦃x y⦄, (graph i).Adj x y → x ∈ vertices i ∧ y ∈ vertices i
  subset : ∀ i, vertices i ⊆ Y
  vertex_cover : Y ⊆ univ.biUnion vertices
  order_le : ∀ i, ((vertices i).card:ℝ) ≤ B
  mass_le : (∑ i, ((vertices i).card:ℝ)) ≤ T
  count_le : (Fintype.card Index:ℝ) ≤ 1+2*T/B
attribute [instance] GraphBatches.finite

theorem materialize_batches {V I : Type} [Fintype I]
    (F : SimpleGraph V) (Y : Finset V) (H : I → SimpleGraph V) (U : I → Finset V)
    (hHH : Pairwise fun i j => Disjoint (H i).edgeSet (H j).edgeSet)
    (hu : (⋃ i, (H i).edgeSet) = F.edgeSet)
    (hU : ∀ i, ∀ ⦃x y⦄, (H i).Adj x y → x ∈ U i ∧ y ∈ U i)
    (hUY : ∀ i, U i ⊆ Y) (hY : Y ⊆ univ.biUnion U)
    (B : ℝ) (hB : 0 < B) (hsmall : ∀ i, ((U i).card:ℝ) ≤ B/2) :
    Nonempty (GraphBatches F Y B (∑ i, ((U i).card:ℝ))) := by
  classical
  obtain ⟨L,hLd,hLc,hLn,hLm,hLnum⟩ := indexed_batch_partition (fun i => (U i).card) univ B hB (fun i _ => hsmall i)
  let A := Fin L.length
  let bag (a : A) : Finset I := L.get a
  let W (a : A) := (bag a).biUnion U
  let J (a : A) : SimpleGraph V := ⨆ i ∈ bag a, H i
  have hbagd : Pairwise fun a b => Disjoint (bag a) (bag b) := list_pairwise_get hLd (fun _ _ h => h.symm)
  have hbagcov (i : I) : ∃ a : A, i ∈ bag a := by
    obtain ⟨b,hb,hi⟩ := (hLc i).mp (mem_univ _)
    obtain ⟨k,hk⟩ := List.mem_iff_get.mp hb
    exact ⟨k,by change i ∈ L.get k; rwa [hk]⟩
  have hJedge (a : A) : (J a).edgeSet = ⋃ i ∈ bag a, (H i).edgeSet := by
    ext e
    induction e using Sym2.ind with
    | _ x y => simp [J,SimpleGraph.mem_edgeSet,SimpleGraph.iSup_adj]
  have hJsub (a : A) : (J a).edgeSet ⊆ F.edgeSet := by
    rw [hJedge,← hu]
    exact Set.iUnion₂_subset fun i _ => Set.subset_iUnion (fun j : I => (H j).edgeSet) i
  have hWweight (a : A) : ((W a).card:ℝ) ≤ batchWeight (fun i => (U i).card) (bag a) := by
    have hh := Finset.card_biUnion_le (s := bag a) (t := U)
    dsimp only [W,batchWeight]
    exact_mod_cast hh
  have hJd : Pairwise fun a b => Disjoint (J a).edgeSet (J b).edgeSet := by
    intro a b hab
    rw [hJedge,hJedge]
    apply Set.disjoint_left.mpr
    rintro e he he'
    obtain ⟨i,hi,he⟩ := Set.mem_iUnion₂.mp he
    obtain ⟨j,hj,he'⟩ := Set.mem_iUnion₂.mp he'
    have hij : i ≠ j := by rintro rfl; exact Finset.disjoint_left.mp (hbagd hab) hi hj
    exact Set.disjoint_left.mp (hHH hij) he he'
  refine ⟨{
    Index := A
    finite := inferInstance
    graph := J
    vertices := W
    graph_le := fun a => SimpleGraph.edgeSet_subset_edgeSet.mp (hJsub a)
    disjoint := hJd
    edge_cover := ?_
    supported := ?_
    subset := ?_
    vertex_cover := ?_
    order_le := ?_
    mass_le := ?_
    count_le := ?_ }⟩
  · apply Set.Subset.antisymm (Set.iUnion_subset hJsub)
    intro e he
    rw [← hu] at he
    obtain ⟨i,hi⟩ := Set.mem_iUnion.mp he
    obtain ⟨a,hia⟩ := hbagcov i
    exact Set.mem_iUnion.mpr ⟨a,by rw [hJedge]; exact Set.mem_iUnion₂.mpr ⟨i,hia,hi⟩⟩
  · intro a x y hxy
    have he : s(x,y) ∈ (J a).edgeSet := hxy
    rw [hJedge] at he
    obtain ⟨i,hi,he⟩ := Set.mem_iUnion₂.mp he
    exact ⟨Finset.mem_biUnion.mpr ⟨i,hi,(hU i he).1⟩,Finset.mem_biUnion.mpr ⟨i,hi,(hU i he).2⟩⟩
  · intro a v hv
    obtain ⟨i,_,hi⟩ := Finset.mem_biUnion.mp hv
    exact hUY i hi
  · intro v hv
    obtain ⟨i,_,hi⟩ := Finset.mem_biUnion.mp (hY hv)
    obtain ⟨a,ha⟩ := hbagcov i
    exact Finset.mem_biUnion.mpr ⟨a,mem_univ _,Finset.mem_biUnion.mpr ⟨i,ha,hi⟩⟩
  · intro a
    exact (hWweight a).trans ((hLn (bag a) (L.get_mem a)).2)
  · calc
      _ ≤ ∑ a, batchWeight (fun i => (U i).card) (bag a) := Finset.sum_le_sum (fun a _ => hWweight a)
      _ = _ := by rw [list_sum_get,hLm]; rfl
  · simpa only [A,Fintype.card_fin,batchWeight] using hLnum

end
end ErdosGallai.Indexing

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

def goodVertices {V : Type} [Fintype V] (F : SimpleGraph V) (Y : Finset V) (a : ℝ) : Finset V :=
  Y.filter fun v => (F.degree v:ℝ) ≤ a

lemma bad_vertices_degree_bound {V : Type} [Fintype V] (F : SimpleGraph V) (Y : Finset V) (a : ℝ) :
    a * ((Y \ goodVertices F Y a).card:ℝ) ≤ 2 * (F.edgeFinset.card:ℝ) := by
  classical
  let bad := Y \ goodVertices F Y a
  have hbad (v) (hv : v ∈ bad) : a ≤ (F.degree v:ℝ) := by
    have hn := (Finset.mem_sdiff.mp hv).2
    exact le_of_lt (lt_of_not_ge (fun h => hn (Finset.mem_filter.mpr ⟨(Finset.mem_sdiff.mp hv).1,h⟩)))
  calc
    _ = ∑ v ∈ bad, a := by simp [bad,mul_comm]
    _ ≤ ∑ v ∈ bad, (F.degree v:ℝ) := Finset.sum_le_sum hbad
    _ ≤ ∑ v, (F.degree v:ℝ) := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (by intros; positivity)
    _ = _ := by exact_mod_cast F.sum_degrees_eq_twice_card_edges

structure ActiveFamily {V R B : Type} [Fintype V] [Fintype R] [Fintype B]
    (F : SimpleGraph V) (Y : Finset V) (W : B → Finset V) (U : R → Finset V) (a L : ℝ) where
  Index : B → Type
  finite : ∀ b, Fintype (Index b)
  vertices : ∀ b, Index b → Finset V
  router : ∀ b, Index b → R
  subset_batch : ∀ b i, vertices b i ⊆ W b
  subset_router : ∀ b i, vertices b i ⊆ U (router b i)
  disjoint : ∀ b, Pairwise fun i j => Disjoint (vertices b i) (vertices b j)
  degree_le : ∀ b i v, v ∈ vertices b i → (F.degree v:ℝ) ≤ a
  large : ∀ b i, L ≤ ((vertices b i).card:ℝ)
  lower : (∑ r, ((U r).card:ℝ)) - ((Y \ goodVertices F Y a).card:ℝ) -
    L * Fintype.card B * Fintype.card R ≤ ∑ b, ∑ i, ((vertices b i).card:ℝ)
  upper : (∑ b, ∑ i, ((vertices b i).card:ℝ)) + Y.card ≤
    (∑ r, ((U r).card:ℝ)) + ∑ b, ((W b).card:ℝ)
attribute [instance] ActiveFamily.finite

theorem choose_active_family {V R B : Type} [Fintype V] [Fintype R] [Fintype B]
    (F : SimpleGraph V) (Y : Finset V) (W : B → Finset V) (U : R → Finset V) (a L : ℝ)
    (hL : 0 ≤ L) (hW : ∀ b, W b ⊆ Y) (hU : ∀ r, U r ⊆ Y)
    (hcov : Y ⊆ univ.biUnion W) (hUd : Pairwise fun r s => Disjoint (U r) (U s)) :
    Nonempty (ActiveFamily F Y W U a L) := by
  classical
  let good := goodVertices F Y a
  let S (b : B) (r : R) := W b ∩ U r ∩ good
  let keep (b : B) (r : R) := L ≤ ((S b r).card:ℝ)
  let I (b : B) := {r : R // keep b r}
  let X (b : B) (i : I b) := S b i.val
  have hsum (b : B) : (∑ i : I b, ((X b i).card:ℝ)) =
      ∑ r, if keep b r then ((S b r).card:ℝ) else 0 := by
    rw [← Finset.sum_filter]
    simpa only [Finset.subtype_univ] using (Finset.sum_subtype_eq_sum_filter (s := univ) (p := keep b) (fun r => ((S b r).card:ℝ)))
  have hadd := active_occurrences Y good W U hW hU hcov hUd keep
  dsimp only at hadd
  have hlow : (∑ r, ((U r).card:ℝ)) ≤
      (∑ b, ∑ r, if keep b r then ((S b r).card:ℝ) else 0) +
      (∑ b, ∑ r, if keep b r then 0 else ((S b r).card:ℝ)) + ((Y \ good).card:ℝ) := by
    exact_mod_cast hadd.1
  have hhigh : (∑ b, ∑ r, if keep b r then ((S b r).card:ℝ) else 0) + Y.card ≤
      (∑ r, ((U r).card:ℝ)) + ∑ b, ((W b).card:ℝ) := by exact_mod_cast hadd.2
  have hskip : (∑ b, ∑ r, if keep b r then 0 else ((S b r).card:ℝ)) ≤
      L * Fintype.card B * Fintype.card R := by
    calc
      _ ≤ ∑ _b : B, ∑ _r : R, L := by
        apply Finset.sum_le_sum; intro b _
        apply Finset.sum_le_sum; intro r _
        split_ifs with hk
        · exact hL
        · exact le_of_lt (lt_of_not_ge hk)
      _ = _ := by simp; ring
  refine ⟨{
    Index := I
    finite := fun _ => inferInstance
    vertices := X
    router := fun _ i => i.val
    subset_batch := fun _ _ => Finset.inter_subset_left.trans Finset.inter_subset_left
    subset_router := fun _ _ => Finset.inter_subset_left.trans Finset.inter_subset_right
    disjoint := ?_
    degree_le := ?_
    large := fun _ i => i.property
    lower := ?_
    upper := ?_ }⟩
  · intro b i j hij
    exact (hUd (fun h => hij (Subtype.ext h))).mono
      (Finset.inter_subset_left.trans Finset.inter_subset_right)
      (Finset.inter_subset_left.trans Finset.inter_subset_right)
  · intro b i v hv
    exact (Finset.mem_filter.mp (Finset.mem_inter.mp hv).2).2
  · simp_rw [hsum]
    dsimp only [good] at hlow hskip
    linarith
  · simpa only [hsum] using hhigh

lemma thirds_le_halves {k : ℕ} (hk : 8 ≤ k) : (k:ℝ)/3 ≤ (k/2:ℕ) := by
  have h : k ≤ 3*(k/2) := by omega
  have h' : (k:ℝ) ≤ 3*(k/2:ℕ) := by exact_mod_cast h
  linarith

end
end ErdosGallai.Indexing

end
end
end

end OAI