math / data /lean /OAI /Combinatorics /Automata /Network.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
16.6 kB
import OAI.Combinatorics.Automata.Cells
import OAI.Combinatorics.Automata.Tours
import OAI.Combinatorics.Automata.Normalization
namespace OAI
namespace OneWayLiveness
namespace CellNetwork
variable (Q : Type)
/-- Edges of all crossing and stay candidates, together with all outward
slots. Every outward slot is an edge to its own external leaf. -/
abbrev Edge (n : ℕ) := (Fin (n + 1) × Slot Q) ⊕
((Fin (n + 2) × (Q × Q)) ⊕ (Bool × Slot Q))
abbrev WholeInc (n : ℕ) := (Fin (n + 2) × Incidence Q) ⊕ (Bool × Slot Q)
def outCell (n : ℕ) (s : Bool) : Fin (n + 2) :=
if s then ⟨n + 1, by omega⟩ else ⟨0, by omega⟩
/-- Locate an oriented incidence in its cell, or at its external leaf. -/
def edgeInc (n : ℕ) : Edge Q n × Bool → WholeInc Q n
| (.inl (j,slot),b) =>
if slot.1 ^^ b then .inl (j.castSucc, .inl (true,slot))
else .inl (j.succ, .inl (false,slot))
| (.inr (.inl (i,pq)),b) => .inl (i,.inr (pq,b))
| (.inr (.inr (s,slot)),b) =>
if b then .inl (outCell n s,.inl (s,slot)) else .inr (s,slot)
def incEdge (n : ℕ) : WholeInc Q n → Edge Q n × Bool
| .inl (i,.inl (false,slot)) =>
if h : i.val = 0 then (.inr (.inr (false,slot)),true)
else (.inl (⟨i.val - 1, by omega⟩,slot),slot.1)
| .inl (i,.inl (true,slot)) =>
if h : i.val = n + 1 then (.inr (.inr (true,slot)),true)
else (.inl (⟨i.val, by omega⟩,slot),!slot.1)
| .inl (i,.inr (pq,b)) => (.inr (.inl (i,pq)),b)
| .inr (s,slot) => (.inr (.inr (s,slot)),false)
lemma incEdge_edgeInc (n : ℕ) (d : Edge Q n × Bool) : incEdge Q n (edgeInc Q n d) = d := by
rcases d with ⟨(⟨j,⟨dir,p,q⟩⟩ | (⟨i,pq⟩ | ⟨s,slot⟩)),b⟩
· have hj : j.val ≠ n + 1 := Nat.ne_of_lt j.isLt
cases dir <;> cases b <;> simp [edgeInc, incEdge, hj]
· rfl
· cases s <;> cases b <;> simp [edgeInc, incEdge, outCell]
lemma edgeInc_incEdge (n : ℕ) (d : WholeInc Q n) : edgeInc Q n (incEdge Q n d) = d := by
rcases d with ⟨i,(⟨s,⟨dir,p,q⟩⟩ | ⟨pq,b⟩)⟩ | ⟨s,slot⟩
· cases s with
| false =>
simp only [incEdge]
split_ifs with hi
· have he : i = ⟨0,by omega⟩ := Fin.ext hi
rw [he]
rfl
· cases dir <;> simp only [edgeInc, Bool.false_xor, Bool.true_xor, Bool.not_true,
Bool.false_eq_true, ↓reduceIte]
all_goals congr 2; apply Fin.ext; dsimp; omega
| true =>
simp only [incEdge]
split_ifs with hi
· have he : i = ⟨n+1,by omega⟩ := Fin.ext hi
rw [he]
rfl
· cases dir <;> simp [edgeInc]
· rfl
· rfl
def incidenceEquiv (n : ℕ) : (Edge Q n × Bool) ≃ WholeInc Q n where
toFun := edgeInc Q n
invFun := incEdge Q n
left_inv := incEdge_edgeInc Q n
right_inv := edgeInc_incEdge Q n
/-- A complete proposed successor, including its source and target state. -/
abbrev Key := Move × Q × Q
def sourceInc : Key Q → Incidence Q
| (.left,p,q) => .inl (false,(false,p,q))
| (.stay,p,q) => .inr ((p,q),false)
| (.right,p,q) => .inl (true,(true,p,q))
lemma sourceInc_injective : Function.Injective (sourceInc Q) := by
rintro ⟨d,p,q⟩ ⟨d',p',q'⟩ h
cases d <;> cases d' <;> simp_all [sourceInc]
variable {Q} {Alpha : Type} (M : Machine Alpha Q)
noncomputable def sourceAttach (b : Symbol Alpha) (k : Key Q) : LocalVertex Q := by
classical
exact if M.transition k.2.1 b = some (k.2.2,k.1) then .inl k.2.1 else .inr (sourceInc Q k)
lemma sourceAttach_injective (b : Symbol Alpha) : Function.Injective (sourceAttach M b) := by
classical
rintro ⟨d,p,q⟩ ⟨d',p',q'⟩ h
dsimp only [sourceAttach] at h
split_ifs at h with hk hk'
· have he : p = p' := Sum.inl.inj h
subst p'
have he := Option.some.inj (hk.symm.trans hk')
have hq : q = q' := congrArg Prod.fst he
cases hq
have hd : d = d' := congrArg Prod.snd he
cases hd
rfl
· exact sourceInc_injective Q (Sum.inr.inj h)
lemma sourceAttach_eq_state (b : Symbol Alpha) (k : Key Q) (p : Q) :
sourceAttach M b k = .inl p ↔ k.2.1 = p ∧ M.transition p b = some (k.2.2,k.1) := by
classical
simp only [sourceAttach]
split_ifs with hk
· simp only [Sum.inl.injEq]
constructor
· intro h; exact ⟨h, h ▸ hk⟩
· exact And.left
· constructor
· intro h; cases h
· rintro ⟨h, hh⟩; exact (hk (h.symm ▸ hh)).elim
/-- Only the side facing away from the input is outward. -/
def outward : Symbol Alpha → Bool → Bool
| .left, s => !s
| .right, s => s
| .letter _, _ => false
def testSlot (finish : Q) : Slot Q := (true, M.initial, finish)
noncomputable def localVertex (finish : Q) (b : Symbol Alpha) : Incidence Q → LocalVertex Q := by
classical
exact fun i => match i with
| .inl (s,slot) =>
if outward b s then
if slot = testSlot M finish then .inl (if s then finish else M.initial) else .inr i
else if s = slot.1 then
sourceAttach M b (if s then .right else .left,slot.2.1,slot.2.2)
else .inl slot.2.2
| .inr (pq,r) => if r then .inl pq.2 else sourceAttach M b (.stay,pq.1,pq.2)
variable (Q)
/-- An edge is uniquely determined by the cell, move and states of its
source proposal, or by its outward slot. -/
def edgeKey (n : ℕ) : Edge Q n → (Fin (n + 2) × Key Q) ⊕ (Bool × Slot Q)
| .inl (j,(true,p,q)) => .inl (j.castSucc,(.right,p,q))
| .inl (j,(false,p,q)) => .inl (j.succ,(.left,p,q))
| .inr (.inl (i,(p,q))) => .inl (i,(.stay,p,q))
| .inr (.inr z) => .inr z
lemma edgeKey_injective (n : ℕ) : Function.Injective (edgeKey Q n) := by
rintro (⟨i,⟨d,p,q⟩⟩ | (⟨i,⟨p,q⟩⟩ | z)) (⟨j,⟨d',p',q'⟩⟩ | (⟨j,⟨p',q'⟩⟩ | z')) h
all_goals first
| (cases d <;> cases d' <;> simp_all [edgeKey])
| (cases d <;> simp_all [edgeKey])
| (cases d' <;> simp_all [edgeKey])
| simp_all [edgeKey]
abbrev Vertex (n : ℕ) := (Fin (n + 2) × LocalVertex Q) ⊕ (Bool × Slot Q)
variable {Q}
noncomputable def decorate (w : List Alpha) :
(Fin (w.length + 2) × Key Q) ⊕ (Bool × Slot Q) → Vertex Q w.length
| .inl (i,k) => .inl (i,sourceAttach M (scanned w i) k)
| .inr z => .inr z
lemma decorate_injective (w : List Alpha) : Function.Injective (decorate M w) := by
rintro (⟨i,k⟩ | z) (⟨j,k'⟩ | z') h
· have he := Sum.inl.inj h
have hij : i = j := congrArg Prod.fst he
subst j
have hk := sourceAttach_injective M (scanned w i) (congrArg Prod.snd he)
cases hk
rfl
· cases h
· cases h
· exact congrArg Sum.inr (Sum.inr.inj h)
noncomputable def destination (finish : Q) (w : List Alpha) : Edge Q w.length → Vertex Q w.length
| .inl (j,(true,_p,q)) => .inl (j.succ,.inl q)
| .inl (j,(false,_p,q)) => .inl (j.castSucc,.inl q)
| .inr (.inl (i,(_p,q))) => .inl (i,.inl q)
| .inr (.inr (s,slot)) => .inl (outCell w.length s,
localVertex M finish (scanned w (outCell w.length s)) (.inl (s,slot)))
noncomputable def graph (finish : Q) (w : List Alpha) : FunctionalEdges (Vertex Q w.length) (Edge Q w.length) where
src e := decorate M w (edgeKey Q w.length e)
dst := destination M finish w
src_injective := (decorate_injective M w).comp (edgeKey_injective Q w.length)
noncomputable def wholeVertex (finish : Q) (w : List Alpha) : WholeInc Q w.length → Vertex Q w.length
| .inl (i,j) => .inl (i,localVertex M finish (scanned w i) j)
| .inr z => .inr z
lemma outward_internal (w : List Alpha) (j : Fin (w.length + 1)) :
outward (scanned w j.castSucc) true = false ∧ outward (scanned w j.succ) false = false := by
constructor
· have hr : scanned w j.castSucc ≠ .right := by
rw [ne_eq, scanned_eq_right_iff]; exact Nat.ne_of_lt j.isLt
cases h : scanned w j.castSucc <;> simp_all [outward]
· have hl : scanned w j.succ ≠ .left := by
rw [ne_eq, scanned_eq_left_iff]; simp
cases h : scanned w j.succ <;> simp_all [outward]
lemma graph_vertex (finish : Q) (w : List Alpha) (d : Edge Q w.length × Bool) :
(graph M finish w).vertex d = wholeVertex M finish w (edgeInc Q w.length d) := by
classical
rcases d with ⟨(⟨j,⟨dir,p,q⟩⟩ | (⟨i,pq⟩ | ⟨s,slot⟩)),b⟩
· obtain ⟨hl,hr⟩ := outward_internal w j
cases dir <;> cases b <;>
simp [FunctionalEdges.vertex, graph, decorate, edgeKey, destination, wholeVertex, edgeInc,
localVertex, hl, hr]
· cases b <;> rfl
· cases b <;> rfl
/-- The same local cyclic orders are used at every occurrence of a symbol. -/
def wholePerm (w : List Alpha) (r : Symbol Alpha → Equiv.Perm (Incidence Q)) :
Equiv.Perm (WholeInc Q w.length) where
toFun x := match x with
| .inl (i,j) => .inl (i,r (scanned w i) j)
| .inr z => .inr z
invFun x := match x with
| .inl (i,j) => .inl (i,(r (scanned w i)).symm j)
| .inr z => .inr z
left_inv x := by cases x <;> simp
right_inv x := by cases x <;> simp
lemma wholePerm_pow (w : List Alpha) (r : Symbol Alpha → Equiv.Perm (Incidence Q))
(n : ℕ) (i : Fin (w.length + 2)) (j : Incidence Q) :
(wholePerm w r ^ n) (.inl (i,j)) = .inl (i,(r (scanned w i) ^ n) j) := by
induction n with
| zero => rfl
| succ n ih => simp only [pow_succ', Equiv.Perm.mul_apply, ih]; rfl
noncomputable def orders [Fintype Q] (finish : Q) (b : Symbol Alpha) :
CyclicOrder (localVertex M finish b) := CyclicOrder.choose _
noncomputable def wholeOrder [Fintype Q] (finish : Q) (w : List Alpha) :
CyclicOrder (wholeVertex M finish w) where
perm := wholePerm w (fun b => (orders M finish b).perm)
vertex_eq x := by
rcases x with ⟨i,j⟩ | z
· change Sum.inl (i,localVertex M finish _ ((orders M finish (scanned w i)).perm j)) = _
rw [(orders M finish (scanned w i)).vertex_eq]
rfl
· rfl
cyclic := by
rintro (⟨i,j⟩ | z) (⟨i',j'⟩ | z') h
· have he := Sum.inl.inj h
have hi : i = i' := congrArg Prod.fst he
subst i'
have hj := congrArg Prod.snd he
obtain ⟨n, hn⟩ := ((orders M finish (scanned w i)).cyclic j j' hj).exists_nat_pow_eq
refine ⟨n, ?_⟩
simp only [zpow_natCast, wholePerm_pow, hn]
· cases h
· cases h
· have hz := Sum.inr.inj h
exact (congrArg Sum.inr hz).sameCycle _
noncomputable def graphOrder [Fintype Q] (finish : Q) (w : List Alpha) :
(graph M finish w).Rotation where
perm := (incidenceEquiv Q w.length).symm.permCongrHom (wholeOrder M finish w).perm
vertex_eq d := by
rw [graph_vertex, graph_vertex]
change wholeVertex M finish w (incidenceEquiv Q w.length
((incidenceEquiv Q w.length).symm ((wholeOrder M finish w).perm (incidenceEquiv Q w.length d)))) = _
rw [Equiv.apply_symm_apply]
exact (wholeOrder M finish w).vertex_eq _
cyclic d d' h := by
rw [graph_vertex, graph_vertex] at h
have hh := (wholeOrder M finish w).cyclic _ _ h
change (wholeOrder M finish w).perm.SameCycle (incidenceEquiv Q w.length d)
(incidenceEquiv Q w.length d') at hh
simpa only [Equiv.symm_apply_apply] using
sameCycle_permCongr (incidenceEquiv Q w.length).symm (wholeOrder M finish w).perm hh
lemma graphOrder_apply [Fintype Q] (finish : Q) (w : List Alpha) (d : Edge Q w.length × Bool) :
edgeInc Q w.length ((graphOrder M finish w).perm d) =
(wholeOrder M finish w).perm (edgeInc Q w.length d) := by
change incidenceEquiv Q w.length ((incidenceEquiv Q w.length).symm (_)) = _
exact (incidenceEquiv Q w.length).apply_symm_apply _
/-- State configurations embed without identifying any added leaves. -/
def stateVertex (w : List Alpha) (c : Machine.Config (Q := Q) w) : Vertex Q w.length :=
.inl (c.1,.inl c.2)
lemma stateVertex_injective (w : List Alpha) : Function.Injective (stateVertex (Q := Q) w) := by
rintro ⟨i,p⟩ ⟨j,q⟩ h
simpa [stateVertex] using h
lemma graph_step_from_state (finish : Q) (w : List Alpha) (c : Machine.Config (Q := Q) w)
(v : Vertex Q w.length) :
(graph M finish w).Step (stateVertex w c) v ↔
∃ c', v = stateVertex w c' ∧ M.Step w c c' := by
classical
constructor
· rintro ⟨e, hs, hd⟩
rcases c with ⟨i,p⟩
rcases e with ⟨j,⟨dir,p',q⟩⟩ | (⟨j,⟨p',q⟩⟩ | z)
· cases dir with
| false =>
change Sum.inl (j.succ,sourceAttach M (scanned w j.succ) (.left,p',q)) =
Sum.inl (i,Sum.inl p) at hs
have he := Sum.inl.inj hs
have hi : j.succ = i := congrArg Prod.fst he
subst i
obtain ⟨hp, ht⟩ := (sourceAttach_eq_state M _ _ _).mp (congrArg Prod.snd he)
exact ⟨(j.castSucc,q), hd.symm, .left, ht, rfl⟩
| true =>
change Sum.inl (j.castSucc,sourceAttach M (scanned w j.castSucc) (.right,p',q)) =
Sum.inl (i,Sum.inl p) at hs
have he := Sum.inl.inj hs
have hi : j.castSucc = i := congrArg Prod.fst he
subst i
obtain ⟨hp, ht⟩ := (sourceAttach_eq_state M _ _ _).mp (congrArg Prod.snd he)
exact ⟨(j.succ,q), hd.symm, .right, ht, rfl⟩
· change Sum.inl (j,sourceAttach M (scanned w j) (.stay,p',q)) =
Sum.inl (i,Sum.inl p) at hs
have he := Sum.inl.inj hs
have hi : j = i := congrArg Prod.fst he
subst i
obtain ⟨hp, ht⟩ := (sourceAttach_eq_state M _ _ _).mp (congrArg Prod.snd he)
exact ⟨(j,q), hd.symm, .stay, ht, rfl⟩
· cases hs
· rintro ⟨⟨j,q⟩, rfl, d, ht, hr⟩
rcases c with ⟨i,p⟩
cases d with
| left =>
change j.val + 1 = i.val at hr
let k : Fin (w.length + 1) := ⟨j.val, by omega⟩
have hk : k.succ = i := Fin.ext hr
refine ⟨.inl (k,(false,p,q)), ?_, ?_⟩
· change Sum.inl (k.succ,sourceAttach M (scanned w k.succ) (.left,p,q)) = _
rw [hk]
rw [(sourceAttach_eq_state M _ _ _).mpr ⟨rfl, ht⟩]
rfl
· rfl
| stay =>
have hj : j = i := Fin.ext hr
subst j
refine ⟨.inr (.inl (i,(p,q))), ?_, rfl⟩
change Sum.inl (i,sourceAttach M (scanned w i) (.stay,p,q)) = _
rw [(sourceAttach_eq_state M _ _ _).mpr ⟨rfl, ht⟩]
rfl
| right =>
change j.val = i.val + 1 at hr
let k : Fin (w.length + 1) := ⟨i.val, by omega⟩
have hk : k.succ = j := Fin.ext hr.symm
refine ⟨.inl (k,(true,p,q)), ?_, ?_⟩
· change Sum.inl (i,sourceAttach M (scanned w i) (.right,p,q)) = _
rw [(sourceAttach_eq_state M _ _ _).mpr ⟨rfl, ht⟩]
rfl
· change stateVertex w (k.succ,q) = _
rw [hk]
lemma graph_reach_state (finish : Q) (w : List Alpha) (c c' : Machine.Config (Q := Q) w) :
(graph M finish w).Reach (stateVertex w c) (stateVertex w c') ↔
Relation.ReflTransGen (M.Step w) c c' := by
constructor
· intro h
have aux (v : Vertex Q w.length) (hv : (graph M finish w).Reach (stateVertex w c) v) :
∃ d, v = stateVertex w d ∧ Relation.ReflTransGen (M.Step w) c d := by
induction hv with
| refl => exact ⟨c,rfl,.refl⟩
| @tail v v' _ hvv ih =>
obtain ⟨d,rfl,hd⟩ := ih
obtain ⟨d',he,hs⟩ := (graph_step_from_state M finish w d v').mp hvv
exact ⟨d',he,hd.tail hs⟩
obtain ⟨d,hd,hp⟩ := aux _ h
exact stateVertex_injective w hd ▸ hp
· intro h
exact h.lift (stateVertex w) (fun a b hab =>
(graph_step_from_state M finish w a _).mpr ⟨b,rfl,hab⟩)
lemma graph_terminal (finish : Q) (w : List Alpha) (t : Machine.Config (Q := Q) w)
(ht : M.transition t.2 (scanned w t.1) = none) :
∀ e, (graph M finish w).src e ≠ stateVertex w t := by
intro e he
obtain ⟨c,_,d,hd,_⟩ := (graph_step_from_state M finish w t _).mp ⟨e,he,rfl⟩
simp [ht] at hd
lemma scanned_outCell (w : List Alpha) (s : Bool) :
scanned w (outCell w.length s) = if s then .right else .left := by
cases s with
| false => exact (scanned_eq_left_iff _ _).mpr rfl
| true => exact (scanned_eq_right_iff _ _).mpr rfl
lemma test_destination (finish : Q) (w : List Alpha) (s : Bool) :
(graph M finish w).dst (.inr (.inr (s,testSlot M finish))) =
stateVertex w (outCell w.length s,if s then finish else M.initial) := by
classical
change Sum.inl (_,localVertex M finish _ _) = _
rw [scanned_outCell]
cases s <;> simp [localVertex, outward, stateVertex]
lemma test_step (finish : Q) (w : List Alpha) (s : Bool) :
(graph M finish w).Step (.inr (s,testSlot M finish))
(stateVertex w (outCell w.length s,if s then finish else M.initial)) :=
⟨.inr (.inr (s,testSlot M finish)),rfl,test_destination M finish w s⟩
end CellNetwork
end OneWayLiveness
end OAI