| import OAI.Combinatorics.Automata.Model |
|
|
| namespace OAI |
|
|
| namespace OneWayLiveness |
|
|
| / |
| When there is only one entrance, its entrance dart lies on the same tour. -/ |
| lemma permutation_single_entrance {D : Type*} [Finite D] (τ : Equiv.Perm D) |
| (U : Set D) (a b : D) (ha : a ∈ U) (ha' : τ a ∉ U) |
| (hin : ∀ d, d ∉ U → τ d ∈ U → d = b) : τ.SameCycle a b := by |
| classical |
| by_contra hb |
| let S : Set D := {d | τ.SameCycle a d ∧ d ∉ U} |
| have hm : Set.MapsTo τ S S := by |
| rintro d ⟨hd, hdu⟩ |
| refine ⟨by simpa using hd, ?_⟩ |
| intro hτd |
| exact hb (hin d hdu hτd ▸ hd) |
| have hbij := (Set.toFinite S).injOn_iff_bijOn_of_mapsTo hm |>.mp τ.injective.injOn |
| obtain ⟨c, hc, he⟩ := hbij.surjOn ⟨by simpa using (Equiv.Perm.SameCycle.refl τ a), ha'⟩ |
| have hca : c = a := τ.injective he |
| exact hc.2 (hca ▸ ha) |
|
|
| / |
| structure CyclicOrder {D V : Type*} (vertex : D → V) where |
| perm : Equiv.Perm D |
| vertex_eq : ∀ d, vertex (perm d) = vertex d |
| cyclic : ∀ d d', vertex d = vertex d' → perm.SameCycle d d' |
|
|
| noncomputable def CyclicOrder.choose {D V : Type*} [Fintype D] (vertex : D → V) : |
| CyclicOrder vertex := by |
| classical |
| have hex (v : V) := (Finset.univ.filter fun d => vertex d = v).exists_cycleOn |
| choose p hp _hps using hex |
| have hpres (v : V) (d : D) (hd : vertex d = v) : vertex (p v d) = v := by |
| have := (hp v).1.mapsTo (by simpa using hd) |
| simpa using this |
| have hinv (v : V) (d : D) (hd : vertex d = v) : vertex ((p v).symm d) = v := by |
| have := (hp v).1.perm_inv.mapsTo (by simpa using hd) |
| simpa using this |
| let τ : Equiv.Perm D := { |
| toFun d := p (vertex d) d |
| invFun d := (p (vertex d)).symm d |
| left_inv d := by simp only [hpres _ _ rfl]; exact (p (vertex d)).symm_apply_apply d |
| right_inv d := by simp only [hinv _ _ rfl]; exact (p (vertex d)).apply_symm_apply d } |
| refine ⟨τ, fun d => hpres _ _ rfl, ?_⟩ |
| intro d d' hdd' |
| have hc : (p (vertex d)).SameCycle d d' := |
| (hp (vertex d)).2 (by simp) (by simpa using hdd'.symm) |
| obtain ⟨n, hn⟩ := hc.exists_nat_pow_eq |
| have hpow : ∀ n : ℕ, (τ ^ n) d = (p (vertex d) ^ n) d ∧ vertex ((τ ^ n) d) = vertex d := by |
| intro n |
| induction n with |
| | zero => exact ⟨rfl, rfl⟩ |
| | succ n ih => |
| simp only [pow_succ', Equiv.Perm.mul_apply] |
| constructor |
| · change p (vertex ((τ ^ n) d)) ((τ ^ n) d) = _ |
| rw [ih.2, ih.1] |
| · exact (hpres _ _ rfl).trans ih.2 |
| exact ⟨n, by simpa only [zpow_natCast, (hpow n).1] using hn⟩ |
|
|
| lemma sameCycle_permCongr {D D' : Type*} (e : D ≃ D') (τ : Equiv.Perm D) |
| {d d' : D} (h : τ.SameCycle d d') : (e.permCongrHom τ).SameCycle (e d) (e d') := by |
| obtain ⟨n, hn⟩ := h |
| refine ⟨n, ?_⟩ |
| rw [← map_zpow] |
| change e ((τ ^ n) (e.symm (e d))) = e d' |
| simpa only [Equiv.symm_apply_apply] using congrArg e hn |
|
|
| / |
| edges are permitted a priori; the source map nevertheless is injective. -/ |
| structure FunctionalEdges (V E : Type*) where |
| src : E → V |
| dst : E → V |
| src_injective : Function.Injective src |
|
|
| namespace FunctionalEdges |
| variable {V E : Type*} (G : FunctionalEdges V E) |
| def Step (v w : V) : Prop := ∃ e, G.src e = v ∧ G.dst e = w |
| abbrev Reach := Relation.ReflTransGen G.Step |
| lemma deterministic {v w z : V} (h : G.Step v w) (h' : G.Step v z) : w = z := by |
| obtain ⟨e, hs, hd⟩ := h |
| obtain ⟨e', hs', hd'⟩ := h' |
| have he : e = e' := G.src_injective (hs.trans hs'.symm) |
| exact hd.symm.trans (he ▸ hd') |
|
|
| lemma reach_of_terminal {t v : V} (ht : ∀ e, G.src e ≠ t) (h : G.Reach t v) : t = v := by |
| rcases h.cases_head with h | ⟨w, ⟨e, he, _⟩, _⟩ |
| · exact h |
| · exact (ht e he).elim |
|
|
| lemma successor_reaches {t v w : V} (ht : ∀ e, G.src e ≠ t) |
| (hv : G.Reach v t) (hvw : G.Step v w) : G.Reach w t := by |
| rcases hv.cases_head with rfl | ⟨z, hvz, hzt⟩ |
| · obtain ⟨e, he, _⟩ := hvw |
| exact (ht e he).elim |
| · exact G.deterministic hvw hvz ▸ hzt |
|
|
| lemma edge_cut {e f : E} (hne : f ≠ e) : |
| G.Reach (G.src f) (G.src e) ↔ G.Reach (G.dst f) (G.src e) := by |
| constructor |
| · intro h |
| rcases h.cases_head with heq | ⟨v, hfv, hve⟩ |
| · exact (hne (G.src_injective heq)).elim |
| · have heq : G.dst f = v := G.deterministic ⟨f, rfl, rfl⟩ hfv |
| exact heq ▸ hve |
| · exact fun h => h.head ⟨f, rfl, rfl⟩ |
|
|
| lemma edge_not_return {t : V} (ht : ∀ e, G.src e ≠ t) (e : E) |
| (h : G.Reach (G.src e) t) : ¬ G.Reach (G.dst e) (G.src e) := by |
| intro he |
| have closed {v w : V} (hv : G.Reach v (G.src e)) (hvw : G.Step v w) : |
| G.Reach w (G.src e) := by |
| rcases hv.cases_head with rfl | ⟨z, hvz, hze⟩ |
| · have this := G.deterministic hvw (show G.Step (G.src e) (G.dst e) from ⟨e, rfl, rfl⟩) |
| simpa [this] using he |
| · exact G.deterministic hvw hvz ▸ hze |
| have hh : G.Reach t (G.src e) := by |
| clear ht |
| induction h with |
| | refl => exact .refl |
| | tail _ hvw ih => exact closed ih hvw |
| exact ht e (G.reach_of_terminal ht hh).symm |
|
|
| abbrev Dart := E × Bool |
|
|
| def flip (_G : FunctionalEdges V E) : Equiv.Perm (E × Bool) where |
| toFun d := (d.1, !d.2) |
| invFun d := (d.1, !d.2) |
| left_inv d := by simp |
| right_inv d := by simp |
|
|
| def vertex (d : E × Bool) : V := if d.2 then G.dst d.1 else G.src d.1 |
|
|
| @[simp] lemma vertex_false (e : E) : G.vertex (e, false) = G.src e := rfl |
| @[simp] lemma vertex_true (e : E) : G.vertex (e, true) = G.dst e := rfl |
| @[simp] lemma flip_apply (d : E × Bool) : G.flip d = (d.1, !d.2) := rfl |
|
|
| / |
| abbrev Rotation := CyclicOrder G.vertex |
|
|
| namespace Rotation |
| variable {G} (R : G.Rotation) |
| def tour : Equiv.Perm (E × Bool) := R.perm * G.flip |
|
|
| lemma tour_vertex (d : E × Bool) : G.vertex (R.tour d) = G.vertex (G.flip d) := R.vertex_eq _ |
|
|
| lemma edge_sameCycle [Finite E] {t : V} (ht : ∀ e, G.src e ≠ t) (e : E) |
| (h : G.Reach (G.src e) t) : R.tour.SameCycle (e, false) (e, true) := by |
| let U : Set (E × Bool) := {d | G.Reach (G.vertex d) (G.src e)} |
| have hae : (e, false) ∈ U := Relation.ReflTransGen.refl |
| have hae' : R.tour (e, false) ∉ U := by |
| change ¬ G.Reach (G.vertex (R.tour (e, false))) (G.src e) |
| rw [R.tour_vertex] |
| exact G.edge_not_return ht e h |
| apply permutation_single_entrance R.tour U (e, false) (e, true) hae hae' |
| rintro ⟨f, b⟩ ho hi |
| change G.Reach (G.vertex (R.tour (f,b))) (G.src e) at hi |
| rw [R.tour_vertex] at hi |
| cases b with |
| | false => exact (ho (hi.head ⟨f, rfl, rfl⟩)).elim |
| | true => |
| have hfe : f = e := by |
| by_contra hne |
| exact ho ((G.edge_cut hne).mp hi) |
| exact Prod.ext hfe rfl |
|
|
| @[simp] lemma tour_flip (d : E × Bool) : R.tour (G.flip d) = R.perm d := by |
| rcases d with ⟨e, b⟩ |
| simp [tour, flip] |
|
|
| lemma flip_sameCycle [Finite E] {t : V} (ht : ∀ e, G.src e ≠ t) (d : E × Bool) |
| (hd : G.Reach (G.vertex d) t) : R.tour.SameCycle d (G.flip d) := by |
| rcases d with ⟨e, b⟩ |
| cases b with |
| | false => exact R.edge_sameCycle ht e hd |
| | true => exact (R.edge_sameCycle ht e (hd.head ⟨e, rfl, rfl⟩)).symm |
|
|
| lemma perm_sameCycle [Finite E] {t : V} (ht : ∀ e, G.src e ≠ t) (d : E × Bool) |
| (hd : G.Reach (G.vertex d) t) : R.tour.SameCycle d (R.perm d) := by |
| simpa only [tour_flip] using (R.flip_sameCycle ht d hd).apply_right |
|
|
| lemma vertex_pow (n : ℕ) (d : E × Bool) : G.vertex ((R.perm ^ n) d) = G.vertex d := by |
| induction n with |
| | zero => rfl |
| | succ n ih => simpa only [pow_succ', Equiv.Perm.mul_apply, R.vertex_eq] using ih |
|
|
| lemma vertex_sameCycle [Finite E] {t : V} (ht : ∀ e, G.src e ≠ t) (d d' : E × Bool) |
| (hd : G.Reach (G.vertex d) t) (he : G.vertex d = G.vertex d') : |
| R.tour.SameCycle d d' := by |
| obtain ⟨n, rfl⟩ := (R.cyclic d d' he).exists_nat_pow_eq |
| clear he |
| induction n with |
| | zero => exact .refl _ _ |
| | succ n ih => |
| rw [pow_succ', Equiv.Perm.mul_apply] |
| exact ih.trans (R.perm_sameCycle ht _ (by simpa only [R.vertex_pow] using hd)) |
|
|
| lemma reach_sameCycle [Finite E] {t : V} (ht : ∀ e, G.src e ≠ t) (d d' : E × Bool) |
| (h : G.Reach (G.vertex d) (G.vertex d')) (ht' : G.Reach (G.vertex d') t) : |
| R.tour.SameCycle d d' := by |
| have aux : ∀ v, G.Reach v (G.vertex d') → ∀ u : E × Bool, |
| G.vertex u = v → R.tour.SameCycle u d' := by |
| intro v hv |
| induction hv using Relation.ReflTransGen.head_induction_on with |
| | refl => |
| intro u hu |
| exact R.vertex_sameCycle ht u d' (hu ▸ ht') hu |
| | @head a b hab hbe ih => |
| intro u hu |
| obtain ⟨e, hs, he⟩ := hab |
| have hae : G.Reach (G.src e) t := hs ▸ (hbe.head ⟨e, hs, he⟩).trans ht' |
| exact (R.vertex_sameCycle ht u (e, false) (hu ▸ hs ▸ hae) (hu.trans hs.symm)).trans |
| ((R.edge_sameCycle ht e hae).trans (ih (e, true) he)) |
| exact aux _ h d rfl |
|
|
| / |
| lemma basin_sameCycle [Finite E] {t : V} (ht : ∀ e, G.src e ≠ t) (d d' r : E × Bool) |
| (hd : G.Reach (G.vertex d) t) (hd' : G.Reach (G.vertex d') t) |
| (hr : G.vertex r = t) : R.tour.SameCycle d d' := by |
| exact (R.reach_sameCycle ht d r (hr ▸ hd) (hr ▸ .refl)).trans |
| (R.reach_sameCycle ht d' r (hr ▸ hd') (hr ▸ .refl)).symm |
|
|
| lemma color_eq_of_sameCycle {D C : Type*} [Finite D] (τ : Equiv.Perm D) |
| (color : D → C) (hc : ∀ d, color (τ d) = color d) |
| {d d' : D} (h : τ.SameCycle d d') : color d = color d' := by |
| obtain ⟨n, rfl⟩ := h.exists_nat_pow_eq |
| clear h |
| induction n with |
| | zero => rfl |
| | succ n ih => simpa only [pow_succ', Equiv.Perm.mul_apply, hc] using ih |
|
|
| end Rotation |
| end FunctionalEdges |
| end OneWayLiveness |
|
|
| end OAI |
|
|
