File size: 2,746 Bytes
caec230 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | import OAI.MathematicalPhysics.RapidForcing.RawMachine
namespace OAI
section
open Encodable
namespace RapidForcing
private lemma flatMap_getElem_block {A B : Type} (l : List A) (f : A → List B)
(s : ℕ) (hf : ∀ a ∈ l, (f a).length = s) (i j : ℕ) (hj : j < s) :
(l.flatMap f)[i * s + j]? = l[i]?.bind (fun a => (f a)[j]?) := by
induction l generalizing i with
| nil => simp
| cons a l ih =>
have ha := hf a (by simp)
have hl := fun b hb => hf b (List.mem_cons_of_mem a hb)
cases i with
| zero =>
simp only [Nat.zero_mul, Nat.zero_add, List.flatMap_cons, List.getElem?_cons_zero,
Option.bind_some]
exact List.getElem?_append_left (by simpa only [ha] using hj)
| succ i =>
rw [List.flatMap_cons, List.getElem?_append_right (by rw [ha, Nat.succ_mul]; omega), ha]
have he : (i + 1) * s + j - s = i * s + j := by rw [Nat.add_mul, Nat.one_mul]; omega
simpa only [he, List.getElem?_cons_succ] using ih hl i
namespace Machine
lemma description_instruction (M : Machine) (q z : ℕ) :
RawMachine.instruction M.description q z = M.instruction q z := by
unfold RawMachine.instruction instruction
by_cases hq : q < M.states
· by_cases hz : z < M.symbols
· simp only [description, hq, hz, and_self, ↓reduceIte, ↓reduceDIte]
rw [flatMap_getElem_block _ _ M.symbols
(fun a _ => by simp) q z hz]
have hqs : (List.finRange M.states)[q]? = some ⟨q, hq⟩ := by
rw [List.getElem?_eq_getElem (by simpa using hq)]
simp
have hzs : (List.finRange M.symbols)[z]? = some ⟨z, hz⟩ := by
rw [List.getElem?_eq_getElem (by simpa using hz)]
simp
simp only [hqs, Option.bind_some, List.getElem?_map, hzs, Option.map_some]
cases M.transition ⟨q, hq⟩ ⟨z, hz⟩ <;> rfl
· simp [description, hq, hz]
· simp [description, hq]
@[simp] lemma description_scaleData (M : Machine) (w : M.Input) :
RawMachine.scaleData M.description (w.map Fin.val) = M.scaleData w := by
simp [RawMachine.scaleData, description, scaleData]
@[simp] lemma description_terminalDigit (M : Machine) (d : ScaleData) (k : ℕ) :
RawMachine.terminalDigit M.description d k = M.terminalDigit d k := rfl
@[simp] lemma description_nextDigit (M : Machine) (d : ScaleData) (n k : ℕ) :
RawMachine.nextDigit M.description d n k = M.nextDigit d n k := by
simp only [RawMachine.nextDigit, nextDigit, description_instruction]
rfl
@[simp] lemma description_initialDigit (M : Machine) (w : M.Input) :
RawMachine.initialDigit M.description (w.map Fin.val) = M.initialDigit w := by
simp only [RawMachine.initialDigit, initialDigit, description_scaleData]
rfl
end Machine
end RapidForcing
end
end OAI
|