| import Mathlib |
| import OAI.Analysis.HardSphere.Thermodynamics.SpatialCloseScale |
| import OAI.Analysis.HardSphere.Geometry.SmoothSiteWeight |
|
|
| 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 |
| open ProbabilityTheory |
| noncomputable section |
| open MeasureTheory Filter Set |
| open scoped ENNReal Topology |
| noncomputable section |
| open MeasureTheory Set |
| open scoped ENNReal |
| namespace HardSphere |
| open MeasureTheory Set Filter ProbabilityTheory |
| open scoped ComplexConjugate |
| noncomputable section |
|
|
| def expWeightedMultiplier (n : ℕ) (L : Length) (A : Finset (Torus L)) (t : ℝ) : SmoothMultiplier n L := |
| (smoothWeightedCountMultiplier n L A).realComp (fun x ↦ Real.exp (t*x/2)) |
| (Real.contDiff_exp.comp ((contDiff_const.mul contDiff_id).div_const 2)) |
|
|
| lemma expWeightedMultiplier_apply (n : ℕ) (L : Length) (A : Finset (Torus L)) (t : ℝ) (X : Configuration n L) : |
| (expWeightedMultiplier n L A t).toFun X=(Real.exp (t*smoothWeightedCount L A X/2):ℂ) := by |
| change (Real.exp (t*((smoothWeightedCountMultiplier n L A).toFun X).re/2):ℂ)=_ |
| rw [smoothWeightedCountMultiplier_apply,Complex.ofReal_re] |
|
|
| lemma expWeightedMultiplier_real (n : ℕ) (L : Length) (A : Finset (Torus L)) (t : ℝ) (X : Configuration n L) : |
| conj ((expWeightedMultiplier n L A t).toFun X)=(expWeightedMultiplier n L A t).toFun X := by |
| rw [expWeightedMultiplier_apply,Complex.conj_ofReal] |
|
|
| lemma expWeightedMultiplier_norm_sq (n : ℕ) (L : Length) (A : Finset (Torus L)) (t : ℝ) (X : Configuration n L) : |
| ‖(expWeightedMultiplier n L A t).toFun X‖^2=Real.exp (t*smoothWeightedCount L A X) := by |
| rw [expWeightedMultiplier_apply,Complex.norm_real,Real.norm_eq_abs,sq_abs,←Real.exp_nat_mul] |
| congr 1 |
| ring |
|
|
| lemma expWeightedMultiplier_partial_sq (n : ℕ) (L : Length) (A : Finset (Torus L)) (t : ℝ) |
| (p : Direction n) (X : Configuration n L) : |
| ‖coordDerivative n L (expWeightedMultiplier n L A t).toFun p X‖^2= |
| (t^2/4)*Real.exp (t*smoothWeightedCount L A X)* |
| ‖coordDerivative n L (smoothWeightedCountMultiplier n L A).toFun p X‖^2 := by |
| rw [expWeightedMultiplier,SmoothMultiplier.partial_realComp _ _ _ (smoothWeightedCountMultiplier_real n L A)] |
| have hd (x : ℝ) : deriv (fun x : ℝ ↦ Real.exp (t*x/2)) x=(t/2)*Real.exp (t*x/2) := by |
| simpa [mul_comm] using ((((hasDerivAt_id x).const_mul t).div_const 2).exp).deriv |
| rw [hd,smoothWeightedCountMultiplier_apply,Complex.ofReal_re,norm_mul,mul_pow, |
| Complex.norm_real,Real.norm_eq_abs,sq_abs,mul_pow,←Real.exp_nat_mul] |
| congr 1 |
| congr 1 |
| · ring |
| · congr 1; ring |
|
|
| lemma expWeightedMultiplier_gradient (n : ℕ) (L : Length) (A : Finset (Torus L)) (t : ℝ) |
| (X : Configuration n L) : |
| (∑ p : Direction n, ‖coordDerivative n L (expWeightedMultiplier n L A t).toFun p X‖^2)≤ |
| (t^2/4)*(3*(spatialMetricConstant:ℝ)^2*Real.exp 1)* |
| (smoothWeightedCount L A X*Real.exp (t*smoothWeightedCount L A X)) := by |
| simp_rw [expWeightedMultiplier_partial_sq,←Finset.mul_sum] |
| apply (mul_le_mul_of_nonneg_left (smoothWeightedCount_gradient L A X) |
| (by positivity : 0≤t^2/4*Real.exp (t*smoothWeightedCount L A X))).trans_eq |
| ring |
|
|
| lemma SmoothMultiplier.error_integrable {n : ℕ} {L : Length} (f : SmoothMultiplier n L) (u : ScalarL2 n L) : |
| Integrable (fun X ↦ (∑ p : Direction n, ‖coordDerivative n L f.toFun p X‖^2)*‖u X‖^2) volume := by |
| have hi (p : Direction n) : Integrable (fun X ↦ ‖(f.derivativeScalar p u) X‖^2) volume := |
| (Lp.memLp _).integrable_norm_pow (by norm_num) |
| apply (integrable_finsetSum Finset.univ (fun p _ ↦ hi p)).congr |
| have hc : ∀ᵐ X ∂volume, ∀ p, (f.derivativeScalar p u) X=coordDerivative n L f.toFun p X*u X := |
| ae_all_iff.mpr (fun p ↦ f.coe_derivativeScalar p u) |
| filter_upwards [hc] with X hX |
| simp_rw [hX,norm_mul,mul_pow,Finset.sum_mul] |
|
|
| lemma SmoothMultiplier.error_integral {n : ℕ} {L : Length} (f : SmoothMultiplier n L) (u : ScalarL2 n L) : |
| (∑ p : Direction n, ‖f.derivativeScalar p u‖^2)= |
| ∫ X, (∑ p : Direction n, ‖coordDerivative n L f.toFun p X‖^2)*‖u X‖^2 := by |
| simpa using SmoothMultiplier.partition_error_integral (fun _ : Unit ↦ f) u |
|
|
| lemma SmoothMultiplier.weighted_norm_integral {n : ℕ} {L : Length} (f : SmoothMultiplier n L) |
| (u : ScalarL2 n L) (F : Configuration n L → ℝ) : |
| (∫ X, F X*‖(f.onScalar u) X‖^2)=∫ X, F X*‖f.toFun X‖^2*‖u X‖^2 := by |
| apply integral_congr_ae |
| filter_upwards [f.coe_onScalar u] with X hX |
| rw [hX,norm_mul,mul_pow,mul_assoc] |
|
|
| lemma expWeightedMultiplier_mass {n : ℕ} {L : Length} (A : Finset (Torus L)) (t : ℝ) (g : Jet n L) : |
| ‖(expWeightedMultiplier n L A t).onScalar g.1‖^2= |
| mgf (smoothWeightedCount L A) (groundPositionLaw n L g) t := by |
| rw [IndicatorStrong.norm_sq_integral,mgf,groundPositionLaw_integral] |
| apply integral_congr_ae |
| filter_upwards [(expWeightedMultiplier n L A t).coe_onScalar g.1] with X hX |
| rw [hX,norm_mul,mul_pow,expWeightedMultiplier_norm_sq] |
|
|
| lemma smoothWeightedCount_exp_integrable {n : ℕ} {L : Length} (A : Finset (Torus L)) (t : ℝ) (g : Jet n L) : |
| Integrable (fun X ↦ (smoothWeightedCount L A X*Real.exp (t*smoothWeightedCount L A X))*‖g.1 X‖^2) volume := by |
| let G := smoothWeightedCount (n:=n) L A |
| let B := Real.exp 1*(n:ℝ) |
| have hb (X : Configuration n L) : |G X| ≤ B := by |
| rw [abs_of_nonneg (smoothWeightedCount_nonneg L A X)] |
| exact smoothWeightedCount_le L A X |
| apply L2_bounded_weight_integrable g.1 |
| ((smoothWeightedCount_continuous L A).measurable.mul |
| (((smoothWeightedCount_continuous L A).measurable.const_mul t).exp)) |
| intro X |
| change |G X*Real.exp (t*G X)| ≤ _ |
| rw [abs_mul,abs_of_pos (Real.exp_pos _)] |
| exact mul_le_mul (hb X) (Real.exp_le_exp.mpr (calc |
| t*G X ≤ |t*G X| := le_abs_self _ |
| _ = |t| *|G X| := abs_mul _ _ |
| _ ≤ |t| *B := mul_le_mul_of_nonneg_left (hb X) (abs_nonneg t))) |
| (Real.exp_pos _).le (by dsimp [B]; positivity) |
|
|
| lemma expWeightedMultiplier_defect {n : ℕ} {L : Length} {r : ℝ} (A : Finset (Torus L)) (t : ℝ) |
| {g : Jet n L} (hg : IsGroundVector n L r g) : |
| energy ((expWeightedMultiplier n L A t).onJet g)-energy g*‖(expWeightedMultiplier n L A t).onScalar g.1‖^2≤ |
| (t^2/4)*(3*(spatialMetricConstant:ℝ)^2*Real.exp 1)* |
| (∫ X, smoothWeightedCount L A X*Real.exp (t*smoothWeightedCount L A X) ∂groundPositionLaw n L g) := by |
| rw [hg.smooth_multiplier_identity _ (expWeightedMultiplier_real n L A t), |
| SmoothMultiplier.error_integral,groundPositionLaw_integral,←integral_const_mul] |
| apply integral_mono ((expWeightedMultiplier n L A t).error_integrable g.1) |
| ((smoothWeightedCount_exp_integrable A t g).const_mul _) |
| intro X |
| simpa only [mul_assoc] using mul_le_mul_of_nonneg_right (expWeightedMultiplier_gradient n L A t X) (sq_nonneg ‖g.1 X‖) |
|
|
| end |
| end HardSphere |
|
|
| namespace HardSphere |
| open MeasureTheory Set Filter ProbabilityTheory |
| open scoped ComplexConjugate |
| noncomputable section |
|
|
| lemma weighted_count_penalty : ∃ C : ℝ, 0 < C ∧ |
| ∀ (n K : ℕ) (L : Length) (_hL : L.val=(K:ℝ)) (r D : ℝ), |
| D=(n:ℝ)/L.val^3 → 1≤D → 1≤D*r → 0<r → 1≤L.val → |
| (n:ℝ)*(2*Real.pi*r)^3≤L.val^3/2 → |
| ∀ (g : Jet n L), IsGroundVector n L r g → |
| ∀ (A : Finset (Torus L)) (u : Jet n L), u∈dirichletDomain n L r → |
| (D*r)*((∫ X, weightedSiteCount L A X*‖u.1 X‖^2)-C*D*(A.card:ℝ)*‖u.1‖^2)≤ |
| energy u-energy g*‖u.1‖^2 := by |
| obtain ⟨C,c,hC,hc,h⟩ := weighted_local_penalty |
| refine ⟨C,hC,?_⟩ |
| intro n K L hL r D hDeq hD hα hr hsize hsmall g hg A u hu |
| by_cases hA : A.Nonempty |
| · have hp := h n K L hL r (1/10) D hDeq hD hα hr (by norm_num) (by norm_num) |
| (by norm_num; exact hsize) hsmall g hg A hA u hu |
| have hi : 0≤∫ X, ((localizedNearLabels L A (1/10) X).card:ℝ)*‖u.1 X‖^2 := |
| integral_nonneg (fun X ↦ by positivity) |
| have hn : 0≤c*r/(1/10:ℝ)^3*(∫ X, ((localizedNearLabels L A (1/10) X).card:ℝ)*‖u.1 X‖^2) := |
| mul_nonneg (by positivity) hi |
| linarith only [hp,hn] |
| · have he : A=∅ := Finset.not_nonempty_iff_eq_empty.mp hA |
| subst A |
| simp only [weightedSiteCount,Finset.not_nonempty_empty,ite_false,Finset.card_empty,Nat.cast_zero, |
| mul_zero,zero_mul,integral_zero,sub_zero] |
| exact sub_nonneg.mpr (hg.rayleigh_all u hu) |
|
|
| lemma exp_neg_one_mul_exp_one : Real.exp (-1)*Real.exp 1=1 := by rw [←Real.exp_add]; norm_num |
|
|
| lemma exp_one_mul_exp_neg_one : Real.exp 1*Real.exp (-1)=1 := by rw [mul_comm,exp_neg_one_mul_exp_one] |
|
|
| lemma smoothWeightedCount_lower_for_penalty {n : ℕ} (L : Length) (A : Finset (Torus L)) |
| (hA : A.Nonempty) (X : Configuration n L) : |
| Real.exp (-1)*smoothWeightedCount L A X ≤ weightedSiteCount L A X := by |
| have h := mul_le_mul_of_nonneg_left (smoothWeightedCount_bounds L A hA X).2 (Real.exp_pos (-1)).le |
| rwa [←mul_assoc,exp_neg_one_mul_exp_one,one_mul] at h |
|
|
| lemma weightedSiteCount_le_smooth {n : ℕ} (L : Length) (A : Finset (Torus L)) |
| (hA : A.Nonempty) (X : Configuration n L) : |
| weightedSiteCount L A X ≤ Real.exp 1*smoothWeightedCount L A X := by |
| have h := mul_le_mul_of_nonneg_left (smoothWeightedCount_bounds L A hA X).1 (Real.exp_pos 1).le |
| rwa [←mul_assoc,exp_one_mul_exp_neg_one,one_mul] at h |
|
|
| lemma expWeightedMultiplier_weight_integrable {n : ℕ} {L : Length} (A : Finset (Torus L)) |
| (t : ℝ) (g : Jet n L) : |
| Integrable (fun X ↦ weightedSiteCount L A X*Real.exp (t*smoothWeightedCount L A X)*‖g.1 X‖^2) volume := by |
| apply (weightedSiteCount_integrable L A ((expWeightedMultiplier n L A t).onScalar g.1)).congr |
| filter_upwards [(expWeightedMultiplier n L A t).coe_onScalar g.1] with X hX |
| rw [hX,norm_mul,mul_pow,expWeightedMultiplier_norm_sq,mul_assoc] |
|
|
| lemma expWeightedMultiplier_weight_lower {n : ℕ} {L : Length} (A : Finset (Torus L)) (hA : A.Nonempty) |
| (t : ℝ) (g : Jet n L) : |
| Real.exp (-1)*(∫ X, smoothWeightedCount L A X*Real.exp (t*smoothWeightedCount L A X) ∂groundPositionLaw n L g)≤ |
| ∫ X, weightedSiteCount L A X*‖((expWeightedMultiplier n L A t).onScalar g.1) X‖^2 := by |
| rw [groundPositionLaw_integral,←integral_const_mul,SmoothMultiplier.weighted_norm_integral] |
| simp_rw [expWeightedMultiplier_norm_sq] |
| apply integral_mono ((smoothWeightedCount_exp_integrable A t g).const_mul _) |
| (expWeightedMultiplier_weight_integrable A t g) |
| intro X |
| have h := mul_le_mul_of_nonneg_right |
| (mul_le_mul_of_nonneg_right (smoothWeightedCount_lower_for_penalty L A hA X) (Real.exp_pos (t*smoothWeightedCount L A X)).le) |
| (sq_nonneg ‖g.1 X‖) |
| simpa only [mul_assoc] using h |
|
|
| end |
| end HardSphere |
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
