| import OAI.MathematicalPhysics.NavierStokes.Material.Machines |
| import OAI.MathematicalPhysics.NavierStokes.Material.Decoder |
| import OAI.MathematicalPhysics.NavierStokes.Material.Signal |
|
|
| namespace OAI |
|
|
| namespace Alternating.Memory |
|
|
| def alphabetBase (M : Machine) : ℕ := 2 * (1 + max (M.stateCount + 1) M.symbolCount) |
|
|
| theorem alphabetBase_ge_four (M : Machine) : 4 ≤ alphabetBase M := by |
| have h := Nat.le_max_left (M.stateCount + 1) M.symbolCount |
| dsimp [alphabetBase, Machine.stateCount] at * |
| omega |
|
|
| theorem state_digit_allowed {M : Machine} {q : ℕ} (hq : q ≤ M.stateCount) : |
| Even (2 * q) ∧ 2 * q + 2 ≤ alphabetBase M := by |
| refine ⟨even_two_mul q, ?_⟩ |
| have h := Nat.le_max_left (M.stateCount + 1) M.symbolCount |
| dsimp [alphabetBase] |
| omega |
|
|
| theorem symbol_digit_allowed {M : Machine} {a : ℕ} (ha : a < M.symbolCount) : |
| Even (2 * a) ∧ 2 * a + 2 ≤ alphabetBase M := by |
| refine ⟨even_two_mul a, ?_⟩ |
| have h := Nat.le_max_right (M.stateCount + 1) M.symbolCount |
| dsimp [alphabetBase] |
| omega |
|
|
| def leftDigits (K : ℕ) (c : Configuration) : List ℕ := |
| (List.range K).map (fun i : ℕ => 2 * c.tape (c.head - 1 - (i : ℤ))) |
|
|
| def rightDigits (K : ℕ) (c : Configuration) : List ℕ := |
| (List.range K).map (fun i : ℕ => 2 * c.tape (c.head + (i : ℤ))) |
|
|
| theorem leftDigits_allowed {M : Machine} {c : Configuration} (hc : c.ValidFor M) (K : ℕ) : |
| AllowedDigits (alphabetBase M) (leftDigits K c) := by |
| intro d hd |
| obtain ⟨i, _, rfl⟩ := List.mem_map.1 hd |
| exact symbol_digit_allowed (hc.2 _) |
|
|
| theorem rightDigits_allowed {M : Machine} {c : Configuration} (hc : c.ValidFor M) (K : ℕ) : |
| AllowedDigits (alphabetBase M) (rightDigits K c) := by |
| intro d hd |
| obtain ⟨i, _, rfl⟩ := List.mem_map.1 hd |
| exact symbol_digit_allowed (hc.2 _) |
|
|
| def actualBlock (I : MachineInput) (hI : ValidInput I) (n : ℕ) : |
| Block (alphabetBase I.1) (width I.2.length n) where |
| stateDigit := 2 * (configurationAt I n).state |
| left := leftDigits (width I.2.length n) (configurationAt I n) |
| right := rightDigits (width I.2.length n) (configurationAt I n) |
| state_allowed := state_digit_allowed (configurationAt_valid hI n).1 |
| left_allowed := leftDigits_allowed (configurationAt_valid hI n) _ |
| right_allowed := rightDigits_allowed (configurationAt_valid hI n) _ |
| left_length := by simp [leftDigits] |
| right_length := by simp [rightDigits] |
|
|
| theorem actualBlock_full_tape (I : MachineInput) (n : ℕ) {i : ℕ} (hi : width I.2.length n ≤ i) : |
| (configurationAt I n).tape ((configurationAt I n).head - 1 - (i : ℤ)) = 0 ∧ |
| (configurationAt I n).tape ((configurationAt I n).head + (i : ℤ)) = 0 := by |
| have hhead := configurationAt_head_bounds I n |
| dsimp [width] at hi |
| constructor |
| · apply configurationAt_tape_outside I n |
| left |
| omega |
| · apply configurationAt_tape_outside I n |
| right |
| omega |
|
|
| theorem actualBlock_left_get (I : MachineInput) (hI : ValidInput I) (n i : ℕ) |
| (hi : i < width I.2.length n) : |
| (actualBlock I hI n).left[i]'(by simpa [actualBlock, leftDigits] using hi) = |
| 2 * (configurationAt I n).tape ((configurationAt I n).head - 1 - (i : ℤ)) := by |
| simp only [actualBlock, leftDigits, List.getElem_map, List.getElem_range] |
|
|
| theorem actualBlock_right_get (I : MachineInput) (hI : ValidInput I) (n i : ℕ) |
| (hi : i < width I.2.length n) : |
| (actualBlock I hI n).right[i]'(by simpa [actualBlock, rightDigits] using hi) = |
| 2 * (configurationAt I n).tape ((configurationAt I n).head + (i : ℤ)) := by |
| simp only [actualBlock, rightDigits, List.getElem_map, List.getElem_range] |
|
|
| theorem actualBlock_read (I : MachineInput) (hI : ValidInput I) (n : ℕ) : |
| let b := alphabetBase I.1 |
| let N := I.2.length |
| let D := donor b N (actualBlock I hI) n |
| safeDecoder b ((b : ℝ) ^ scale N n * D) = (actualBlock I hI n).code ∧ |
| safeDecoder b ((b : ℝ) ^ (scale N n + 1 + width N n) * D) = (actualBlock I hI n).rightCode ∧ |
| safeDecoder b ((b : ℝ) ^ (scale N n + 1) * D) - |
| (b : ℝ)⁻¹ ^ width N n * safeDecoder b ((b : ℝ) ^ (scale N n + 1 + width N n) * D) = |
| (actualBlock I hI n).leftCode := by |
| exact safe_read_exact (by have := alphabetBase_ge_four I.1; omega) (actualBlock I hI) n |
|
|
| theorem actualSignal_hit_iff (I : MachineInput) : |
| (∃ (n : ℕ) (u : ℝ), u ∈ Set.Icc 0 1 ∧ |
| 0 < signalAlong (alphabetBase I.1) I.2.length |
| (fun j => I.1.isHalting (configurationAt I j).state) n u) ↔ Halts I := by |
| exact signal_hit_iff (by have := alphabetBase_ge_four I.1; omega) I.2.length _ |
|
|
| end Alternating.Memory |
|
|
| end OAI |
|
|
