| import OAI.MathematicalPhysics.RapidForcing.FieldExpressions |
|
|
| namespace OAI |
|
|
| open scoped BigOperators Topology ENNReal ContDiff |
| open Set Filter |
| namespace RapidForcing |
|
|
| lemma finite_order (k : ℕ) : (k : ℕ∞ω) ≤ (⊤ : ℕ∞) := by |
| exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤) |
|
|
| section JetEstimates |
| variable {E F G : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] |
| lemma jet_sum_le {ι : Type} (s : Finset ι) (f : ι → E → F) |
| (hf : ∀ i ∈ s, ContDiff ℝ (⊤ : ℕ∞) (f i)) (k : ℕ) (x : E) : |
| ‖iteratedFDeriv ℝ k (fun y => ∑ i ∈ s, f i y) x‖ ≤ |
| ∑ i ∈ s, ‖iteratedFDeriv ℝ k (f i) x‖ := by |
| rw [iteratedFDeriv_fun_sum_apply (fun i hi => ((hf i hi).of_le (finite_order k)).contDiffAt)] |
| exact norm_sum_le _ _ |
| lemma jet_postcomp_le (L : F →L[ℝ] G) {f : E → F} |
| (hf : ContDiff ℝ (⊤ : ℕ∞) f) (k : ℕ) (x : E) (C : ℝ) (hC : ‖L‖ ≤ C) : |
| ‖iteratedFDeriv ℝ k (fun y => L (f y)) x‖ ≤ C * ‖iteratedFDeriv ℝ k f x‖ := |
| (L.norm_iteratedFDeriv_comp_left hf.contDiffAt (finite_order k)).trans |
| (mul_le_mul_of_nonneg_right hC (norm_nonneg _)) |
| lemma jet_smul_const_le {f : E → ℝ} (hf : ContDiff ℝ (⊤ : ℕ∞) f) |
| (v : F) (k : ℕ) (x : E) : |
| ‖iteratedFDeriv ℝ k (fun y => f y • v) x‖ ≤ ‖v‖ * ‖iteratedFDeriv ℝ k f x‖ := by |
| exact jet_postcomp_le (ContinuousLinearMap.toSpanSingleton ℝ v) hf k x ‖v‖ |
| (by rw [ContinuousLinearMap.norm_toSpanSingleton]) |
| end JetEstimates |
|
|
| namespace EffectiveProfile.Formula |
| variable {d : ℕ} |
| lemma fderiv_eq_sum (a : Formula d) (x : Fin d → ℝ) : |
| fderiv ℝ a.value x = ∑ i : Fin d, (a.diff i).value x • ContinuousLinearMap.proj i := by |
| ext v |
| have he : v = ∑ i : Fin d, (v i) • Pi.single i (1 : ℝ) := by |
| simpa only [← Pi.single_smul, smul_eq_mul, mul_one] using (Finset.univ_sum_single v).symm |
| calc |
| _ = ∑ i : Fin d, v i * (a.diff i).value x := by |
| rw [he, map_sum] |
| apply Finset.sum_congr rfl |
| intro i _ |
| simp only [map_smul, fderiv_apply_single, smul_eq_mul] |
| congr 1 |
| exact congrFun he i |
| _ = _ := by simp [mul_comm] |
|
|
| lemma jet_succ_le (a : Formula d) (k : ℕ) (x : Fin d → ℝ) : |
| ‖iteratedFDeriv ℝ (k+1) a.value x‖ ≤ |
| ∑ i : Fin d, ‖iteratedFDeriv ℝ k (a.diff i).value x‖ := by |
| rw [← norm_iteratedFDeriv_fderiv] |
| have he : fderiv ℝ a.value = fun y => ∑ i : Fin d, |
| (a.diff i).value y • ContinuousLinearMap.proj i := funext (a.fderiv_eq_sum) |
| rw [he] |
| apply (jet_sum_le _ _ (fun i _ => (a.diff i).contDiff.smul contDiff_const) _ _).trans |
| apply Finset.sum_le_sum |
| intro i _ |
| have hp : ‖(ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ)‖ ≤ 1 := |
| ContinuousLinearMap.opNorm_le_bound _ zero_le_one (fun v => by simpa using norm_le_pi_norm v i) |
| exact (jet_smul_const_le (a.diff i).contDiff _ k x).trans (by |
| simpa using mul_le_mul_of_nonneg_right hp (norm_nonneg (iteratedFDeriv ℝ k (a.diff i).value x))) |
|
|
| def allDiff (as : List (Formula d)) : List (Formula d) := |
| as.flatMap fun a => (List.finRange d).map (fun i => a.diff i) |
|
|
| def jetBound (R : ℚ) (k : ℕ) (a : Formula d) : ℚ := |
| ((allDiff^[k] [a]).map (fun e => e.bound R)).sum |
|
|
| lemma jetBound_nonneg (R : ℚ) (k : ℕ) (a : Formula d) : 0 ≤ a.jetBound R k := by |
| apply List.sum_nonneg |
| intro r hr |
| obtain ⟨e, _, rfl⟩ := List.mem_map.mp hr |
| exact e.bound_nonneg R |
|
|
| lemma jet_list_le (R : ℚ) (k : ℕ) (as : List (Formula d)) (x : Fin d → ℝ) |
| (hx : ∀ i, |x i| ≤ |(R : ℝ)|) : |
| (as.map fun a => ‖iteratedFDeriv ℝ k a.value x‖).sum ≤ |
| (((allDiff^[k] as).map fun a => a.bound R).sum : ℚ) := by |
| induction k generalizing as with |
| | zero => |
| simp only [Function.iterate_zero_apply, norm_iteratedFDeriv_zero, Real.norm_eq_abs] |
| induction as with |
| | nil => simp |
| | cons a as ih => |
| simpa only [List.map_cons, List.sum_cons, Rat.cast_add] using add_le_add (a.abs_value_le R x hx) ih |
| | succ k ih => |
| rw [Function.iterate_succ_apply] |
| apply le_trans _ (ih (allDiff as)) |
| induction as with |
| | nil => simp [allDiff] |
| | cons a as ih' => |
| simp only [List.map_cons, List.sum_cons, allDiff, List.flatMap_cons, List.map_append, List.sum_append] at ih' ⊢ |
| apply add_le_add _ ih' |
| simpa only [List.map_map, Function.comp_def, ← List.ofFn_eq_map, List.map_ofFn, List.sum_ofFn] using a.jet_succ_le k x |
|
|
| lemma norm_jet_le (R : ℚ) (k : ℕ) (a : Formula d) (x : Fin d → ℝ) |
| (hx : ∀ i, |x i| ≤ |(R : ℝ)|) : |
| ‖iteratedFDeriv ℝ k a.value x‖ ≤ (a.jetBound R k : ℝ) := by |
| simpa only [List.map_singleton, List.sum_singleton, jetBound] using jet_list_le R k [a] x hx |
| end EffectiveProfile.Formula |
| end RapidForcing |
|
|
| end OAI |
|
|
