| import OAI.MathematicalPhysics.NavierStokes.Material.MachineEncoding |
| import OAI.MathematicalPhysics.NavierStokes.Material.Selectors |
|
|
| namespace OAI |
|
|
| namespace Alternating.Memory |
| open scoped BigOperators |
|
|
| theorem selector_sum {b d k : ℕ} {x : ℝ} (hd : d < k) |
| (hx : (b : ℝ) * x ∈ Set.Icc (2 * (d : ℝ)) (2 * d + 1)) (v : ℕ → ℝ) : |
| ∑ e ∈ Finset.range k, digitSelector b e x * v e = v d := by |
| simp_rw [digitSelector_selects hx, ite_mul, one_mul, zero_mul] |
| simp [hd] |
|
|
| theorem Block.code_state_cylinder {b K d : ℕ} (hb : 2 ≤ b) (c : Block b K) |
| (hd : c.stateDigit = 2 * d) : |
| (b : ℝ) * c.code ∈ Set.Icc (2 * (d : ℝ)) (2 * d + 1) := by |
| have hb0 : (b : ℝ) ≠ 0 := by exact_mod_cast (by omega : b ≠ 0) |
| have htail := c.tail_mem hb |
| have hm1 := tailBound_lt_one hb |
| rw [c.code_formula (by omega)] |
| have he : (b : ℝ) * |
| (((c.stateDigit : ℝ) + c.leftCode + (b : ℝ)⁻¹ ^ K * c.rightCode) / b) = |
| (c.stateDigit : ℝ) + (c.leftCode + (b : ℝ)⁻¹ ^ K * c.rightCode) := by |
| field_simp |
| ring |
| rw [he, hd] |
| push_cast |
| exact ⟨by linarith [htail.1], by linarith [htail.2]⟩ |
|
|
| noncomputable def readState (b N n : ℕ) (D : ℝ) : ℝ := |
| safeDecoder b ((b : ℝ) ^ scale N n * D) |
|
|
| noncomputable def readRight (b N n : ℕ) (D : ℝ) : ℝ := |
| safeDecoder b ((b : ℝ) ^ (scale N n + 1 + width N n) * D) |
|
|
| noncomputable def readLeft (b N n : ℕ) (D : ℝ) : ℝ := |
| safeDecoder b ((b : ℝ) ^ (scale N n + 1) * D) - |
| (b : ℝ)⁻¹ ^ width N n * readRight b N n D |
|
|
| theorem readState_smooth {b : ℕ} (hb : 2 ≤ b) (N n : ℕ) : |
| ContDiff ℝ (⊤ : ℕ∞) (readState b N n) := |
| (safeDecoder_smooth hb).comp (contDiff_const.mul contDiff_id) |
|
|
| theorem readRight_smooth {b : ℕ} (hb : 2 ≤ b) (N n : ℕ) : |
| ContDiff ℝ (⊤ : ℕ∞) (readRight b N n) := |
| (safeDecoder_smooth hb).comp (contDiff_const.mul contDiff_id) |
|
|
| theorem readLeft_smooth {b : ℕ} (hb : 2 ≤ b) (N n : ℕ) : |
| ContDiff ℝ (⊤ : ℕ∞) (readLeft b N n) := by |
| exact ((safeDecoder_smooth hb).comp (contDiff_const.mul contDiff_id)).sub |
| (contDiff_const.mul (readRight_smooth hb N n)) |
|
|
| noncomputable def haltingSelector (M : Machine) (C : ℝ) : ℝ := |
| ∑ q ∈ Finset.range (M.stateCount + 1), |
| digitSelector (alphabetBase M) q C * (if M.isHalting q then 1 else 0) |
|
|
| theorem haltingSelector_smooth (M : Machine) : |
| ContDiff ℝ (⊤ : ℕ∞) (haltingSelector M) := by |
| unfold haltingSelector |
| apply ContDiff.sum |
| intro q _ |
| exact (digitSelector_smooth _ _).mul contDiff_const |
|
|
| theorem haltingSelector_exact {M : Machine} {q : ℕ} (hq : q ≤ M.stateCount) |
| {C : ℝ} (hC : (alphabetBase M : ℝ) * C ∈ Set.Icc (2 * (q : ℝ)) (2 * q + 1)) : |
| haltingSelector M C = if M.isHalting q then 1 else 0 := |
| selector_sum (by omega) hC _ |
|
|
| noncomputable def localSignal (M : Machine) (N n : ℕ) (D : ℝ) : ℝ := |
| epsilon (alphabetBase M) N n - epsilon (alphabetBase M) N (n + 1) + |
| 2 * epsilon (alphabetBase M) N (n + 1) * |
| haltingSelector M (readState (alphabetBase M) N n D) |
|
|
| theorem localSignal_smooth (M : Machine) (N n : ℕ) : |
| ContDiff ℝ (⊤ : ℕ∞) (localSignal M N n) := by |
| apply contDiff_const.add |
| apply contDiff_const.mul |
| exact (haltingSelector_smooth M).comp |
| (readState_smooth (by have := alphabetBase_ge_four M; omega) N n) |
|
|
| theorem localSignal_exact (I : MachineInput) (hI : ValidInput I) (n : ℕ) : |
| localSignal I.1 I.2.length n |
| (donor (alphabetBase I.1) I.2.length (actualBlock I hI) n) = |
| signalIncrement (alphabetBase I.1) I.2.length |
| (fun j => I.1.isHalting (configurationAt I j).state) n := by |
| have hb : 2 ≤ alphabetBase I.1 := by have := alphabetBase_ge_four I.1; omega |
| have hr := (actualBlock_read I hI n).1 |
| change readState (alphabetBase I.1) I.2.length n |
| (donor (alphabetBase I.1) I.2.length (actualBlock I hI) n) = (actualBlock I hI n).code at hr |
| have hq := (configurationAt_valid hI n).1 |
| have hc := (actualBlock I hI n).code_state_cylinder hb rfl |
| unfold localSignal signalIncrement |
| rw [hr, haltingSelector_exact hq hc] |
| split_ifs <;> ring |
|
|
| end Alternating.Memory |
|
|
| end OAI |
|
|
