| import Mathlib |
| import OAI.Computability.Interspersed.Machines |
| import OAI.Computability.Interspersed.Stacks |
|
|
| namespace OAI |
|
|
| /-! Reversible interspersed-history instruction cylinders. -/ |
|
|
| noncomputable section |
| open scoped ContDiff |
| namespace PrefixFlows |
| namespace Interspersed |
| inductive Control (Q : Type*) where |
| | main (q : Q) (incoming : Move) |
| | scanRight (q : Q) |
| | scanLeft (q : Q) |
| deriving DecidableEq |
|
|
| |
|
|
| abbrev Record (Q A : Type*) (H : Set Q) := {q : Q // q ∉ H} × Move × A |
| abbrev Symbol (Q A : Type*) (H : Set Q) := A ⊕ Record Q A H |
| abbrev Config (Q A : Type*) (H : Set Q) := |
| Control Q × Stack (Symbol Q A H) × Stack (Symbol Q A H) |
|
|
| |
|
|
| inductive Branch (Q A : Type*) (H : Set Q) where |
| | main (q : {q : Q // q ∉ H}) (incoming : Move) (a : A) |
| | rightRecord (q : Q) (g : Record Q A H) |
| | rightWork (q : Q) (a : A) |
| | leftRecord (q : Q) (g : Record Q A H) |
| | leftWork (q : Q) (a : A) |
|
|
| variable {Q A : Type*} {H : Set Q} |
|
|
| |
| def source (r : Branch Q A H) (L R : Stack (Symbol Q A H)) : Config Q A H := |
| match r with |
| | .main q h a => (.main q h, L, push (.inl a) R) |
| | .rightRecord q g => (.scanRight q, L, push (.inr g) R) |
| | .rightWork q a => (.scanRight q, L, push (.inl a) R) |
| | .leftRecord q g => (.scanLeft q, push (.inr g) L, R) |
| | .leftWork q a => (.scanLeft q, push (.inl a) L, R) |
|
|
| |
|
|
| def target (δ : Q → A → Q × A × Move) (r : Branch Q A H) |
| (L R : Stack (Symbol Q A H)) : Config Q A H := |
| match r with |
| | .main q h a => |
| let (q', b, d) := δ q a |
| let g : Record Q A H := (q, h, a) |
| match d with |
| | .stay => (.main q' .stay, push (.inr g) L, push (.inl b) R) |
| | .right => (.scanRight q', push (.inl b) (push (.inr g) L), R) |
| | .left => (.scanLeft q', L, push (.inl b) (push (.inr g) R)) |
| | .rightRecord q g => (.scanRight q, push (.inr g) L, R) |
| | .rightWork q a => (.main q .right, L, push (.inl a) R) |
| | .leftRecord q g => (.scanLeft q, L, push (.inr g) R) |
| | .leftWork q a => (.main q .left, L, push (.inl a) R) |
|
|
| |
|
|
| theorem source_unique {r s : Branch Q A H} {L R L' R' : Stack (Symbol Q A H)} |
| (h : source r L R = source s L' R') : r = s ∧ L = L' ∧ R = R' := by |
| cases r <;> cases s <;> simp_all [source, push_inj, Subtype.ext_iff] |
|
|
| |
|
|
| theorem target_unique (δ : Q → A → Q × A × Move) |
| {r s : Branch Q A H} {L R L' R' : Stack (Symbol Q A H)} |
| (h : target δ r L R = target δ s L' R') : r = s ∧ L = L' ∧ R = R' := by |
| cases r <;> cases s <;> simp only [target] at h |
| all_goals (repeat' (split at h)) <;> simp_all [push_inj, Subtype.ext_iff] |
|
|
| |
| def sourceCylinder (r : Branch Q A H) : Set (Config Q A H) := |
| {c | ∃ L R, source r L R = c} |
|
|
| |
| def imageCylinder (δ : Q → A → Q × A × Move) (r : Branch Q A H) : |
| Set (Config Q A H) := |
| {c | ∃ L R, target δ r L R = c} |
|
|
| theorem source_cylinders_disjoint {r s : Branch Q A H} (hrs : r ≠ s) : |
| Disjoint (sourceCylinder r) (sourceCylinder s) := by |
| rw [Set.disjoint_left] |
| rintro c ⟨L, R, h⟩ ⟨L', R', h'⟩ |
| exact hrs (source_unique (h.trans h'.symm)).1 |
|
|
| theorem image_cylinders_disjoint (δ : Q → A → Q × A × Move) |
| {r s : Branch Q A H} (hrs : r ≠ s) : |
| Disjoint (imageCylinder δ r) (imageCylinder δ s) := by |
| rw [Set.disjoint_left] |
| rintro c ⟨L, R, h⟩ ⟨L', R', h'⟩ |
| exact hrs (target_unique δ (h.trans h'.symm)).1 |
|
|
| |
| def Step (δ : Q → A → Q × A × Move) (c d : Config Q A H) : Prop := |
| ∃ r L R, source r L R = c ∧ target δ r L R = d |
|
|
| theorem Step.of_branch (δ : Q → A → Q × A × Move) (r : Branch Q A H) |
| (L R : Stack (Symbol Q A H)) : Step δ (source r L R) (target δ r L R) := |
| ⟨r, L, R, rfl, rfl⟩ |
|
|
| theorem Step.deterministic {δ : Q → A → Q × A × Move} |
| {c d e : Config Q A H} (h : Step δ c d) (h' : Step δ c e) : d = e := by |
| rcases h with ⟨r, L, R, hs, ht⟩ |
| rcases h' with ⟨s, L', R', hs', ht'⟩ |
| rcases source_unique (hs.trans hs'.symm) with ⟨rfl, rfl, rfl⟩ |
| exact ht.symm.trans ht' |
|
|
| theorem Step.injective {δ : Q → A → Q × A × Move} |
| {c d e : Config Q A H} (h : Step δ c e) (h' : Step δ d e) : c = d := by |
| rcases h with ⟨r, L, R, hs, ht⟩ |
| rcases h' with ⟨s, L', R', hs', ht'⟩ |
| rcases target_unique δ (ht.trans ht'.symm) with ⟨rfl, rfl, rfl⟩ |
| exact hs.symm.trans hs' |
|
|
| theorem no_step_from_halt (δ : Q → A → Q × A × Move) |
| (q : Q) (hq : q ∈ H) (h : Move) (L R : Stack (Symbol Q A H)) : |
| ¬ ∃ d, Step δ (.main q h, L, R) d := by |
| rintro ⟨d, r, L', R', hs, ht⟩ |
| cases r with |
| | main q' h' a => |
| have he : Control.main (q' : Q) h' = Control.main q h := congrArg Prod.fst hs |
| have e : (q' : Q) = q := (Control.main.inj he).1 |
| exact q'.property (e.symm ▸ hq) |
| | rightRecord q' g => simp [source] at hs |
| | rightWork q' a => simp [source] at hs |
| | leftRecord q' g => simp [source] at hs |
| | leftWork q' a => simp [source] at hs |
| end Interspersed |
| end PrefixFlows |
| end |
|
|
| end OAI |
|
|
