| import OAI.Combinatorics.Automata.Model |
|
|
| namespace OAI |
|
|
| namespace OneWayLiveness |
|
|
| @[ext] structure Pairing (P : Type*) where |
| link : P → P → Prop |
| symm : ∀ {x y}, link x y → link y x |
| irrefl : ∀ x, ¬ link x x |
| unique : ∀ x, ∃! y, link x y |
|
|
| namespace Pairing |
| variable {P : Type*} (a : Pairing P) |
| noncomputable def mate (x : P) : P := (a.unique x).choose |
| lemma mate_link (x : P) : a.link x (a.mate x) := (a.unique x).choose_spec.1 |
| lemma eq_mate {x y : P} (h : a.link x y) : y = a.mate x := |
| (a.unique x).choose_spec.2 y h |
| lemma mate_involutive : Function.Involutive a.mate := by |
| intro x |
| exact (a.eq_mate (a.symm (a.mate_link x))).symm |
| lemma mate_ne (x : P) : a.mate x ≠ x := by |
| intro h |
| exact a.irrefl x (by simpa only [h] using a.mate_link x) |
| lemma link_iff (x y : P) : a.link x y ↔ a.mate x = y := |
| ⟨fun h => (a.eq_mate h).symm, fun h => h ▸ a.mate_link x⟩ |
| instance [Finite P] : Finite (Pairing P) := |
| Finite.of_injective Pairing.link (fun _ _ h => Pairing.ext h) |
| end Pairing |
|
|
|
|
| namespace Pairing |
| variable {P : Type*} (a : Pairing P) |
|
|
| / |
| def Compatible {C : Type*} (color : P → C) : Prop := |
| ∀ x y, a.link x y → color x = color y |
|
|
| / |
| def connected (x y : P) : Prop := x = y ∨ a.link x y |
|
|
| lemma connected_refl (x : P) : a.connected x x := Or.inl rfl |
| lemma connected_symm {x y : P} (h : a.connected x y) : a.connected y x := by |
| rcases h with h | h |
| · exact Or.inl h.symm |
| · exact Or.inr (a.symm h) |
| lemma connected_trans {x y z : P} (h : a.connected x y) (k : a.connected y z) : |
| a.connected x z := by |
| rcases h with rfl | h |
| · exact k |
| rcases k with rfl | k |
| · exact Or.inr h |
| exact Or.inl ((a.eq_mate (a.symm h)).trans (a.eq_mate k).symm) |
|
|
| noncomputable def testColor (x : P) (y : P) : Bool := by |
| classical |
| exact decide (a.connected x y) |
|
|
| @[simp] lemma testColor_self (x : P) : a.testColor x x = true := by |
| classical |
| simp [testColor, connected] |
|
|
| lemma compatible_testColor (x : P) : a.Compatible (a.testColor x) := by |
| classical |
| intro u v huv |
| apply Bool.eq_iff_iff.mpr |
| simp only [testColor, decide_eq_true_eq] |
| constructor |
| · intro h |
| exact a.connected_trans h (.inr huv) |
| · intro h |
| exact a.connected_trans h (.inr (a.symm huv)) |
|
|
| / |
| connectivity among one side of its ports. -/ |
| lemma eq_of_compatible {b : Pairing P} |
| (h : ∀ c : P → Bool, a.Compatible c ↔ b.Compatible c) : a = b := by |
| have sub : ∀ (a b : Pairing P), (∀ c : P → Bool, a.Compatible c → b.Compatible c) → |
| ∀ x y, b.link x y → a.link x y := by |
| intro a b hab x y hxy |
| have he := hab (a.testColor x) (a.compatible_testColor x) x y hxy |
| rw [a.testColor_self] at he |
| have hc : a.connected x y := by |
| simpa only [testColor, decide_eq_true_eq] using he.symm |
| rcases hc with heq | hc |
| · subst y |
| exact (b.irrefl x hxy).elim |
| · exact hc |
| apply Pairing.ext |
| funext x y |
| apply propext |
| exact ⟨sub b a (fun c => (h c).mpr) x y, sub a b (fun c => (h c).mp) x y⟩ |
|
|
| end Pairing |
|
|
| namespace FiniteWiring |
| open SimpleGraph |
| variable {V : Type*} [Fintype V] (G : SimpleGraph V) |
|
|
| / |
| The proof uses the degree-sum formula and the edge-count bound for a connected graph. -/ |
| lemma leaves_card_le_two [DecidableRel G.Adj] (hc : G.Connected) (hd : ∀ v, G.degree v ≤ 2) : |
| (Finset.univ.filter fun v => G.degree v = 1).card ≤ 2 := by |
| classical |
| have hb := hc.card_vert_le_card_edgeSet_add_one |
| rw [Nat.card_eq_fintype_card, Nat.card_eq_fintype_card, |
| ← G.edgeFinset_card] at hb |
| have hs : (∑ v, G.degree v) + (Finset.univ.filter fun v => G.degree v = 1).card ≤ |
| 2 * Fintype.card V := by |
| calc |
| _ = ∑ v, (G.degree v + if G.degree v = 1 then 1 else 0) := by |
| rw [Finset.sum_add_distrib] |
| simp |
| _ ≤ ∑ _v : V, 2 := Finset.sum_le_sum fun v _ => by |
| have := hd v |
| split_ifs <;> omega |
| _ = _ := by simp [Nat.mul_comm] |
| rw [G.sum_degrees_eq_twice_card_edges] at hs |
| omega |
|
|
| / |
| one other leaf. -/ |
| lemma unique_other_leaf [DecidableRel G.Adj] (hc : G.Connected) (hd : ∀ v, G.degree v ≤ 2) (x : V) (hx : G.degree x = 1) : |
| ∃! y : V, y ≠ x ∧ G.degree y = 1 := by |
| classical |
| have ho : Odd (G.degree x) := by simp [hx] |
| obtain ⟨y, hyx, hyodd⟩ := G.exists_ne_odd_degree_of_exists_odd_degree x ho |
| have hy : G.degree y = 1 := by |
| have := hd y |
| obtain ⟨k, hk⟩ := hyodd |
| omega |
| refine ⟨y, ⟨hyx, hy⟩, ?_⟩ |
| intro z hz |
| by_contra hzy |
| have hsub : ({x, y, z} : Finset V) ⊆ Finset.univ.filter (fun v => G.degree v = 1) := by |
| intro v hv |
| simp only [Finset.mem_insert, Finset.mem_singleton] at hv |
| rcases hv with rfl | rfl | rfl <;> simp [hx, hy, hz.2] |
| have hnum := Finset.card_le_card hsub |
| have hbound := leaves_card_le_two G hc hd |
| have hthree : ({x, y, z} : Finset V).card = 3 := by |
| simp [Ne.symm hyx, Ne.symm hz.1, Ne.symm hzy] |
| omega |
|
|
| / |
| lemma component_degree [DecidableRel G.Adj] |
| (C : G.ConnectedComponent) [Fintype C] [DecidableRel C.toSimpleGraph.Adj] (v : C) : |
| C.toSimpleGraph.degree v = G.degree v.val := by |
| classical |
| rw [← card_neighborSet_eq_degree, ← card_neighborSet_eq_degree] |
| apply Fintype.card_congr |
| refine { |
| toFun := fun w => ⟨w.val.val, w.property⟩ |
| invFun := fun w => ⟨⟨w.val, (C.mem_supp_congr_adj w.property).mp v.property⟩, w.property⟩ |
| left_inv := ?_ |
| right_inv := ?_ } |
| · intro w; rfl |
| · intro w; rfl |
|
|
| / |
| when other connected components are cycles. -/ |
| lemma unique_reachable_leaf [DecidableRel G.Adj] |
| (hd : ∀ v, G.degree v ≤ 2) (x : V) (hx : G.degree x = 1) : |
| ∃! y : V, y ≠ x ∧ G.degree y = 1 ∧ G.Reachable x y := by |
| classical |
| let C := G.connectedComponentMk x |
| let xc : C := ⟨x, rfl⟩ |
| have hdc : ∀ v : C, C.toSimpleGraph.degree v ≤ 2 := by |
| intro v |
| rw [component_degree G C] |
| exact hd v.val |
| have hxc : C.toSimpleGraph.degree xc = 1 := by |
| rw [component_degree G C] |
| exact hx |
| obtain ⟨y, hy, hu⟩ := unique_other_leaf C.toSimpleGraph C.connected_toSimpleGraph hdc xc hxc |
| refine ⟨y.val, ⟨?_, ?_, ?_⟩, ?_⟩ |
| · intro he |
| apply hy.1 |
| exact Subtype.ext he |
| · rw [component_degree G C] at hy |
| exact hy.2 |
| · exact (ConnectedComponent.exact y.property).symm |
| · intro z hz |
| let zc : C := ⟨z, ConnectedComponent.sound hz.2.2.symm⟩ |
| have hzc : zc ≠ xc ∧ C.toSimpleGraph.degree zc = 1 := by |
| constructor |
| · intro he; exact hz.1 (congrArg Subtype.val he) |
| · rw [component_degree G C]; exact hz.2.1 |
| exact congrArg Subtype.val (hu zc hzc) |
|
|
| / |
| are precisely degree one at the exposed ports and degree zero or two |
| elsewhere. Closed components disappear. -/ |
| noncomputable def boundaryPairing {P : Type*} (port : P ↪ V) |
| [DecidableRel G.Adj] (hd : ∀ v, G.degree v ≤ 2) |
| (hb : ∀ v, G.degree v = 1 ↔ ∃ p, port p = v) : Pairing P where |
| link x y := x ≠ y ∧ G.Reachable (port x) (port y) |
| symm h := ⟨Ne.symm h.1, h.2.symm⟩ |
| irrefl x h := h.1 rfl |
| unique x := by |
| classical |
| obtain ⟨v, hv, hu⟩ := unique_reachable_leaf G hd (port x) ((hb _).mpr ⟨x, rfl⟩) |
| obtain ⟨y, rfl⟩ := (hb v).mp hv.2.1 |
| refine ⟨y, ⟨?_, hv.2.2⟩, ?_⟩ |
| · intro h; exact hv.1 (congrArg port h.symm) |
| · intro z hz |
| apply port.injective |
| apply hu |
| refine ⟨?_, (hb _).mpr ⟨z, rfl⟩, hz.2⟩ |
| intro he; exact hz.1 (port.injective he).symm |
|
|
|
|
| omit [Fintype V] in |
| / |
| lemma color_eq_of_reachable {C : Type*} (color : V → C) |
| (hc : ∀ x y, G.Adj x y → color x = color y) {x y : V} |
| (h : G.Reachable x y) : color x = color y := by |
| obtain ⟨p⟩ := h |
| induction p with |
| | nil => rfl |
| | @cons x y z h p ih => exact (hc x y h).trans ih |
|
|
| / |
| justifies replacing a cell's wiring by its boundary matching. -/ |
| lemma coloring_extension {P : Type*} (port : P ↪ V) |
| [DecidableRel G.Adj] (hd : ∀ v, G.degree v ≤ 2) |
| (hb : ∀ v, G.degree v = 1 ↔ ∃ p, port p = v) (color : P → Bool) : |
| (boundaryPairing G port hd hb).Compatible color ↔ |
| ∃ c : V → Bool, (∀ p, c (port p) = color p) ∧ |
| ∀ x y, G.Adj x y → c x = c y := by |
| classical |
| constructor |
| · intro hc |
| have heq {p q : P} (h : G.Reachable (port p) (port q)) : color p = color q := by |
| by_cases hpq : p = q |
| · exact congrArg color hpq |
| · exact hc p q ⟨hpq, h⟩ |
| let touches (v : V) : Prop := ∃ p, G.Reachable v (port p) |
| let c : V → Bool := fun v => if h : touches v then color h.choose else false |
| have hc_at (v : V) (p : P) (hv : G.Reachable v (port p)) : c v = color p := by |
| have ht : touches v := ⟨p, hv⟩ |
| dsimp [c] |
| rw [dite_eq_left ht] |
| exact heq (ht.choose_spec.symm.trans hv) |
| refine ⟨c, ?_, ?_⟩ |
| · intro p |
| exact hc_at (port p) p (.refl _) |
| · intro x y hxy |
| by_cases ht : touches x |
| · obtain ⟨p, hp⟩ := ht |
| exact (hc_at x p hp).trans (hc_at y p (hxy.reachable.symm.trans hp)).symm |
| · have hty : ¬ touches y := by |
| intro hy |
| obtain ⟨p, hp⟩ := hy |
| exact ht ⟨p, hxy.reachable.trans hp⟩ |
| simp [c, ht, hty] |
| · rintro ⟨c, hp, hc⟩ x y hxy |
| have he := color_eq_of_reachable G c hc hxy.2 |
| simpa only [hp] using he |
|
|
|
|
| end FiniteWiring |
|
|
| namespace Pairing |
| variable {A B C : Type*} |
|
|
| private def glueAdj (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) : |
| ((A ⊕ B) ⊕ (B ⊕ C)) → ((A ⊕ B) ⊕ (B ⊕ C)) → Prop |
| | .inl x, .inl y => a.link x y |
| | .inr x, .inr y => b.link x y |
| | .inl (.inr i), .inr (.inl j) => i = j |
| | .inr (.inl j), .inl (.inr i) => i = j |
| | _, _ => False |
|
|
| / |
| This subdivision avoids parallel edges without changing boundary paths. -/ |
| def glueGraph (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) : SimpleGraph ((A ⊕ B) ⊕ (B ⊕ C)) where |
| Adj := glueAdj a b |
| symm := ⟨by |
| intro v w h |
| rcases v with (v | v) | (v | v) <;> |
| rcases w with (w | w) | (w | w) <;> |
| simp only [glueAdj] at h ⊢ |
| all_goals first | exact a.symm h | exact b.symm h | exact h⟩ |
| loopless := ⟨by |
| intro v |
| rcases v with (v | v) | (v | v) <;> |
| simp only [glueAdj] |
| all_goals first | exact a.irrefl _ | exact b.irrefl _⟩ |
|
|
| def outer : (A ⊕ C) ↪ ((A ⊕ B) ⊕ (B ⊕ C)) where |
| toFun |
| | .inl i => .inl (.inl i) |
| | .inr i => .inr (.inr i) |
| inj' := by |
| intro v w h |
| rcases v with v | v <;> rcases w with w | w <;> simp_all |
|
|
| noncomputable instance glueDec (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) : |
| DecidableRel (glueGraph a b).Adj := Classical.decRel _ |
|
|
| variable [Fintype A] [Fintype B] [Fintype C] (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) |
|
|
| lemma glue_degree_LL (i : A) : (glueGraph a b).degree (.inl (.inl i)) = 1 := by |
| classical |
| have hn : (glueGraph a b).neighborFinset (.inl (.inl i)) = |
| {Sum.inl (a.mate (.inl i))} := by |
| ext w |
| rw [SimpleGraph.mem_neighborFinset] |
| change glueAdj a b _ w ↔ _ |
| rcases w with (w | w) | (w | w) <;> |
| simp [glueAdj, link_iff, eq_comm] |
| simp only [SimpleGraph.degree, hn, Finset.card_singleton] |
|
|
| lemma glue_degree_RR (i : C) : (glueGraph a b).degree (.inr (.inr i)) = 1 := by |
| classical |
| have hn : (glueGraph a b).neighborFinset (.inr (.inr i)) = |
| {Sum.inr (b.mate (.inr i))} := by |
| ext w |
| rw [SimpleGraph.mem_neighborFinset] |
| change glueAdj a b _ w ↔ _ |
| rcases w with (w | w) | (w | w) <;> |
| simp [glueAdj, link_iff, eq_comm] |
| simp only [SimpleGraph.degree, hn, Finset.card_singleton] |
|
|
| lemma glue_degree_LR (i : B) : (glueGraph a b).degree (.inl (.inr i)) = 2 := by |
| classical |
| have hn : (glueGraph a b).neighborFinset (.inl (.inr i)) = |
| {Sum.inl (a.mate (.inr i)), Sum.inr (Sum.inl i)} := by |
| ext w |
| rw [SimpleGraph.mem_neighborFinset] |
| change glueAdj a b _ w ↔ _ |
| rcases w with (w | w) | (w | w) <;> |
| simp [glueAdj, link_iff, eq_comm] |
| simp [SimpleGraph.degree, hn] |
|
|
| lemma glue_degree_RL (i : B) : (glueGraph a b).degree (.inr (.inl i)) = 2 := by |
| classical |
| have hn : (glueGraph a b).neighborFinset (.inr (.inl i)) = |
| {Sum.inr (b.mate (.inl i)), Sum.inl (Sum.inr i)} := by |
| ext w |
| rw [SimpleGraph.mem_neighborFinset] |
| change glueAdj a b _ w ↔ _ |
| rcases w with (w | w) | (w | w) <;> |
| simp [glueAdj, link_iff, eq_comm] |
| simp [SimpleGraph.degree, hn] |
|
|
| lemma glue_degree_le_two (v) : (glueGraph a b).degree v ≤ 2 := by |
| classical |
| rcases v with (v | v) | (v | v) |
| · simp [glue_degree_LL] |
| · simp [glue_degree_LR] |
| · simp [glue_degree_RL] |
| · simp [glue_degree_RR] |
|
|
| lemma glue_boundary (v) : (glueGraph a b).degree v = 1 ↔ ∃ p, outer p = v := by |
| classical |
| rcases v with (v | v) | (v | v) |
| · simp only [glue_degree_LL, true_iff] |
| exact ⟨.inl v, rfl⟩ |
| · simp only [glue_degree_LR, OfNat.ofNat_ne_one, false_iff, not_exists] |
| intro p |
| cases p <;> intro h <;> cases h |
| · simp only [glue_degree_RL, OfNat.ofNat_ne_one, false_iff, not_exists] |
| intro p |
| cases p <;> intro h <;> cases h |
| · simp only [glue_degree_RR, true_iff] |
| exact ⟨.inr v, rfl⟩ |
|
|
| noncomputable def compose : Pairing (A ⊕ C) := by |
| classical |
| exact FiniteWiring.boundaryPairing (glueGraph a b) outer |
| (glue_degree_le_two a b) (glue_boundary a b) |
|
|
| / |
| lemma compose_compatible (f : A → Bool) (g : C → Bool) : |
| (compose a b).Compatible (Sum.elim f g) ↔ |
| ∃ k : B → Bool, a.Compatible (Sum.elim f k) ∧ b.Compatible (Sum.elim k g) := by |
| classical |
| rw [compose, FiniteWiring.coloring_extension] |
| constructor |
| · rintro ⟨c, hc, he⟩ |
| let k : B → Bool := fun i => c (.inl (.inr i)) |
| have hk (i : B) : c (.inl (.inr i)) = c (.inr (.inl i)) := |
| he _ _ (show (glueGraph a b).Adj (.inl (.inr i)) (.inr (.inl i)) from rfl) |
| have hl (i : A) : c (.inl (.inl i)) = f i := hc (.inl i) |
| have hr (i : C) : c (.inr (.inr i)) = g i := hc (.inr i) |
| refine ⟨k, ?_, ?_⟩ |
| · intro x y hxy |
| have hh := he (.inl x) (.inl y) hxy |
| rcases x with x | x <;> rcases y with y | y <;> |
| simpa only [hl, Sum.elim_inl, Sum.elim_inr] using hh |
| · intro x y hxy |
| have hh := he (.inr x) (.inr y) hxy |
| rcases x with x | x <;> rcases y with y | y <;> |
| simpa only [← hk, hr, Sum.elim_inl, Sum.elim_inr] using hh |
| · rintro ⟨k, hk₁, hk₂⟩ |
| refine ⟨Sum.elim (Sum.elim f k) (Sum.elim k g), ?_, ?_⟩ |
| · intro p; cases p <;> rfl |
| · intro x y hxy |
| rcases x with (x | x) | (x | x) <;> |
| rcases y with (y | y) | (y | y) <;> |
| simp only [glueGraph, glueAdj] at hxy |
| all_goals first |
| | exact hk₁ _ _ hxy |
| | exact hk₂ _ _ hxy |
| | exact congrArg k hxy |
| | exact congrArg k hxy.symm |
|
|
| end Pairing |
|
|
|
|
| namespace Pairing |
| variable {P Q : Type*} |
|
|
| def ofInvolution (f : P → P) (hf : Function.Involutive f) (hn : ∀ p, f p ≠ p) : Pairing P where |
| link x y := f x = y |
| symm {x y} h := by rw [← h, hf] |
| irrefl x := hn x |
| unique x := ⟨f x, rfl, fun _ h => h.symm⟩ |
|
|
| def transport (a : Pairing P) (e : P ≃ Q) : Pairing Q where |
| link x y := a.link (e.symm x) (e.symm y) |
| symm := a.symm |
| irrefl x := a.irrefl _ |
| unique x := by |
| obtain ⟨y, hy, hu⟩ := a.unique (e.symm x) |
| refine ⟨e y, ?_, ?_⟩ |
| · simpa using hy |
| · intro z hz |
| exact (e.symm.injective (by simpa using hu (e.symm z) hz)) |
|
|
| variable {A B C D : Type*} |
|
|
| / |
| renumbering finite port sets without changing the underlying diagram. -/ |
| def bijection (e : A ≃ B) : Pairing (A ⊕ B) := |
| ofInvolution (Sum.elim (Sum.inr ∘ e) (Sum.inl ∘ e.symm)) |
| (by intro x; cases x <;> simp) (by intro x; cases x <;> simp) |
|
|
| def identity (A : Type*) : Pairing (A ⊕ A) := bijection (Equiv.refl A) |
|
|
| lemma bijection_compatible (e : A ≃ B) (f : A → Bool) (g : B → Bool) : |
| (bijection e).Compatible (Sum.elim f g) ↔ ∀ x, f x = g (e x) := by |
| constructor |
| · intro h x |
| exact h (.inl x) (.inr (e x)) rfl |
| · intro h x y hxy |
| rcases x with x | x <;> rcases y with y | y |
| · cases hxy |
| · change Sum.inr (e x) = Sum.inr y at hxy |
| cases hxy |
| exact h x |
| · change Sum.inl (e.symm x) = Sum.inl y at hxy |
| cases hxy |
| simpa using (h (e.symm x)).symm |
| · cases hxy |
|
|
| lemma identity_compatible (f g : A → Bool) : |
| (identity A).Compatible (Sum.elim f g) ↔ f = g := by |
| rw [identity, bijection_compatible] |
| exact funext_iff.symm |
|
|
| lemma ext_colors {a b : Pairing (A ⊕ B)} |
| (h : ∀ f : A → Bool, ∀ g : B → Bool, |
| a.Compatible (Sum.elim f g) ↔ b.Compatible (Sum.elim f g)) : a = b := by |
| apply a.eq_of_compatible |
| intro c |
| have hc : Sum.elim (fun i => c (.inl i)) (fun i => c (.inr i)) = c := by |
| funext p; cases p <;> rfl |
| simpa only [hc] using h (fun i => c (.inl i)) (fun i => c (.inr i)) |
|
|
| / |
| lemma connected_of_color_eq (a : Pairing P) (x y : P) |
| (h : ∀ c : P → Bool, a.Compatible c → c x = c y) : a.connected x y := by |
| have he := h (a.testColor x) (a.compatible_testColor x) |
| rw [testColor_self] at he |
| simpa only [testColor, decide_eq_true_eq] using he.symm |
|
|
| lemma link_of_color_eq (a : Pairing P) {x y : P} (hne : x ≠ y) |
| (h : ∀ c : P → Bool, a.Compatible c → c x = c y) : a.link x y := |
| (a.connected_of_color_eq x y h).resolve_left hne |
|
|
| variable [Fintype A] [Fintype B] [Fintype C] [Fintype D] |
|
|
| lemma compose_assoc (a : Pairing (A ⊕ B)) (b : Pairing (B ⊕ C)) |
| (c : Pairing (C ⊕ D)) : compose (compose a b) c = compose a (compose b c) := by |
| apply ext_colors |
| intro f g |
| simp only [compose_compatible] |
| aesop |
|
|
| lemma identity_compose (a : Pairing (A ⊕ B)) : compose (identity A) a = a := by |
| apply ext_colors |
| intro f g |
| simp [compose_compatible, identity_compatible] |
|
|
| lemma compose_identity (a : Pairing (A ⊕ B)) : compose a (identity B) = a := by |
| apply ext_colors |
| intro f g |
| simp [compose_compatible, identity_compatible] |
|
|
| end Pairing |
|
|
| end OneWayLiveness |
|
|
| end OAI |
|
|
