| import OAI.MathematicalPhysics.RapidForcing.AnalyticResult |
| import OAI.MathematicalPhysics.RapidForcing.BoundsPrograms |
| import OAI.MathematicalPhysics.RapidForcing.EvaluatorPrograms |
|
|
| namespace OAI |
|
|
| section |
| open Encodable Nat.Partrec |
| open scoped BigOperators |
| namespace RapidForcing |
| open EffectiveArithmetic |
|
|
| abbrev BoundQuery := ℕ × ℕ × ℕ × ℕ × ℕ |
| abbrev BoundParameters := RawInput × ℚ |
|
|
| def boundTable (p : BoundParameters × BoundQuery) : ℕ := |
| ⌈2^p.2.1 * forceJetBound (RawMachine.scaleData p.1.1.1 p.1.1.2) p.1.2 |
| p.2.1 (p.2.2.1 + p.2.2.2.1 + p.2.2.2.2.1 + p.2.2.2.2.2)⌉₊ |
|
|
| attribute [local irreducible] forceJetBound velocityJetBound RawMachine.scaleData |
|
|
| @[fun_prop] lemma computable_boundTable : Computable boundTable := by |
| let F (p : BoundParameters × BoundQuery) := |
| forceJetBound (RawMachine.scaleData p.1.1.1 p.1.1.2) p.1.2 |
| p.2.1 (p.2.2.1 + p.2.2.2.1 + p.2.2.2.2.1 + p.2.2.2.2.2) |
| have hf : Computable F := by |
| unfold F |
| apply computable_forceJetBound.comp (g := fun p : BoundParameters × BoundQuery => |
| (RawMachine.scaleData p.1.1.1 p.1.1.2, p.1.2, p.2.1, |
| p.2.2.1 + p.2.2.2.1 + p.2.2.2.2.1 + p.2.2.2.2.2)) |
| apply Computable.pair |
| · exact RawMachine.computable_scaleData.comp (Computable.fst.comp Computable.fst) |
| · fun_prop |
| have hw : Computable (fun p : BoundParameters × BoundQuery => (2:ℚ)^p.2.1) := by fun_prop |
| exact (computable_rat_natCeil.comp (computable_rat_mul.comp (hw.pair hf))).of_eq (fun _ => rfl) |
|
|
| noncomputable def boundsProgram (p : BoundParameters) : Program := |
| (typedCode (fun p => Part.some (boundTable p)) computable_boundTable.partrec).curry (encode p) |
|
|
| @[fun_prop] lemma computable_boundsProgram : Computable boundsProgram := |
| computable_specialize.comp ((Computable.const _).pair Computable.id) |
|
|
| lemma boundsProgram_eval (p : BoundParameters) (q : BoundQuery) : |
| (boundsProgram p).eval (encode q) = Part.some (boundTable (p,q)) := by |
| rw [boundsProgram, Code.eval_curry, ← encode_prod_val] |
| exact (typedCode_eval (fun a => Part.some (boundTable a)) computable_boundTable.partrec (p,q)).trans rfl |
|
|
| lemma boundsProgram_spec (ν : ℝ) (νBound : ℚ) (hν : ‖ν‖ ≤ (νBound:ℝ)) |
| (M : Machine) (w : M.Input) : |
| BoundsMixed (boundsProgram ((M.description, w.map Fin.val), νBound)) |
| (addressedForce ν M w) := by |
| intro J l α |
| let C := boundTable (((M.description, w.map Fin.val), νBound), |
| (J, l, α 0, α 1, α 2)) |
| refine ⟨C, ?_, ?_⟩ |
| · rw [boundQuery, boundsProgram_eval] |
| exact Part.mem_some _ |
| · intro t ht x |
| have hb := (addressedForce_jetControl ν νBound hν M w).mixed_bound J l α t ht x |
| apply hb.trans |
| dsimp [C, boundTable] |
| rw [Machine.description_scaleData] |
| exact_mod_cast (Nat.le_ceil (2^J * forceJetBound (M.scaleData w) νBound J |
| (l+α 0+α 1+α 2))) |
|
|
| def decodeInput (n : ℕ) : RawInput := |
| (decode n).getD ((1,1,0,[]), []) |
|
|
| @[fun_prop] lemma computable_decodeInput : Computable decodeInput := |
| Computable.option_getD Computable.decode (Computable.const _) |
|
|
| @[simp] lemma decodeInput_description (M : Machine) (w : M.Input) : |
| decodeInput (M.inputDescription w) = (M.description, w.map Fin.val) := by |
| simp [decodeInput, Machine.inputDescription] |
|
|
| noncomputable def forceCompiler (visc : Program) (νBound : ℚ) (n : ℕ) : ℕ × ℕ := |
| (encode (evaluationProgram (decodeInput n, visc)), |
| encode (boundsProgram (decodeInput n, νBound))) |
|
|
| lemma computable_forceCompiler (visc : Program) (νBound : ℚ) : |
| Computable (forceCompiler visc νBound) := by |
| apply Computable.pair |
| · exact Computable.encode.comp (computable_evaluationProgram.comp |
| (computable_decodeInput.pair (Computable.const visc))) |
| · exact Computable.encode.comp (computable_boundsProgram.comp |
| (computable_decodeInput.pair (Computable.const νBound))) |
|
|
| @[simp] lemma ofNatCode_encode (c : Program) : Code.ofNatCode (encode c) = c := |
| Denumerable.ofNat_encode c |
|
|
| lemma forceCompiler_spec (ν : ℝ) (visc : Program) (hν : NamesReal visc ν) |
| (νBound : ℚ) (hb : ‖ν‖ ≤ (νBound:ℝ)) (M : Machine) (w : M.Input) : |
| ForceProgram (forceCompiler visc νBound (M.inputDescription w)) (addressedForce ν M w) := by |
| simp only [ForceProgram, forceCompiler, ofNatCode_encode, decodeInput_description] |
| exact ⟨evaluationProgram_spec ν visc hν M w, boundsProgram_spec ν νBound hb M w⟩ |
|
|
| lemma computableReal_norm_bound (ν : ℝ) (visc : Program) (hν : NamesReal visc ν) : |
| ∃ q : ℚ, ‖ν‖ ≤ (q:ℝ) := by |
| obtain ⟨q, _, he⟩ := hν 0 |
| refine ⟨|q|+1, ?_⟩ |
| have h := norm_add_le (ν-(q:ℝ)) (q:ℝ) |
| simp only [sub_add_cancel, Real.norm_eq_abs, abs_sub_comm ν (q:ℝ)] at h |
| simp only [accuracy, pow_zero] at he |
| rw [Rat.cast_add, Rat.cast_abs, Rat.cast_one, Real.norm_eq_abs] |
| linarith |
|
|
| theorem addressed_effective (ν : ℝ) (hνcomp : ComputableReal ν) : |
| ∃ compile : ℕ → ℕ × ℕ, Computable compile ∧ ∀ (M : Machine) (w : M.Input), |
| ForceProgram (compile (M.inputDescription w)) (addressedForce ν M w) := by |
| obtain ⟨visc,hν⟩ := hνcomp |
| obtain ⟨νBound, hb⟩ := computableReal_norm_bound ν visc hν |
| exact ⟨forceCompiler visc νBound, computable_forceCompiler visc νBound, |
| forceCompiler_spec ν visc hν νBound hb⟩ |
|
|
| theorem compact_support_rapid_decay (ν : ℝ) (hν : 0 < ν) |
| (hνcomp : ComputableReal ν) : |
| ∃ compile : ℕ → ℕ × ℕ, Computable compile ∧ |
| ∀ (M : Machine) (w : M.Input), |
| let u := addressedVelocity M w |
| let f := addressedForce ν M w |
| ForceProgram (compile (M.inputDescription w)) f ∧ |
| Smooth f ∧ Supported f ∧ Rapid f ∧ RapidSpaceTime f ∧ |
| Smooth u ∧ Supported u ∧ Rapid u ∧ RapidSpaceTime u ∧ |
| UniqueEnergySolution ν f u (fun _ _ => 0) ∧ |
| ∃ X : ℝ → Space → Space, MaterialFlow u X ∧ |
| (M.Halts w ↔ ∃ t : ℝ, 0 ≤ t ∧ (X t 0) 0 < -1) := by |
| obtain ⟨compile, hc, hf⟩ := addressed_effective ν hνcomp |
| exact ⟨compile, hc, fun M w => ⟨hf M w, addressed_analytic_realization ν hν M w⟩⟩ |
| end RapidForcing |
|
|
| end |
|
|
| end OAI |
|
|
