| import OAI.Combinatorics.Hamiltonian.MinorModel |
|
|
| namespace OAI |
|
|
| /-! Extending disjoint connected branches to a connected vertex partition. -/ |
|
|
| namespace Barnette |
| noncomputable section |
| open scoped Classical |
|
|
| namespace BranchPartition |
| variable {V W : Type*} [Fintype V] [Fintype W] [Nonempty V] |
| (H : SimpleGraph W) |
|
|
| omit [Fintype W] in |
| lemma walk_crosses_boundary {S : Set W} {v w : W} (p : H.Walk v w) |
| (hv : v ∈ S) (hw : w ∉ S) : |
| ∃ a ∈ S, ∃ b ∉ S, H.Adj a b := by |
| induction p with |
| | nil => exact (hw hv).elim |
| | @cons u z w h p ih => |
| by_cases hz : z ∈ S |
| · exact ih hz hw |
| · exact ⟨u, hv, z, hz, h⟩ |
|
|
| theorem extend (hH : H.Connected) (B₀ : V → Set W) |
| (hB₀ : ∀ v, (H.induce (B₀ v)).Connected) |
| (hd₀ : ∀ v w, v ≠ w → Disjoint (B₀ v) (B₀ w)) : |
| ∃ B : V → Set W, |
| (∀ v, B₀ v ⊆ B v) ∧ |
| (∀ v, (H.induce (B v)).Connected) ∧ |
| (∀ v w, v ≠ w → Disjoint (B v) (B w)) ∧ |
| (∀ w, ∃ v, w ∈ B v) := by |
| let S : Set (V → Set W) := {B | (∀ v, B₀ v ⊆ B v) ∧ |
| (∀ v, (H.induce (B v)).Connected) ∧ |
| (∀ v w, v ≠ w → Disjoint (B v) (B w))} |
| let size (B : V → Set W) := (⋃ v, B v).ncard |
| have hS : S.Nonempty := ⟨B₀, fun _ => Set.Subset.rfl, hB₀, hd₀⟩ |
| obtain ⟨B, hB, hmax⟩ := S.exists_max_image size (Set.toFinite _) hS |
| refine ⟨B, hB.1, hB.2.1, hB.2.2, ?_⟩ |
| intro w |
| by_contra hw |
| have hwU : w ∉ ⋃ v, B v := by simpa only [Set.mem_iUnion] using hw |
| obtain ⟨v₀⟩ := ‹Nonempty V› |
| obtain ⟨a₀⟩ := (hB.2.1 v₀).nonempty |
| obtain ⟨p⟩ := hH a₀.val w |
| obtain ⟨a, ha, b, hb, hab⟩ := walk_crosses_boundary H p |
| (Set.mem_iUnion.mpr ⟨v₀, a₀.property⟩) hwU |
| obtain ⟨v, hv⟩ := Set.mem_iUnion.mp ha |
| let B' : V → Set W := fun z => if z = v then insert b (B v) else B z |
| have hle : ∀ z, B z ⊆ B' z := by |
| intro z x hx |
| by_cases hz : z = v |
| · subst z; simp only [B', ite_true]; exact Set.mem_insert_of_mem _ hx |
| · simpa only [B', hz, ite_false] using hx |
| have hB' : B' ∈ S := by |
| refine ⟨fun z => (hB.1 z).trans (hle z), ?_, ?_⟩ |
| · intro z |
| by_cases hz : z = v |
| · subst z |
| have hsingle : (H.induce ({b} : Set W)).Preconnected := by |
| intro x y |
| have he : x = y := Subsingleton.elim _ _ |
| subst y |
| exact .rfl |
| have hh := SimpleGraph.connected_induce_union (hB.2.1 v).preconnected hsingle |
| hv (show b ∈ ({b} : Set W) by simp) hab |
| rw [show B' v = insert b (B v) by simp [B']] |
| rw [Set.union_singleton] at hh |
| exact hh |
| · rw [show B' z = B z by simp [B', hz]] |
| exact hB.2.1 z |
| · intro z t hzt |
| rw [Set.disjoint_left] |
| intro x hxz hxt |
| by_cases hz : z = v |
| · subst z |
| have ht : t ≠ v := Ne.symm hzt |
| simp only [B', ite_true, Set.mem_insert_iff] at hxz |
| rw [show B' t = B t by simp only [B', ht, ite_false]] at hxt |
| rcases hxz with rfl | hxz |
| · exact hb (Set.mem_iUnion.mpr ⟨t, hxt⟩) |
| · exact Set.disjoint_left.mp (hB.2.2 v t hzt) hxz hxt |
| · rw [show B' z = B z by simp only [B', hz, ite_false]] at hxz |
| by_cases ht : t = v |
| · subst t |
| simp only [B', ite_true, Set.mem_insert_iff] at hxt |
| rcases hxt with rfl | hxt |
| · exact hb (Set.mem_iUnion.mpr ⟨z, hxz⟩) |
| · exact Set.disjoint_left.mp (hB.2.2 z v hzt) hxz hxt |
| · rw [show B' t = B t by simp only [B', ht, ite_false]] at hxt |
| exact Set.disjoint_left.mp (hB.2.2 z t hzt) hxz hxt |
| have hstrict : (⋃ z, B z) ⊂ ⋃ z, B' z := by |
| refine ⟨Set.iUnion_mono hle, ?_⟩ |
| intro hh |
| apply hb (hh ?_) |
| exact Set.mem_iUnion.mpr ⟨v, by simp [B']⟩ |
| exact (not_lt_of_ge (hmax B' hB')) (Set.ncard_lt_ncard hstrict) |
|
|
| omit [Fintype V] [Fintype W] [Nonempty V] in |
|
|
| theorem quotient (B : V → Set W) |
| (hB : ∀ v, (H.induce (B v)).Connected) |
| (hd : ∀ v w, v ≠ w → Disjoint (B v) (B w)) |
| (hcover : ∀ w, ∃ v, w ∈ B v) : |
| ∃ q : W → V, Function.Surjective q ∧ (∀ w v, q w = v ↔ w ∈ B v) := by |
| choose q hq using hcover |
| have he (w : W) (v : V) : q w = v ↔ w ∈ B v := by |
| constructor |
| · intro hv; exact hv ▸ hq w |
| · intro hw |
| by_contra hne |
| exact Set.disjoint_left.mp (hd (q w) v hne) (hq w) hw |
| refine ⟨q, ?_, he⟩ |
| intro v |
| obtain ⟨w⟩ := (hB v).nonempty |
| exact ⟨w.val, (he w.val v).mpr w.property⟩ |
|
|
| end BranchPartition |
| end |
| end Barnette |
|
|
| end OAI |
|
|
