| import OAI.MathematicalPhysics.AlternatingFlow.MixedPrograms |
|
|
| namespace OAI |
|
|
| section CompilersDevelopment |
|
|
| open scoped BigOperators Topology ContDiff |
| namespace AlternatingNS.Effective |
| attribute [local instance] Arithmetic.rationalCoding |
|
|
| variable {A : Type*} [Primcodable A] |
|
|
| lemma space_norm_le_sum (v : Space) : ‖v‖ ≤ ∑ i : Fin 3, |v i| := by |
| have he : (∑ i : Fin 3, v i • e i) = v := by |
| ext j |
| simp [e, Finset.sum_apply, Pi.single_apply] |
| calc |
| ‖v‖ = ‖∑ i : Fin 3, v i • e i‖ := congrArg norm he.symm |
| _ ≤ ∑ i : Fin 3, ‖v i • e i‖ := norm_sum_le _ _ |
| _ = _ := by simp only [norm_smul, Bounds.norm_e, mul_one, Real.norm_eq_abs] |
|
|
| lemma rationalVector_error (q : RationalVector) (v : Space) (k : ℕ) |
| (h : ∀ i, |v i - rationalVector q i| ≤ (tolerance (k+2) : ℝ)) : |
| ‖rationalVector q - v‖ ≤ dyadicError k := by |
| apply (space_norm_le_sum _).trans |
| have hi (i : Fin 3) : |(rationalVector q-v) i| ≤ (tolerance (k+2) : ℝ) := by |
| change |rationalVector q i-v i| ≤ _ |
| rw [abs_sub_comm] |
| exact h i |
| have hsum : (∑ i : Fin 3, |(rationalVector q-v) i|) ≤ 3 * (tolerance (k+2) : ℝ) := by |
| calc |
| _ ≤ ∑ _i : Fin 3, (tolerance (k+2) : ℝ) := Finset.sum_le_sum (fun i _ => hi i) |
| _ = _ := by simp |
| apply hsum.trans |
| simp only [tolerance_cast, dyadicError, pow_add] |
| nlinarith [pow_pos (by norm_num : (0:ℝ)<1/2) k] |
|
|
| lemma mul_precision (C k : ℕ) : (C : ℝ) * (tolerance (k+C) : ℝ) ≤ tolerance k := by |
| rw [tolerance_add, mul_left_comm] |
| exact mul_le_of_le_one_right (tolerance_pos _).le (nat_mul_tolerance C) |
|
|
| abbrev EvalInput := ℕ × IndexCode × RationalPoint × ℕ |
| abbrev ModInput := ℕ × IndexCode × ℕ × ℕ |
| abbrev BoundInput := ℕ × ℕ × IndexCode |
|
|
| def sample (b : (((A × Fin 3) × List (Fin 4)) × RationalPoint) × ℕ → ℚ) |
| (a : A) (q : EvalInput) (i : Fin 3) : ℚ := |
| b ((((a,i),mixedWord q.1 q.2.1),q.2.2.1),q.2.2.2+2) |
|
|
| def values (b : (((A × Fin 3) × List (Fin 4)) × RationalPoint) × ℕ → ℚ) |
| (a : A) (q : EvalInput) : RationalVector := |
| (sample b a q 0,sample b a q 1,sample b a q 2) |
|
|
| lemma sample_computable (b : (((A × Fin 3) × List (Fin 4)) × RationalPoint) × ℕ → ℚ) |
| (hb : Computable b) (i : Fin 3) : Computable₂ (fun a : A => fun q : EvalInput => sample b a q i) := by |
| have hl : Computable (fun z : A × EvalInput => z.2.1) := Computable.fst.comp Computable.snd |
| have hα : Computable (fun z : A × EvalInput => z.2.2.1) := Computable.fst.comp (Computable.snd.comp Computable.snd) |
| have hq : Computable (fun z : A × EvalInput => z.2.2.2.1) := Computable.fst.comp (Computable.snd.comp (Computable.snd.comp Computable.snd)) |
| have hk : Computable (fun z : A × EvalInput => z.2.2.2.2) := Computable.snd.comp (Computable.snd.comp (Computable.snd.comp Computable.snd)) |
| exact hb.comp ((((Computable.fst.pair (Computable.const i)).pair |
| (mixedWord_computable.comp hl hα)).pair hq).pair |
| (Primrec.nat_add.to_comp.comp hk (Computable.const 2))) |
|
|
| lemma values_computable (b : (((A × Fin 3) × List (Fin 4)) × RationalPoint) × ℕ → ℚ) |
| (hb : Computable b) : Computable₂ (values b) := |
| (sample_computable b hb 0).pair ((sample_computable b hb 1).pair (sample_computable b hb 2)) |
|
|
| def modulus (B : A × ℕ × ℕ → ℕ) (a : A) (q : ModInput) : ℕ := |
| q.2.2.2 + B (a,0,(mixedWord q.1 q.2.1).length+1) |
|
|
| lemma modulus_computable (B : A × ℕ × ℕ → ℕ) (hB : Computable B) : Computable₂ (modulus B) := by |
| have hl : Computable (fun z : A × ModInput => z.2.1) := Computable.fst.comp Computable.snd |
| have hα : Computable (fun z : A × ModInput => z.2.2.1) := Computable.fst.comp (Computable.snd.comp Computable.snd) |
| have hk : Computable (fun z : A × ModInput => z.2.2.2.2) := Computable.snd.comp (Computable.snd.comp (Computable.snd.comp Computable.snd)) |
| exact Primrec.nat_add.to_comp.comp hk (hB.comp (Computable.fst.pair |
| ((Computable.const 0).pair (Computable.succ.comp (Computable.list_length.comp |
| (mixedWord_computable.comp hl hα)))))) |
|
|
| def bound (B : A × ℕ × ℕ → ℕ) (a : A) (q : BoundInput) : ℕ := |
| B (a,q.1,(mixedWord q.2.1 q.2.2).length) |
|
|
| lemma bound_computable (B : A × ℕ × ℕ → ℕ) (hB : Computable B) : Computable₂ (bound B) := by |
| have hJ : Computable (fun z : A × BoundInput => z.2.1) := Computable.fst.comp Computable.snd |
| have hl : Computable (fun z : A × BoundInput => z.2.2.1) := Computable.fst.comp (Computable.snd.comp Computable.snd) |
| have hα : Computable (fun z : A × BoundInput => z.2.2.2) := Computable.snd.comp (Computable.snd.comp Computable.snd) |
| exact hB.comp (Computable.fst.pair (hJ.pair |
| (Computable.list_length.comp (mixedWord_computable.comp hl hα)))) |
|
|
| lemma Certified.programs {f : A → Velocity} |
| (hf : Certified (fun a => Function.uncurry (f a))) |
| (hn : Named (fun z : (A × Fin 3) × RationalPoint => |
| f z.1.1 (rationalPoint z.2).1 (rationalPoint z.2).2 z.1.2)) : |
| ∃ compile : A → FieldProgram, Computable compile ∧ ∀ a, ProgramFor (compile a) (f a) := by |
| obtain ⟨b,hb,hbError⟩ := hf.jetBound.named_component_words hn |
| obtain ⟨sf,B,hB,hBound⟩ := hf |
| obtain ⟨ce,hce,he⟩ := compiler_of_computable (values b) (values_computable b hb) |
| obtain ⟨cm,hcm,hm⟩ := compiler_of_computable (modulus B) (modulus_computable B hB) |
| obtain ⟨cb,hcb,hc⟩ := compiler_of_computable (bound B) (bound_computable B hB) |
| refine ⟨fun a => (ce a,cm a,cb a), hce.pair (hcm.pair hcb), fun a => ⟨?_,?_,?_⟩⟩ |
| · intro l α q k |
| refine ⟨values b a (l,α,q,k),?_,fun ht => ?_⟩ |
| · have hh := he a (l,α,q,k) |
| rcases q with ⟨t,x,y,z⟩ |
| simpa only [Returns, values, Encodable.encode_prod_val, Arithmetic.rationalCoding_encode] using hh |
| · rw [mixed_eq_wordJet (f a) (sf a) l α _ (by change 0 ≤ (q.1 : ℝ); exact_mod_cast ht)] |
| apply rationalVector_error |
| intro i |
| have hh := hbError (((a,i),mixedWord l α),q) (k+2) |
| have heq : rationalVector (values b a (l,α,q,k)) i = (sample b a (l,α,q,k) i : ℝ) := by |
| fin_cases i <;> rfl |
| rw [heq] |
| exact hh |
| · intro l α R k |
| refine ⟨modulus B a (l,α,R,k),hm a (l,α,R,k),fun z z' ht ht' _ _ hd => ?_⟩ |
| rw [mixed_eq_wordJet (f a) (sf a) l α z.1 ht z.2, |
| mixed_eq_wordJet (f a) (sf a) l α z'.1 ht' z'.2] |
| let C := B (a,0,(mixedWord l α).length+1) |
| have hC (y : ℝ × Space) : ‖iteratedFDeriv ℝ 1 (wordJet (Function.uncurry (f a)) (mixedWord l α)) y‖ ≤ C := by |
| have hC' : ‖iteratedFDeriv ℝ (1+(mixedWord l α).length) (Function.uncurry (f a)) y‖ ≤ C := by |
| rw [Nat.add_comm 1 (mixedWord l α).length] |
| simpa only [C, pow_zero, one_mul] using hBound a 0 ((mixedWord l α).length+1) y |
| exact (wordJet_bound (sf a) (mixedWord l α) 1 y).trans hC' |
| have hLip := jet_lipschitz (wordJet_smooth (sf a) (mixedWord l α)) C hC z z' |
| exact hLip.trans ((mul_le_mul_of_nonneg_left hd (Nat.cast_nonneg C)).trans (by |
| simpa only [modulus, C, tolerance_cast] using mul_precision C k)) |
| · intro J l α |
| refine ⟨bound B a (J,l,α),hc a (J,l,α),fun t ht x => ?_⟩ |
| rw [mixed_eq_wordJet (f a) (sf a) l α t ht x] |
| have hnorm : ‖wordJet (Function.uncurry (f a)) (mixedWord l α) (t,x)‖ ≤ |
| ‖iteratedFDeriv ℝ (mixedWord l α).length (Function.uncurry (f a)) (t,x)‖ := by |
| have hh := wordJet_bound (sf a) (mixedWord l α) 0 (t,x) |
| rw [Nat.zero_add] at hh |
| simpa only [norm_iteratedFDeriv_zero] using hh |
| apply (mul_le_mul_of_nonneg_left hnorm (by positivity : (0:ℝ) ≤ (1+t+‖x‖)^J)).trans |
| simpa only [bound, weight, abs_of_nonneg ht] using hBound a J (mixedWord l α).length (t,x) |
|
|
| end AlternatingNS.Effective |
|
|
| namespace AlternatingNS |
|
|
| lemma ProgramFor.congr_half {c : FieldProgram} {f g : Velocity} |
| (hf : ProgramFor c f) (h : Bounds.HalfEq f g) : ProgramFor c g := by |
| refine ⟨?_,?_,?_⟩ |
| · intro l α q k |
| obtain ⟨v,hv,he⟩ := hf.1 l α q k |
| refine ⟨v,hv,fun ht => ?_⟩ |
| rw [← h.mixed l (index α) _ (by change 0 ≤ (q.1 : ℝ); exact_mod_cast ht) _] |
| exact he ht |
| · intro l α R k |
| obtain ⟨m,hm,he⟩ := hf.2.1 l α R k |
| refine ⟨m,hm,fun z z' ht ht' hz hz' hd => ?_⟩ |
| rw [← h.mixed l (index α) _ ht _, ← h.mixed l (index α) _ ht' _] |
| exact he z z' ht ht' hz hz' hd |
| · intro J l α |
| obtain ⟨B,hB,he⟩ := hf.2.2 J l α |
| refine ⟨B,hB,fun t ht x => ?_⟩ |
| rw [← h.mixed l (index α) _ ht _] |
| exact he t ht x |
|
|
| end AlternatingNS |
|
|
| end CompilersDevelopment |
|
|
| end OAI |
|
|
