| import OAI.Combinatorics.ListHadwiger.Routing |
|
|
| namespace OAI |
|
|
| namespace LinearListHadwiger |
| open SimpleGraph PathPacking |
|
|
| namespace MinorModel |
| variable {V W : Type} {G : SimpleGraph V} {H : SimpleGraph W} |
|
|
| def expand (M : MinorModel G H) (S : Set W) : Set V := |
| {v | ∃ w ∈ S, v ∈ M.branch w} |
|
|
| lemma branch_subset_expand (M : MinorModel G H) {S : Set W} {w : W} (hw : w ∈ S) : |
| M.branch w ⊆ M.expand S := fun _ hv => ⟨w, hw, hv⟩ |
|
|
| lemma expand_connected (M : MinorModel G H) {S : Set W} |
| (hS : (H.induce S).Connected) : (G.induce (M.expand S)).Connected := by |
| have hsame (w : S) (a b : M.branch w.val) : |
| (G.induce (M.expand S)).Reachable |
| ⟨a.val, M.branch_subset_expand w.property a.property⟩ |
| ⟨b.val, M.branch_subset_expand w.property b.property⟩ := |
| ((M.connected w.val).preconnected a b).map |
| (G.induceHomOfLE (M.branch_subset_expand w.property)).toHom |
| have hwalk : ∀ {u v : S} (p : (H.induce S).Walk u v) |
| (a : M.branch u.val) (b : M.branch v.val), |
| (G.induce (M.expand S)).Reachable |
| ⟨a.val, M.branch_subset_expand u.property a.property⟩ |
| ⟨b.val, M.branch_subset_expand v.property b.property⟩ := by |
| intro u v p |
| induction p with |
| | nil => exact hsame _ |
| | @cons u v z hadj p ih => |
| intro a b |
| obtain ⟨x, hx, y, hy, hxy⟩ := M.adjacent hadj |
| have hxy' : (G.induce (M.expand S)).Adj |
| ⟨x, M.branch_subset_expand u.property hx⟩ |
| ⟨y, M.branch_subset_expand v.property hy⟩ := hxy |
| exact (hsame u a ⟨x, hx⟩).trans (hxy'.reachable.trans (ih ⟨y, hy⟩ b)) |
| refine { preconnected := ?_, nonempty := ?_ } |
| · intro a b |
| obtain ⟨u, hu, hau⟩ := a.property |
| obtain ⟨v, hv, hbv⟩ := b.property |
| obtain ⟨p⟩ := hS.preconnected ⟨u, hu⟩ ⟨v, hv⟩ |
| exact hwalk p ⟨a.val, hau⟩ ⟨b.val, hbv⟩ |
| · obtain ⟨w⟩ := hS.nonempty |
| obtain ⟨v⟩ := (M.connected w.val).nonempty |
| exact ⟨⟨v.val, M.branch_subset_expand w.property v.property⟩⟩ |
|
|
| lemma expand_disjoint (M : MinorModel G H) {S T : Set W} (hST : Disjoint S T) : |
| Disjoint (M.expand S) (M.expand T) := by |
| apply Set.disjoint_left.mpr |
| rintro v ⟨a, ha, hva⟩ ⟨b, hb, hvb⟩ |
| by_cases hab : a = b |
| · exact Set.disjoint_left.mp hST ha (hab ▸ hb) |
| · exact Set.disjoint_left.mp (M.disjoint a b hab) hva hvb |
|
|
| theorem lift_clique (M : MinorModel G H) {t : ℕ} (h : HasCliqueMinor H t) : |
| HasCliqueMinor G t := by |
| obtain ⟨B, hc, hd, he⟩ := h |
| refine ⟨fun i => M.expand (B i), fun i => M.expand_connected (hc i), |
| fun i j hij => M.expand_disjoint (hd i j hij), ?_⟩ |
| intro i j hij |
| obtain ⟨a, ha, b, hb, hab⟩ := he i j hij |
| obtain ⟨x, hx, y, hy, hxy⟩ := M.adjacent hab |
| exact ⟨x, ⟨a, ha, hx⟩, y, ⟨b, hb, hy⟩, hxy⟩ |
|
|
| theorem hadwiger_le [Fintype V] [Fintype W] (M : MinorModel G H) : |
| hadwigerNumber H ≤ hadwigerNumber G := |
| cliqueMinor_le_hadwigerNumber (M.lift_clique (hasCliqueMinor_hadwigerNumber H)) |
|
|
| end MinorModel |
|
|
| structure BagRouting {V I J : Type} (G : SimpleGraph V) (s : I → V) |
| (B : J → Set V) where |
| paths : ∀ i, Σ v, G.Path (s i) v |
| bag : I → J |
| bag_injective : Function.Injective bag |
| endpoint_mem : ∀ i, (paths i).1 ∈ B (bag i) |
| overlap : ∀ i j, i ≠ j → ∀ v, |
| v ∈ (paths i).2.val.support → v ∈ (paths j).2.val.support → |
| v = s i ∧ v = s j |
|
|
| namespace BagRouting |
| variable {V I J : Type} {G : SimpleGraph V} {s : I → V} {B : J → Set V} |
|
|
| noncomputable def totalLength [Fintype I] (D : BagRouting G s B) : ℕ := |
| ∑ i, (D.paths i).2.val.length |
|
|
| noncomputable def truncate [DecidableEq V] [DecidableEq I] |
| (D : BagRouting G s B) (i : I) (j : J) (hj : j ∉ Set.range D.bag) |
| (v : V) (hv : v ∈ (D.paths i).2.val.support) (hB : v ∈ B j) : |
| BagRouting G s B := by |
| classical |
| let p : G.Path (s i) v := |
| ⟨(D.paths i).2.val.takeUntil v hv, (D.paths i).2.property.takeUntil hv⟩ |
| let paths : ∀ a, Σ w, G.Path (s a) w := |
| fun a => if h : a = i then h.symm ▸ (⟨v, p⟩ : Σ w, G.Path (s i) w) else D.paths a |
| let f : I → J := Function.update D.bag i j |
| refine ⟨paths, f, ?_, ?_, ?_⟩ |
| · intro a b hab |
| by_cases ha : a = i <;> by_cases hb : b = i |
| · exact ha.trans hb.symm |
| · subst a |
| have h : j = D.bag b := by simpa [f, Function.update, hb] using hab |
| exact (hj ⟨b, h.symm⟩).elim |
| · subst b |
| have h : D.bag a = j := by simpa [f, Function.update, ha] using hab |
| exact (hj ⟨a, h⟩).elim |
| · exact D.bag_injective (by simpa [f, Function.update, ha, hb] using hab) |
| · intro a |
| by_cases ha : a = i |
| · subst a; simpa [paths, f, p] using hB |
| · simpa [paths, f, ha] using D.endpoint_mem a |
| · intro a b hab w hwa hwb |
| have hsub (z : I) : (paths z).2.val.support ⊆ (D.paths z).2.val.support := by |
| by_cases hz : z = i |
| · subst z |
| have heq : paths i = ⟨v, p⟩ := dite_eq_left rfl |
| rw [heq] |
| exact (D.paths i).2.val.support_takeUntil_subset_support hv |
| · have heq : paths z = D.paths z := dite_eq_right hz |
| rw [heq] |
| exact D.overlap a b hab w (hsub a hwa) (hsub b hwb) |
|
|
| lemma truncate_length_lt [Fintype I] [DecidableEq V] [DecidableEq I] |
| (D : BagRouting G s B) (hdis : ∀ a b, a ≠ b → Disjoint (B a) (B b)) |
| (i : I) (j : J) (hj : j ∉ Set.range D.bag) |
| (v : V) (hv : v ∈ (D.paths i).2.val.support) (hB : v ∈ B j) : |
| (D.truncate i j hj v hv hB).totalLength < D.totalLength := by |
| classical |
| have hne : v ≠ (D.paths i).1 := by |
| intro heq |
| have hx : j ≠ D.bag i := fun h => hj ⟨i, h.symm⟩ |
| exact Set.disjoint_left.mp (hdis j (D.bag i) hx) hB (heq ▸ D.endpoint_mem i) |
| have hlt : ((D.paths i).2.val.takeUntil v hv).length < (D.paths i).2.val.length := by |
| have hh := (D.paths i).2.val.length_takeUntil_le_length hv |
| apply lt_of_le_of_ne hh |
| intro heq |
| have h := Walk.getVert_length_takeUntil hv |
| rw [heq, Walk.getVert_length] at h |
| exact hne h.symm |
| have hi : (D.truncate i j hj v hv hB).paths i = |
| ⟨v, ⟨(D.paths i).2.val.takeUntil v hv, (D.paths i).2.property.takeUntil hv⟩⟩ := |
| dite_eq_left rfl |
| have ha : ∀ a, a ≠ i → (D.truncate i j hj v hv hB).paths a = D.paths a := |
| fun a h => dite_eq_right h |
| apply Finset.sum_lt_sum |
| · intro a _ |
| by_cases h : a = i |
| · subst a |
| rw [hi] |
| exact hlt.le |
| · rw [ha a h] |
| · refine ⟨i, Finset.mem_univ _, ?_⟩ |
| rw [hi] |
| exact hlt |
|
|
| theorem exists_avoiding_unused [Fintype I] [DecidableEq V] [DecidableEq I] |
| (hdis : ∀ a b, a ≠ b → Disjoint (B a) (B b)) |
| (h : Nonempty (BagRouting G s B)) : |
| ∃ D : BagRouting G s B, ∀ j, j ∉ Set.range D.bag → |
| ∀ i v, v ∈ (D.paths i).2.val.support → v ∉ B j := by |
| classical |
| have hex : ∃ n : ℕ, ∃ D : BagRouting G s B, D.totalLength = n := by |
| obtain ⟨D⟩ := h |
| exact ⟨D.totalLength, D, rfl⟩ |
| obtain ⟨D, hd⟩ := Nat.find_spec hex |
| refine ⟨D, ?_⟩ |
| intro j hj i v hv hB |
| have hmin := Nat.find_min' hex ⟨D.truncate i j hj v hv hB, rfl⟩ |
| rw [← hd] at hmin |
| exact (not_le_of_gt (D.truncate_length_lt hdis i j hj v hv hB)) hmin |
|
|
| end BagRouting |
|
|
| theorem bagRouting_of_double_packing {V J : Type} [Fintype V] [Fintype J] |
| [DecidableEq V] (G : SimpleGraph V) (A : Finset V) (B : J → Set V) |
| (hc : KConnectedOn G Finset.univ (2 * A.card)) |
| (hcB : ∀ j, (G.induce (B j)).Connected) |
| (hdB : ∀ i j, i ≠ j → Disjoint (B i) (B j)) |
| (haB : ∀ j, Disjoint (↑A : Set V) (B j)) |
| (hcard : 2 * A.card ≤ Fintype.card J) : |
| Nonempty (BagRouting G (fun i : ↥A × Bool => i.1.val) B) := by |
| classical |
| have hex : ∀ j, ∃ v, v ∈ B j := fun j => by |
| obtain ⟨v⟩ := (hcB j).nonempty |
| exact ⟨v.val, v.property⟩ |
| choose rep hrep using hex |
| have hinj : Function.Injective rep := by |
| intro i j heq |
| by_contra hij |
| exact Set.disjoint_left.mp (hdB i j hij) (hrep i) (heq ▸ hrep j) |
| let T : Finset V := Finset.univ.image rep |
| have hAT : Disjoint A T := by |
| apply Finset.disjoint_left.mpr |
| intro a ha ht |
| obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp ht |
| exact Set.disjoint_left.mp (haB j) ha (hrep j) |
| have hT : T.card = Fintype.card J := by |
| simp [T, Finset.card_image_of_injective _ hinj] |
| obtain ⟨D⟩ := double_packing G A T hAT hc (hT ▸ hcard) |
| have htar : ∀ i : ↥A × Bool, ∃ j, rep j = (D.target i).val := by |
| intro i |
| obtain ⟨j, _, heq⟩ := Finset.mem_image.mp (D.target i).property |
| exact ⟨j, heq⟩ |
| choose idx hidx using htar |
| refine ⟨⟨fun i => ⟨(D.target i).val, D.route i⟩, idx, ?_, ?_, D.overlap⟩⟩ |
| · intro i j hij |
| apply D.target_injective |
| apply Subtype.ext |
| rw [← hidx i, ← hidx j, hij] |
| · intro i |
| change (D.target i).val ∈ B (idx i) |
| rw [← hidx] |
| exact hrep (idx i) |
|
|
| open scoped Classical |
|
|
| lemma exists_region_avoiding {V I : Type} [Fintype I] [DecidableEq V] |
| (C : I → Set V) (X : Finset V) (c r : ℕ) (hc : 0 < c) |
| (hI : c * r ≤ Fintype.card I) (hX : X.card < r) |
| (hcon : ∀ v ∈ X, (Finset.univ.filter fun i => v ∈ C i).card ≤ c) : |
| ∃ i, ∀ v ∈ C i, v ∉ X := by |
| classical |
| let met : Finset I := X.biUnion fun v => Finset.univ.filter fun i => v ∈ C i |
| have hmet : met.card ≤ X.card * c := by |
| calc |
| met.card ≤ ∑ v ∈ X, (Finset.univ.filter fun i => v ∈ C i).card := |
| Finset.card_biUnion_le |
| _ ≤ ∑ _v ∈ X, c := Finset.sum_le_sum hcon |
| _ = X.card * c := by simp |
| have hmI : met.card < Fintype.card I := by |
| have hmul := Nat.mul_lt_mul_of_pos_right hX hc |
| nlinarith |
| obtain ⟨i, _, hi⟩ := Finset.exists_mem_notMem_of_card_lt_card |
| (show met.card < (Finset.univ : Finset I).card by simpa using hmI) |
| refine ⟨i, ?_⟩ |
| intro v hv hvX |
| exact hi (Finset.mem_biUnion.mpr ⟨v, hvX, Finset.mem_filter.mpr ⟨Finset.mem_univ _, hv⟩⟩) |
|
|
| structure RootedCliqueModel {V I : Type} (G : SimpleGraph V) (roots : I → V) where |
| branch : I → Set V |
| connected : ∀ i, (G.induce (branch i)).Connected |
| disjoint : ∀ i j, i ≠ j → Disjoint (branch i) (branch j) |
| adjacent : ∀ i j, i ≠ j → ∃ x ∈ branch i, ∃ y ∈ branch j, G.Adj x y |
| root_mem : ∀ i, roots i ∈ branch i |
|
|
| theorem rootedModel_of_packing {V W : Type} [DecidableEq W] |
| {G : SimpleGraph V} {H : SimpleGraph W} (M : MinorModel G H) |
| {A B : Finset W} (D : FullPacking H A B) |
| (hcl : ∀ x ∈ B, ∀ y ∈ B, x ≠ y → H.Adj x y) |
| (roots : ↥A → V) (hr : ∀ a, roots a ∈ M.branch a.val) : |
| Nonempty (RootedCliqueModel G roots) := by |
| let S : ↥A → Set W := fun a => {w | w ∈ (D.route a).val.support} |
| refine ⟨⟨fun a => M.expand (S a), ?_, ?_, ?_, ?_⟩⟩ |
| · intro a |
| exact M.expand_connected (D.route a).val.connected_induce_support |
| · intro a b hab |
| exact M.expand_disjoint (D.disjoint a b hab) |
| · intro a b hab |
| have hne : (D.target a).val ≠ (D.target b).val := by |
| intro h |
| exact hab (D.target_injective (Subtype.ext h)) |
| obtain ⟨x, hx, y, hy, hxy⟩ := M.adjacent |
| (hcl _ (D.target a).property _ (D.target b).property hne) |
| exact ⟨x, ⟨_, (D.route a).val.end_mem_support, hx⟩, |
| y, ⟨_, (D.route b).val.end_mem_support, hy⟩, hxy⟩ |
| · intro a |
| exact ⟨a.val, (D.route a).val.start_mem_support, hr a⟩ |
|
|
| end LinearListHadwiger |
|
|
| end OAI |
|
|
