| import OAI.Combinatorics.CycleDecomposition.CycleLifting |
|
|
| namespace OAI |
|
|
| universe cycleUniverse1 cycleUniverse2 cycleUniverse3 cycleUniverse4 cycleUniverse5 cycleUniverse6 cycleUniverse7 cycleUniverse8 cycleUniverse9 cycleUniverse10 cycleUniverse11 cycleUniverse12 |
|
|
| section |
| open Filter Asymptotics Real |
| open scoped Topology |
| noncomputable section |
| open MeasureTheory ProbabilityTheory Finset |
| section |
| namespace ErdosGallai.Batch |
| noncomputable section |
| open Finset SimpleGraph |
| attribute [local instance] Classical.propDecidable |
|
|
| def demandLoad {I : Type cycleUniverse1} {V : Type cycleUniverse2} [Fintype I] (x y : I → V) (v : V) : ℕ := |
| (univ.filter fun i => x i = v ∨ y i = v).card |
|
|
| theorem demand_load_le_degree {V : Type cycleUniverse3} {I : Type cycleUniverse4} {B : Type cycleUniverse5} [Fintype V] [Fintype I] |
| [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] |
| (E : B → Set (Sym2 V)) |
| (hE : Pairwise fun b c => Disjoint (E b) (E c)) |
| (owner : I → B) (x y : I → V) |
| (hunique : ∀ i j v, owner i = owner j → |
| (x i = v ∨ y i = v) → (x j = v ∨ y j = v) → i = j) |
| (hedge : ∀ i v, x i = v ∨ y i = v → |
| ∃ w, G.Adj v w ∧ s(v,w) ∈ E (owner i)) (v : V) : |
| demandLoad x y v ≤ G.degree v := by |
| classical |
| let S := {i : I |
| have hs (i : S) := hedge i.val v i.property |
| let f : S → G.neighborFinset v := fun i => |
| ⟨(hs i).choose, by simpa using (hs i).choose_spec.1⟩ |
| have hf : Function.Injective f := by |
| intro i j hij |
| have he : (hs i).choose = (hs j).choose := congrArg Subtype.val hij |
| apply Subtype.ext |
| by_cases ho : owner i.val = owner j.val |
| · exact hunique i.val j.val v ho i.property j.property |
| · exact False.elim (Set.disjoint_left.mp (hE ho) |
| (hs i).choose_spec.2 (by rw [he]; exact (hs j).choose_spec.2)) |
| have hc := Fintype.card_le_of_injective f hf |
| have hn : Fintype.card (G.neighborFinset v) = G.degree v := by |
| rw [Fintype.card_coe, SimpleGraph.card_neighborFinset_eq_degree] |
| rw [hn] at hc |
| have hcS : Fintype.card S = demandLoad x y v := by |
| simp only [S, Fintype.card_subtype, demandLoad] |
| congr 1 |
| ext i |
| simp |
| rw [hcS] at hc |
| exact hc |
|
|
| lemma start_has_incident_edge {V : Type cycleUniverse6} {G : SimpleGraph V} {a b : V} |
| (p : G.Walk a b) (hp : ¬p.Nil) : |
| ∃ w, G.Adj a w ∧ s(a,w) ∈ p.edgeSet := by |
| exact ⟨p.snd,p.adj_snd hp,p.mk_start_snd_mem_edges hp⟩ |
|
|
| lemma finish_has_incident_edge {V : Type cycleUniverse7} {G : SimpleGraph V} {a b : V} |
| (p : G.Walk a b) (hp : ¬p.Nil) : |
| ∃ w, G.Adj b w ∧ s(b,w) ∈ p.edgeSet := by |
| refine ⟨p.penultimate,(p.adj_penultimate hp).symm,?_⟩ |
| change s(b,p.penultimate) ∈ p.edges |
| simpa only [Sym2.eq_swap] using p.mk_penultimate_end_mem_edges hp |
|
|
| theorem path_demands_load_le_degree {V : Type cycleUniverse8} {I : Type cycleUniverse9} [Fintype V] [Fintype I] |
| [DecidableEq V] (G : SimpleGraph V) [DecidableRel G.Adj] |
| (x y : I → V) (p : ∀ i, G.Walk (x i) (y i)) |
| (hpos : ∀ i, ¬(p i).Nil) |
| (hd : Pairwise fun i j => Disjoint (p i).edgeSet (p j).edgeSet) (v : V) : |
| demandLoad x y v ≤ G.degree v := by |
| apply demand_load_le_degree G (fun i => (p i).edgeSet) hd id x y |
| · intro i j _ hij _ _; exact hij |
| · intro i w hw |
| rcases hw with rfl | rfl |
| · exact start_has_incident_edge (p i) (hpos i) |
| · exact finish_has_incident_edge (p i) (hpos i) |
|
|
| lemma disjoint_sum_blocks {α : Type cycleUniverse10} {B : Type cycleUniverse11} {C : Type cycleUniverse12} (E : B → Set α) (F : C → Set α) |
| (hE : Pairwise fun b c => Disjoint (E b) (E c)) |
| (hF : Pairwise fun b c => Disjoint (F b) (F c)) |
| (hEF : ∀ b c, Disjoint (E b) (F c)) : |
| Pairwise (fun i j : B ⊕ C => Disjoint (Sum.elim E F i) (Sum.elim E F j)) := by |
| intro i j hij |
| cases i with |
| | inl b => |
| cases j with |
| | inl c => exact hE (fun he => hij (congrArg Sum.inl he)) |
| | inr c => exact hEF b c |
| | inr b => |
| cases j with |
| | inl c => exact (hEF c b).symm |
| | inr c => exact hF (fun he => hij (congrArg Sum.inr he)) |
|
|
| end |
| end ErdosGallai.Batch |
|
|
| namespace ErdosGallai.Batch |
|
|
| def CycleOrSingleEdge {V : Type} (G : SimpleGraph V) |
| (s : Set (Sym2 V)) : Prop := |
| (∃ (v : V) (p : G.Walk v v), p.IsCycle ∧ s = p.edgeSet) ∨ |
| ∃ e ∈ G.edgeSet, s = {e} |
|
|
| def EdgeDecomposition {V : Type} (G : SimpleGraph V) (k : ℕ) : Prop := |
| ∃ parts : Fin k → Set (Sym2 V), |
| (∀ i, CycleOrSingleEdge G (parts i)) ∧ |
| Pairwise (fun i j => Disjoint (parts i) (parts j)) ∧ |
| (⋃ i, parts i) = G.edgeSet |
|
|
| noncomputable section |
| open SimpleGraph |
|
|
| lemma cycleOrSingleEdge_subset {V : Type} {G : SimpleGraph V} |
| {s : Set (Sym2 V)} (hs : CycleOrSingleEdge G s) : s ⊆ G.edgeSet := by |
| rcases hs with ⟨v,p,hp,rfl⟩ | ⟨e,he,rfl⟩ |
| · exact p.edges_subset_edgeSet |
| · simpa using he |
|
|
| lemma cycleOrSingleEdge_map {V W : Type} {G : SimpleGraph V} {H : SimpleGraph W} |
| (f : G →g H) (hf : Function.Injective f) {s : Set (Sym2 V)} |
| (hs : CycleOrSingleEdge G s) : CycleOrSingleEdge H (Sym2.map f '' s) := by |
| rcases hs with ⟨v,p,hp,rfl⟩ | ⟨e,he,rfl⟩ |
| · exact Or.inl ⟨f v,p.map f,hp.map hf,(p.edgeSet_map f).symm⟩ |
| · refine Or.inr ⟨Sym2.map f e, ?_, by simp⟩ |
| induction e using Sym2.ind with | _ x y => |
| exact f.map_adj he |
|
|
| lemma edgeDecomposition_of_indexed {V I : Type} [Fintype I] (G : SimpleGraph V) |
| (parts : I → Set (Sym2 V)) (hp : ∀ i, CycleOrSingleEdge G (parts i)) |
| (hd : Pairwise (fun i j => Disjoint (parts i) (parts j))) |
| (hu : (⋃ i, parts i) = G.edgeSet) : EdgeDecomposition G (Fintype.card I) := by |
| let e := Fintype.equivFin I |
| refine ⟨fun j => parts (e.symm j), fun j => hp _, ?_, ?_⟩ |
| · intro i j hij |
| exact hd (fun he => hij (e.symm.injective he)) |
| · ext x |
| simp only [Set.mem_iUnion] |
| rw [← hu] |
| simp only [Set.mem_iUnion] |
| constructor |
| · rintro ⟨i,hi⟩; exact ⟨e.symm i,hi⟩ |
| · rintro ⟨i,hi⟩; exact ⟨e i, by simpa using hi⟩ |
|
|
| theorem edgeDecomposition_singleEdges {V : Type} [Fintype V] (G : SimpleGraph V) : |
| EdgeDecomposition G (Nat.card G.edgeSet) := by |
| classical |
| let : Fintype G.edgeSet := Fintype.ofFinite _ |
| rw [Nat.card_eq_fintype_card] |
| apply edgeDecomposition_of_indexed G (fun e : G.edgeSet => {e.1}) |
| · intro e; exact Or.inr ⟨e.1,e.2,rfl⟩ |
| · intro e d hed |
| exact Set.disjoint_singleton.mpr (fun h => hed (Subtype.ext h)) |
| · ext e; simp |
|
|
| theorem edgeDecomposition_assemble {V I : Type} [Fintype I] (G : SimpleGraph V) |
| (W : I → Type) (H : ∀ i, SimpleGraph (W i)) |
| (f : ∀ i, H i →g G) (hf : ∀ i, Function.Injective (f i)) |
| (hdisj : Pairwise (fun i j => |
| Disjoint (Sym2.map (f i) '' (H i).edgeSet) (Sym2.map (f j) '' (H j).edgeSet))) |
| (hcover : (⋃ i, Sym2.map (f i) '' (H i).edgeSet) = G.edgeSet) |
| (k : I → ℕ) (hparts : ∀ i, EdgeDecomposition (H i) (k i)) : |
| EdgeDecomposition G (∑ i, k i) := by |
| classical |
| choose parts hp hd hu using hparts |
| let J := Σ i, Fin (k i) |
| let P : J → Set (Sym2 V) := fun j => Sym2.map (f j.1) '' parts j.1 j.2 |
| have hpart : ∀ j, CycleOrSingleEdge G (P j) := by |
| intro j; exact cycleOrSingleEdge_map (f j.1) (hf j.1) (hp j.1 j.2) |
| have hsub : ∀ i a, parts i a ⊆ (H i).edgeSet := by |
| intro i a; exact cycleOrSingleEdge_subset (hp i a) |
| have hdisjP : Pairwise (fun i j => Disjoint (P i) (P j)) := by |
| rintro ⟨i,a⟩ ⟨j,b⟩ hij |
| by_cases h : i = j |
| · subst j |
| have hab : a ≠ b := fun he => hij (by cases he; rfl) |
| apply Set.disjoint_left.mpr |
| rintro e ⟨x,hx,he⟩ ⟨y,hy,he'⟩ |
| have hxy : x = y := Sym2.map.injective (hf i) (he.trans he'.symm) |
| subst y |
| exact Set.disjoint_left.mp (hd i hab) hx hy |
| · exact (hdisj h).mono (Set.image_mono (hsub i a)) (Set.image_mono (hsub j b)) |
| have hcoverP : (⋃ j, P j) = G.edgeSet := by |
| rw [← hcover] |
| ext e |
| simp only [Set.mem_iUnion] |
| constructor |
| · rintro ⟨⟨i,a⟩,x,hx,he⟩ |
| exact ⟨i,x,hsub i a hx,he⟩ |
| · rintro ⟨i,x,hx,he⟩ |
| rw [← hu i] at hx |
| obtain ⟨a,ha⟩ := Set.mem_iUnion.mp hx |
| exact ⟨⟨i,a⟩,x,ha,he⟩ |
| have hc : Fintype.card J = ∑ i, k i := by simp [J, Fintype.card_sigma] |
| rw [← hc] |
| exact edgeDecomposition_of_indexed G P hpart hdisjP hcoverP |
|
|
| end |
| end ErdosGallai.Batch |
|
|
| namespace ErdosGallai.Batch |
| noncomputable section |
| open SimpleGraph Finset |
| attribute [local instance] Classical.propDecidable |
|
|
| def decompositionCost {V : Type} [Fintype V] (G : SimpleGraph V) : ℕ := |
| Nat.find (show ∃ k, EdgeDecomposition G k from ⟨_,edgeDecomposition_singleEdges G⟩) |
|
|
| lemma decompositionCost_spec {V : Type} [Fintype V] (G : SimpleGraph V) : |
| EdgeDecomposition G (decompositionCost G) := Nat.find_spec _ |
|
|
| lemma decompositionCost_le {V : Type} [Fintype V] {G : SimpleGraph V} {k : ℕ} |
| (h : EdgeDecomposition G k) : decompositionCost G ≤ k := Nat.find_min' _ h |
| |
| lemma decompositionCost_singleEdges {V : Type} [Fintype V] (G : SimpleGraph V) : |
| decompositionCost G ≤ Nat.card G.edgeSet := decompositionCost_le (edgeDecomposition_singleEdges G) |
| |
| theorem edgeDecomposition_adjoin {V I J : Type} [Fintype I] [Fintype J] |
| (G : SimpleGraph V) (parts : I → Set (Sym2 V)) |
| (hp : ∀ i, CycleOrSingleEdge G (parts i)) |
| (hd : Pairwise fun i j => Disjoint (parts i) (parts j)) |
| (W : J → Type) (H : ∀ j, SimpleGraph (W j)) (f : ∀ j, H j →g G) |
| (hf : ∀ j, Function.Injective (f j)) |
| (hHH : Pairwise fun i j => Disjoint (Sym2.map (f i) '' (H i).edgeSet) |
| (Sym2.map (f j) '' (H j).edgeSet)) |
| (hHP : ∀ j i, Disjoint (Sym2.map (f j) '' (H j).edgeSet) (parts i)) |
| (hu : (⋃ i, parts i) ∪ (⋃ j, Sym2.map (f j) '' (H j).edgeSet) = G.edgeSet) |
| (k : J → ℕ) (hD : ∀ j, EdgeDecomposition (H j) (k j)) : |
| EdgeDecomposition G (Fintype.card I + ∑ j, k j) := by |
| classical |
| choose P hP hPd hPc using hD |
| let R : (I ⊕ Σ j, Fin (k j)) → Set (Sym2 V) := |
| Sum.elim parts (fun z => Sym2.map (f z.1) '' P z.1 z.2) |
| have hsub : ∀ j i, P j i ⊆ (H j).edgeSet := fun j i => cycleOrSingleEdge_subset (hP j i) |
| have hRp : ∀ z, CycleOrSingleEdge G (R z) := by |
| intro z |
| rcases z with z | ⟨j,i⟩ |
| · exact hp z |
| · exact cycleOrSingleEdge_map (f j) (hf j) (hP j i) |
| have hRd : Pairwise fun z t => Disjoint (R z) (R t) := by |
| intro z t hzt |
| rcases z with z | ⟨j,i⟩ <;> rcases t with t | ⟨l,a⟩ |
| · exact hd (fun h => hzt (congrArg Sum.inl h)) |
| · exact ((hHP l z).mono_left (Set.image_mono (hsub l a))).symm |
| · exact (hHP j t).mono_left (Set.image_mono (hsub j i)) |
| · by_cases hjl : j = l |
| · subst l |
| have hia : i ≠ a := fun h => hzt (by cases h; rfl) |
| apply Set.disjoint_left.mpr |
| rintro e ⟨x,hx,he⟩ ⟨y,hy,he'⟩ |
| have hxy := Sym2.map.injective (hf j) (he.trans he'.symm) |
| subst y |
| exact Set.disjoint_left.mp (hPd j hia) hx hy |
| · exact (hHH hjl).mono (Set.image_mono (hsub j i)) (Set.image_mono (hsub l a)) |
| have hRu : (⋃ z, R z) = G.edgeSet := by |
| rw [← hu] |
| ext e |
| simp only [Set.mem_iUnion, Set.mem_union] |
| constructor |
| · rintro ⟨z,hz⟩ |
| rcases z with z | ⟨j,i⟩ |
| · exact Or.inl ⟨z,hz⟩ |
| · obtain ⟨x,hx,he⟩ := hz |
| exact Or.inr ⟨j,x,hsub j i hx,he⟩ |
| · rintro (⟨i,hi⟩ | ⟨j,x,hx,he⟩) |
| · exact ⟨Sum.inl i,hi⟩ |
| · rw [← hPc j] at hx |
| obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hx |
| exact ⟨Sum.inr ⟨j,i⟩,x,hi,he⟩ |
| simpa only [Fintype.card_sum,Fintype.card_sigma,Fintype.card_fin] using |
| edgeDecomposition_of_indexed G R hRp hRd hRu |
| |
| lemma decompositionCost_adjoin {V I J : Type} [Fintype V] [Fintype I] [Fintype J] |
| (G : SimpleGraph V) (parts : I → Set (Sym2 V)) |
| (hp : ∀ i, CycleOrSingleEdge G (parts i)) |
| (hd : Pairwise fun i j => Disjoint (parts i) (parts j)) |
| (W : J → Type) [∀ j, Fintype (W j)] (H : ∀ j, SimpleGraph (W j)) |
| (f : ∀ j, H j →g G) (hf : ∀ j, Function.Injective (f j)) |
| (hHH : Pairwise fun i j => Disjoint (Sym2.map (f i) '' (H i).edgeSet) |
| (Sym2.map (f j) '' (H j).edgeSet)) |
| (hHP : ∀ j i, Disjoint (Sym2.map (f j) '' (H j).edgeSet) (parts i)) |
| (hu : (⋃ i, parts i) ∪ (⋃ j, Sym2.map (f j) '' (H j).edgeSet) = G.edgeSet) : |
| decompositionCost G ≤ Fintype.card I + ∑ j, decompositionCost (H j) := |
| decompositionCost_le (edgeDecomposition_adjoin G parts hp hd W H f hf hHH hHP hu _ |
| (fun j => decompositionCost_spec (H j))) |
| |
| end |
| end ErdosGallai.Batch |
| namespace ErdosGallai.Batch |
| noncomputable section |
| open SimpleGraph Finset |
| attribute [local instance] Classical.propDecidable |
| |
| lemma edgeDecomposition_map {V W : Type} {G : SimpleGraph V} {H : SimpleGraph W} |
| (f : H →g G) (hf : Function.Injective f) |
| (hu : Sym2.map f '' H.edgeSet = G.edgeSet) {k : ℕ} (hk : EdgeDecomposition H k) : |
| EdgeDecomposition G k := by |
| have := edgeDecomposition_assemble (I := Unit) G (fun _ : Unit => W) (fun _ => H) (fun _ => f) |
| (fun _ => hf) (by intro i j hij; exact False.elim (hij (Subsingleton.elim _ _))) |
| (by rw [Set.iUnion_const]; exact hu) (fun _ => k) (fun _ => hk) |
| simpa using this |
| |
| lemma decompositionCost_on {V : Type} [Fintype V] (G : SimpleGraph V) |
| (A : Finset V) (hA : ∀ ⦃x y⦄, G.Adj x y → x ∈ A ∧ y ∈ A) : |
| decompositionCost G ≤ decompositionCost (G.induce (A:Set V)) := by |
| classical |
| let f : G.induce (A:Set V) →g G := ⟨Subtype.val,fun h => h⟩ |
| have hu : Sym2.map f '' (G.induce (A:Set V)).edgeSet = G.edgeSet := by |
| ext e |
| constructor |
| · rintro ⟨e,he,rfl⟩ |
| induction e using Sym2.ind with | _ x y => exact he |
| · intro he |
| induction e using Sym2.ind with |
| | _ x y => |
| exact ⟨s(⟨x,(hA he).1⟩,⟨y,(hA he).2⟩),he,rfl⟩ |
| exact decompositionCost_le (edgeDecomposition_map f Subtype.val_injective hu (decompositionCost_spec _)) |
| |
| lemma edgeDecomposition_on {V : Type} (G : SimpleGraph V) |
| (A : Finset V) (hA : ∀ ⦃x y⦄, G.Adj x y → x ∈ A ∧ y ∈ A) |
| {k : ℕ} (hk : EdgeDecomposition (G.induce (A:Set V)) k) : EdgeDecomposition G k := by |
| classical |
| let f : G.induce (A:Set V) →g G := ⟨Subtype.val,fun h => h⟩ |
| apply edgeDecomposition_map f Subtype.val_injective _ hk |
| ext e |
| constructor |
| · rintro ⟨e,he,rfl⟩ |
| induction e using Sym2.ind with | _ x y => exact he |
| · intro he |
| induction e using Sym2.ind with |
| | _ x y => exact ⟨s(⟨x,(hA he).1⟩,⟨y,(hA he).2⟩),he,rfl⟩ |
| |
| end |
| end ErdosGallai.Batch |
| |
| namespace ErdosGallai.Batch |
| noncomputable section |
| open Finset SimpleGraph |
| attribute [local instance] Classical.propDecidable |
| |
| lemma endpointLoad_subtype_le {V I : Type} [Fintype I] |
| (x y : I → V) (s : I → Prop) (v : V) : |
| endpointLoad univ (fun i : {i // s i} => x i) (fun i => y i) v ≤ endpointLoad univ x y v := by |
| classical |
| simp only [endpointLoad] |
| apply Finset.card_le_card_of_injOn (fun i : {i // s i} => i.val) |
| · intro i hi; simpa using hi |
| · intro i _ j _ h; exact Subtype.ext h |
| |
| theorem uniform_multi_batch_routing : |
| ∃ D₀ : ℝ, 1 < D₀ ∧ ∀ D ≥ D₀, |
| ∀ (V R I T : Type) [Fintype V] [Fintype R] [Fintype I], |
| ∀ (G : SimpleGraph V) (P : R → SimpleGraph V) (U : R → Finset V), |
| (∀ r, P r ≤ G) → Pairwise (fun r s => Disjoint (P r).edgeSet (P s).edgeSet) → |
| Pairwise (fun r s => Disjoint (U r) (U s)) → |
| (∀ r, CutExpansionOn (P r) (U r) (D^(9/10:ℝ)/4)) → |
| (∀ r, D^(9/10:ℝ) ≤ ((U r).card:ℝ) ∧ ((U r).card:ℝ) ≤ D^(51/50:ℝ)) → |
| ∀ (owner : I → R) (x y : I → V), |
| (∀ i, x i ∈ U (owner i) ∧ y i ∈ U (owner i) ∧ x i ≠ y i) → |
| ∀ (team : I → T) (Z : I → Finset V), |
| (∀ v, (endpointLoad univ x y v:ℝ) ≤ D^(1/100:ℝ)) → |
| (∀ i, ((univ.filter (fun j => team j = team i)).card:ℝ) ≤ D^(3/10:ℝ)) → |
| (∀ i, ((Z i).card:ℝ) ≤ 2*D^(3/10:ℝ)) → |
| ∃ q : ∀ i, G.Walk (x i) (y i), |
| (∀ i, (q i).IsPath ∧ (∀ v ∈ (q i).support, v ∈ U (owner i)) ∧ |
| (q i).edgeSet ⊆ (P (owner i)).edgeSet ∧ Disjoint (pathInterior (q i)) (Z i)) ∧ |
| Pairwise (fun i j => Disjoint (q i).edgeSet (q j).edgeSet) ∧ |
| (∀ i j, i ≠ j → team i = team j → Disjoint (pathInterior (q i)) (pathInterior (q j))) := by |
| classical |
| obtain ⟨D₀,hD₀,hroute⟩ := uniform_batch_routing |
| refine ⟨D₀,hD₀,?_⟩ |
| intro D hD V R I T _ _ _ G P U hPG hPP hUU he hr owner x y hxy team Z hl ht hZ |
| let J := fun r => {i // owner i = r} |
| have hex : ∀ r, ∃ q : ∀ i : J r, G.Walk (x i) (y i), |
| (∀ i, (q i).IsPath ∧ (∀ v ∈ (q i).support, v ∈ U r) ∧ |
| (q i).edgeSet ⊆ (P r).edgeSet ∧ Disjoint (pathInterior (q i)) (Z i)) ∧ |
| Pairwise (fun i j => Disjoint (q i).edgeSet (q j).edgeSet) ∧ |
| (∀ i j : J r, i ≠ j → team i = team j → Disjoint (pathInterior (q i)) (pathInterior (q j))) := by |
| intro r |
| obtain ⟨q,hq,hd,hi⟩ := hroute D hD V G (P r) (hPG r) (U r) (he r) (hr r).1 (hr r).2 |
| (J r) T (fun i => x i) (fun i => y i) |
| (fun i => by simpa only [← i.property] using (hxy i).1) |
| (fun i => by simpa only [← i.property] using (hxy i).2.1) |
| (fun i => (hxy i).2.2) (fun i => team i) (fun i => Z i) |
| (fun v => (show (endpointLoad univ (fun i : J r => x i) (fun i => y i) v:ℝ) ≤ |
| endpointLoad univ x y v by exact_mod_cast endpointLoad_subtype_le x y (fun i => owner i = r) v).trans (hl v)) |
| (fun i => le_trans (by |
| apply Nat.cast_le.mpr |
| apply Finset.card_le_card_of_injOn (fun i : J r => i.val) |
| · intro j hj; simpa using hj |
| · intro j _ l _ h; exact Subtype.ext h) (ht i)) (fun i => hZ i) |
| exact ⟨q,fun i => ⟨(hq i).1,(hq i).2.2⟩,hd,hi⟩ |
| choose q hq hd hi using hex |
| let f : ∀ i, G.Walk (x i) (y i) := fun i => q (owner i) ⟨i,rfl⟩ |
| have hf (i : I) (r : R) (h : owner i = r) : f i = q r ⟨i,h⟩ := by |
| subst r; rfl |
| refine ⟨f,fun i => hq _ _,?_,?_⟩ |
| · intro i j hij |
| by_cases hh : owner i = owner j |
| · have h := hd (owner i) (show (⟨i,rfl⟩:J (owner i)) ≠ ⟨j,hh.symm⟩ from |
| fun h => hij (congrArg Subtype.val h)) |
| rw [hf j (owner i) hh.symm] |
| exact h |
| · exact (hPP hh).mono (hq _ _).2.2.1 (hq _ _).2.2.1 |
| · intro i j hij hteam |
| by_cases hh : owner i = owner j |
| · have h := hi (owner i) ⟨i,rfl⟩ ⟨j,hh.symm⟩ |
| (fun h => hij (congrArg Subtype.val h)) hteam |
| rw [hf j (owner i) hh.symm] |
| exact h |
| · apply (hUU hh).mono |
| · intro v hv; exact (hq (owner i) ⟨i,rfl⟩).2.1 v (List.mem_toFinset.mp (Finset.mem_sdiff.mp hv).1) |
| · intro v hv; exact (hq (owner j) ⟨j,rfl⟩).2.1 v (List.mem_toFinset.mp (Finset.mem_sdiff.mp hv).1) |
| |
| structure CycleOutline {V : Type} (G : SimpleGraph V) where |
| W : Type |
| finiteW : Fintype W |
| Q : SimpleGraph W |
| base : W |
| cycle : Q.Walk base base |
| isCycle : cycle.IsCycle |
| rep : Q.Dart → G.Dart |
| start : W → V |
| finish : W → V |
| project : V → W |
| ports : ∀ d ∈ cycle.darts, finish d.fst = (rep d).fst ∧ start d.snd = (rep d).snd |
| projects : ∀ z ∈ cycle.dropLast.support, project (start z) = z ∧ project (finish z) = z |
| outside : ∀ z, z ∉ cycle.dropLast.support → start z = finish z |
| attribute [instance] CycleOutline.finiteW |
| |
| namespace CycleOutline |
| variable {V : Type} {G : SimpleGraph V} (c : CycleOutline G) |
| |
| def edges : Set (Sym2 V) := {e | ∃ d ∈ c.cycle.darts, e = (c.rep d).edge} |
| def vertices : Finset V := c.cycle.darts.toFinset.biUnion fun d => {(c.rep d).fst,(c.rep d).snd} |
| abbrev Switch := {z : c.W // z ∈ c.cycle.dropLast.support ∧ c.start z ≠ c.finish z} |
| instance : Fintype c.Switch := inferInstanceAs (Fintype {_z : c.W // _}) |
| |
| lemma edges_subset : c.edges ⊆ G.edgeSet := by |
| rintro e ⟨d,hd,rfl⟩; exact (c.rep d).edge_mem |
| |
| lemma fst_mem {d : c.Q.Dart} (hd : d ∈ c.cycle.darts) : d.fst ∈ c.cycle.dropLast.support := by |
| rw [c.cycle.support_dropLast c.isCycle.not_nil,← Walk.map_fst_darts] |
| exact List.mem_map.mpr ⟨d,hd,rfl⟩ |
| |
| lemma snd_mem {d : c.Q.Dart} (hd : d ∈ c.cycle.darts) : d.snd ∈ c.cycle.dropLast.support := by |
| rw [c.cycle.support_dropLast c.isCycle.not_nil] |
| apply c.cycle.tail_support_perm_dropLast_support.mem_iff.mp |
| rw [← Walk.map_snd_darts] |
| exact List.mem_map.mpr ⟨d,hd,rfl⟩ |
| |
| lemma outgoing (z : c.W) (hz : z ∈ c.cycle.dropLast.support) : |
| ∃ d ∈ c.cycle.darts, d.fst = z := by |
| have h : z ∈ c.cycle.darts.map (fun d => d.fst) := by |
| rw [Walk.map_fst_darts,← c.cycle.support_dropLast c.isCycle.not_nil]; exact hz |
| exact List.mem_map.mp h |
| |
| lemma incoming (z : c.W) (hz : z ∈ c.cycle.dropLast.support) : |
| ∃ d ∈ c.cycle.darts, d.snd = z := by |
| have h : z ∈ c.cycle.darts.map (fun d => d.snd) := by |
| rw [Walk.map_snd_darts] |
| apply c.cycle.tail_support_perm_dropLast_support.mem_iff.mpr |
| rw [← c.cycle.support_dropLast c.isCycle.not_nil]; exact hz |
| exact List.mem_map.mp h |
| |
| lemma endpoint_incident (z : c.Switch) (v : V) (hv : c.start z = v ∨ c.finish z = v) : |
| ∃ w, G.Adj v w ∧ s(v,w) ∈ c.edges := by |
| rcases hv with rfl | rfl |
| · obtain ⟨d,hd,he⟩ := c.incoming z z.property.1 |
| have hh := (c.ports d hd).2 |
| rw [he] at hh |
| refine ⟨(c.rep d).fst,?_,?_⟩ |
| · rw [hh]; exact (c.rep d).adj.symm |
| · refine ⟨d,hd,?_⟩ |
| rw [hh]; exact Sym2.eq_swap |
| · obtain ⟨d,hd,he⟩ := c.outgoing z z.property.1 |
| have hh := (c.ports d hd).1 |
| rw [he] at hh |
| refine ⟨(c.rep d).snd,?_,?_⟩ |
| · rw [hh]; exact (c.rep d).adj |
| · refine ⟨d,hd,?_⟩; rw [hh]; rfl |
| |
| lemma endpoint_unique (z w : c.Switch) (v : V) |
| (hz : c.start z = v ∨ c.finish z = v) (hw : c.start w = v ∨ c.finish w = v) : z = w := by |
| apply Subtype.ext |
| have hf : ∀ (z : c.Switch), c.start z = v ∨ c.finish z = v → c.project v = z := by |
| intro z hz |
| rcases hz with h | h |
| · rw [← h]; exact (c.projects z z.property.1).1 |
| · rw [← h]; exact (c.projects z z.property.1).2 |
| exact (hf z hz).symm.trans (hf w hw) |
| |
| lemma vertices_card_support : c.vertices.card ≤ 2 * c.cycle.dropLast.support.toFinset.card := by |
| have hfirst : c.vertices.card ≤ 2*c.cycle.darts.toFinset.card := by |
| calc |
| _ ≤ ∑ d ∈ c.cycle.darts.toFinset, ({(c.rep d).fst,(c.rep d).snd}:Finset V).card := Finset.card_biUnion_le |
| _ ≤ ∑ d ∈ c.cycle.darts.toFinset, 2 := Finset.sum_le_sum (fun d _ => Finset.card_le_two) |
| _ = _ := by simp [mul_comm] |
| have hd : c.cycle.darts.toFinset.card ≤ c.cycle.dropLast.support.toFinset.card := by |
| calc |
| _ ≤ c.cycle.darts.length := List.toFinset_card_le _ |
| _ = c.cycle.dropLast.support.length := by |
| rw [Walk.length_darts,Walk.length_support,Walk.length_dropLast] |
| have := c.isCycle.three_le_length; omega |
| _ = c.cycle.dropLast.support.toFinset.card := (List.toFinset_card_of_nodup c.isCycle.isPath_dropLast.support_nodup).symm |
| omega |
| |
| lemma vertices_card : c.vertices.card ≤ 2 * Fintype.card c.W := |
| c.vertices_card_support.trans (Nat.mul_le_mul_left _ (Finset.card_le_univ _)) |
| |
| lemma mem_vertices (v : V) : v ∈ c.vertices ↔ ∃ d ∈ c.cycle.darts, v = (c.rep d).fst ∨ v = (c.rep d).snd := by |
| simp [vertices] |
| |
| theorem complete [DecidableEq V] |
| (route : ∀ z : c.Switch, G.Walk (c.start z) (c.finish z)) |
| (hs : ∀ z, (route z).IsPath) |
| (ha : ∀ z, Disjoint (pathInterior (route z)) c.vertices) |
| (hd : Pairwise fun z w => Disjoint (pathInterior (route z)) (pathInterior (route w))) : |
| ∃ (v : V) (p : G.Walk v v), p.IsCycle ∧ |
| p.edgeSet = c.edges ∪ ⋃ z, (route z).edgeSet := by |
| classical |
| let visits : ∀ z, G.Walk (c.start z) (c.finish z) := fun z => |
| if h : z ∈ c.cycle.dropLast.support ∧ c.start z ≠ c.finish z then route ⟨z,h⟩ |
| else (Walk.nil : G.Walk (c.start z) (c.start z)).copy rfl (by |
| by_cases hz : z ∈ c.cycle.dropLast.support |
| · exact not_not.mp (fun hn => h ⟨hz,hn⟩) |
| · exact c.outside z hz) |
| have hv (z : c.Switch) : visits z = route z := by simp only [visits,dite_eq_left z.property] |
| have hnil (z : c.W) (hz : ¬(z ∈ c.cycle.dropLast.support ∧ c.start z ≠ c.finish z)) : |
| (visits z).Nil := by simp only [visits,dite_eq_right hz,Walk.nil_copy,Walk.nil_nil] |
| have hpath : ∀ z, (visits z).IsPath := by |
| intro z |
| by_cases hz : z ∈ c.cycle.dropLast.support ∧ c.start z ≠ c.finish z |
| · simpa only [visits,dite_eq_left hz] using hs ⟨z,hz⟩ |
| · simp [visits,dite_eq_right hz] |
| have hinter (z : c.W) : visitInterior c.start c.finish visits z = (pathInterior (visits z):Set V) := by |
| ext v; simp [visitInterior,pathInterior] |
| have h_avoid : ∀ z ∈ c.cycle.dropLast.support, Disjoint |
| (visitInterior c.start c.finish visits z) {v | ∃ d ∈ c.cycle.darts, v = (c.rep d).fst ∨ v = (c.rep d).snd} := by |
| intro z hz |
| rw [hinter] |
| have he : {v | ∃ d ∈ c.cycle.darts, v = (c.rep d).fst ∨ v = (c.rep d).snd} = (c.vertices:Set V) := by |
| ext v; exact (c.mem_vertices v).symm |
| rw [he,Finset.disjoint_coe] |
| by_cases hne : c.start z ≠ c.finish z |
| · rw [hv ⟨z,hz,hne⟩]; exact ha _ |
| · have hn := hnil z (by tauto) |
| simp [Finset.disjoint_left,pathInterior,Walk.nil_iff_support_eq.mp hn] |
| have h_dis : Pairwise fun z w : {z // z ∈ c.cycle.dropLast.support} => |
| Disjoint (visitInterior c.start c.finish visits z) (visitInterior c.start c.finish visits w) := by |
| intro z w hzw |
| rw [hinter,hinter,Finset.disjoint_coe] |
| by_cases hz : c.start z ≠ c.finish z |
| · by_cases hw : c.start w ≠ c.finish w |
| · rw [hv ⟨z,z.property,hz⟩,hv ⟨w,w.property,hw⟩] |
| exact hd (fun h => hzw (Subtype.ext (congrArg (fun t : c.Switch => (t:c.W)) h))) |
| · have hn := hnil w (by tauto); simp [Finset.disjoint_left,pathInterior,Walk.nil_iff_support_eq.mp hn] ; tauto |
| · have hn := hnil z (by tauto); simp [Finset.disjoint_left,pathInterior,Walk.nil_iff_support_eq.mp hn] |
| obtain ⟨v,p,hp,hedge⟩ := inflate_represented_cycle c.rep c.start c.finish c.cycle c.isCycle c.ports visits |
| (fun z _ => hpath z) (switch_supports_separated {z | z ∈ c.cycle.dropLast.support} |
| c.project c.start c.finish visits c.projects |
| (by |
| intro z hz |
| rw [cyclePortSet_eq_representative_vertices c.rep c.start c.finish c.cycle c.isCycle c.ports] |
| exact h_avoid z hz) |
| (fun z hz w hw hzw => h_dis (show (⟨z,hz⟩:{z // z ∈ c.cycle.dropLast.support}) ≠ ⟨w,hw⟩ from |
| fun h => hzw (congrArg Subtype.val h)))) |
| refine ⟨v,p,hp,hedge.trans ?_⟩ |
| congr 1 |
| ext e |
| simp only [Set.mem_iUnion] |
| constructor |
| · rintro ⟨z,hz,he⟩ |
| by_cases hne : c.start z ≠ c.finish z |
| · exact ⟨⟨z,hz,hne⟩,by rwa [hv ⟨z,hz,hne⟩] at he⟩ |
| · have hn := hnil z (by tauto) |
| have hh := he |
| simp [Walk.edgeSet,Walk.edges_eq_nil.mpr hn] at hh |
| · rintro ⟨z,he⟩; exact ⟨z,z.property.1,by rwa [hv]⟩ |
| |
| end CycleOutline |
| end |
| end ErdosGallai.Batch |
| |
| namespace ErdosGallai.Batch |
| noncomputable section |
| open Finset SimpleGraph |
| attribute [local instance] Classical.propDecidable |
| |
| structure RoutingTemplate {V : Type} (G : SimpleGraph V) where |
| Arity : Type |
| finiteArity : Fintype Arity |
| x : Arity → V |
| y : Arity → V |
| ne : ∀ i, x i ≠ y i |
| edges : Set (Sym2 V) |
| subset : edges ⊆ G.edgeSet |
| vertices : Finset V |
| incident : ∀ i v, x i = v ∨ y i = v → ∃ w, s(v,w) ∈ edges |
| unique : ∀ i j v, (x i = v ∨ y i = v) → (x j = v ∨ y j = v) → i = j |
| complete : ∀ q : ∀ i, G.Walk (x i) (y i), |
| (∀ i, (q i).IsPath) → |
| (∀ i, Disjoint (pathInterior (q i)) vertices) → |
| Pairwise (fun i j => Disjoint (pathInterior (q i)) (pathInterior (q j))) → |
| CycleOrSingleEdge G (edges ∪ ⋃ i, (q i).edgeSet) |
| attribute [instance] RoutingTemplate.finiteArity |
| |
| namespace RoutingTemplate |
| variable {V : Type} {G : SimpleGraph V} |
| |
| def ofCycle (c : CycleOutline G) : RoutingTemplate G where |
| Arity := c.Switch |
| finiteArity := inferInstance |
| x := fun i => c.start i |
| y := fun i => c.finish i |
| ne := fun i => i.property.2 |
| edges := c.edges |
| subset := c.edges_subset |
| vertices := c.vertices |
| incident := fun i v h => by obtain ⟨w,_,he⟩ := c.endpoint_incident i v h; exact ⟨w,he⟩ |
| unique := c.endpoint_unique |
| complete := by |
| intro q hs ha hd |
| obtain ⟨v,p,hp,he⟩ := c.complete q hs ha hd |
| exact Or.inl ⟨v,p,hp,he.symm⟩ |
| |
| def ofSingle (e : Sym2 V) (he : e ∈ G.edgeSet) : RoutingTemplate G where |
| Arity := Empty |
| finiteArity := inferInstance |
| x := Empty.elim |
| y := Empty.elim |
| ne := fun i => i.elim |
| edges := {e} |
| subset := Set.singleton_subset_iff.mpr he |
| vertices := ∅ |
| incident := fun i => i.elim |
| unique := fun i => i.elim |
| complete := by intro q _ _ _; exact Or.inr ⟨e,he,by simp⟩ |
| |
| def ofPath {x y : V} (p : G.Walk x y) (hp : p.IsPath) (hl : 2 ≤ p.length) : RoutingTemplate G where |
| Arity := Unit |
| finiteArity := inferInstance |
| x := fun _ => y |
| y := fun _ => x |
| ne := fun _ he => by |
| have hn : p.Nil := hp.nil_iff_eq.mpr he.symm |
| have := Walk.length_eq_zero_iff.mpr hn |
| omega |
| edges := p.edgeSet |
| subset := p.edges_subset_edgeSet |
| vertices := p.support.toFinset |
| incident := by |
| intro i v hv |
| have hn : ¬p.Nil := fun h => by have := Walk.length_eq_zero_iff.mpr h; omega |
| rcases hv with rfl | rfl |
| · obtain ⟨w,_,he⟩ := finish_has_incident_edge p hn; exact ⟨w,he⟩ |
| · obtain ⟨w,_,he⟩ := start_has_incident_edge p hn; exact ⟨w,he⟩ |
| unique := fun _ _ _ _ _ => Subsingleton.elim _ _ |
| complete := by |
| intro q hs ha hd |
| obtain ⟨hc,he⟩ := close_trimmed_path p (q ()) hp (hs ()) hl (by |
| intro v hv hxa hxb hpv |
| exact Finset.disjoint_left.mp (ha ()) |
| (by simp [pathInterior,hv,hxa,hxb]) (List.mem_toFinset.mpr hpv)) |
| refine Or.inl ⟨x,p.append (q ()),hc,?_⟩ |
| have hh : ∀ i : Unit, q i = q () := fun i => by cases i; rfl |
| simp_rw [hh,Set.iUnion_const] |
| exact he.symm |
| |
| lemma ofCycle_arity_card (c : CycleOutline G) : |
| Fintype.card (ofCycle c).Arity ≤ Fintype.card c.W := Fintype.card_subtype_le _ |
| |
| lemma ofPath_vertices_card [Fintype V] {x y : V} (p : G.Walk x y) (hp : p.IsPath) (hl : 2 ≤ p.length) : |
| (ofPath p hp hl).vertices.card ≤ Fintype.card V := Finset.card_le_univ _ |
| |
| end RoutingTemplate |
| |
| theorem uniform_resolve_templates : |
| ∃ D₀ : ℝ, 1 < D₀ ∧ ∀ D ≥ D₀, |
| ∀ (V R B : Type) [Fintype V] [Fintype R] [Fintype B], |
| ∀ (G F : SimpleGraph V) (P : R → SimpleGraph V) (U : R → Finset V), |
| F ≤ G → (∀ r, P r ≤ G) → |
| Pairwise (fun r s => Disjoint (P r).edgeSet (P s).edgeSet) → |
| Pairwise (fun r s => Disjoint (U r) (U s)) → |
| (∀ r, Disjoint F.edgeSet (P r).edgeSet) → |
| (∀ r, CutExpansionOn (P r) (U r) (D^(9/10:ℝ)/4)) → |
| (∀ r, D^(9/10:ℝ) ≤ ((U r).card:ℝ) ∧ ((U r).card:ℝ) ≤ D^(51/50:ℝ)) → |
| ∀ (b : B → RoutingTemplate G), |
| (∀ j, (b j).edges ⊆ F.edgeSet) → |
| Pairwise (fun j k => Disjoint (b j).edges (b k).edges) → |
| ∀ owner : (j : B) → (b j).Arity → R, |
| (∀ j i, (b j).x i ∈ U (owner j i) ∧ (b j).y i ∈ U (owner j i)) → |
| (∀ j i, (F.degree ((b j).x i):ℝ) ≤ D^(1/100:ℝ) ∧ |
| (F.degree ((b j).y i):ℝ) ≤ D^(1/100:ℝ)) → |
| (∀ j, (Fintype.card (b j).Arity:ℝ) ≤ D^(3/10:ℝ)) → |
| (∀ j, ((b j).vertices.card:ℝ) ≤ 2*D^(3/10:ℝ)) → |
| ∃ (parts : B → Set (Sym2 V)) (used : Set (Sym2 V)), |
| (∀ j, CycleOrSingleEdge G (parts j)) ∧ |
| Pairwise (fun j k => Disjoint (parts j) (parts k)) ∧ |
| used ⊆ ⋃ r, (P r).edgeSet ∧ Disjoint F.edgeSet used ∧ |
| (⋃ j, parts j) = (⋃ j, (b j).edges) ∪ used := by |
| classical |
| obtain ⟨D₀,hD₀,hr⟩ := uniform_multi_batch_routing |
| refine ⟨D₀,hD₀,?_⟩ |
| intro D hD V R B _ _ _ G F P U hFG hPG hPP hUU hFP he hsize b hsub hdis owner hends hdeg hnum hvertices |
| let I := Σ j, (b j).Arity |
| let x : I → V := fun i => (b i.1).x i.2 |
| let y : I → V := fun i => (b i.1).y i.2 |
| have hl (v : V) : (endpointLoad univ x y v:ℝ) ≤ D^(1/100:ℝ) := by |
| have hload : endpointLoad univ x y v ≤ F.degree v := by |
| have hh := demand_load_le_degree F (fun j => (b j).edges) hdis |
| Sigma.fst x y (by |
| rintro ⟨j,i⟩ ⟨k,l⟩ v h h₁ h₂ |
| dsimp only at h; subst k |
| congr 1; exact (b j).unique i l v h₁ h₂) (by |
| rintro ⟨j,i⟩ v h |
| obtain ⟨w,hw⟩ := (b j).incident i v h |
| exact ⟨w,hsub j hw,hw⟩) v |
| simpa [demandLoad,endpointLoad] using hh |
| by_cases hz : endpointLoad univ x y v = 0 |
| · rw [hz,Nat.cast_zero]; exact Real.rpow_nonneg (by linarith) _ |
| · have hp : 0 < (univ.filter fun i => x i = v ∨ y i = v).card := by |
| change 0 < endpointLoad univ x y v; omega |
| obtain ⟨⟨j,i⟩,hi⟩ := Finset.card_pos.mp hp |
| have hv : (b j).x i = v ∨ (b j).y i = v := (Finset.mem_filter.mp hi).2 |
| have hh : (F.degree v:ℝ) ≤ D^(1/100:ℝ) := by |
| rcases hv with rfl | rfl |
| · exact (hdeg j i).1 |
| · exact (hdeg j i).2 |
| exact (Nat.cast_le.mpr hload).trans hh |
| have hteam (i : I) : ((univ.filter fun j : I => j.1 = i.1).card:ℝ) ≤ D^(3/10:ℝ) := by |
| have hc : (univ.filter fun j : I => j.1 = i.1).card = Fintype.card (b i.1).Arity := by |
| rw [Finset.card_eq_sum_ones,Finset.sum_filter,Fintype.sum_sigma] |
| calc |
| _ = ∑ j : B, if j = i.1 then Fintype.card (b j).Arity else 0 := by |
| apply Finset.sum_congr rfl; intro j _ |
| by_cases hh : j = i.1 <;> simp [hh] |
| _ = _ := by simp |
| rw [hc]; exact hnum i.1 |
| obtain ⟨q,hq,hqd,hqi⟩ := hr D hD V R I B G P U hPG hPP hUU he hsize |
| (fun i => owner i.1 i.2) x y (fun i => ⟨(hends i.1 i.2).1,(hends i.1 i.2).2,(b i.1).ne i.2⟩) |
| Sigma.fst (fun i => (b i.1).vertices) hl hteam (fun i => hvertices i.1) |
| let used := ⋃ i, (q i).edgeSet |
| let parts := fun j => (b j).edges ∪ ⋃ i, (q ⟨j,i⟩).edgeSet |
| have hu : used ⊆ ⋃ r, (P r).edgeSet := by |
| apply Set.iUnion_subset; intro i |
| exact Set.subset_iUnion_of_subset (owner i.1 i.2) (hq i).2.2.1 |
| have hFu : Disjoint F.edgeSet used := by |
| refine Set.disjoint_iUnion_right.mpr (fun i => ?_) |
| exact (hFP _).mono_right (hq i).2.2.1 |
| have hbu : ∀ j, Disjoint (b j).edges used := fun j => hFu.mono_left (hsub j) |
| refine ⟨parts,used,?_,?_,hu,hFu,?_⟩ |
| · intro j |
| exact (b j).complete (fun i => q ⟨j,i⟩) (fun i => (hq _).1) (fun i => (hq _).2.2.2) |
| (fun i l hil => hqi _ _ (fun h => hil (eq_of_heq (Sigma.mk.inj_iff.mp h).2)) rfl) |
| · intro j k hjk |
| apply Set.disjoint_union_left.mpr; constructor |
| · apply Set.disjoint_union_right.mpr; constructor |
| · exact hdis hjk |
| · exact (hbu j).mono_right (Set.iUnion_subset (fun i => Set.subset_iUnion (fun z : I => (q z).edgeSet) ⟨k,i⟩)) |
| · apply Set.disjoint_union_right.mpr; constructor |
| · exact ((hbu k).mono_right (Set.iUnion_subset (fun i => Set.subset_iUnion (fun z : I => (q z).edgeSet) ⟨j,i⟩))).symm |
| · apply Set.disjoint_iUnion_left.mpr; intro i |
| apply Set.disjoint_iUnion_right.mpr; intro l |
| exact hqd (fun h => hjk (congrArg Sigma.fst h)) |
| · ext e |
| simp only [parts,used,Set.mem_iUnion,Set.mem_union] |
| constructor |
| · rintro ⟨j,he|⟨i,hi⟩⟩ |
| · exact Or.inl ⟨j,he⟩ |
| · exact Or.inr ⟨⟨j,i⟩,hi⟩ |
| · rintro (⟨j,he⟩|⟨⟨j,i⟩,he⟩) |
| · exact ⟨j,Or.inl he⟩ |
| · exact ⟨j,Or.inr ⟨i,he⟩⟩ |
| |
| end |
| end ErdosGallai.Batch |
| end |
| end |
| end |
| |
| end OAI |
| |
