| import Mathlib |
| import OAI.Probability.SKBarriers.Calculus.ParameterDerivatives |
| import OAI.Probability.SKBarriers.Calculus.ParameterSmooth |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory ProbabilityTheory Filter |
| namespace SK.Analytic |
| theorem ParamExpGrowth.weakAdd {P E F : Type} [NormedAddCommGroup P] |
| [NormedAddCommGroup E] [Norm F] [Add F] {f g : P × E → F} |
| (hf : ParamExpGrowth f) (hg : ParamExpGrowth g) |
| (hadd : ∀ z, ‖f z+g z‖ ≤ ‖f z‖+‖g z‖) : ParamExpGrowth (fun z => f z+g z) := by |
| intro R |
| obtain ⟨C,M,hC,hM,hf⟩ := hf R |
| obtain ⟨D,L,hD,hL,hg⟩ := hg R |
| refine ⟨C+D,max M L,add_nonneg hC hD,(le_max_left M L).trans' hM,?_⟩ |
| intro p e hp |
| calc |
| _ ≤ ‖f (p,e)‖+‖g (p,e)‖ := hadd (p,e) |
| _ ≤ C*Real.exp (M*‖e‖)+D*Real.exp (L*‖e‖) := add_le_add (hf p e hp) (hg p e hp) |
| _ ≤ C*Real.exp (max M L*‖e‖)+D*Real.exp (max M L*‖e‖) := by |
| gcongr <;> first | exact le_max_left _ _ | exact le_max_right _ _ |
| _ = _ := by ring |
|
|
| section ParameterAlgebra |
| variable {P E : Type} [NormedAddCommGroup P] [NormedSpace ℝ P] |
| [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| def ParamSmooth (f : P × E → ℝ) : Prop := |
| ContDiff ℝ 2 f ∧ ParamExpGrowth f ∧ ParamExpGrowth (fderiv ℝ f) ∧ |
| ParamExpGrowth (fderiv ℝ (fderiv ℝ f)) |
|
|
| theorem ParamSmooth.add {f g : P × E → ℝ} (hf : ParamSmooth f) (hg : ParamSmooth g) : |
| ParamSmooth (fun z => f z+g z) := by |
| have he : fderiv ℝ (fun z => f z+g z) = fun z => fderiv ℝ f z+fderiv ℝ g z := by |
| funext z |
| exact ((hf.1.differentiable (by norm_num) z).hasFDerivAt.fun_add |
| (hg.1.differentiable (by norm_num) z).hasFDerivAt).fderiv |
| have he₂ : fderiv ℝ (fderiv ℝ (fun z => f z+g z)) = |
| fun z => fderiv ℝ (fderiv ℝ f) z+fderiv ℝ (fderiv ℝ g) z := by |
| rw [he] |
| funext z |
| exact (((hf.1.fderiv_right (m := 1) (by norm_num)).differentiable (by norm_num) z).hasFDerivAt.fun_add |
| ((hg.1.fderiv_right (m := 1) (by norm_num)).differentiable (by norm_num) z).hasFDerivAt).fderiv |
| refine ⟨hf.1.add hg.1,hf.2.1.add hg.2.1,?_,?_⟩ |
| · rw [he] |
| exact hf.2.2.1.add hg.2.2.1 |
| · rw [he₂] |
| exact hf.2.2.2.weakAdd hg.2.2.2 (fun _ => ContinuousLinearMap.opNorm_add_le _ _) |
|
|
| theorem paramSmooth_const (c : ℝ) : ParamSmooth (fun _ : P × E => c) := by |
| refine ⟨contDiff_const,?_,?_,?_⟩ |
| · exact ParamExpGrowth.of_bounded (norm_nonneg c) (fun _ => le_rfl) |
| · exact ParamExpGrowth.of_bounded (C := 0) le_rfl (by intro z; simp) |
| · have he : fderiv ℝ (fun _ : P × E => c) = fun _ => (0 : P × E →L[ℝ] ℝ) := by |
| funext z |
| simp |
| rw [he] |
| intro R |
| refine ⟨0,0,le_rfl,le_rfl,?_⟩ |
| intro p e _ |
| simp only [fderiv_const_apply,ContinuousLinearMap.opNorm_zero,zero_mul,le_refl] |
|
|
| theorem ParamSmooth.sum {ι : Type} (s : Finset ι) (f : ι → P × E → ℝ) |
| (hf : ∀ i ∈ s, ParamSmooth (f i)) : ParamSmooth (fun z => ∑ i ∈ s, f i z) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simpa only [Finset.sum_empty] using (paramSmooth_const (P := P) (E := E) 0) |
| | @insert a s ha ih => |
| simpa only [Finset.sum_insert ha] using (hf a (Finset.mem_insert_self a s)).add |
| (ih (fun i hi => hf i (Finset.mem_insert_of_mem hi))) |
|
|
| theorem ParamRegular.toSmooth {f : P × E → ℝ} (hf : ParamRegular f) : ParamSmooth f := |
| ⟨hf.1,hf.2.1.expGrowth,hf.2.2⟩ |
|
|
| theorem ParamRegular.expSmooth {f : P × E → ℝ} (hf : ParamRegular f) : |
| ParamSmooth (fun z => Real.exp (f z)) := by |
| have hg : ParamExpGrowth (fun z => Real.exp (f z)) := by |
| simpa only [one_mul] using hf.2.1.exp_mul 1 |
| exact ⟨hf.1.exp,hg, |
| param_fderiv_exp_growth f id (hf.1.differentiable (by norm_num)) hg hf.2.2.1, |
| param_second_exp_growth f id hf.1 hg hf.2.2.1 hf.2.2.2⟩ |
|
|
| omit [NormedSpace ℝ P] [NormedSpace ℝ E] in |
| theorem ParamLinearGrowth.add {f g : P × E → ℝ} (hf : ParamLinearGrowth f) |
| (hg : ParamLinearGrowth g) : ParamLinearGrowth (fun z => f z+g z) := by |
| intro R |
| obtain ⟨C,hC,hf⟩ := hf R |
| obtain ⟨D,hD,hg⟩ := hg R |
| refine ⟨C+D,add_nonneg hC hD,?_⟩ |
| intro p e hp |
| exact (abs_add_le _ _).trans ((add_le_add (hf p e hp) (hg p e hp)).trans_eq (add_mul _ _ _).symm) |
|
|
| theorem ParamRegular.add {f g : P × E → ℝ} (hf : ParamRegular f) (hg : ParamRegular g) : |
| ParamRegular (fun z => f z+g z) := by |
| have H := hf.toSmooth.add hg.toSmooth |
| exact ⟨H.1,hf.2.1.add hg.2.1,H.2.2⟩ |
|
|
| theorem paramRegular_const (c : ℝ) : ParamRegular (fun _ : P × E => c) := by |
| have H := paramSmooth_const (P := P) (E := E) c |
| refine ⟨H.1,?_,H.2.2⟩ |
| intro R |
| refine ⟨|c|,abs_nonneg c,?_⟩ |
| intro p e _ |
| nlinarith [abs_nonneg c,norm_nonneg e] |
| end ParameterAlgebra |
| end SK.Analytic |
|
|
| end |
| end |
|
|
| end |
|
|
| end OAI |
|
|
