| import Mathlib | |
| import OAI.Analysis.HardSphere.Geometry.HeatScalar | |
| import OAI.Analysis.HardSphere.Orbitals.StrongContractionLimitDense | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped ENNReal Topology BigOperators | |
| noncomputable section | |
| open scoped BigOperators ComplexConjugate | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Real Complex | |
| open scoped ENNReal ComplexConjugate | |
| namespace HardSphere | |
| open scoped Topology | |
| open ContinuousLinearMap | |
| def regularizationWeight (δ x : ℝ) : ℝ := (δ+(1-δ)*x)⁻¹ | |
| lemma regularization_denom_pos {δ x : ℝ} (hδ : 0<δ) (hx : x∈Set.Icc (0:ℝ) 1) : | |
| 0<δ+(1-δ)*x := by | |
| have he : δ+(1-δ)*x=δ*(1-x)+x := by ring | |
| rw [he] | |
| by_cases h : x=0 | |
| · simp [h,hδ] | |
| · exact add_pos_of_nonneg_of_pos (mul_nonneg hδ.le (sub_nonneg.mpr hx.2)) | |
| (lt_of_le_of_ne hx.1 (Ne.symm h)) | |
| lemma regularization_weight_continuous {δ : ℝ} (hδ : 0<δ) : | |
| ContinuousOn (regularizationWeight δ) (Set.Icc (0:ℝ) 1) := by | |
| apply (continuous_const.add (continuous_const.mul continuous_id)).continuousOn.inv₀ | |
| exact fun x hx ↦ ne_of_gt (regularization_denom_pos hδ hx) | |
| lemma regularization_energy_bound {δ x : ℝ} (hδ : 0<δ) (hx : x∈Set.Icc (0:ℝ) 1) : | |
| x*(regularizationWeight δ x)^2 ≤ 1+δ⁻¹*(1-heatScalar δ x) := by | |
| by_cases hx0 : x=0 | |
| · simp only [hx0,zero_mul,heatScalar_zero,sub_zero,mul_one] | |
| positivity | |
| have hxp : 0<x := lt_of_le_of_ne hx.1 (Ne.symm hx0) | |
| let e : ℝ := x⁻¹-1 | |
| have he0 : 0≤e := by | |
| dsimp [e] | |
| exact sub_nonneg.mpr ((one_le_inv₀ hxp).mpr hx.2) | |
| have hd : 0<1+δ*e := by positivity | |
| have hexp : Real.exp (-δ*e)≤(1+δ*e)⁻¹ := by | |
| rw [neg_mul,Real.exp_neg] | |
| exact inv_anti₀ hd (by simpa [add_comm] using Real.add_one_le_exp (δ*e)) | |
| have hh : heatScalar δ x=Real.exp (-δ*e) := by | |
| rw [heatScalar_of_pos hδ hxp] | |
| congr 1 | |
| dsimp [e] | |
| field_simp | |
| ring | |
| have he : x*(regularizationWeight δ x)^2=(1+e)/(1+δ*e)^2 := by | |
| dsimp [regularizationWeight,e] | |
| field_simp | |
| ring | |
| rw [he,hh] | |
| have hden : 1≤1+δ*e := by linarith [mul_nonneg hδ.le he0] | |
| calc | |
| _ ≤ (1+e)/(1+δ*e) := div_le_div_of_nonneg_left (by positivity) hd (by nlinarith) | |
| _ ≤ 1+e/(1+δ*e) := by | |
| apply (div_le_iff₀ hd).mpr | |
| rw [add_mul,div_mul_cancel₀ _ hd.ne'] | |
| nlinarith | |
| _ = 1+δ⁻¹*(1-(1+δ*e)⁻¹) := by field_simp; ring | |
| _ ≤ _ := add_le_add_right (mul_le_mul_of_nonneg_left (sub_le_sub_left hexp _) (inv_nonneg.mpr hδ.le)) _ | |
| section | |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedAddCommGroup F] | |
| [InnerProductSpace ℂ E] [InnerProductSpace ℂ F] [CompleteSpace E] [CompleteSpace F] [Nontrivial F] | |
| local instance scalarOperatorRealAlgebraRegularizedLift : Algebra ℝ (F →L[ℂ] F) := Algebra.restrictScalars ℝ ℂ _ | |
| lemma positive_contraction_spectrum {R : F →L[ℂ] F} (hR : R.IsPositive) (hRn : ‖R‖≤1) : | |
| spectrum ℝ R⊆Set.Icc (0:ℝ) 1 := by | |
| intro x hx | |
| refine ⟨spectrum_nonneg_of_nonneg (ContinuousLinearMap.nonneg_iff_isPositive.mpr hR) hx,?_⟩ | |
| have hb : |x|≤‖R‖ := by simpa only [Real.norm_eq_abs] using spectrum.norm_le_norm_of_mem hx | |
| exact (le_abs_self x).trans (hb.trans hRn) | |
| lemma regularized_lift_norm_sq (A : E →L[ℂ] F) (hA : ‖A‖≤1) {δ : ℝ} | |
| (hδ : 0<δ) (f : F) : | |
| let R := A.comp A.adjoint | |
| let W := cfc (p := IsSelfAdjoint) (regularizationWeight δ) R | |
| ‖A.adjoint (W f)‖^2 ≤ | |
| ‖f‖^2+δ⁻¹*(‖f‖^2-(inner ℂ f ((cfc (p := IsSelfAdjoint) (heatScalar δ) R) f)).re) := by | |
| intro R W | |
| have hRp : R.IsPositive := by | |
| simpa [R] using isPositive_adjoint_comp_self A.adjoint | |
| have hRn : ‖R‖≤1 := by | |
| exact (opNorm_comp_le _ _).trans (by rw [adjoint.norm_map]; nlinarith [norm_nonneg A]) | |
| have hspec := positive_contraction_spectrum hRp hRn | |
| have hw := (regularization_weight_continuous hδ).mono hspec | |
| have hW : IsSelfAdjoint W := IsSelfAdjoint.cfc | |
| have hnorm : ‖A.adjoint (W f)‖^2 = (inner ℂ f | |
| ((cfc (p := IsSelfAdjoint) (fun x ↦ x*(regularizationWeight δ x)^2) R) f)).re := by | |
| rw [norm_sq_eq_re_inner (𝕜 := ℂ)] | |
| have he : cfc (p := IsSelfAdjoint) (fun x ↦ x*(regularizationWeight δ x)^2) R = W*R*W := by | |
| calc | |
| _ = cfc (p := IsSelfAdjoint) (fun x ↦ regularizationWeight δ x*x*regularizationWeight δ x) R := by | |
| congr 1 | |
| funext x | |
| ring | |
| _ = _ := by | |
| rw [cfc_mul (fun x:ℝ ↦ regularizationWeight δ x*x) (regularizationWeight δ) R (hw.mul continuous_id.continuousOn) hw, | |
| cfc_mul (regularizationWeight δ) (fun x:ℝ ↦ x) R hw continuous_id.continuousOn,cfc_id' ℝ R hRp.isSelfAdjoint] | |
| rw [he,mul_apply_eq_comp,mul_apply_eq_comp] | |
| change (inner ℂ (A.adjoint (W f)) (A.adjoint (W f))).re = _ | |
| rw [adjoint_inner_left] | |
| change (inner ℂ (W f) (R (W f))).re = _ | |
| rw [← adjoint_inner_right W f (R (W f)),hW.adjoint_eq] | |
| have hle : cfc (p := IsSelfAdjoint) (fun x ↦ x*(regularizationWeight δ x)^2) R ≤ | |
| cfc (p := IsSelfAdjoint) (fun x ↦ 1+δ⁻¹*(1-heatScalar δ x)) R := | |
| cfc_mono (fun x hx ↦ regularization_energy_bound hδ (hspec hx)) | |
| (continuous_id.continuousOn.mul (hw.pow 2)) | |
| (continuousOn_const.add (continuousOn_const.mul | |
| (continuousOn_const.sub (heatScalar_smooth δ).continuous.continuousOn))) | |
| have hp := ContinuousLinearMap.le_def.mp hle |>.re_inner_nonneg_right f | |
| have heval : cfc (p := IsSelfAdjoint) (fun x ↦ 1+δ⁻¹*(1-heatScalar δ x)) R = | |
| 1+δ⁻¹ • (1-cfc (p := IsSelfAdjoint) (heatScalar δ) R) := by | |
| have hh := (heatScalar_smooth δ).continuous.continuousOn (s := spectrum ℝ R) | |
| rw [cfc_add (a := R) (fun _ : ℝ ↦ 1) (fun x:ℝ ↦ δ⁻¹*(1-heatScalar δ x)) continuousOn_const (continuousOn_const.mul (continuousOn_const.sub hh)), | |
| cfc_mul (fun _ : ℝ ↦ δ⁻¹) (fun x:ℝ ↦ 1-heatScalar δ x) R continuousOn_const (continuousOn_const.sub hh), | |
| cfc_sub (fun _ : ℝ ↦ 1) (heatScalar δ) R continuousOn_const hh, | |
| cfc_const 1 R hRp.isSelfAdjoint,cfc_const δ⁻¹ R hRp.isSelfAdjoint] | |
| simp only [Algebra.algebraMap_eq_smul_one,one_smul,smul_mul_assoc,one_mul] | |
| change 0≤(inner ℂ f ((cfc (p := IsSelfAdjoint) (fun x ↦ 1+δ⁻¹*(1-heatScalar δ x)) R- | |
| cfc (p := IsSelfAdjoint) (fun x ↦ x*(regularizationWeight δ x)^2) R) f)).re at hp | |
| rw [sub_apply,inner_sub_right,Complex.sub_re,heval,add_apply,smul_apply,sub_apply, | |
| one_apply_eq_self,inner_add_right,Complex.add_re] at hp | |
| have hself : (inner ℂ f f).re=‖f‖^2 := (norm_sq_eq_re_inner (𝕜 := ℂ) f).symm | |
| have hi : (inner ℂ f (δ⁻¹ • (f-(cfc (p := IsSelfAdjoint) (heatScalar δ) R) f))).re = | |
| δ⁻¹*(‖f‖^2-(inner ℂ f ((cfc (p := IsSelfAdjoint) (heatScalar δ) R) f)).re) := by | |
| rw [RCLike.real_smul_eq_coe_smul (K := ℂ),inner_smul_real_right,inner_sub_right,Complex.real_smul,Complex.mul_re,Complex.sub_re] | |
| simp only [Complex.ofReal_re,Complex.ofReal_im,zero_mul,sub_zero,hself] | |
| rw [hi,hself,← hnorm] at hp | |
| linarith | |
| end | |
| end HardSphere | |
| namespace HardSphere | |
| open ContinuousLinearMap Filter | |
| open scoped Topology | |
| lemma regularization_scalar_mem {δ x : ℝ} (hδ : 0<δ) (hx : x∈Set.Icc (0:ℝ) 1) : | |
| x*regularizationWeight δ x∈Set.Icc (0:ℝ) 1 := by | |
| have hd := regularization_denom_pos hδ hx | |
| change 0≤x*(δ+(1-δ)*x)⁻¹ ∧ x*(δ+(1-δ)*x)⁻¹≤1 | |
| rw [← div_eq_mul_inv,div_le_one hd] | |
| exact ⟨div_nonneg hx.1 hd.le,by nlinarith [mul_nonneg hδ.le (sub_nonneg.mpr hx.2)]⟩ | |
| lemma regularization_error_bound {δ x : ℝ} (hδ : 0<δ) (hx : x∈Set.Icc (0:ℝ) 1) : | |
| |(x*regularizationWeight δ x-1)*x|≤δ := by | |
| have hs := regularization_scalar_mem hδ hx | |
| have he : (x*regularizationWeight δ x-1)*x = -δ*(1-x)*(x*regularizationWeight δ x) := by | |
| have hd := regularization_denom_pos hδ hx | |
| dsimp [regularizationWeight] | |
| have hi : (δ+(1-δ)*x)*(δ+(1-δ)*x)⁻¹=1 := mul_inv_cancel₀ hd.ne' | |
| nlinarith only [congrArg (fun y:ℝ ↦ y*x) hi] | |
| rw [he,abs_mul,abs_mul,abs_neg,abs_of_pos hδ,abs_of_nonneg (sub_nonneg.mpr hx.2),abs_of_nonneg hs.1] | |
| calc | |
| _ ≤ δ*1*1 := mul_le_mul (mul_le_mul_of_nonneg_left (by linarith [hx.1] : 1-x≤1) hδ.le) | |
| hs.2 hs.1 (by positivity) | |
| _ = δ := by ring | |
| section | |
| variable {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℂ F] | |
| [CompleteSpace F] [Nontrivial F] | |
| local instance : Algebra ℝ (F →L[ℂ] F) := Algebra.restrictScalars ℝ ℂ _ | |
| def regularizationOperator (R : F →L[ℂ] F) (δ : ℝ) : F →L[ℂ] F := | |
| cfc (p := IsSelfAdjoint) (fun x ↦ x*regularizationWeight δ x) R | |
| lemma regularizationOperator_norm_le {R : F →L[ℂ] F} (hRp : R.IsPositive) (hRn : ‖R‖≤1) | |
| {δ : ℝ} (hδ : 0<δ) : ‖regularizationOperator R δ‖≤1 := by | |
| apply norm_cfc_le zero_le_one | |
| intro x hx | |
| have hs := regularization_scalar_mem hδ (positive_contraction_spectrum hRp hRn hx) | |
| simpa only [Real.norm_eq_abs,abs_of_nonneg hs.1] using hs.2 | |
| lemma regularizationOperator_eq {R : F →L[ℂ] F} (hRp : R.IsPositive) (hRn : ‖R‖≤1) | |
| {δ : ℝ} (hδ : 0<δ) : | |
| regularizationOperator R δ = R*cfc (p := IsSelfAdjoint) (regularizationWeight δ) R := by | |
| rw [regularizationOperator,cfc_mul (fun x:ℝ ↦ x) (regularizationWeight δ) R | |
| continuous_id.continuousOn ((regularization_weight_continuous hδ).mono | |
| (positive_contraction_spectrum hRp hRn)),cfc_id' ℝ R hRp.isSelfAdjoint] | |
| lemma regularizationOperator_range_error {R : F →L[ℂ] F} (hRp : R.IsPositive) (hRn : ‖R‖≤1) | |
| {δ : ℝ} (hδ : 0<δ) : ‖(regularizationOperator R δ-1)*R‖≤δ := by | |
| have hw := (regularization_weight_continuous hδ).mono (positive_contraction_spectrum hRp hRn) | |
| have he : (regularizationOperator R δ-1)*R = | |
| cfc (p := IsSelfAdjoint) (fun x ↦ (x*regularizationWeight δ x-1)*x) R := by | |
| rw [cfc_mul (fun x:ℝ ↦ x*regularizationWeight δ x-1) (fun x:ℝ ↦ x) R | |
| ((continuous_id.continuousOn.mul hw).sub continuousOn_const) continuous_id.continuousOn, | |
| cfc_sub (fun x:ℝ ↦ x*regularizationWeight δ x) (fun _:ℝ ↦ 1) R | |
| (continuous_id.continuousOn.mul hw) continuousOn_const, | |
| cfc_const 1 R hRp.isSelfAdjoint,cfc_id' ℝ R hRp.isSelfAdjoint] | |
| simp only [map_one,regularizationOperator] | |
| rw [he] | |
| exact norm_cfc_le hδ.le (fun x hx ↦ by | |
| simpa only [Real.norm_eq_abs] using regularization_error_bound hδ (positive_contraction_spectrum hRp hRn hx)) | |
| lemma regularizationOperator_tendsto {ι : Type*} {l : Filter ι} {d : ι→ℝ} | |
| (hd : ∀ i, 0<d i) (ht : Tendsto d l (𝓝 0)) | |
| {R : F →L[ℂ] F} (hRp : R.IsPositive) (hRn : ‖R‖≤1) (hRd : DenseRange R) (f : F) : | |
| Tendsto (fun i ↦ regularizationOperator R (d i) f) l (𝓝 f) := by | |
| have hC (i : ι) (u : F) : ‖regularizationOperator R (d i) u‖≤‖u‖ := by | |
| exact (le_opNorm _ _).trans (by simpa only [one_mul] using | |
| (mul_le_mul_of_nonneg_right (regularizationOperator_norm_le hRp hRn (hd i)) (norm_nonneg u))) | |
| have hRange : ∀ u : F, Tendsto (fun i ↦ regularizationOperator R (d i) (R u)) l (𝓝 (R u)) := by | |
| intro u | |
| rw [← tendsto_sub_nhds_zero_iff, tendsto_zero_iff_norm_tendsto_zero] | |
| apply squeeze_zero' (g := fun i ↦ d i*‖u‖) (Eventually.of_forall fun _ ↦ norm_nonneg _) ?_ ?_ | |
| · exact Eventually.of_forall fun i ↦ by | |
| change ‖((regularizationOperator R (d i)-1)*R) u‖≤_ | |
| exact (le_opNorm _ _).trans (mul_le_mul_of_nonneg_right | |
| (regularizationOperator_range_error hRp hRn (hd i)) (norm_nonneg u)) | |
| · simpa using ht.mul_const ‖u‖ | |
| have h := strong_contraction_limit_of_dense (fun i ↦ regularizationOperator R (d i)) | |
| (ContinuousLinearMap.id ℂ F) hC (by simp) R hRd hRange f | |
| exact h | |
| end | |
| end HardSphere | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end OAI | |