| import Mathlib |
| import OAI.Computability.SolenoidalRecorder.Machines |
|
|
| namespace OAI |
|
|
| /-! Full-domain reversible recorder instructions and unique predecessors. -/ |
|
|
| namespace Solenoidal |
| namespace Recorder |
| variable (M : Machine) |
|
|
| |
| inductive History |
| | empty | frontier | record (r : M.Instruction) |
| deriving DecidableEq, Fintype |
|
|
| inductive Control |
| | S (q : M.State) | A (r : M.Instruction) | R (r : M.Instruction) |
| | F (q : M.State) | L (q : M.State) |
| deriving DecidableEq, Fintype |
|
|
| @[ext] structure Letter where |
| work : M.Symbol |
| history : History M |
| mark : Bool |
| deriving DecidableEq, Fintype |
|
|
| |
|
|
| inductive Rule : Control M → Letter M → Control M → Letter M → Move → Prop |
| | work (r : M.Instruction) (ℓ : History M) (hℓ : ℓ ≠ .frontier) : |
| Rule (.S r.oldState) ⟨r.read, ℓ, false⟩ (.A r) ⟨r.write, ℓ, false⟩ r.move |
| | mark (r : M.Instruction) (c : M.Symbol) (ℓ : History M) (hℓ : ℓ ≠ .frontier) : |
| Rule (.A r) ⟨c, ℓ, false⟩ (.R r) ⟨c, ℓ, true⟩ .right |
| | scanRight (r : M.Instruction) (c : M.Symbol) (ℓ : History M) |
| (hℓ : ℓ ≠ .frontier) : |
| Rule (.R r) ⟨c, ℓ, false⟩ (.R r) ⟨c, ℓ, false⟩ .right |
| | record (r : M.Instruction) (c : M.Symbol) : |
| Rule (.R r) ⟨c, .frontier, false⟩ (.F r.nextState) ⟨c, .record r, false⟩ .right |
| | advance (q : M.State) (c : M.Symbol) : |
| Rule (.F q) ⟨c, .empty, false⟩ (.L q) ⟨c, .frontier, false⟩ .left |
| | scanLeft (q : M.State) (c : M.Symbol) (ℓ : History M) (hℓ : ℓ ≠ .frontier) : |
| Rule (.L q) ⟨c, ℓ, false⟩ (.L q) ⟨c, ℓ, false⟩ .left |
| | finish (q : M.State) (c : M.Symbol) (ℓ : History M) (hℓ : ℓ ≠ .frontier) : |
| Rule (.L q) ⟨c, ℓ, true⟩ (.S q) ⟨c, ℓ, false⟩ .stay |
|
|
| |
| def incoming : Control M → Move |
| | .S _ => .stay |
| | .A r => r.move |
| | .R _ => .right |
| | .F _ => .right |
| | .L _ => .left |
|
|
| |
|
|
| def undo (s : Control M) (b : Letter M) : Control M × Letter M := |
| match s with |
| | .A r => (.S r.oldState, ⟨r.read, b.history, false⟩) |
| | .R r => if b.mark then (.A r, ⟨b.work, b.history, false⟩) else (.R r, b) |
| | .F q => match b.history with |
| | .record r => (.R r, ⟨b.work, .frontier, false⟩) |
| | _ => (.S q, b) |
| | .L q => if b.history = .frontier then (.F q, ⟨b.work, .empty, false⟩) |
| else (.L q, b) |
| | .S q => (.L q, ⟨b.work, b.history, true⟩) |
|
|
| variable {M} {s s' s₁ s₂ : Control M} {a b a₁ a₂ : Letter M} {d d₁ d₂ : Move} |
|
|
| |
| theorem fixed_incoming (h : Rule M s a s' b d) : d = incoming M s' := by |
| cases h <;> rfl |
|
|
| |
| theorem undo_rule (h : Rule M s a s' b d) : undo M s' b = (s, a) := by |
| cases h <;> simp_all [undo] |
|
|
| |
| theorem local_predecessor_unique |
| (h₁ : Rule M s₁ a₁ s' b d₁) (h₂ : Rule M s₂ a₂ s' b d₂) : |
| s₁ = s₂ ∧ a₁ = a₂ ∧ d₁ = d₂ := by |
| have hu : (s₁, a₁) = (s₂, a₂) := (undo_rule h₁).symm.trans (undo_rule h₂) |
| exact ⟨congrArg Prod.fst hu, congrArg Prod.snd hu, |
| (fixed_incoming h₁).trans (fixed_incoming h₂).symm⟩ |
|
|
| |
| theorem rule_deterministic {u₁ u₂ t₁ t₂ : Control M} {a₁ a₂ b₁ b₂ : Letter M} |
| (h₁ : Rule M u₁ a₁ t₁ b₁ d₁) (h₂ : Rule M u₂ a₂ t₂ b₂ d₂) |
| (hu : u₁ = u₂) (ha : a₁ = a₂) : |
| t₁ = t₂ ∧ b₁ = b₂ ∧ d₁ = d₂ := by |
| cases h₁ <;> cases h₂ <;> |
| simp_all [Letter.mk.injEq, Machine.Instruction.oldState, Machine.Instruction.read] |
| rename_i r₁ ℓ₁ r₂ ℓ₂ hℓ |
| have hr : r₁ = r₂ := Subtype.ext (Prod.ext hu ha.1) |
| simp [hr] |
|
|
| @[ext] structure Config (M : Machine) where |
| control : Control M |
| head : ℤ |
| tape : ℤ → Letter M |
|
|
| |
| def successor (c : Config M) (s : Control M) (b : Letter M) (d : Move) : Config M := |
| ⟨s, c.head + d.displacement, Function.update c.tape c.head b⟩ |
|
|
| def Step (c c' : Config M) : Prop := |
| ∃ s b d, Rule M c.control (c.tape c.head) s b d ∧ c' = successor c s b d |
|
|
| |
| theorem step_deterministic {c c₁ c₂ : Config M} |
| (h₁ : Step c c₁) (h₂ : Step c c₂) : c₁ = c₂ := by |
| obtain ⟨s₁, b₁, d₁, hr₁, he₁⟩ := h₁ |
| obtain ⟨s₂, b₂, d₂, hr₂, he₂⟩ := h₂ |
| obtain ⟨rfl, rfl, rfl⟩ := rule_deterministic hr₁ hr₂ rfl rfl |
| exact he₁.trans he₂.symm |
|
|
| |
| theorem predecessor_unique {c₁ c₂ c' : Config M} |
| (h₁ : Step c₁ c') (h₂ : Step c₂ c') : c₁ = c₂ := by |
| obtain ⟨s₁, b₁, d₁, hr₁, he₁⟩ := h₁ |
| obtain ⟨s₂, b₂, d₂, hr₂, he₂⟩ := h₂ |
| have he : successor c₁ s₁ b₁ d₁ = successor c₂ s₂ b₂ d₂ := he₁.symm.trans he₂ |
| have hs : s₁ = s₂ := congrArg Config.control he |
| subst s₂ |
| have hd : d₁ = d₂ := (fixed_incoming hr₁).trans (fixed_incoming hr₂).symm |
| subst d₂ |
| have hh : c₁.head = c₂.head := add_right_cancel (congrArg Config.head he) |
| have ht : Function.update c₁.tape c₁.head b₁ = Function.update c₂.tape c₂.head b₂ := |
| congrArg Config.tape he |
| have hb : b₁ = b₂ := by |
| have := congrFun ht c₁.head |
| simpa [hh] using this |
| subst b₂ |
| obtain ⟨hc, ha, _⟩ := local_predecessor_unique hr₁ hr₂ |
| apply Config.ext hc hh |
| funext k |
| by_cases hk : k = c₁.head |
| · subst k |
| simpa only [hh] using ha |
| · have hk' : k ≠ c₂.head := by simpa only [hh] using hk |
| simpa [Function.update_of_ne hk, Function.update_of_ne hk'] using congrFun ht k |
| end Recorder |
| end Solenoidal |
|
|
| end OAI |
|
|
