| import OAI.Combinatorics.Hamiltonian.BranchPartition |
|
|
| namespace OAI |
|
|
| /-! Rectangular primal and dual networks and finite lattice containment. -/ |
|
|
| namespace Barnette.RectangularDual |
| noncomputable section |
|
|
| abbrev Vertex (n m : ℕ) := Fin (n + 1) × Fin (m + 1) |
| abbrev Edge (n m : ℕ) := (Fin n × Fin (m + 1)) ⊕ (Fin (n + 1) × Fin m) |
| abbrev Face (n m : ℕ) := Option (Fin n × Fin m) |
|
|
| def primal (n m : ℕ) : Network (Vertex n m) (Edge n m) where |
| tail := Sum.elim (fun e => (e.1.castSucc, e.2)) (fun e => (e.1, e.2.castSucc)) |
| head := Sum.elim (fun e => (e.1.succ, e.2)) (fun e => (e.1, e.2.succ)) |
|
|
| def lower {n : ℕ} : Fin (n + 1) → Option (Fin n) := Fin.cases none some |
| def upper {n : ℕ} : Fin (n + 1) → Option (Fin n) := Fin.lastCases none some |
|
|
| def dual (n m : ℕ) : Network (Face n m) (Edge n m) where |
| tail := Sum.elim |
| (fun e => (lower e.2).map (fun j => (e.1, j))) |
| (fun e => (upper e.1).map (fun i => (i, e.2))) |
| head := Sum.elim |
| (fun e => (upper e.2).map (fun j => (e.1, j))) |
| (fun e => (lower e.1).map (fun i => (i, e.2))) |
|
|
| def lowerValue {n : ℕ} (f : Fin n → ℝ) : Fin (n + 1) → ℝ := Fin.cases 0 f |
| def upperValue {n : ℕ} (f : Fin n → ℝ) : Fin (n + 1) → ℝ := Fin.lastCases 0 f |
|
|
| def stepCoeff {n : ℕ} (v : Fin (n + 1)) (e : Fin n) : ℝ := |
| (if e.succ = v then 1 else 0) - (if e.castSucc = v then 1 else 0) |
|
|
| lemma sum_succ {n : ℕ} (f : Fin n → ℝ) (v : Fin (n + 1)) : |
| (∑ i, if i.succ = v then f i else 0) = lowerValue f v := by |
| induction v using Fin.cases with |
| | zero => simp [lowerValue] |
| | succ v => simp [lowerValue] |
|
|
| lemma sum_castSucc {n : ℕ} (f : Fin n → ℝ) (v : Fin (n + 1)) : |
| (∑ i, if i.castSucc = v then f i else 0) = upperValue f v := by |
| induction v using Fin.lastCases with |
| | last => simp [upperValue, Fin.castSucc_ne_last] |
| | cast v => simp [upperValue] |
|
|
| lemma sum_stepCoeff {n : ℕ} (f : Fin n → ℝ) (v : Fin (n + 1)) : |
| (∑ i, stepCoeff v i * f i) = lowerValue f v - upperValue f v := by |
| simp only [stepCoeff, sub_mul, ite_mul, one_mul, zero_mul, |
| Finset.sum_sub_distrib, sum_succ, sum_castSucc] |
|
|
| lemma lower_eval {n : ℕ} (f : Fin n → ℝ) (v : Fin (n + 1)) : |
| (lower v).elim 0 f = lowerValue f v := by |
| induction v using Fin.cases <;> simp [lower, lowerValue] |
|
|
| lemma upper_eval {n : ℕ} (f : Fin n → ℝ) (v : Fin (n + 1)) : |
| (upper v).elim 0 f = upperValue f v := by |
| induction v using Fin.lastCases <;> simp [upper, upperValue] |
|
|
| def potential {n m : ℕ} (f : Fin n × Fin m → ℝ) : Face n m → ℝ := |
| fun z => z.elim 0 f |
|
|
| lemma eval_map {A B : Type*} (g : B → ℝ) (f : A → B) (z : Option A) : |
| (z.map f).elim 0 g = z.elim 0 (g ∘ f) := by cases z <;> rfl |
|
|
| lemma dual_horizontal {n m : ℕ} (f : Fin n × Fin m → ℝ) |
| (i : Fin n) (j : Fin (m + 1)) : |
| (dual n m).gradient (potential f) (.inl (i, j)) = |
| -∑ q, stepCoeff j q * f (i, q) := by |
| change ((upper j).map _).elim 0 f - ((lower j).map _).elim 0 f = _ |
| rw [eval_map, eval_map, upper_eval, lower_eval, sum_stepCoeff] |
| dsimp only [Function.comp_def] |
| ring |
|
|
| lemma dual_vertical {n m : ℕ} (f : Fin n × Fin m → ℝ) |
| (i : Fin (n + 1)) (j : Fin m) : |
| (dual n m).gradient (potential f) (.inr (i, j)) = |
| ∑ p, stepCoeff i p * f (p, j) := by |
| change ((lower i).map _).elim 0 f - ((upper i).map _).elim 0 f = _ |
| rw [eval_map, eval_map, upper_eval, lower_eval, sum_stepCoeff] |
| rfl |
|
|
| lemma boundary_formula {n m : ℕ} (x : Edge n m → ℝ) (i : Fin (n + 1)) |
| (j : Fin (m + 1)) : |
| (primal n m).boundary x (i, j) = |
| (∑ p, stepCoeff i p * x (.inl (p, j))) + |
| (∑ q, stepCoeff j q * x (.inr (i, q))) := by |
| classical |
| rw [Network.boundary_apply, Fintype.sum_sum_type] |
| simp only [primal, Sum.elim_inl, Sum.elim_inr, Prod.mk.injEq, |
| Fintype.sum_prod_type, stepCoeff, sub_mul, ite_mul, one_mul, zero_mul, |
| Finset.sum_sub_distrib, ite_and] |
| simp |
|
|
| lemma orthogonal_potential (n m : ℕ) (f : Fin n × Fin m → ℝ) : |
| (primal n m).boundary ((dual n m).gradient (potential f)) = 0 := by |
| ext ⟨i, j⟩ |
| rw [boundary_formula] |
| simp only [dual_horizontal, dual_vertical, mul_neg, Finset.sum_neg_distrib, |
| Finset.mul_sum] |
| rw [Finset.sum_comm (f := fun q p => stepCoeff j q * (stepCoeff i p * f (p, q)))] |
| have he : (∑ p, ∑ q, stepCoeff j q * (stepCoeff i p * f (p, q))) = |
| ∑ p, ∑ q, stepCoeff i p * (stepCoeff j q * f (p, q)) := by |
| apply Finset.sum_congr rfl |
| intro p _ |
| apply Finset.sum_congr rfl |
| intro q _ |
| ring |
| rw [he] |
| exact neg_add_cancel _ |
|
|
| lemma orthogonal (n m : ℕ) (f : Face n m → ℝ) : |
| (primal n m).boundary ((dual n m).gradient f) = 0 := by |
| let g : Fin n × Fin m → ℝ := fun t => f (some t) - f none |
| have hf : f = potential g + (fun _ => f none) := by |
| ext z |
| cases z <;> simp [potential, g] |
| rw [hf, map_add, Network.gradient_const, add_zero] |
| exact orthogonal_potential n m g |
|
|
| lemma horizontal_adj {n m : ℕ} (i : Fin n) (j : Fin (m + 1)) : |
| (primal n m).graph.Adj (i.castSucc, j) (i.succ, j) := by |
| refine ⟨?_, .inl (i, j), Or.inl ⟨rfl, rfl⟩⟩ |
| intro h |
| have hh := congrArg (fun z : Vertex n m => z.1.val) h |
| simp only [Fin.val_castSucc, Fin.val_succ] at hh |
| omega |
|
|
| lemma vertical_adj {n m : ℕ} (i : Fin (n + 1)) (j : Fin m) : |
| (primal n m).graph.Adj (i, j.castSucc) (i, j.succ) := by |
| refine ⟨?_, .inr (i, j), Or.inl ⟨rfl, rfl⟩⟩ |
| intro h |
| have hh := congrArg (fun z : Vertex n m => z.2.val) h |
| simp only [Fin.val_castSucc, Fin.val_succ] at hh |
| omega |
|
|
| lemma primal_connected (n m : ℕ) : (primal n m).graph.Connected := by |
| apply (SimpleGraph.connected_iff_exists_forall_reachable _).mpr |
| refine ⟨(0, 0), ?_⟩ |
| rintro ⟨i, j⟩ |
| have hv : (primal n m).graph.Reachable (0, 0) (0, j) := by |
| induction j using Fin.induction with |
| | zero => exact .rfl |
| | succ j ih => exact ih.trans (vertical_adj (0 : Fin (n + 1)) j).reachable |
| have hh : (primal n m).graph.Reachable (0, j) (i, j) := by |
| induction i using Fin.induction with |
| | zero => exact .rfl |
| | succ i ih => exact ih.trans (horizontal_adj i j).reachable |
| exact hv.trans hh |
|
|
| lemma dual_connected (n m : ℕ) : (dual n m).graph.Connected := by |
| apply (SimpleGraph.connected_iff_exists_forall_reachable _).mpr |
| refine ⟨none, ?_⟩ |
| intro z |
| cases z with |
| | none => exact .rfl |
| | some z => |
| obtain ⟨i, j⟩ := z |
| cases n with |
| | zero => exact isEmptyElim i |
| | succ n => |
| induction i using Fin.induction with |
| | zero => |
| have h := ((dual (n + 1) m).edge_reachable (.inr (0, j))).symm |
| have hu : upper (0 : Fin (n + 2)) = some (0 : Fin (n + 1)) := by |
| change upper (0 : Fin (n + 1)).castSucc = _ |
| exact Fin.lastCases_castSucc _ |
| simpa only [dual, Sum.elim_inr, lower, Fin.cases_zero, hu, |
| Option.map_none, Option.map_some] using h |
| | succ i ih => |
| have h := ((dual (n + 1) m).edge_reachable (.inr (i.succ.castSucc, j))).symm |
| have hl : lower i.succ.castSucc = some i.castSucc := by |
| have he : i.succ.castSucc = i.castSucc.succ := by ext; rfl |
| rw [he] |
| simp [lower] |
| have hu : upper i.succ.castSucc = some i.succ := Fin.lastCases_castSucc _ |
| exact ih.trans (by |
| simpa only [dual, Sum.elim_inr, hl, hu, Option.map_some] using h) |
|
|
| theorem grid_duality (n m : ℕ) : (primal n m).Duality (dual n m) := by |
| apply Network.duality_of_orth_card (primal n m) (dual n m) |
| (primal_connected n m) (dual_connected n m) |
| · simp only [Vertex, Face, Edge, Fintype.card_prod, Fintype.card_fin, |
| Fintype.card_option, Fintype.card_sum] |
| ring |
| · exact orthogonal n m |
|
|
| end |
| end Barnette.RectangularDual |
|
|
| namespace Barnette.MinorModel |
| noncomputable section |
| open scoped Classical |
| variable {V W U : Type*} {G : SimpleGraph V} {H : SimpleGraph W} |
| {J : SimpleGraph U} [Fintype U] |
|
|
| def pullHost (M : MinorModel G H) (f : J ↪g H) |
| (hf : ∀ v, M.branch v ⊆ Set.range f) : MinorModel G J where |
| branch v := f ⁻¹' M.branch v |
| branch_finite _ := Set.toFinite _ |
| branch_connected v := by |
| let g : {x // f x ∈ M.branch v} → M.branch v := fun x => ⟨f x.val, x.property⟩ |
| have hg : Function.Bijective g := by |
| refine ⟨?_, ?_⟩ |
| · intro x y hxy |
| apply Subtype.ext |
| exact f.injective (congrArg Subtype.val hxy) |
| · intro y |
| obtain ⟨x, hx⟩ := hf v y.property |
| refine ⟨⟨x, hx ▸ y.property⟩, ?_⟩ |
| exact Subtype.ext hx |
| let e : J.induce (f ⁻¹' M.branch v) ≃g H.induce (M.branch v) := |
| { toEquiv := Equiv.ofBijective g hg |
| map_rel_iff' := by intro x y; exact f.map_rel_iff } |
| exact e.connected_iff.mpr (M.branch_connected v) |
| branches_disjoint v w hvw := (M.branches_disjoint v w hvw).preimage f |
| adjacency v w h := by |
| obtain ⟨a, ha, b, hb, hab⟩ := M.adjacency v w h |
| obtain ⟨a', rfl⟩ := hf v ha |
| obtain ⟨b', rfl⟩ := hf w hb |
| exact ⟨a', ha, b', hb, f.map_rel_iff.mp hab⟩ |
| end |
| end Barnette.MinorModel |
| |
| namespace Barnette.RectangularDual |
| noncomputable section |
| open scoped Classical |
| |
| lemma primal_adj_iff {n m : ℕ} (p q : Vertex n m) : |
| (primal n m).graph.Adj p q ↔ |
| ((p.1.val + 1 = q.1.val ∨ q.1.val + 1 = p.1.val) ∧ p.2 = q.2) ∨ |
| ((p.2.val + 1 = q.2.val ∨ q.2.val + 1 = p.2.val) ∧ p.1 = q.1) := by |
| constructor |
| · rintro ⟨_, e, he⟩ |
| rcases e with ⟨i, j⟩ | ⟨i, j⟩ <;> |
| rcases he with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> simp [primal] |
| · have hx (a b : Vertex n m) (h : a.1.val + 1 = b.1.val) (hj : a.2 = b.2) : |
| (primal n m).graph.Adj a b := by |
| have hi : a.1.val < n := by have := b.1.isLt; omega |
| refine ⟨?_, .inl (⟨a.1.val, hi⟩, a.2), Or.inl ⟨?_, ?_⟩⟩ |
| · intro he; have hh := congrArg (fun x : Vertex n m => x.1.val) he; omega |
| · apply Prod.ext <;> rfl |
| · apply Prod.ext |
| · apply Fin.ext; exact h |
| · exact hj |
| have hy (a b : Vertex n m) (h : a.2.val + 1 = b.2.val) (hi : a.1 = b.1) : |
| (primal n m).graph.Adj a b := by |
| have hj : a.2.val < m := by have := b.2.isLt; omega |
| refine ⟨?_, .inr (a.1, ⟨a.2.val, hj⟩), Or.inl ⟨?_, ?_⟩⟩ |
| · intro he; have hh := congrArg (fun x : Vertex n m => x.2.val) he; omega |
| · apply Prod.ext <;> rfl |
| · apply Prod.ext |
| · exact hi |
| · apply Fin.ext; exact h |
| rintro (⟨h | h, hj⟩ | ⟨h | h, hi⟩) |
| · exact hx p q h hj |
| · exact (hx q p h hj.symm).symm |
| · exact hy p q h hi |
| · exact (hy q p h hi.symm).symm |
| |
| def latticePoint (r : ℕ) (p : Vertex (2 * r) (2 * r)) : ℤ × ℤ := |
| ((p.1.val : ℤ) - r, (p.2.val : ℤ) - r) |
| |
| lemma latticePoint_injective (r : ℕ) : Function.Injective (latticePoint r) := by |
| intro p q h |
| have h₁ := congrArg Prod.fst h |
| have h₂ := congrArg Prod.snd h |
| dsimp [latticePoint] at h₁ h₂ |
| apply Prod.ext <;> apply Fin.ext <;> omega |
| |
| def latticeEmbedding (r : ℕ) : (primal (2 * r) (2 * r)).graph ↪g SquareGrid.graph where |
| toFun := latticePoint r |
| inj' := latticePoint_injective r |
| map_rel_iff' := by |
| intro p q |
| rw [primal_adj_iff] |
| change SquareGrid.graph.Adj (latticePoint r p) (latticePoint r q) ↔ _ |
| simp only [SquareGrid.graph, latticePoint, Fin.ext_iff] |
| omega |
| |
| lemma bounded_mem_range (r : ℕ) (z : ℤ × ℤ) |
| (h₁ : z.1.natAbs ≤ r) (h₂ : z.2.natAbs ≤ r) : |
| z ∈ Set.range (latticeEmbedding r) := by |
| have ha : z.1 ≤ (z.1.natAbs : ℤ) := Int.le_natAbs |
| have hb : -z.1 ≤ (z.1.natAbs : ℤ) := by simpa using (Int.le_natAbs (a := -z.1)) |
| have hc : z.2 ≤ (z.2.natAbs : ℤ) := Int.le_natAbs |
| have hd : -z.2 ≤ (z.2.natAbs : ℤ) := by simpa using (Int.le_natAbs (a := -z.2)) |
| refine ⟨(⟨(z.1 + r).toNat, ?_⟩, ⟨(z.2 + r).toNat, ?_⟩), ?_⟩ |
| · omega |
| · omega |
| · apply Prod.ext <;> dsimp [latticeEmbedding, latticePoint] <;> omega |
| |
| lemma finite_subset_box (s : Set (ℤ × ℤ)) (hs : s.Finite) : |
| ∃ r : ℕ, s ⊆ Set.range (latticeEmbedding r) := by |
| let r := ∑ z ∈ hs.toFinset, (z.1.natAbs + z.2.natAbs) |
| refine ⟨r, ?_⟩ |
| intro z hz |
| have hle : z.1.natAbs + z.2.natAbs ≤ r := |
| Finset.single_le_sum (f := fun z : ℤ × ℤ => z.1.natAbs + z.2.natAbs) |
| (fun _ _ => Nat.zero_le _) (hs.mem_toFinset.mpr hz) |
| exact bounded_mem_range r z (by omega) (by omega) |
| |
| theorem lattice_minor_in_rectangle {V : Type*} [Fintype V] {G : SimpleGraph V} |
| (M : MinorModel G SquareGrid.graph) : |
| ∃ r : ℕ, Nonempty (MinorModel G (primal (2 * r) (2 * r)).graph) := by |
| let s := ⋃ v, M.branch v |
| have hs : s.Finite := Set.finite_iUnion M.branch_finite |
| obtain ⟨r, hr⟩ := finite_subset_box s hs |
| refine ⟨r, ⟨M.pullHost (latticeEmbedding r) ?_⟩⟩ |
| intro v z hz |
| exact hr (Set.mem_iUnion.mpr ⟨v, hz⟩) |
| |
| end |
| end Barnette.RectangularDual |
| |
| end OAI |
| |
