| import OAI.Combinatorics.Hamiltonian.Corridors |
|
|
| namespace OAI |
|
|
| /-! Clean finite walks, disjoint grown branches, and lattice minors. -/ |
|
|
| namespace Barnette |
|
|
| noncomputable section |
|
|
| structure MinorModel {V W : Type*} (G : SimpleGraph V) (H : SimpleGraph W) where |
| branch : V → Set W |
| branch_finite : ∀ v, (branch v).Finite |
| branch_connected : ∀ v, (H.induce (branch v)).Connected |
| branches_disjoint : ∀ v w, v ≠ w → Disjoint (branch v) (branch w) |
| adjacency : ∀ v w, G.Adj v w → ∃ a ∈ branch v, ∃ b ∈ branch w, H.Adj a b |
|
|
| namespace WalkSelection |
|
|
| variable {W : Type*} {H : SimpleGraph W} |
|
|
| theorem shortest_join {A B : Set W} |
| (hex : ∃ a ∈ A, ∃ b ∈ B, H.Reachable a b) : |
| ∃ (a : W) (_ha : a ∈ A) (b : W) (_hb : b ∈ B) (p : H.Walk a b), |
| p.IsPath ∧ (∀ x ∈ p.support, x ∈ A → x = a) ∧ |
| (∀ x ∈ p.support, x ∈ B → x = b) := by |
| classical |
| let P : ℕ → Prop := fun n => ∃ a ∈ A, ∃ b ∈ B, ∃ p : H.Walk a b, p.length = n |
| have hp : ∃ n, P n := by |
| obtain ⟨a, ha, b, hb, ⟨p⟩⟩ := hex |
| exact ⟨p.length, a, ha, b, hb, p, rfl⟩ |
| obtain ⟨a, ha, b, hb, p, hlen⟩ := Nat.find_spec hp |
| have minimal {x y : W} (hx : x ∈ A) (hy : y ∈ B) (q : H.Walk x y) : |
| p.length ≤ q.length := by |
| rw [hlen] |
| exact Nat.find_min' hp ⟨x, hx, y, hy, q, rfl⟩ |
| have hpath : p.IsPath := by |
| obtain ⟨q, hq⟩ := p.reachable.exists_walk_length_eq_dist |
| apply p.isPath_of_length_eq_dist |
| exact le_antisymm (hq ▸ minimal ha hb q) (SimpleGraph.dist_le p) |
| refine ⟨a, ha, b, hb, p, hpath, ?_, ?_⟩ |
| · intro x hx hxA |
| by_contra hxa |
| have hshort := p.length_dropUntil_lt_length hx hxa |
| exact (not_lt_of_ge (minimal hxA hb (p.dropUntil x hx))) hshort |
| · intro x hx hxB |
| by_contra hxb |
| have hshort := p.length_takeUntil_lt_length hx hxb |
| exact (not_lt_of_ge (minimal ha hxB (p.takeUntil x hx))) hshort |
|
|
| structure CleanConnection (A B C : Set W) where |
| start : W |
| finish : W |
| start_mem : start ∈ A |
| finish_mem : finish ∈ B |
| walk : H.Walk start finish |
| isPath : walk.IsPath |
| support_subset : ∀ x ∈ walk.support, x ∈ C |
| clean_start : ∀ x ∈ walk.support, x ∈ A → x = start |
| clean_finish : ∀ x ∈ walk.support, x ∈ B → x = finish |
|
|
| theorem exists_clean_connection {A B C : Set W} |
| (hC : (H.induce C).Connected) (hA : (A ∩ C).Nonempty) (hB : (B ∩ C).Nonempty) : |
| Nonempty (CleanConnection (H := H) A B C) := by |
| classical |
| obtain ⟨a, ha, haC⟩ := hA |
| obtain ⟨b, hb, hbC⟩ := hB |
| obtain ⟨u, hu, v, hv, p, hpath, hcleanA, hcleanB⟩ := |
| shortest_join (H := H.induce C) (A := {x | x.val ∈ A}) (B := {x | x.val ∈ B}) |
| ⟨⟨a, haC⟩, ha, ⟨b, hbC⟩, hb, hC _ _⟩ |
| let f : H.induce C →g H := ⟨Subtype.val, fun h => h⟩ |
| let q : H.Walk u.val v.val := p.map f |
| have hs : q.support = p.support.map Subtype.val := p.support_map _ |
| refine ⟨{ |
| start := u.val |
| finish := v.val |
| start_mem := hu |
| finish_mem := hv |
| walk := q |
| isPath := hpath.map Subtype.val_injective |
| support_subset := ?_ |
| clean_start := ?_ |
| clean_finish := ?_ |
| }⟩ |
| · intro x hx |
| rw [hs] at hx |
| obtain ⟨z, _, rfl⟩ := List.mem_map.mp hx |
| exact z.property |
| · intro x hx hxA |
| rw [hs] at hx |
| obtain ⟨z, hz, rfl⟩ := List.mem_map.mp hx |
| exact congrArg Subtype.val (hcleanA z hz hxA) |
| · intro x hx hxB |
| rw [hs] at hx |
| obtain ⟨z, hz, rfl⟩ := List.mem_map.mp hx |
| exact congrArg Subtype.val (hcleanB z hz hxB) |
|
|
| namespace CleanConnection |
| variable {A B C : Set W} (p : CleanConnection (H := H) A B C) |
|
|
| def leftSet : Set W := {x | x ∈ p.walk.dropLast.support} |
|
|
| theorem leftSet_finite : p.leftSet.Finite := p.walk.dropLast.support.finite_toSet |
|
|
| theorem leftSet_connected : (H.induce p.leftSet).Connected := |
| p.walk.dropLast.connected_induce_support |
|
|
| theorem start_mem_leftSet : p.start ∈ p.leftSet := p.walk.dropLast.start_mem_support |
|
|
| theorem leftSet_subset : p.leftSet ⊆ C := by |
| intro x hx |
| apply p.support_subset x |
| exact (p.walk.isSubwalk_take _).support_subset hx |
|
|
| theorem leftSet_disjoint_finish (hAB : Disjoint A B) : Disjoint p.leftSet B := by |
| have hne : p.start ≠ p.finish := by |
| intro heq |
| exact Set.disjoint_left.mp hAB p.start_mem (heq ▸ p.finish_mem) |
| have hn : ¬p.walk.Nil := SimpleGraph.Walk.not_nil_of_ne hne |
| have hd := p.isPath.support_nodup |
| rw [← p.walk.support_dropLast_concat hn] at hd |
| have hfinish : p.finish ∉ p.leftSet := by |
| intro h |
| exact hd.disjoint h (by simp) |
| rw [Set.disjoint_left] |
| intro x hx hxB |
| have hs : x ∈ p.walk.support := (p.walk.isSubwalk_take _).support_subset hx |
| have heq := p.clean_finish x hs hxB |
| exact hfinish (heq ▸ hx) |
|
|
| theorem leftSet_adj_finish (hAB : Disjoint A B) : |
| ∃ a ∈ p.leftSet, H.Adj a p.finish := by |
| have hne : p.start ≠ p.finish := by |
| intro heq |
| exact Set.disjoint_left.mp hAB p.start_mem (heq ▸ p.finish_mem) |
| exact ⟨p.walk.penultimate, p.walk.dropLast.end_mem_support, |
| p.walk.adj_penultimate (SimpleGraph.Walk.not_nil_of_ne hne)⟩ |
|
|
| end CleanConnection |
|
|
| end WalkSelection |
| end |
| end Barnette |
|
|
| namespace Barnette |
|
|
| namespace CorridorModel |
| noncomputable section |
| variable {V W : Type*} {G : SimpleGraph V} {H : SimpleGraph W} |
|
|
| private theorem exists_edgeDart (e : G.edgeSet) : ∃ d : G.Dart, d.edge = e.val := by |
| rcases e with ⟨e, he⟩ |
| induction e using Sym2.inductionOn with |
| | _ a b => exact ⟨⟨(a, b), he⟩, rfl⟩ |
|
|
| def edgeDart (e : G.edgeSet) : G.Dart := Classical.choose (exists_edgeDart e) |
|
|
| @[simp] theorem edgeDart_edge (e : G.edgeSet) : (edgeDart e).edge = e.val := |
| Classical.choose_spec (exists_edgeDart e) |
|
|
| variable (M : CorridorModel G H) |
|
|
| def connection (e : G.edgeSet) : WalkSelection.CleanConnection (H := H) |
| (M.branch (edgeDart e).fst) (M.branch (edgeDart e).snd) (M.corridor (edgeDart e)) := |
| Classical.choice (WalkSelection.exists_clean_connection |
| (M.corridor_connected _) (M.incident_meets _).1 (M.incident_meets _).2) |
|
|
| def extension (e : G.edgeSet) : Set W := (M.connection e).leftSet |
|
|
| theorem extension_finite (e : G.edgeSet) : (M.extension e).Finite := |
| (M.connection e).leftSet_finite |
|
|
| theorem extension_connected (e : G.edgeSet) : (H.induce (M.extension e)).Connected := |
| (M.connection e).leftSet_connected |
|
|
| theorem extension_subset (e : G.edgeSet) : M.extension e ⊆ M.corridor (edgeDart e) := |
| (M.connection e).leftSet_subset |
|
|
| theorem extension_disjoint_branch (e : G.edgeSet) (v : V) (hv : v ≠ (edgeDart e).fst) : |
| Disjoint (M.extension e) (M.branch v) := by |
| by_cases hs : v = (edgeDart e).snd |
| · subst v |
| exact (M.connection e).leftSet_disjoint_finish |
| (M.branches_disjoint _ _ (edgeDart e).fst_ne_snd) |
| · exact ((M.nonincident_disjoint _ _ hv hs).mono_right (M.extension_subset e)).symm |
|
|
| theorem extensions_disjoint (e f : G.edgeSet) (hef : e ≠ f) : |
| Disjoint (M.extension e) (M.extension f) := by |
| have hne : (edgeDart e).edge ≠ (edgeDart f).edge := by |
| simpa only [edgeDart_edge] using (fun h => hef (Subtype.ext h) : e.val ≠ f.val) |
| exact (M.corridors_disjoint _ _ hne).mono (M.extension_subset e) (M.extension_subset f) |
|
|
| def grownBranch (v : V) : Set W := M.branch v ∪ |
| ⋃ e : {e : G.edgeSet // (edgeDart e).fst = v}, M.extension e.val |
|
|
| theorem branch_subset_grown (v : V) : M.branch v ⊆ M.grownBranch v := |
| Set.subset_union_left |
|
|
| theorem extension_subset_grown (e : G.edgeSet) : M.extension e ⊆ M.grownBranch (edgeDart e).fst := |
| fun _ hx => Or.inr (Set.mem_iUnion.mpr ⟨⟨e, rfl⟩, hx⟩) |
|
|
| theorem grownBranch_connected (v : V) : (H.induce (M.grownBranch v)).Connected := by |
| obtain ⟨⟨a, ha⟩⟩ := (M.branch_connected v).nonempty |
| apply H.induce_connected_of_patches a (M.branch_subset_grown v ha) |
| intro x hx |
| rcases hx with hx | hx |
| · exact ⟨M.branch v, M.branch_subset_grown v, ha, hx, M.branch_connected v _ _⟩ |
| · obtain ⟨⟨e, he⟩, hx⟩ := Set.mem_iUnion.mp hx |
| have hext : M.extension e ⊆ M.grownBranch v := by |
| simpa only [he] using M.extension_subset_grown e |
| have hi : (M.branch v ∩ M.extension e).Nonempty := by |
| refine ⟨(M.connection e).start, ?_, (M.connection e).start_mem_leftSet⟩ |
| simpa only [he] using (M.connection e).start_mem |
| exact ⟨M.branch v ∪ M.extension e, |
| Set.union_subset (M.branch_subset_grown v) hext, Or.inl ha, Or.inr hx, |
| SimpleGraph.induce_union_connected (M.branch_connected v).preconnected |
| (M.extension_connected e).preconnected hi _ _⟩ |
|
|
| theorem grownBranches_disjoint (v w : V) (hvw : v ≠ w) : |
| Disjoint (M.grownBranch v) (M.grownBranch w) := by |
| rw [Set.disjoint_left] |
| intro x hx hy |
| rcases hx with hx | hx <;> rcases hy with hy | hy |
| · exact Set.disjoint_left.mp (M.branches_disjoint v w hvw) hx hy |
| · obtain ⟨⟨e, he⟩, hy⟩ := Set.mem_iUnion.mp hy |
| exact Set.disjoint_left.mp (M.extension_disjoint_branch e v (he ▸ hvw)) hy hx |
| · obtain ⟨⟨e, he⟩, hx⟩ := Set.mem_iUnion.mp hx |
| exact Set.disjoint_left.mp (M.extension_disjoint_branch e w (he ▸ hvw.symm)) hx hy |
| · obtain ⟨⟨e, he⟩, hx⟩ := Set.mem_iUnion.mp hx |
| obtain ⟨⟨f, hf⟩, hy⟩ := Set.mem_iUnion.mp hy |
| have hef : e ≠ f := by |
| intro h |
| subst f |
| exact hvw (he.symm.trans hf) |
| exact Set.disjoint_left.mp (M.extensions_disjoint e f hef) hx hy |
|
|
| theorem grownBranch_adjacency (v w : V) (hvw : G.Adj v w) : |
| ∃ a ∈ M.grownBranch v, ∃ b ∈ M.grownBranch w, H.Adj a b := by |
| let e : G.edgeSet := ⟨s(v, w), hvw⟩ |
| have hAB := M.branches_disjoint _ _ (edgeDart e).fst_ne_snd |
| obtain ⟨a, ha, hadj⟩ := (M.connection e).leftSet_adj_finish hAB |
| have ha' : a ∈ M.grownBranch (edgeDart e).fst := M.extension_subset_grown e ha |
| have hb' : (M.connection e).finish ∈ M.grownBranch (edgeDart e).snd := |
| M.branch_subset_grown _ (M.connection e).finish_mem |
| have hd : (edgeDart e).edge = s(v, w) := edgeDart_edge e |
| rcases SimpleGraph.dart_edge_eq_mk'_iff'.mp hd with ⟨h₁, h₂⟩ | ⟨h₂, h₁⟩ |
| · exact ⟨a, h₁ ▸ ha', (M.connection e).finish, h₂ ▸ hb', hadj⟩ |
| · exact ⟨(M.connection e).finish, h₁ ▸ hb', a, h₂ ▸ ha', hadj.symm⟩ |
|
|
| variable [Fintype V] |
|
|
| theorem grownBranch_finite (v : V) : (M.grownBranch v).Finite := by |
| classical |
| exact (M.branch_finite v).union (Set.finite_iUnion (fun e => M.extension_finite e.val)) |
|
|
| def toMinorModel : MinorModel G H where |
| branch := M.grownBranch |
| branch_finite := M.grownBranch_finite |
| branch_connected := M.grownBranch_connected |
| branches_disjoint := M.grownBranches_disjoint |
| adjacency := M.grownBranch_adjacency |
|
|
| end |
| end CorridorModel |
| end Barnette |
|
|
| namespace Barnette.PlaneEmbedding |
| noncomputable section |
| variable {V : Type*} [Fintype V] {G : SimpleGraph V} |
|
|
| theorem exists_lattice_minor_model (E : PlaneEmbedding G) : |
| Nonempty (MinorModel G SquareGrid.graph) := by |
| classical |
| obtain ⟨M⟩ := E.exists_lattice_corridor_model |
| exact ⟨M.toMinorModel⟩ |
| end |
| end Barnette.PlaneEmbedding |
|
|
| end OAI |
|
|
