| import OAI.Combinatorics.CycleDecomposition.CollisionEstimates |
|
|
| 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 cycleUniverse32 cycleUniverse33 cycleUniverse34 |
|
|
| 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} {I : Type cycleUniverse2} [Fintype V] [Fintype I] (X : I → Finset V) |
| (hd : Pairwise (fun i j => Disjoint (X i) (X j))) |
|
|
| lemma crossGraph_card (G : SimpleGraph V) (S T : Finset V) (hst : Disjoint S T) : |
| (crossGraph G S T).edgeFinset.card = betweenCount G S T := by |
| classical |
| have hdeg (v : V) : (crossGraph G S T).degree v = |
| (if v ∈ S then neighborsIn G T v else 0) + |
| (if v ∈ T then neighborsIn G S v else 0) := by |
| rw [← SimpleGraph.card_neighborFinset_eq_degree] |
| have hfin : (crossGraph G S T).neighborFinset v = |
| (if v ∈ S then T.filter (G.Adj v) else ∅) ∪ |
| (if v ∈ T then S.filter (G.Adj v) else ∅) := by |
| ext x |
| simp only [SimpleGraph.mem_neighborFinset,Finset.mem_union] |
| change (G.Adj v x ∧ ((v ∈ S ∧ x ∈ T) ∨ (v ∈ T ∧ x ∈ S))) ↔ _ |
| split_ifs <;> simp_all only [Finset.mem_filter,Finset.notMem_empty] <;> tauto |
| rw [hfin,Finset.card_union_of_disjoint] |
| · split_ifs <;> simp [neighborsIn] |
| · split_ifs with hs ht ht |
| · exact False.elim (Finset.disjoint_left.mp hst hs ht) |
| all_goals simp |
| have hh := (crossGraph G S T).sum_degrees_eq_twice_card_edges |
| simp_rw [hdeg] at hh |
| rw [Finset.sum_add_distrib] at hh |
| have hS : (∑ v, if v ∈ S then neighborsIn G T v else 0) = betweenCount G S T := by |
| simp [betweenCount] |
| have hT : (∑ v, if v ∈ T then neighborsIn G S v else 0) = betweenCount G T S := by |
| simp [betweenCount] |
| rw [hS,hT,betweenCount_comm G T S] at hh |
| omega |
|
|
| def edgePairEvent (p : ∀ i, PairingSpace (X i)) (q : Finset (Sym2 V)) : Prop := |
| (q.image (Sym2.map (familyProject X hd p))).card = 1 |
|
|
| lemma edgePairEvent_pair (p : ∀ i, PairingSpace (X i)) (e f : Sym2 V) : |
| edgePairEvent X hd p {e,f} ↔ |
| Sym2.map (familyProject X hd p) e = Sym2.map (familyProject X hd p) f := by |
| classical |
| by_cases h : Sym2.map (familyProject X hd p) e = Sym2.map (familyProject X hd p) f |
| · simp [edgePairEvent,h] |
| · simp [edgePairEvent,h,Finset.card_pair h] |
|
|
| def DisjointEdgePair (q : Finset (Sym2 V)) : Prop := |
| ∃ u v x y : V, u ≠ v ∧ x ≠ y ∧ u ≠ x ∧ u ≠ y ∧ v ≠ x ∧ v ≠ y ∧ |
| q = {s(u,v),s(x,y)} |
|
|
| def pairErrors (H : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) := |
| ((H.edgeFinset.powersetCard 2).filter DisjointEdgePair).filter (edgePairEvent X hd p) |
|
|
| def loopErrors (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) (i : I) := |
| (internalGraph G (X i)).edgeFinset.filter |
| (fun e => (Sym2.map (familyProject X hd p) e).IsDiag) |
|
|
| lemma loopErrors_average (G : SimpleGraph V) (i : I) (hm : 2 ≤ (X i).card) : |
| finiteAverage (fun p : ∀ j, PairingSpace (X j) => ((loopErrors X hd G p i).card : ℝ)) ≤ |
| ((internalGraph G (X i)).edgeFinset.card : ℝ) / ((X i).card-1:ℝ) := by |
| classical |
| change finiteAverage (fun p => (((internalGraph G (X i)).edgeFinset.filter _).card:ℝ)) ≤ _ |
| have hav := finiteAverage_filter_card (s:=(internalGraph G (X i)).edgeFinset) |
| (P:=fun (p : ∀ j, PairingSpace (X j)) e => (Sym2.map (familyProject X hd p) e).IsDiag) |
| calc |
| _ = ∑ e ∈ (internalGraph G (X i)).edgeFinset, |
| finiteAverage (fun p : ∀ j, PairingSpace (X j) => |
| if (Sym2.map (familyProject X hd p) e).IsDiag then 1 else 0) := by |
| convert hav using 1 <;> congr 4 |
| · funext p |
| congr 2 |
| ext e |
| simp only [Finset.mem_filter] |
| · funext e |
| congr 1 |
| funext p |
| split_ifs <;> rfl |
| _ ≤ _ := by |
| calc |
| _ ≤ ∑ _e ∈ (internalGraph G (X i)).edgeFinset, 1 / ((X i).card-1:ℝ) := by |
| apply Finset.sum_le_sum |
| intro e he |
| obtain ⟨u,v⟩ := e |
| obtain ⟨huv,hu,hv⟩ := mem_internalGraph.mp he |
| have heq (p : ∀ j, PairingSpace (X j)) : |
| (Sym2.map (familyProject X hd p) s(u,v)).IsDiag ↔ vertexPairEvent X p {u,v} := |
| (loop_iff_familyPaired X hd p huv.ne).trans (vertexPairEvent_pair X p u v huv.ne).symm |
| simp_rw [heq] |
| exact vertexPairEvent_average X hd i {u,v} (by intro z hz; rcases Finset.mem_insert.mp hz with rfl | hz; exact hu; exact Finset.mem_singleton.mp hz ▸ hv) |
| (by simp [huv.ne]) hm |
| _ = _ := by simp [div_eq_mul_inv] |
|
|
| lemma internal_pairErrors_average (G : SimpleGraph V) (i : I) (hm : 4 ≤ (X i).card) : |
| finiteAverage (fun p : ∀ j, PairingSpace (X j) => |
| ((pairErrors X hd (internalGraph G (X i)) p).card : ℝ)) ≤ |
| ((internalGraph G (X i)).edgeFinset.card.choose 2 : ℝ) * |
| (2 / (((X i).card-1:ℝ)*((X i).card-3:ℝ))) := by |
| classical |
| change finiteAverage (fun p => (((((internalGraph G (X i)).edgeFinset.powersetCard 2).filter DisjointEdgePair).filter _).card:ℝ)) ≤ _ |
| rw [finiteAverage_filter_card] |
| calc |
| _ ≤ ∑ _q ∈ ((internalGraph G (X i)).edgeFinset.powersetCard 2).filter DisjointEdgePair, |
| 2 / (((X i).card-1:ℝ)*((X i).card-3:ℝ)) := by |
| apply Finset.sum_le_sum |
| intro q hq |
| obtain ⟨hq,hdis⟩ := Finset.mem_filter.mp hq |
| obtain ⟨u,v,x,y,huv,hxy,hux,huy,hvx,hvy,rfl⟩ := hdis |
| have hsub := (Finset.mem_powersetCard.mp hq).1 |
| obtain ⟨he,hu,hv⟩ := mem_internalGraph.mp (hsub (by simp : s(u,v) ∈ ({s(u,v),s(x,y)}:Finset (Sym2 V)))) |
| obtain ⟨hf,hx,hy⟩ := mem_internalGraph.mp (hsub (by simp : s(x,y) ∈ ({s(u,v),s(x,y)}:Finset (Sym2 V)))) |
| simp_rw [edgePairEvent_pair] |
| exact internal_collision_average X hd i hm ⟨u,hu⟩ ⟨v,hv⟩ ⟨x,hx⟩ ⟨y,hy⟩ |
| (fun h => huv (congrArg Subtype.val h)) (fun h => hux (congrArg Subtype.val h)) |
| (fun h => huy (congrArg Subtype.val h)) (fun h => hvx (congrArg Subtype.val h)) |
| (fun h => hvy (congrArg Subtype.val h)) (fun h => hxy (congrArg Subtype.val h)) |
| _ ≤ _ := by |
| simp only [Finset.sum_const, nsmul_eq_mul] |
| apply mul_le_mul_of_nonneg_right |
| · exact_mod_cast (Finset.card_filter_le _ _).trans_eq (Finset.card_powersetCard _ _) |
| · have : (4:ℝ) ≤ (X i).card := by exact_mod_cast hm |
| exact div_nonneg (by norm_num) (mul_nonneg (by linarith) (by linarith)) |
|
|
| lemma cross_pair_orientation {V : Type cycleUniverse3} {I : Type cycleUniverse4} [_contextInstance2 : Fintype V] [_contextInstance3 : Fintype I] (X : I → Finset V) (G : SimpleGraph V) (i j : I) |
| (q : Finset (Sym2 V)) (hq : q ⊆ (crossGraph G (X i) (X j)).edgeFinset) |
| (hdis : DisjointEdgePair q) : |
| ∃ (u x : X i) (v y : X j), u ≠ x ∧ v ≠ y ∧ q = {s((u:V),(v:V)),s((x:V),(y:V))} := by |
| classical |
| obtain ⟨u,v,x,y,huv,hxy,hux,huy,hvx,hvy,rfl⟩ := hdis |
| have he := SimpleGraph.mem_edgeFinset.mp (hq (by simp : s(u,v) ∈ ({s(u,v),s(x,y)}:Finset (Sym2 V)))) |
| have hf := SimpleGraph.mem_edgeFinset.mp (hq (by simp : s(x,y) ∈ ({s(u,v),s(x,y)}:Finset (Sym2 V)))) |
| rcases he.2 with ⟨hui,hvj⟩ | ⟨huj,hvi⟩ <;> rcases hf.2 with ⟨hxi,hyj⟩ | ⟨hxj,hyi⟩ |
| · exact ⟨⟨u,hui⟩,⟨x,hxi⟩,⟨v,hvj⟩,⟨y,hyj⟩, |
| (fun h => hux (congrArg Subtype.val h)),(fun h => hvy (congrArg Subtype.val h)),rfl⟩ |
| · refine ⟨⟨u,hui⟩,⟨y,hyi⟩,⟨v,hvj⟩,⟨x,hxj⟩, |
| (fun h => huy (congrArg Subtype.val h)),(fun h => hvx (congrArg Subtype.val h)),?_⟩ |
| rw [Sym2.eq_swap (a:=y) (b:=x)] |
| · refine ⟨⟨v,hvi⟩,⟨x,hxi⟩,⟨u,huj⟩,⟨y,hyj⟩, |
| (fun h => hvx (congrArg Subtype.val h)),(fun h => huy (congrArg Subtype.val h)),?_⟩ |
| rw [Sym2.eq_swap (a:=v) (b:=u)] |
| · refine ⟨⟨v,hvi⟩,⟨y,hyi⟩,⟨u,huj⟩,⟨x,hxj⟩, |
| (fun h => hvy (congrArg Subtype.val h)),(fun h => hux (congrArg Subtype.val h)),?_⟩ |
| rw [Sym2.eq_swap (a:=v) (b:=u),Sym2.eq_swap (a:=y) (b:=x)] |
|
|
| lemma cross_pairErrors_average (G : SimpleGraph V) (i j : I) (hij : i ≠ j) |
| (hi : 2 ≤ (X i).card) (hj : 2 ≤ (X j).card) : |
| finiteAverage (fun p : ∀ k, PairingSpace (X k) => |
| ((pairErrors X hd (crossGraph G (X i) (X j)) p).card : ℝ)) ≤ |
| ((betweenCount G (X i) (X j)).choose 2 : ℝ) * |
| (1 / (((X i).card-1:ℝ)*((X j).card-1:ℝ))) := by |
| classical |
| change finiteAverage (fun p => (((((crossGraph G (X i) (X j)).edgeFinset.powersetCard 2).filter DisjointEdgePair).filter _).card:ℝ)) ≤ _ |
| rw [finiteAverage_filter_card] |
| calc |
| _ ≤ ∑ _q ∈ ((crossGraph G (X i) (X j)).edgeFinset.powersetCard 2).filter DisjointEdgePair, |
| 1 / (((X i).card-1:ℝ)*((X j).card-1:ℝ)) := by |
| apply Finset.sum_le_sum |
| intro q hq |
| obtain ⟨hq,hdis⟩ := Finset.mem_filter.mp hq |
| obtain ⟨u,x,v,y,hux,hvy,rfl⟩ := cross_pair_orientation X G i j q |
| (Finset.mem_powersetCard.mp hq).1 hdis |
| simp_rw [edgePairEvent_pair] |
| exact cross_collision_average X hd i j hij hi hj u x v y hux hvy |
| _ ≤ _ := by |
| rw [← crossGraph_card G (X i) (X j) (hd hij)] |
| simp only [Finset.sum_const, nsmul_eq_mul] |
| apply mul_le_mul_of_nonneg_right |
| · exact_mod_cast (Finset.card_filter_le _ _).trans_eq (Finset.card_powersetCard _ _) |
| · have : (2:ℝ) ≤ (X i).card := by exact_mod_cast hi |
| have : (2:ℝ) ≤ (X j).card := by exact_mod_cast hj |
| exact div_nonneg (by norm_num) (mul_nonneg (by linarith) (by linarith)) |
|
|
| end |
| end ErdosGallai.Batch |
|
|
| namespace ErdosGallai.Batch |
| open Finset |
| noncomputable section |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type cycleUniverse5} {I : Type cycleUniverse6} [Fintype V] [Fintype I] (X : I → Finset V) |
| (hd : Pairwise (fun i j => Disjoint (X i) (X j))) |
|
|
| lemma mem_pairErrors (H : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) |
| (q : Finset (Sym2 V)) : |
| q ∈ pairErrors X hd H p ↔ q ⊆ H.edgeFinset ∧ q.card = 2 ∧ |
| DisjointEdgePair q ∧ edgePairEvent X hd p q := by |
| classical |
| simp [pairErrors,and_assoc] |
|
|
| lemma mem_crossGraph {G : SimpleGraph V} {S T : Finset V} {u v : V} : |
| s(u,v) ∈ (crossGraph G S T).edgeFinset ↔ |
| G.Adj u v ∧ ((u ∈ S ∧ v ∈ T) ∨ (u ∈ T ∧ v ∈ S)) := by |
| rw [SimpleGraph.mem_edgeFinset] |
| rfl |
|
|
| lemma two_paired_edges_placement (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) |
| {u v x y : V} (he : G.Adj u v) (hf : G.Adj x y) |
| (hux : familyPaired X p u x) (hvy : familyPaired X p v y) : |
| (∃ i, {s(u,v),s(x,y)} ⊆ (internalGraph G (X i)).edgeFinset) ∨ |
| (∃ i j, i ≠ j ∧ {s(u,v),s(x,y)} ⊆ (crossGraph G (X i) (X j)).edgeFinset) := by |
| classical |
| rcases paired_fibers_placement X p hux hvy with ⟨i,hu,hv,hx,hy⟩ | ⟨i,j,hij,hu,hx,hv,hy⟩ |
| · left |
| refine ⟨i,?_⟩ |
| intro e he' |
| rcases Finset.mem_insert.mp he' with rfl | he' |
| · exact mem_internalGraph.mpr ⟨he,hu,hv⟩ |
| · exact Finset.mem_singleton.mp he' ▸ mem_internalGraph.mpr ⟨hf,hx,hy⟩ |
| · right |
| refine ⟨i,j,hij,?_⟩ |
| intro e he' |
| rcases Finset.mem_insert.mp he' with rfl | he' |
| · exact mem_crossGraph.mpr ⟨he,Or.inl ⟨hu,hv⟩⟩ |
| · exact Finset.mem_singleton.mp he' ▸ mem_crossGraph.mpr ⟨hf,Or.inl ⟨hx,hy⟩⟩ |
|
|
| def wedgeCover (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) : Finset (Finset (Sym2 V)) := |
| Finset.univ.biUnion fun i => Finset.univ.biUnion fun v => |
| (wedgeErrors X G p i v).image (fun q => q.image (fun u => s(v,u))) |
|
|
| def internalCover (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) : Finset (Finset (Sym2 V)) := |
| Finset.univ.biUnion fun i => pairErrors X hd (internalGraph G (X i)) p |
|
|
| def crossCover (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) : Finset (Finset (Sym2 V)) := |
| Finset.univ.biUnion fun i => (Finset.univ.erase i).biUnion fun j => |
| pairErrors X hd (crossGraph G (X i) (X j)) p |
|
|
| lemma all_collisions_covered (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) : |
| CollisionPairs (Sym2.map (familyProject X hd p)) G.edgeFinset ⊆ |
| wedgeCover X G p ∪ internalCover X hd G p ∪ crossCover X hd G p := by |
| classical |
| intro q hq |
| obtain ⟨hsub,hcard,himage⟩ := (mem_collisionPairs _ _ _).mp hq |
| obtain ⟨e,f,hef,rfl⟩ := Finset.card_eq_two.mp hcard |
| have he := hsub (by simp : e ∈ ({e,f}:Finset (Sym2 V))) |
| have hf := hsub (by simp : f ∈ ({e,f}:Finset (Sym2 V))) |
| have hev : edgePairEvent X hd p {e,f} := himage |
| have heq := (edgePairEvent_pair X hd p e f).mp hev |
| rcases distinct_edge_cases G he hf hef with hshared | hdis |
| · obtain ⟨v,u,w,hvu,hvw,huw,rfl,rfl⟩ := hshared |
| have hpair := shared_endpoint_collision X hd p huw heq |
| obtain ⟨i,hu,hw,hpair'⟩ := hpair |
| apply Finset.mem_union_left |
| apply Finset.mem_union_left |
| apply Finset.mem_biUnion.mpr |
| refine ⟨i,Finset.mem_univ _,Finset.mem_biUnion.mpr ⟨v,Finset.mem_univ _,?_⟩⟩ |
| apply Finset.mem_image.mpr |
| refine ⟨{u,w},?_,by simp⟩ |
| apply Finset.mem_filter.mpr |
| refine ⟨Finset.mem_powersetCard.mpr ⟨?_,by simp [huw]⟩,?_⟩ |
| · intro z hz |
| rcases Finset.mem_insert.mp hz with rfl | hz |
| · exact Finset.mem_filter.mpr ⟨hu,SimpleGraph.mem_edgeFinset.mp he⟩ |
| · exact Finset.mem_singleton.mp hz ▸ Finset.mem_filter.mpr ⟨hw,SimpleGraph.mem_edgeFinset.mp hf⟩ |
| · exact (vertexPairEvent_pair X p u w huw).mpr ⟨i,hu,hw,hpair'⟩ |
| · obtain ⟨u,v,x,y,huv,hxy,hux,huy,hvx,hvy,rfl,rfl⟩ := hdis |
| have hdis : DisjointEdgePair ({s(u,v),s(x,y)}:Finset (Sym2 V)) := |
| ⟨u,v,x,y,huv,hxy,hux,huy,hvx,hvy,rfl⟩ |
| have hplace : (∃ i, {s(u,v),s(x,y)} ⊆ (internalGraph G (X i)).edgeFinset) ∨ |
| (∃ i j, i ≠ j ∧ {s(u,v),s(x,y)} ⊆ (crossGraph G (X i) (X j)).edgeFinset) := by |
| rcases four_endpoint_collision X hd p hux huy hvx hvy heq with hh | hh |
| · exact two_paired_edges_placement X G p (SimpleGraph.mem_edgeFinset.mp he) |
| (SimpleGraph.mem_edgeFinset.mp hf) hh.1 hh.2 |
| · have hh' := two_paired_edges_placement X G p (SimpleGraph.mem_edgeFinset.mp he) |
| (SimpleGraph.mem_edgeFinset.mp hf).symm hh.1 hh.2 |
| simpa only [Sym2.eq_swap (a:=y) (b:=x)] using hh' |
| rcases hplace with ⟨i,hi⟩ | ⟨i,j,hij,hij'⟩ |
| · apply Finset.mem_union_left |
| apply Finset.mem_union_right |
| exact Finset.mem_biUnion.mpr ⟨i,Finset.mem_univ _, |
| (mem_pairErrors X hd _ p _).mpr ⟨hi,by simp [hef],hdis,hev⟩⟩ |
| · apply Finset.mem_union_right |
| apply Finset.mem_biUnion.mpr |
| refine ⟨i,Finset.mem_univ _,Finset.mem_biUnion.mpr ⟨j,by simp [hij.symm],?_⟩⟩ |
| exact (mem_pairErrors X hd _ p _).mpr ⟨hij',by simp [hef],hdis,hev⟩ |
|
|
| lemma all_loops_covered (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) : |
| G.edgeFinset.filter (fun e => (Sym2.map (familyProject X hd p) e).IsDiag) ⊆ |
| Finset.univ.biUnion (fun i => loopErrors X hd G p i) := by |
| classical |
| intro e he |
| obtain ⟨he,hloop⟩ := Finset.mem_filter.mp he |
| obtain ⟨u,v⟩ := e |
| have huv := SimpleGraph.mem_edgeFinset.mp he |
| obtain ⟨i,hu,hv,hp⟩ := (loop_iff_familyPaired X hd p huv.ne).mp hloop |
| exact Finset.mem_biUnion.mpr ⟨i,Finset.mem_univ _, |
| Finset.mem_filter.mpr ⟨mem_internalGraph.mpr ⟨huv,hu,hv⟩,hloop⟩⟩ |
|
|
| def foldErrorBudget (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) : ℕ := |
| ∑ i, ((loopErrors X hd G p i).card + |
| (∑ v, (wedgeErrors X G p i v).card) + |
| (pairErrors X hd (internalGraph G (X i)) p).card + |
| ∑ j ∈ Finset.univ.erase i, (pairErrors X hd (crossGraph G (X i) (X j)) p).card) |
|
|
| lemma quotientDefect_le_budget (G : SimpleGraph V) (p : ∀ i, PairingSpace (X i)) : |
| quotientDefect G (familyProject X hd p) ≤ foldErrorBudget X hd G p := by |
| classical |
| have hl := (Finset.card_le_card (all_loops_covered X hd G p)).trans |
| (Finset.card_biUnion_le) |
| have hc := (Finset.card_le_card (all_collisions_covered X hd G p)).trans |
| (Finset.card_union_le _ _) |
| have hw : (wedgeCover X G p).card ≤ ∑ i, ∑ v, (wedgeErrors X G p i v).card := by |
| apply Finset.card_biUnion_le.trans |
| apply Finset.sum_le_sum |
| intro i hi |
| apply Finset.card_biUnion_le.trans |
| exact Finset.sum_le_sum fun v hv => Finset.card_image_le |
| have hi : (internalCover X hd G p).card ≤ |
| ∑ i, (pairErrors X hd (internalGraph G (X i)) p).card := Finset.card_biUnion_le |
| have hx : (crossCover X hd G p).card ≤ ∑ i, ∑ j ∈ Finset.univ.erase i, |
| (pairErrors X hd (crossGraph G (X i) (X j)) p).card := by |
| apply Finset.card_biUnion_le.trans |
| exact Finset.sum_le_sum fun i hi => Finset.card_biUnion_le |
| have hc' := Finset.card_le_card (collisionPairs_mono (Sym2.map (familyProject X hd p)) |
| (Finset.filter_subset (fun e => ¬(Sym2.map (familyProject X hd p) e).IsDiag) G.edgeFinset)) |
| have hunion := Finset.card_union_le (wedgeCover X G p) (internalCover X hd G p) |
| unfold quotientDefect foldErrorBudget |
| simp only [Finset.sum_add_distrib] |
| omega |
| |
| end |
| end ErdosGallai.Batch |
| |
| namespace ErdosGallai.Batch |
| open Finset |
| noncomputable section |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type cycleUniverse7} {I : Type cycleUniverse8} [Fintype V] [Fintype I] (X : I → Finset V) |
| (hd : Pairwise (fun i j => Disjoint (X i) (X j))) |
| |
| lemma fold_ratio_one (m : ℝ) (hm : 8 ≤ m) : m/(m-1) ≤ 8/7 := by |
| apply (div_le_iff₀ (show 0 < m-1 by linarith)).mpr |
| linarith |
| lemma fold_ratio_three (m : ℝ) (hm : 8 ≤ m) : m/(m-3) ≤ 8/5 := by |
| apply (div_le_iff₀ (show 0 < m-3 by linarith)).mpr |
| linarith |
| lemma choose_two_real_bound (n : ℕ) : (n.choose 2 : ℝ) ≤ (n:ℝ)^2/2 := by |
| rw [Nat.cast_choose_two] |
| have := Nat.cast_nonneg (α:=ℝ) n |
| nlinarith |
| |
| lemma first_error_numeric (m a e : ℝ) (hm : 8 ≤ m) (he : 2*e ≤ a*m) : |
| e/(m-1) + (a*(a-1)*m/2)/(m-1) ≤ (4/7)*a^2 := by |
| have hp : 0 < m-1 := by linarith |
| calc |
| _ = (e+a*(a-1)*m/2)/(m-1) := by ring |
| _ ≤ (a^2*m/2)/(m-1) := (div_le_div_iff_of_pos_right hp).mpr (by nlinarith) |
| _ = (a^2/2)*(m/(m-1)) := by ring |
| _ ≤ (a^2/2)*(8/7) := mul_le_mul_of_nonneg_left (fold_ratio_one m hm) (by positivity) |
| _ = _ := by ring |
| |
| lemma internal_error_numeric (m a : ℝ) (e : ℕ) (hm : 8 ≤ m) (ha : 0 ≤ a) |
| (he : 2*(e:ℝ) ≤ a*m) : |
| (e.choose 2 : ℝ)*(2/((m-1)*(m-3))) ≤ (16/35)*a^2 := by |
| have hp : 0 < m-1 := by linarith |
| have hp' : 0 < m-3 := by linarith |
| have he2 : (e:ℝ)^2 ≤ (a*m/2)^2 := by |
| apply sq_le_sq₀ (Nat.cast_nonneg _) (by positivity) |>.mpr |
| linarith |
| calc |
| _ ≤ ((e:ℝ)^2/2)*(2/((m-1)*(m-3))) := mul_le_mul_of_nonneg_right |
| (choose_two_real_bound e) (by positivity) |
| _ = (e:ℝ)^2/((m-1)*(m-3)) := by ring |
| _ ≤ (a*m/2)^2/((m-1)*(m-3)) := div_le_div_of_nonneg_right he2 (by positivity) |
| _ = (a^2/4)*((m/(m-1))*(m/(m-3))) := by field_simp ; ring |
| _ ≤ (a^2/4)*((8/7)*(8/5)) := mul_le_mul_of_nonneg_left |
| (mul_le_mul (fold_ratio_one m hm) (fold_ratio_three m hm) |
| (by positivity) (by norm_num)) (by positivity) |
| _ = _ := by ring |
|
|
| lemma cross_error_numeric (m n : ℝ) (e : ℕ) (hm : 8 ≤ m) (hn : 8 ≤ n) : |
| (e.choose 2 : ℝ)*(1/((m-1)*(n-1))) ≤ (32/49)*((e:ℝ)^2/(m*n)) := by |
| have hp : 0 < m-1 := by linarith |
| have hq : 0 < n-1 := by linarith |
| have hm0 : 0 < m := by linarith |
| have hn0 : 0 < n := by linarith |
| calc |
| _ ≤ ((e:ℝ)^2/2)*(1/((m-1)*(n-1))) := mul_le_mul_of_nonneg_right |
| (choose_two_real_bound e) (by positivity) |
| _ = ((e:ℝ)^2/(2*m*n))*((m/(m-1))*(n/(n-1))) := by field_simp |
| _ ≤ ((e:ℝ)^2/(2*m*n))*((8/7)*(8/7)) := mul_le_mul_of_nonneg_left |
| (mul_le_mul (fold_ratio_one m hm) (fold_ratio_one n hn) |
| (by positivity) (by norm_num)) (by positivity) |
| _ = _ := by ring |
|
|
| lemma first_errors_average (G : SimpleGraph V) (i : I) (a : ℝ) (ha : 1 ≤ a) |
| (hm : 8 ≤ (X i).card) |
| (hdegree : ∀ x ∈ X i, (G.degree x : ℝ) ≤ a) |
| (hneighbor : ∀ v, (neighborsIn G (X i) v : ℝ) ≤ a) : |
| finiteAverage (fun p : ∀ j, PairingSpace (X j) => |
| ((loopErrors X hd G p i).card : ℝ) + ∑ v, ((wedgeErrors X G p i v).card:ℝ)) ≤ |
| (4/7)*a^2 := by |
| classical |
| rw [finiteAverage_add,finiteAverage_sum] |
| have hp : 0 < ((X i).card:ℝ)-1 := by |
| have : (8:ℝ) ≤ (X i).card := by exact_mod_cast hm |
| linarith |
| calc |
| _ ≤ ((internalGraph G (X i)).edgeFinset.card:ℝ)/((X i).card-1:ℝ) + |
| ∑ v, ((neighborsIn G (X i) v).choose 2 : ℝ)/((X i).card-1:ℝ) := |
| add_le_add (loopErrors_average X hd G i (by omega)) |
| (Finset.sum_le_sum fun v _ => wedgeErrors_average X hd G i v (by omega)) |
| _ = ((internalGraph G (X i)).edgeFinset.card:ℝ)/((X i).card-1:ℝ) + |
| (∑ v, ((neighborsIn G (X i) v).choose 2 : ℝ))/((X i).card-1:ℝ) := by rw [Finset.sum_div] |
| _ ≤ ((internalGraph G (X i)).edgeFinset.card:ℝ)/((X i).card-1:ℝ) + |
| (a*(a-1)*(X i).card/2)/((X i).card-1:ℝ) := by |
| apply add_le_add_right |
| exact div_le_div_of_nonneg_right (by exact_mod_cast wedge_count_bound G (X i) a ha hdegree hneighbor) hp.le |
| _ ≤ _ := first_error_numeric _ _ _ (by exact_mod_cast hm) (internal_edge_bound G (X i) a hdegree) |
|
|
| lemma internal_errors_average (G : SimpleGraph V) (i : I) (a : ℝ) (ha : 0 ≤ a) |
| (hm : 8 ≤ (X i).card) (hdegree : ∀ x ∈ X i, (G.degree x : ℝ) ≤ a) : |
| finiteAverage (fun p : ∀ j, PairingSpace (X j) => |
| ((pairErrors X hd (internalGraph G (X i)) p).card : ℝ)) ≤ (16/35)*a^2 := |
| (internal_pairErrors_average X hd G i (by omega)).trans |
| (internal_error_numeric _ _ _ (by exact_mod_cast hm) ha (internal_edge_bound G (X i) a hdegree)) |
|
|
| lemma cross_errors_average (G : SimpleGraph V) (i : I) (a : ℝ) (ha : 0 ≤ a) |
| (hm : ∀ i, 8 ≤ (X i).card) |
| (hdegree : ∀ i x, x ∈ X i → (G.degree x : ℝ) ≤ a) : |
| finiteAverage (fun p : ∀ k, PairingSpace (X k) => |
| ∑ j ∈ Finset.univ.erase i, ((pairErrors X hd (crossGraph G (X i) (X j)) p).card : ℝ)) ≤ |
| (32/49)*a^2 := by |
| classical |
| rw [finiteAverage_sum] |
| calc |
| _ ≤ ∑ j ∈ Finset.univ.erase i, (32/49)*((betweenCount G (X i) (X j):ℝ)^2 / |
| ((X i).card*(X j).card)) := by |
| apply Finset.sum_le_sum |
| intro j hj |
| have hij := (Finset.mem_erase.mp hj).1.symm |
| exact (cross_pairErrors_average X hd G i j hij (by have := hm i; omega) (by have := hm j; omega)).trans |
| (cross_error_numeric _ _ _ (by exact_mod_cast hm i) (by exact_mod_cast hm j)) |
| _ ≤ ∑ j, (32/49)*((betweenCount G (X i) (X j):ℝ)^2 / |
| ((X i).card*(X j).card)) := by |
| apply Finset.sum_le_sum_of_subset_of_nonneg (Finset.erase_subset _ _) |
| intro j hj hj' |
| positivity |
| _ = (32/49)*∑ j, ((betweenCount G (X i) (X j):ℝ)^2 / |
| ((X i).card*(X j).card)) := by rw [Finset.mul_sum] |
| _ ≤ _ := mul_le_mul_of_nonneg_left (cross_error_row G X hd a ha (by intro i; have := hm i; omega) hdegree i) (by norm_num) |
| |
| end |
| end ErdosGallai.Batch |
| |
| namespace ErdosGallai.Batch |
| noncomputable section |
| open Finset |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type cycleUniverse9} {I : Type cycleUniverse10} [Fintype V] [Fintype I] |
| |
| theorem folding_average_bound (G : SimpleGraph V) (X : I → Finset V) |
| (hd : Pairwise (fun i j => Disjoint (X i) (X j))) (a : ℝ) (ha : 1 ≤ a) |
| (hm : ∀ i, 8 ≤ (X i).card) (hma : ∀ i, a^2 ≤ (X i).card) |
| (hdegree : ∀ i x, x ∈ X i → (G.degree x : ℝ) ≤ a) |
| (hneighbor : ∀ i v, (neighborsIn G (X i) v : ℝ) ≤ a) : |
| finiteAverage (fun p : ∀ i, PairingSpace (X i) => |
| (foldErrorBudget X hd G p : ℝ)) ≤ 2 * ∑ i, ((X i).card : ℝ) := by |
| classical |
| simp only [foldErrorBudget,Nat.cast_sum,Nat.cast_add] |
| rw [finiteAverage_sum,Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro i hi |
| rw [finiteAverage_add,finiteAverage_add] |
| have hfirst := first_errors_average X hd G i a ha (hm i) (hdegree i) (hneighbor i) |
| have hint := internal_errors_average X hd G i a (by linarith) (hm i) (hdegree i) |
| have hcross := cross_errors_average X hd G i a (by linarith) hm hdegree |
| calc |
| _ ≤ (4/7)*a^2 + (16/35)*a^2 + (32/49)*a^2 := |
| add_le_add (add_le_add hfirst hint) hcross |
| _ ≤ 2 * ((X i).card : ℝ) := by nlinarith [hma i,sq_nonneg a] |
| |
| theorem pair_folding (G : SimpleGraph V) (X : I → Finset V) |
| (hd : Pairwise (fun i j => Disjoint (X i) (X j))) (a : ℝ) (ha : 1 ≤ a) |
| (hm : ∀ i, 8 ≤ (X i).card) (hma : ∀ i, a^2 ≤ (X i).card) |
| (hdegree : ∀ i x, x ∈ X i → (G.degree x : ℝ) ≤ a) |
| (hneighbor : ∀ i v, (neighborsIn G (X i) v : ℝ) ≤ a) : |
| ∃ (p : ∀ i, PairingSpace (X i)) (retained : Finset (Sym2 V)) |
| (Q : SimpleGraph (FamilyQuotient X p)), |
| retained ⊆ G.edgeFinset ∧ |
| (G.edgeFinset \ retained).card ≤ 2 * ∑ i, (X i).card ∧ |
| Q.edgeSet = ((retained.image (Sym2.map (familyProject X hd p)) : |
| Finset (Sym2 (FamilyQuotient X p))) : Set (Sym2 (FamilyQuotient X p))) ∧ |
| (∀ e ∈ Q.edgeSet, ∃! f, f ∈ retained ∧ Sym2.map (familyProject X hd p) f = e) ∧ |
| Fintype.card (FamilyQuotient X p) = Fintype.card V - ∑ i, (X i).card / 2 := by |
| classical |
| obtain ⟨p,hp⟩ := exists_le_finiteAverage (fun p : ∀ i, PairingSpace (X i) => |
| (foldErrorBudget X hd G p : ℝ)) |
| have hcostR := hp.trans (folding_average_bound G X hd a ha hm hma hdegree hneighbor) |
| have hcost : foldErrorBudget X hd G p ≤ 2 * ∑ i, (X i).card := by exact_mod_cast hcostR |
| obtain ⟨retained,Q,hsub,herr,hQ,hrep⟩ := simple_quotient_representatives G (familyProject X hd p) |
| exact ⟨p,retained,Q,hsub,herr.trans ((quotientDefect_le_budget X hd G p).trans hcost), |
| hQ,hrep,family_quotient_order X hd p⟩ |
| |
| end |
| end ErdosGallai.Batch |
| |
| namespace ErdosGallai.Batch |
| open Finset |
| noncomputable section |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type cycleUniverse11} [Fintype V] (G : SimpleGraph V) |
| |
| def heavyNeighbors (X : Finset V) (a : ℝ) : Finset V := |
| Finset.univ.filter (fun v => a < (neighborsIn G X v : ℝ)) |
| |
| lemma mem_heavyNeighbors (X : Finset V) (a : ℝ) (v : V) : |
| v ∈ heavyNeighbors G X a ↔ a < (neighborsIn G X v : ℝ) := by simp [heavyNeighbors] |
| |
| lemma heavyNeighbors_disjoint_active (X Y : Finset V) (a : ℝ) |
| (hY : ∀ v ∈ Y, (G.degree v : ℝ) ≤ a) : |
| Disjoint (heavyNeighbors G X a) Y := by |
| apply Finset.disjoint_left.mpr |
| intro v hv hy |
| have h₁ := (mem_heavyNeighbors G X a v).mp hv |
| have h₂ : (neighborsIn G X v : ℝ) ≤ G.degree v := by |
| exact_mod_cast neighborsIn_le_degree G X v |
| exact (not_lt_of_ge (h₂.trans (hY v hy))) h₁ |
| |
| lemma heavyNeighbors_card_le (X : Finset V) (a : ℝ) (ha : 0 < a) |
| (hX : ∀ v ∈ X, (G.degree v : ℝ) ≤ a) : |
| (heavyNeighbors G X a).card ≤ X.card := by |
| have hsum : a * (heavyNeighbors G X a).card ≤ |
| ∑ v ∈ heavyNeighbors G X a, (neighborsIn G X v : ℝ) := by |
| calc |
| _ = ∑ _v ∈ heavyNeighbors G X a, a := by simp [mul_comm] |
| _ ≤ _ := Finset.sum_le_sum fun v hv => |
| ((mem_heavyNeighbors G X a v).mp hv).le |
| have hsub : (∑ v ∈ heavyNeighbors G X a, (neighborsIn G X v : ℝ)) ≤ |
| ∑ v, (neighborsIn G X v : ℝ) := |
| Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (by intros; positivity) |
| have htotal : (∑ v, (neighborsIn G X v : ℝ)) ≤ a * X.card := by |
| rw [← Nat.cast_sum, sum_incidence_to_set G X, Nat.cast_sum] |
| simpa [mul_comm] using Finset.sum_le_sum (s := X) (fun v hv => hX v hv) |
| have hh := hsum.trans (hsub.trans htotal) |
| have := (mul_le_mul_iff_right₀ ha).mp hh |
| exact_mod_cast this |
| |
| variable {I : Type cycleUniverse12} [Fintype I] (X : I → Finset V) |
| |
| def heavyDesignated (a : ℝ) (i : I) : SimpleGraph V := |
| crossGraph G (X i) (heavyNeighbors G (X i) a) |
| |
| lemma heavyDesignated_le {V : Type cycleUniverse13} [_contextInstance1 : Fintype V] (G : SimpleGraph V) {I : Type cycleUniverse14} [_contextInstance4 : Fintype I] (X : I → Finset V) (a : ℝ) (i : I) : heavyDesignated G X a i ≤ G := |
| fun _ _ h => h.1 |
| |
| theorem heavyDesignated_pairwise {V : Type cycleUniverse15} [_contextInstance1 : Fintype V] (G : SimpleGraph V) {I : Type cycleUniverse16} [_contextInstance4 : Fintype I] (X : I → Finset V) (a : ℝ) |
| (hd : Pairwise (fun i j => Disjoint (X i) (X j))) |
| (hdegree : ∀ i v, v ∈ X i → (G.degree v : ℝ) ≤ a) : |
| Pairwise (fun i j => Disjoint (heavyDesignated G X a i).edgeSet |
| (heavyDesignated G X a j).edgeSet) := by |
| intro i j hij |
| apply Set.disjoint_left.mpr |
| intro e hei hej |
| induction e using Sym2.ind with |
| | _ u v => |
| change G.Adj u v ∧ ((u ∈ X i ∧ v ∈ heavyNeighbors G (X i) a) ∨ |
| (u ∈ heavyNeighbors G (X i) a ∧ v ∈ X i)) at hei |
| change G.Adj u v ∧ ((u ∈ X j ∧ v ∈ heavyNeighbors G (X j) a) ∨ |
| (u ∈ heavyNeighbors G (X j) a ∧ v ∈ X j)) at hej |
| rcases hei.2 with hi | hi <;> rcases hej.2 with hj | hj |
| · exact Finset.disjoint_left.mp (hd hij) hi.1 hj.1 |
| · exact Finset.disjoint_left.mp |
| (heavyNeighbors_disjoint_active G (X j) (X i) a (hdegree i)) hj.1 hi.1 |
| · exact Finset.disjoint_left.mp |
| (heavyNeighbors_disjoint_active G (X i) (X j) a (hdegree j)) hi.1 hj.1 |
| · exact Finset.disjoint_left.mp (hd hij) hi.2 hj.2 |
| |
| def trimHeavyGraph (a : ℝ) : SimpleGraph V where |
| Adj u v := G.Adj u v ∧ ∀ i, ¬ (heavyDesignated G X a i).Adj u v |
| symm := ⟨fun _ _ h => ⟨h.1.symm,fun i hi => h.2 i hi.symm⟩⟩ |
| loopless := ⟨fun _ h => G.irrefl h.1⟩ |
| |
| lemma trimHeavyGraph_le {V : Type cycleUniverse17} [_contextInstance1 : Fintype V] (G : SimpleGraph V) {I : Type cycleUniverse18} [_contextInstance4 : Fintype I] (X : I → Finset V) (a : ℝ) : trimHeavyGraph G X a ≤ G := fun _ _ h => h.1 |
| |
| theorem trimHeavyGraph_neighbors {V : Type cycleUniverse19} [_contextInstance1 : Fintype V] (G : SimpleGraph V) {I : Type cycleUniverse20} [_contextInstance4 : Fintype I] (X : I → Finset V) (a : ℝ) (ha : 0 ≤ a) (i : I) (v : V) : |
| (neighborsIn (trimHeavyGraph G X a) (X i) v : ℝ) ≤ a := by |
| by_cases hv : v ∈ heavyNeighbors G (X i) a |
| · have he : (X i).filter ((trimHeavyGraph G X a).Adj v) = ∅ := by |
| apply Finset.eq_empty_iff_forall_notMem.mpr |
| intro u hu |
| obtain ⟨hui,hvu⟩ := Finset.mem_filter.mp hu |
| exact hvu.2 i ⟨hvu.1,Or.inr ⟨hv,hui⟩⟩ |
| simpa [neighborsIn, he] using ha |
| · have hnon : (neighborsIn G (X i) v : ℝ) ≤ a := |
| le_of_not_gt (fun hh => hv ((mem_heavyNeighbors G (X i) a v).mpr hh)) |
| apply le_trans _ hnon |
| exact_mod_cast Finset.card_le_card (show |
| (X i).filter ((trimHeavyGraph G X a).Adj v) ⊆ (X i).filter (G.Adj v) from |
| fun u hu => Finset.mem_filter.mpr ⟨(Finset.mem_filter.mp hu).1, |
| (Finset.mem_filter.mp hu).2.1⟩) |
| |
| theorem trimHeavyGraph_degree (a : ℝ) (v : V) : |
| (trimHeavyGraph G X a).degree v ≤ G.degree v := by |
| classical |
| exact SimpleGraph.degree_le_of_le (trimHeavyGraph_le G X a) |
| |
| theorem trimHeavyGraph_ledger (a : ℝ) : |
| (trimHeavyGraph G X a).edgeSet ∪ |
| (⋃ i, (heavyDesignated G X a i).edgeSet) = G.edgeSet ∧ |
| Disjoint (trimHeavyGraph G X a).edgeSet |
| (⋃ i, (heavyDesignated G X a i).edgeSet) := by |
| constructor |
| · ext e |
| induction e using Sym2.ind with |
| | _ u v => |
| simp only [Set.mem_union, Set.mem_iUnion, SimpleGraph.mem_edgeSet] |
| change (G.Adj u v ∧ ∀ i, ¬ (heavyDesignated G X a i).Adj u v) ∨ |
| (∃ i, (heavyDesignated G X a i).Adj u v) ↔ G.Adj u v |
| constructor |
| · rintro (h | ⟨i,hi⟩) |
| · exact h.1 |
| · exact hi.1 |
| · intro h |
| by_cases he : ∃ i, (heavyDesignated G X a i).Adj u v |
| · exact Or.inr he |
| · exact Or.inl ⟨h,fun i hi => he ⟨i,hi⟩⟩ |
| · apply Set.disjoint_left.mpr |
| intro e he hf |
| induction e using Sym2.ind with |
| | _ u v => |
| obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hf |
| exact he.2 i hi |
| |
| end |
| end ErdosGallai.Batch |
| |
| namespace ErdosGallai.Batch |
| noncomputable section |
| open SimpleGraph |
| attribute [local instance] Classical.propDecidable |
| |
| structure TrimmedPath {V : Type cycleUniverse21} (G : SimpleGraph V) where |
| start : V |
| finish : V |
| walk : G.Walk start finish |
| simple : walk.IsPath |
| |
| lemma alternating_endpoint_mem {V : Type cycleUniverse22} {G : SimpleGraph V} (X H : Set V) |
| (hbi : ∀ {u v}, G.Adj u v → (u ∈ X ∧ v ∈ H) ∨ (u ∈ H ∧ v ∈ X)) |
| {a b : V} (p : G.Walk a b) (hp : 0 < p.length) : |
| (a ∈ X ∨ a ∈ H) ∧ (b ∈ X ∨ b ∈ H) := by |
| have hn : ¬p.Nil := by intro h; have := h.length_eq_zero; omega |
| constructor |
| · exact (hbi (p.adj_snd hn)).elim (fun h => Or.inl h.1) (fun h => Or.inr h.1) |
| · exact (hbi (p.adj_penultimate hn)).elim (fun h => Or.inr h.2) (fun h => Or.inl h.2) |
| |
| lemma alternating_snd_mem {V : Type cycleUniverse23} {G : SimpleGraph V} (X H : Set V) |
| (hd : Disjoint X H) |
| (hbi : ∀ {u v}, G.Adj u v → (u ∈ X ∧ v ∈ H) ∨ (u ∈ H ∧ v ∈ X)) |
| {a b : V} (p : G.Walk a b) (hp : 0 < p.length) (ha : a ∈ H) : p.snd ∈ X := by |
| have hn : ¬p.Nil := by intro h; have := h.length_eq_zero; omega |
| rcases hbi (p.adj_snd hn) with h | h |
| · exact False.elim (Set.disjoint_left.mp hd h.1 ha) |
| · exact h.2 |
| |
| lemma alternating_penultimate_mem {V : Type cycleUniverse24} {G : SimpleGraph V} (X H : Set V) |
| (hd : Disjoint X H) |
| (hbi : ∀ {u v}, G.Adj u v → (u ∈ X ∧ v ∈ H) ∨ (u ∈ H ∧ v ∈ X)) |
| {a b : V} (p : G.Walk a b) (hp : 0 < p.length) (hb : b ∈ H) : |
| p.penultimate ∈ X := by |
| have hn : ¬p.Nil := by intro h; have := h.length_eq_zero; omega |
| rcases hbi (p.adj_penultimate hn) with h | h |
| · exact h.1 |
| · exact False.elim (Set.disjoint_left.mp hd h.2 hb) |
| |
| theorem trim_bipartite_path {V : Type cycleUniverse25} {G : SimpleGraph V} (X H : Set V) |
| (hd : Disjoint X H) |
| (hbi : ∀ {u v}, G.Adj u v → (u ∈ X ∧ v ∈ H) ∨ (u ∈ H ∧ v ∈ X)) |
| {a b : V} (p : G.Walk a b) (hs : p.IsPath) (hp : 0 < p.length) : |
| ∃ q : TrimmedPath G, |
| q.walk.edgeSet ⊆ p.edgeSet ∧ p.length ≤ q.walk.length + 2 ∧ |
| (0 < q.walk.length → q.start ∈ X ∧ q.finish ∈ X) := by |
| have hends := alternating_endpoint_mem X H hbi p hp |
| by_cases ha : a ∈ H |
| · have hsa := alternating_snd_mem X H hd hbi p hp ha |
| by_cases hb : b ∈ H |
| · refine ⟨⟨p.snd,p.tail.penultimate,p.tail.dropLast,hs.tail.dropLast⟩,?_,?_,?_⟩ |
| · intro e he |
| simp only [Walk.mem_edgeSet, Walk.edges_dropLast, Walk.edges_tail] at he ⊢ |
| exact List.mem_of_mem_tail (List.mem_of_mem_dropLast he) |
| · simp only [Walk.length_dropLast,Walk.length_tail] |
| omega |
| · intro hpos |
| have ht : 0 < p.tail.length := by |
| change 0 < p.tail.dropLast.length at hpos |
| rw [Walk.length_dropLast] at hpos |
| omega |
| exact ⟨hsa,alternating_penultimate_mem X H hd hbi p.tail ht hb⟩ |
| · refine ⟨⟨p.snd,b,p.tail,hs.tail⟩,?_,?_,?_⟩ |
| · intro e he |
| simp only [Walk.mem_edgeSet, Walk.edges_tail] at he ⊢ |
| exact List.mem_of_mem_tail he |
| · simp only [Walk.length_tail]; omega |
| · intro _ |
| exact ⟨hsa,hends.2.resolve_right hb⟩ |
| · by_cases hb : b ∈ H |
| · refine ⟨⟨a,p.penultimate,p.dropLast,hs.dropLast⟩,?_,?_,?_⟩ |
| · intro e he |
| simp only [Walk.mem_edgeSet, Walk.edges_dropLast] at he ⊢ |
| exact List.mem_of_mem_dropLast he |
| · simp only [Walk.length_dropLast]; omega |
| · intro _ |
| exact ⟨hends.1.resolve_right ha,alternating_penultimate_mem X H hd hbi p hp hb⟩ |
| · exact ⟨⟨a,b,p,hs⟩,Set.Subset.rfl,by change p.length ≤ p.length + 2; omega,fun _ => |
| ⟨hends.1.resolve_right ha,hends.2.resolve_right hb⟩⟩ |
| |
| lemma bipartite_path_length {V : Type cycleUniverse26} {G : SimpleGraph V} (X H : Set V) |
| (hd : Disjoint X H) |
| (hbi : ∀ {u v}, G.Adj u v → (u ∈ X ∧ v ∈ H) ∨ (u ∈ H ∧ v ∈ X)) |
| {a b : V} (p : G.Walk a b) (hp : 0 < p.length) (ha : a ∈ X) (hb : b ∈ X) : |
| 2 ≤ p.length := by |
| by_contra h |
| have hlen : p.length = 1 := by omega |
| rcases hbi (Walk.adj_of_length_eq_one hlen) with he | he |
| · exact Set.disjoint_left.mp hd hb he.2 |
| · exact Set.disjoint_left.mp hd ha he.1 |
| |
| lemma path_edgeFinset_card {V : Type cycleUniverse27} {G : SimpleGraph V} |
| {a b : V} (p : G.Walk a b) (hp : p.IsPath) : p.edges.toFinset.card = p.length := by |
| classical |
| rw [List.toFinset_card_of_nodup hp.isTrail.edges_nodup, Walk.length_edges] |
| |
| theorem trim_bipartite_path_ledger {V : Type cycleUniverse28} {G : SimpleGraph V} (X H : Set V) |
| (hd : Disjoint X H) |
| (hbi : ∀ {u v}, G.Adj u v → (u ∈ X ∧ v ∈ H) ∨ (u ∈ H ∧ v ∈ X)) |
| {a b : V} (p : G.Walk a b) (hs : p.IsPath) (hp : 0 < p.length) : |
| ∃ (q : TrimmedPath G) (discarded : Finset (Sym2 V)), |
| discarded.card ≤ 2 ∧ Disjoint (discarded : Set (Sym2 V)) q.walk.edgeSet ∧ |
| (discarded : Set (Sym2 V)) ∪ q.walk.edgeSet = p.edgeSet ∧ |
| (0 < q.walk.length → q.start ∈ X ∧ q.finish ∈ X ∧ 2 ≤ q.walk.length) := by |
| classical |
| obtain ⟨q,hsub,hlen,hends⟩ := trim_bipartite_path X H hd hbi p hs hp |
| have hfs : q.walk.edges.toFinset ⊆ p.edges.toFinset := by |
| intro e he |
| exact List.mem_toFinset.mpr (hsub (List.mem_toFinset.mp he)) |
| refine ⟨q,p.edges.toFinset \ q.walk.edges.toFinset,?_,?_,?_,?_⟩ |
| · rw [Finset.card_sdiff_of_subset hfs, path_edgeFinset_card p hs, |
| path_edgeFinset_card q.walk q.simple] |
| omega |
| · rw [Set.disjoint_left] |
| intro e he hq |
| exact (Finset.mem_sdiff.mp he).2 (List.mem_toFinset.mpr hq) |
| · ext e |
| simp only [Set.mem_union, Finset.mem_coe, Finset.mem_sdiff, List.mem_toFinset, |
| Walk.mem_edgeSet] |
| constructor |
| · rintro (h | h) |
| · exact h.1 |
| · exact hsub h |
| · intro h |
| by_cases he : e ∈ q.walk.edges |
| · exact Or.inr he |
| · exact Or.inl ⟨h,he⟩ |
| · intro hpos |
| obtain ⟨ha,hb⟩ := hends hpos |
| exact ⟨ha,hb,bipartite_path_length X H hd hbi q.walk hpos ha hb⟩ |
| |
| theorem close_trimmed_path {V : Type cycleUniverse29} {G : SimpleGraph V} {a b : V} |
| (p : G.Walk a b) (q : G.Walk b a) (hp : p.IsPath) (hq : q.IsPath) |
| (hlen : 2 ≤ p.length) |
| (havoid : ∀ v ∈ q.support, v ≠ a → v ≠ b → v ∉ p.support) : |
| (p.append q).IsCycle ∧ (p.append q).edgeSet = p.edgeSet ∪ q.edgeSet := by |
| refine ⟨hp.isCycle_append hq ?_ (Or.inl (by omega)), Walk.edgeSet_append p q⟩ |
| rw [List.disjoint_left] |
| intro v hvp hvq |
| have hva : v ≠ a := by |
| intro h; subst v |
| have hn := hp.support_nodup |
| rw [← p.cons_tail_support] at hn |
| exact hn.notMem hvp |
| have hvb : v ≠ b := by |
| intro h; subst v |
| have hn := hq.support_nodup |
| rw [← q.cons_tail_support] at hn |
| exact hn.notMem hvq |
| exact havoid v (List.mem_of_mem_tail hvq) hva hvb (List.mem_of_mem_tail hvp) |
| |
| end |
| end ErdosGallai.Batch |
| |
| namespace ErdosGallai.Batch |
| noncomputable section |
| open Finset SimpleGraph |
| attribute [local instance] Classical.propDecidable |
| |
| lemma endpoint_path_count_on {V : Type cycleUniverse30} {I : Type cycleUniverse31} [Fintype V] [Fintype I] |
| {G : SimpleGraph V} (P : I → PositiveSimplePath G) (S : Finset V) |
| (hends : ∀ i, (P i).start ∈ S ∧ (P i).finish ∈ S) |
| (hload : ∀ v, (univ.filter (fun i => (P i).start = v ∨ (P i).finish = v)).card ≤ 2) : |
| Fintype.card I ≤ S.card := by |
| classical |
| have heq : ∑ v ∈ S, (univ.filter (fun i => (P i).start = v ∨ (P i).finish = v)).card = |
| 2 * Fintype.card I := by |
| simp only [Finset.card_eq_sum_ones,Finset.sum_filter] |
| rw [Finset.sum_comm] |
| have hc : ∀ i : I, (∑ v ∈ S, if (P i).start = v ∨ (P i).finish = v then 1 else 0) = 2 := by |
| intro i |
| have hf : S.filter (fun v => (P i).start = v ∨ (P i).finish = v) = |
| {(P i).start,(P i).finish} := by |
| ext v |
| simp only [Finset.mem_filter,Finset.mem_insert,Finset.mem_singleton] |
| constructor |
| · intro h; simpa only [eq_comm] using h.2 |
| · intro h |
| rcases h with rfl | rfl |
| · exact ⟨(hends i).1,Or.inl rfl⟩ |
| · exact ⟨(hends i).2,Or.inr rfl⟩ |
| rw [← Finset.sum_filter,hf] |
| simp [(P i).endpoints_ne] |
| simp_rw [hc] |
| simp [mul_comm] |
| have hb := Finset.sum_le_sum (fun v (_ : v ∈ S) => hload v) |
| rw [heq] at hb |
| simp only [Finset.sum_const, smul_eq_mul] at hb |
| omega |
| |
| lemma heavy_paths {V : Type cycleUniverse32} [Fintype V] (G : SimpleGraph V) |
| (X : Finset V) (a : ℝ) (ha : 0 < a) |
| (hdeg : ∀ v ∈ X, (G.degree v:ℝ) ≤ a) : |
| let H := heavyNeighbors G X a |
| let B := crossGraph G X H |
| ∃ (k : ℕ) (P : Fin k → PositiveSimplePath B), |
| Pairwise (fun i j => Disjoint (P i).walk.edgeSet (P j).walk.edgeSet) ∧ |
| (⋃ i, (P i).walk.edgeSet) = B.edgeSet ∧ k ≤ 2 * X.card := by |
| classical |
| dsimp only |
| obtain ⟨k,P,hd,hu,hl,_⟩ := endpoint_path_partition (crossGraph G X (heavyNeighbors G X a)) |
| refine ⟨k,P,hd,hu,?_⟩ |
| have hend : ∀ i, (P i).start ∈ X ∪ heavyNeighbors G X a ∧ |
| (P i).finish ∈ X ∪ heavyNeighbors G X a := by |
| intro i |
| have h := alternating_endpoint_mem (X:Set V) (heavyNeighbors G X a : Set V) |
| (fun {_ _} (h : (crossGraph G X (heavyNeighbors G X a)).Adj _ _) => h.2) (P i).walk (P i).positive |
| exact ⟨Finset.mem_union.mpr h.1,Finset.mem_union.mpr h.2⟩ |
| have hk := endpoint_path_count_on P (X ∪ heavyNeighbors G X a) hend hl |
| rw [Fintype.card_fin] at hk |
| have hh := heavyNeighbors_card_le G X a ha hdeg |
| exact hk.trans ((Finset.card_union_le _ _).trans (by omega)) |
| |
| lemma folded_order_saving {V : Type cycleUniverse33} {I : Type cycleUniverse34} [Fintype V] [Fintype I] |
| (X : I → Finset V) (hd : Pairwise fun i j => Disjoint (X i) (X j)) |
| (p : ∀ i, PairingSpace (X i)) (hsize : ∀ i, 2 ≤ (X i).card) : |
| (Fintype.card (FamilyQuotient X p):ℝ) ≤ Fintype.card V - |
| (1/3:ℝ) * ∑ i, ((X i).card:ℝ) := by |
| have he := family_quotient_order_add X hd p |
| have hf : ∀ i, ((X i).card:ℝ)/3 ≤ ((X i).card/2:ℕ) := by |
| intro i |
| have h := Nat.mod_add_div (X i).card 2 |
| have hm := Nat.mod_lt (X i).card (by decide : 0<2) |
| have hs := hsize i |
| have hi : (X i).card ≤ 3 * ((X i).card/2) := by omega |
| exact (div_le_iff₀ (by norm_num : (0:ℝ)<3)).mpr (by simpa only [mul_comm] using (show ((X i).card:ℝ) ≤ 3*((X i).card/2:ℕ) by exact_mod_cast hi)) |
| have hb := Finset.sum_le_sum (fun i (_ : i ∈ (univ:Finset I)) => hf i) |
| have he' : (Fintype.card (FamilyQuotient X p):ℝ) + ∑ i, (((X i).card/2:ℕ):ℝ) = |
| Fintype.card V := by exact_mod_cast he |
| rw [← Finset.sum_div] at hb |
| linarith |
|
|
| structure PreparedBatch {V I : Type} [Fintype V] [Fintype I] |
| (G : SimpleGraph V) (X : I → Finset V) |
| (hd : Pairwise fun i j => Disjoint (X i) (X j)) where |
| pairing : ∀ i, PairingSpace (X i) |
| quotient : SimpleGraph (FamilyQuotient X pairing) |
| retained : Finset (Sym2 V) |
| bad : Finset (Sym2 V) |
| count : I → ℕ |
| path : ∀ i, Fin (count i) → TrimmedPath G |
| count_le : ∀ i, count i ≤ 2 * (X i).card |
| bad_le : bad.card ≤ 6 * ∑ i, (X i).card |
| ends : ∀ i j, 0 < (path i j).walk.length → |
| (path i j).start ∈ X i ∧ (path i j).finish ∈ X i ∧ 2 ≤ (path i j).walk.length |
| paths_disjoint : Pairwise fun z w : Σ i, Fin (count i) => |
| Disjoint (path z.1 z.2).walk.edgeSet (path w.1 w.2).walk.edgeSet |
| bad_paths : ∀ i j, Disjoint (bad : Set (Sym2 V)) (path i j).walk.edgeSet |
| retained_paths : ∀ i j, Disjoint (retained : Set (Sym2 V)) (path i j).walk.edgeSet |
| bad_retained : Disjoint (bad : Set (Sym2 V)) (retained : Set (Sym2 V)) |
| cover : (bad : Set (Sym2 V)) ∪ (retained : Set (Sym2 V)) ∪ |
| (⋃ (i) (j), (path i j).walk.edgeSet) = G.edgeSet |
| quotient_edges : quotient.edgeSet = |
| (Sym2.map (familyProject X hd pairing)) '' (retained : Set (Sym2 V)) |
| representatives : ∀ e ∈ quotient.edgeSet, ∃! f, |
| f ∈ retained ∧ Sym2.map (familyProject X hd pairing) f = e |
| order : Fintype.card (FamilyQuotient X pairing) = |
| Fintype.card V - ∑ i, (X i).card / 2 |
|
|
| lemma PreparedBatch.bad_subset {V I : Type} [Fintype V] [Fintype I] |
| {G : SimpleGraph V} {X : I → Finset V} {hd} |
| (b : PreparedBatch G X hd) : (b.bad : Set (Sym2 V)) ⊆ G.edgeSet := by |
| rw [← b.cover]; exact Set.subset_union_of_subset_left (Set.subset_union_left) _ |
|
|
| lemma PreparedBatch.retained_subset {V I : Type} [Fintype V] [Fintype I] |
| {G : SimpleGraph V} {X : I → Finset V} {hd} |
| (b : PreparedBatch G X hd) : (b.retained : Set (Sym2 V)) ⊆ G.edgeSet := by |
| rw [← b.cover]; exact Set.subset_union_of_subset_left (Set.subset_union_right) _ |
|
|
| theorem prepare_batch {V I : Type} [Fintype V] [Fintype I] |
| (G : SimpleGraph V) (X : I → Finset V) |
| (hd : Pairwise fun i j => Disjoint (X i) (X j)) |
| (a : ℝ) (ha : 1 ≤ a) (hm : ∀ i, 8 ≤ (X i).card) |
| (hma : ∀ i, a^2 ≤ (X i).card) |
| (hdeg : ∀ i v, v ∈ X i → (G.degree v:ℝ) ≤ a) : |
| Nonempty (PreparedBatch G X hd) := by |
| classical |
| let H := heavyDesignated G X a |
| let T := trimHeavyGraph G X a |
| have hHpair := heavyDesignated_pairwise G X a hd hdeg |
| have hT := trimHeavyGraph_ledger G X a |
| have hpaths : ∀ i, ∃ (k : ℕ) (P : Fin k → PositiveSimplePath (H i)), |
| Pairwise (fun j l => Disjoint (P j).walk.edgeSet (P l).walk.edgeSet) ∧ |
| (⋃ j, (P j).walk.edgeSet) = (H i).edgeSet ∧ k ≤ 2*(X i).card := |
| fun i => heavy_paths G (X i) a (by linarith) (hdeg i) |
| choose k P hPd hPu hk using hpaths |
| have htrim : ∀ i j, ∃ (q : TrimmedPath (H i)) (S : Finset (Sym2 V)), |
| S.card ≤ 2 ∧ Disjoint (S:Set _) q.walk.edgeSet ∧ |
| (S:Set _) ∪ q.walk.edgeSet = (P i j).walk.edgeSet ∧ |
| (0 < q.walk.length → q.start ∈ X i ∧ q.finish ∈ X i ∧ 2 ≤ q.walk.length) := by |
| intro i j |
| exact trim_bipartite_path_ledger (X i:Set V) (heavyNeighbors G (X i) a:Set V) |
| (by simpa only [Finset.disjoint_coe] using |
| (heavyNeighbors_disjoint_active G (X i) (X i) a (hdeg i)).symm) |
| (fun {_ _} (h : (H i).Adj _ _) => h.2) (P i j).walk (P i j).isPath (P i j).positive |
| choose q S hSnum hSq hScover hEnds using htrim |
| let Qpath : ∀ i, Fin (k i) → TrimmedPath G := fun i j => |
| ⟨(q i j).start,(q i j).finish,(q i j).walk.map (SimpleGraph.Hom.ofLE (heavyDesignated_le G X a i)), |
| (q i j).simple.map (Function.injective_id)⟩ |
| have hQedges : ∀ i j, (Qpath i j).walk.edgeSet = (q i j).walk.edgeSet := by |
| intro i j; simp [Qpath,Walk.edgeSet_map,SimpleGraph.Hom.ofLE] |
| have hQlen : ∀ i j, (Qpath i j).walk.length = (q i j).walk.length := |
| fun i j => Walk.length_map _ _ |
| have hSsub : ∀ i j, (S i j:Set _) ⊆ (P i j).walk.edgeSet := by |
| intro i j; rw [← hScover i j]; exact Set.subset_union_left |
| have hqsub : ∀ i j, (Qpath i j).walk.edgeSet ⊆ (P i j).walk.edgeSet := by |
| intro i j; rw [hQedges,← hScover i j]; exact Set.subset_union_right |
| have hPsub : ∀ i j, (P i j).walk.edgeSet ⊆ (H i).edgeSet := |
| fun i j => (P i j).walk.edges_subset_edgeSet |
| have hPdall : Pairwise fun z w : Σ i, Fin (k i) => |
| Disjoint (P z.1 z.2).walk.edgeSet (P w.1 w.2).walk.edgeSet := by |
| rintro ⟨i,j⟩ ⟨l,m⟩ hne |
| by_cases hi : i = l |
| · subst l |
| exact hPd i (fun he => hne (by cases he; rfl)) |
| · exact (hHpair hi).mono (hPsub _ _) (hPsub _ _) |
| let B := Finset.univ.biUnion fun z : Σ i, Fin (k i) => S z.1 z.2 |
| have hB : (B:Set (Sym2 V)) = ⋃ i, ⋃ j, (S i j : Set (Sym2 V)) := by |
| ext e; simp [B] |
| have hBnum : B.card ≤ 4 * ∑ i, (X i).card := by |
| have hc : B.card ≤ ∑ z : Σ i, Fin (k i), (S z.1 z.2).card := |
| Finset.card_biUnion_le |
| have hj : (∑ z : Σ i, Fin (k i), (S z.1 z.2).card) ≤ 2 * ∑ i, k i := by |
| calc |
| _ ≤ ∑ z : Σ i, Fin (k i), 2 := Finset.sum_le_sum (fun z _ => hSnum z.1 z.2) |
| _ = _ := by simp [Fintype.card_sigma,mul_comm] |
| have hk' := Finset.sum_le_sum (fun i (_:i∈(univ:Finset I)) => hk i) |
| rw [← Finset.mul_sum] at hk' |
| omega |
| have hBheavy : (B:Set (Sym2 V)) ⊆ ⋃ i, (H i).edgeSet := by |
| rw [hB]; exact Set.iUnion_subset (fun i => Set.iUnion_subset (fun j => |
| Set.subset_iUnion_of_subset i ((hSsub i j).trans (hPsub i j)))) |
| have hBhq : ∀ i j, Disjoint (B:Set (Sym2 V)) (Qpath i j).walk.edgeSet := by |
| intro i j |
| rw [hB,Set.disjoint_iUnion_left] |
| intro l |
| rw [Set.disjoint_iUnion_left] |
| intro m |
| by_cases he : (⟨l,m⟩ : Σ i, Fin (k i)) = ⟨i,j⟩ |
| · cases he |
| rw [hQedges]; exact hSq i j |
| · exact (hPdall he).mono (hSsub l m) (hqsub i j) |
| have hdegT : ∀ i v, v ∈ X i → (T.degree v:ℝ) ≤ a := by |
| intro i v hv |
| exact (show (T.degree v:ℝ) ≤ G.degree v by exact_mod_cast trimHeavyGraph_degree G X a v).trans (hdeg i v hv) |
| obtain ⟨p,R,Q,hR,hBad,hQ,hrep,horder⟩ := pair_folding T X hd a ha hm hma hdegT |
| (trimHeavyGraph_neighbors G X a (by linarith)) |
| let A := T.edgeFinset \ R |
| have hA : (A:Set (Sym2 V)) = T.edgeSet \ (R:Set (Sym2 V)) := by |
| simp [A,SimpleGraph.coe_edgeFinset] |
| have hR' : (R:Set (Sym2 V)) ⊆ T.edgeSet := by |
| intro e he; exact SimpleGraph.mem_edgeFinset.mp (hR he) |
| refine ⟨⟨p,Q,R,A ∪ B,k,Qpath,hk,?_,?_,?_,?_,?_,?_,?_,?_,hrep,horder⟩⟩ |
| · exact (Finset.card_union_le _ _).trans (by |
| have hn : A.card ≤ 2 * ∑ i, (X i).card := hBad |
| omega) |
| · intro i j hp |
| simpa only [Qpath,Walk.length_map] using hEnds i j (by rwa [hQlen] at hp) |
| · intro z w hzw |
| exact (hPdall hzw).mono (hqsub _ _) (hqsub _ _) |
| · intro i j |
| rw [Finset.coe_union,Set.disjoint_union_left] |
| refine ⟨?_,hBhq i j⟩ |
| apply hT.2.mono |
| · rw [hA]; exact Set.sdiff_subset |
| · exact (hqsub i j).trans ((hPsub i j).trans (Set.subset_iUnion (fun i => (H i).edgeSet) i)) |
| · intro i j |
| exact hT.2.mono hR' ((hqsub i j).trans ((hPsub i j).trans (Set.subset_iUnion (fun i => (H i).edgeSet) i))) |
| · rw [Finset.coe_union,Set.disjoint_union_left] |
| refine ⟨?_,hT.2.symm.mono hBheavy hR'⟩ |
| rw [hA]; exact Set.disjoint_sdiff_left |
| · have hheavy : (B:Set (Sym2 V)) ∪ (⋃ i, ⋃ j, (Qpath i j).walk.edgeSet) = |
| ⋃ i, (H i).edgeSet := by |
| rw [hB,← Set.iUnion_union_distrib] |
| congr 1 |
| funext i |
| rw [← Set.iUnion_union_distrib] |
| simp_rw [hQedges,hScover] |
| exact hPu i |
| rw [Finset.coe_union] |
| have hAR : (A:Set (Sym2 V)) ∪ (R:Set (Sym2 V)) = T.edgeSet := by |
| rw [hA]; exact Set.sdiff_union_of_subset hR' |
| calc |
| _ = ((A:Set _) ∪ (R:Set _)) ∪ ((B:Set _) ∪ ⋃ i, ⋃ j, (Qpath i j).walk.edgeSet) := by |
| ext e; simp only [Set.mem_union]; tauto |
| _ = T.edgeSet ∪ ⋃ i, (H i).edgeSet := by rw [hAR,hheavy] |
| _ = G.edgeSet := hT.1 |
| · simpa only [Finset.coe_image] using hQ |
|
|
| end |
| end ErdosGallai.Batch |
| end |
| end |
| end |
|
|
| end OAI |
|
|
