| import OAI.Combinatorics.Hamiltonian.Model |
|
|
| namespace OAI |
|
|
| /-! Oriented finite networks, cycle and cut spaces, and graph realization. -/ |
|
|
| namespace Barnette |
|
|
| structure Network (V E : Type*) where |
| tail : E → V |
| head : E → V |
|
|
| namespace Network |
| noncomputable section |
| variable {V E : Type*} (N : Network V E) |
|
|
| def graph : SimpleGraph V where |
| Adj v w := v ≠ w ∧ ∃ e, (N.tail e = v ∧ N.head e = w) ∨ |
| (N.tail e = w ∧ N.head e = v) |
| symm := ⟨by rintro v w ⟨h, e, hi⟩; exact ⟨h.symm, e, hi.symm⟩⟩ |
| loopless := ⟨fun v h => h.1 rfl⟩ |
|
|
| theorem edge_reachable (e : E) : N.graph.Reachable (N.tail e) (N.head e) := by |
| by_cases h : N.tail e = N.head e |
| · rw [h] |
| · exact (show N.graph.Adj (N.tail e) (N.head e) from |
| ⟨h, e, Or.inl ⟨rfl, rfl⟩⟩).reachable |
|
|
| def gradient : (V → ℝ) →ₗ[ℝ] (E → ℝ) where |
| toFun f e := f (N.head e) - f (N.tail e) |
| map_add' f g := by ext e; dsimp; ring |
| map_smul' c f := by ext e; dsimp; ring |
| |
| @[simp] theorem gradient_apply (f : V → ℝ) (e : E) : |
| N.gradient f e = f (N.head e) - f (N.tail e) := rfl |
|
|
| @[simp] theorem gradient_const (a : ℝ) : N.gradient (fun _ => a) = 0 := by |
| ext e; simp |
| |
| theorem gradient_eq_zero_iff (f : V → ℝ) : |
| N.gradient f = 0 ↔ ∀ e, f (N.head e) = f (N.tail e) := by |
| simp only [funext_iff, gradient_apply, Pi.zero_apply, sub_eq_zero] |
|
|
| theorem gradient_zero_adj {f : V → ℝ} (hf : N.gradient f = 0) |
| {v w : V} (h : N.graph.Adj v w) : f v = f w := by |
| obtain ⟨_, e, ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩⟩ := h |
| · exact ((N.gradient_eq_zero_iff f).mp hf e).symm |
| · exact (N.gradient_eq_zero_iff f).mp hf e |
|
|
| theorem gradient_zero_reachable {f : V → ℝ} (hf : N.gradient f = 0) |
| {v w : V} (h : N.graph.Reachable v w) : f v = f w := by |
| obtain ⟨p⟩ := h |
| induction p with |
| | nil => rfl |
| | cons h p ih => exact (N.gradient_zero_adj hf h).trans ih |
|
|
| def constant : ℝ →ₗ[ℝ] (V → ℝ) where |
| toFun a _ := a |
| map_add' _ _ := rfl |
| map_smul' _ _ := rfl |
|
|
| theorem ker_gradient (h : N.graph.Connected) : |
| N.gradient.ker = (constant (V := V)).range := by |
| obtain ⟨v⟩ := h.nonempty |
| ext f |
| constructor |
| · intro hf |
| refine ⟨f v, ?_⟩ |
| ext w |
| exact N.gradient_zero_reachable hf (h v w) |
| · rintro ⟨a, rfl⟩ |
| exact N.gradient_const a |
|
|
| variable [Fintype V] [Fintype E] |
| local instance : DecidableEq V := Classical.decEq _ |
| local instance : DecidableEq E := Classical.decEq _ |
|
|
| def incidence : Matrix V E ℝ := fun v e => |
| (if N.head e = v then 1 else 0) - (if N.tail e = v then 1 else 0) |
|
|
| def boundary : (E → ℝ) →ₗ[ℝ] (V → ℝ) := Matrix.toLin' N.incidence |
|
|
| omit [Fintype V] in |
| @[simp] theorem boundary_apply (x : E → ℝ) (v : V) : |
| N.boundary x v = ∑ e, ((if N.head e = v then x e else 0) - |
| (if N.tail e = v then x e else 0)) := by |
| classical |
| simp [boundary, Matrix.toLin'_apply, Matrix.mulVec, dotProduct, incidence, |
| sub_mul, ite_mul] |
|
|
| omit [Fintype E] in |
| theorem gradient_matrix : N.gradient = Matrix.toLin' N.incidence.transpose := by |
| classical |
| apply LinearMap.ext |
| intro f |
| ext e |
| simp [Matrix.toLin'_apply, Matrix.mulVec, dotProduct, incidence, |
| sub_mul, ite_mul, Finset.sum_sub_distrib] |
|
|
| theorem sum_boundary (x : E → ℝ) : ∑ v, N.boundary x v = 0 := by |
| classical |
| simp only [boundary_apply] |
| rw [Finset.sum_comm] |
| simp [Finset.sum_sub_distrib] |
|
|
| omit [Fintype E] in |
| theorem rank_gradient (h : N.graph.Connected) : |
| Module.finrank ℝ N.gradient.range + 1 = Fintype.card V := by |
| obtain ⟨v⟩ := h.nonempty |
| have hi : Function.Injective (constant (V := V)) := by |
| intro a b hab |
| exact congrFun hab v |
| have hk : Module.finrank ℝ N.gradient.ker = 1 := by |
| rw [N.ker_gradient h, LinearMap.finrank_range_of_inj hi] |
| exact Module.finrank_self ℝ |
| have hh := N.gradient.finrank_range_add_finrank_ker |
| simpa only [hk, Module.finrank_pi] using hh |
|
|
| theorem rank_boundary (h : N.graph.Connected) : |
| Module.finrank ℝ N.boundary.range + 1 = Fintype.card V := by |
| have hh := N.rank_gradient h |
| have he : Module.finrank ℝ N.boundary.range = Module.finrank ℝ N.gradient.range := by |
| rw [N.gradient_matrix, boundary, Matrix.toLin'_apply', Matrix.toLin'_apply', |
| ← Matrix.rank, ← Matrix.rank, Matrix.rank_transpose] |
| rwa [he] |
|
|
| theorem dim_cycles (h : N.graph.Connected) : |
| Module.finrank ℝ N.boundary.ker + Fintype.card V = Fintype.card E + 1 := by |
| have hr := N.rank_boundary h |
| have hk := N.boundary.finrank_range_add_finrank_ker |
| rw [Module.finrank_pi] at hk |
| omega |
|
|
| theorem boundary_adjoint (x : E → ℝ) (f : V → ℝ) : |
| ∑ v, N.boundary x v * f v = ∑ e, x e * N.gradient f e := by |
| classical |
| simp only [boundary_apply, Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro e _ |
| simp [sub_mul, ite_mul, Finset.sum_sub_distrib, mul_sub] |
|
|
| variable {F : Type*} [Fintype F] (D : Network F E) |
|
|
| theorem orthogonal_symm (h : ∀ f, N.boundary (D.gradient f) = 0) : |
| ∀ f, D.boundary (N.gradient f) = 0 := by |
| classical |
| intro f |
| ext y |
| calc |
| D.boundary (N.gradient f) y = |
| ∑ z, D.boundary (N.gradient f) z * (fun z : F => if z = y then (1 : ℝ) else 0) z := by |
| simp only [mul_ite, mul_one, mul_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true] |
| _ = ∑ e, N.gradient f e * D.gradient ((fun z : F => if z = y then (1 : ℝ) else 0)) e := |
| D.boundary_adjoint _ _ |
| _ = ∑ e, D.gradient ((fun z : F => if z = y then (1 : ℝ) else 0)) e * N.gradient f e := by |
| apply Finset.sum_congr rfl |
| intro e _ |
| exact mul_comm _ _ |
| _ = ∑ v, N.boundary (D.gradient ((fun z : F => if z = y then (1 : ℝ) else 0))) v * f v := |
| (N.boundary_adjoint _ _).symm |
| _ = 0 := by rw [h]; simp |
| |
| structure Duality : Prop where |
| connected : N.graph.Connected |
| dual_connected : D.graph.Connected |
| cycles_eq_cuts : N.boundary.ker = D.gradient.range |
| dual_cycles_eq_cuts : D.boundary.ker = N.gradient.range |
|
|
| private theorem ker_eq_range_of_orth_card |
| (hN : N.graph.Connected) (hD : D.graph.Connected) |
| (hc : Fintype.card V + Fintype.card F = Fintype.card E + 2) |
| (ho : ∀ f, N.boundary (D.gradient f) = 0) : |
| N.boundary.ker = D.gradient.range := by |
| have hle : D.gradient.range ≤ N.boundary.ker := by |
| rintro _ ⟨f, rfl⟩ |
| exact ho f |
| have hd₁ := N.dim_cycles hN |
| have hd₂ := D.rank_gradient hD |
| exact (Submodule.eq_of_le_of_finrank_eq hle (by omega)).symm |
|
|
| theorem duality_of_orth_card |
| (hN : N.graph.Connected) (hD : D.graph.Connected) |
| (hc : Fintype.card V + Fintype.card F = Fintype.card E + 2) |
| (ho : ∀ f, N.boundary (D.gradient f) = 0) : N.Duality D where |
| connected := hN |
| dual_connected := hD |
| cycles_eq_cuts := N.ker_eq_range_of_orth_card D hN hD hc ho |
| dual_cycles_eq_cuts := D.ker_eq_range_of_orth_card N hD hN (by omega) |
| (N.orthogonal_symm D ho) |
|
|
| theorem Duality.euler (h : N.Duality D) : |
| Fintype.card V + Fintype.card F = Fintype.card E + 2 := by |
| have h₁ := N.dim_cycles h.connected |
| rw [h.cycles_eq_cuts] at h₁ |
| have h₂ := D.rank_gradient h.dual_connected |
| omega |
|
|
| end |
| end Network |
| end Barnette |
|
|
| namespace Barnette |
| noncomputable section |
| open scoped Classical |
| variable {V : Type*} [Fintype V] [DecidableEq V] {G : SimpleGraph V} |
| [DecidableRel G.Adj] |
|
|
| omit [DecidableEq V] in |
| lemma cubic_bipartite_order [Nonempty V] (hc : G.IsRegularOfDegree 3) |
| (hb : G.IsBipartite) : 6 ≤ Fintype.card V := by |
| obtain ⟨c⟩ := hb |
| obtain ⟨v⟩ := ‹Nonempty V› |
| have hp : (G.neighborFinset v).Nonempty := by |
| apply Finset.card_pos.mp |
| rw [G.card_neighborFinset_eq_degree, hc v] |
| norm_num |
| obtain ⟨w, hw⟩ := hp |
| have hvw : G.Adj v w := (G.mem_neighborFinset v w).mp hw |
| have hd : Disjoint (G.neighborFinset v) (G.neighborFinset w) := by |
| rw [Finset.disjoint_left] |
| intro x hx hy |
| have h₁ := c.valid hvw |
| have h₂ := c.valid ((G.mem_neighborFinset v x).mp hx) |
| have h₃ := c.valid ((G.mem_neighborFinset w x).mp hy) |
| have hv := (c v).isLt |
| have hw := (c w).isLt |
| have hx := (c x).isLt |
| have h₁' : (c v).val ≠ (c w).val := fun h => h₁ (Fin.ext h) |
| have h₂' : (c v).val ≠ (c x).val := fun h => h₂ (Fin.ext h) |
| have h₃' : (c w).val ≠ (c x).val := fun h => h₃ (Fin.ext h) |
| omega |
| have hle := Finset.card_le_card (Finset.subset_univ |
| (G.neighborFinset v ∪ G.neighborFinset w)) |
| rw [Finset.card_union_of_disjoint hd, G.card_neighborFinset_eq_degree, |
| G.card_neighborFinset_eq_degree, hc v, hc w, Finset.card_univ] at hle |
| exact hle |
|
|
| omit [DecidableRel G.Adj] in |
|
|
| lemma boundary_cover_of_threeConnected (h : ThreeVertexConnected G) |
| (A S : Finset V) (hS : S.card ≤ 2) (hSA : S ⊆ A) |
| (hout : ∃ w, w ∉ A) |
| (hboundary : ∀ v ∈ A, ∀ w, w ∉ A → G.Adj v w → v ∈ S) : A ⊆ S := by |
| intro v hv |
| by_contra hvS |
| obtain ⟨w, hw⟩ := hout |
| have hwS : w ∉ S := fun hs => hw (hSA hs) |
| let H := G.induce {v | v ∉ S} |
| have hr := (h.2 S hS) (⟨v,hvS⟩ : {v | v ∉ S}) ⟨w,hwS⟩ |
| obtain ⟨p⟩ := hr |
| have hp : ∀ {a b : {v | v ∉ S}}, H.Walk a b → a.val ∈ A → b.val ∈ A := by |
| intro a b p |
| induction p with |
| | nil => exact id |
| | @cons a z b haz p ih => |
| intro ha |
| apply ih |
| by_contra hz |
| exact a.property (hboundary a.val ha z.val hz haz) |
| exact hw (hp p hv) |
|
|
| end |
| end Barnette |
|
|
| end OAI |
|
|
