| import Mathlib |
| import OAI.Analysis.HardSphere.FormDomain.EnergyInsertionJet |
| import OAI.Analysis.HardSphere.PathBounds.FiberDerivativeMulTailLocal |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open MeasureTheory Filter Set |
| open scoped ENNReal Topology BigOperators |
| open scoped BigOperators ComplexConjugate |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators |
| open MeasureTheory ProbabilityTheory Real Complex |
| open scoped ENNReal ComplexConjugate |
| open ProbabilityTheory |
| namespace HardSphere |
| open MeasureTheory Set Filter |
| open scoped ComplexConjugate |
|
|
| lemma SmoothMultiplier.insertion_mass_integrable {n : ℕ} {L : Length} |
| (f : SmoothMultiplier (n+1) L) (u : ScalarL2 n L) : |
| Integrable (fun Y : Configuration n L ↦ ‖u Y‖^2 * f.fiberMass Y) volume := by |
| have hm := ((memLp_configurationTail (Lp.memLp u)).mul f.memLp_top).integrable_norm_pow |
| (by decide : (2:ℕ)≠0) |
| let e := MeasurableEquiv.piFinSuccAbove (fun _ : Fin (n+1) ↦ Torus L) 0 |
| have he := (volume_preserving_piFinSuccAbove (fun _ : Fin (n+1) ↦ Torus L) 0).symm |
| have hi := (he.integrable_comp_emb e.symm.measurableEmbedding).mpr hm |
| simp only [MeasurableEquiv.piFinSuccAbove_symm_apply,Fin.insertNthEquiv, |
| Equiv.coe_fn_mk,Fin.insertNth_zero',Function.comp_def,Pi.mul_apply,Fin.tail_cons] at hi |
| convert hi.integral_prod_right using 1 |
| funext Y |
| rw [SmoothMultiplier.fiberMass,← integral_const_mul] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x ↦ by dsimp only; rw [norm_mul,mul_pow,mul_comm] |
| |
| lemma SmoothMultiplier.norm_insertionScalar_le {n : ℕ} {L : Length} |
| (f : SmoothMultiplier (n+1) L) (hn : ∀ Y, f.fiberMass Y≤1) (u : ScalarL2 n L) : |
| ‖f.insertionScalar u‖^2≤‖u‖^2 := by |
| rw [SmoothMultiplier.insertionScalar,ContinuousLinearMap.comp_apply,SmoothMultiplier.onScalar, |
| norm_weightedTail_sq,IndicatorStrong.norm_sq_integral] |
| exact integral_mono (f.insertion_mass_integrable u) |
| ((Lp.memLp u).integrable_norm_pow (by decide : (2:ℕ)≠0)) |
| (fun Y ↦ mul_le_of_le_one_right (sq_nonneg _) (hn Y)) |
|
|
| lemma SmoothMultiplier.norm_insertionScalar_local {n : ℕ} {L : Length} |
| (f : SmoothMultiplier (n+1) L) (u : ScalarL2 n L) |
| (hn : ∀ᵐ Y ∂volume, u Y≠0 → f.fiberMass Y=1) : |
| ‖f.insertionScalar u‖=‖u‖ := by |
| apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp |
| rw [SmoothMultiplier.insertionScalar,ContinuousLinearMap.comp_apply,SmoothMultiplier.onScalar, |
| norm_weightedTail_sq,IndicatorStrong.norm_sq_integral] |
| apply integral_congr_ae |
| filter_upwards [hn] with Y hY |
| by_cases hz : u Y=0 |
| · simp only [hz,norm_zero,zero_pow (by decide : 2≠0),zero_mul] |
| · change ‖u Y‖^2*f.fiberMass Y=_ |
| rw [hY hz,mul_one] |
|
|
| lemma SmoothMultiplier.insertion_cross_zero_local {n : ℕ} {L : Length} |
| (f : SmoothMultiplier (n+1) L) (p : Direction (n+1)) (u v : ScalarL2 n L) |
| (ho : ∀ᵐ Y ∂volume, v Y≠0 → ∫ x : Torus L, |
| conj (f.toFun (Fin.cons x Y))*coordDerivative (n+1) L f.toFun p (Fin.cons x Y)=0) : |
| inner ℂ (f.insertionScalar u) |
| (L2Multiplier.clm _ (f.partial_memLp_top p) (configurationTailCLM n L v))=0 := by |
| rw [SmoothMultiplier.insertionScalar,ContinuousLinearMap.comp_apply,SmoothMultiplier.onScalar, |
| weightedTail_pairing] |
| apply integral_eq_zero_of_ae |
| filter_upwards [ho] with Y hY |
| simp only [Pi.zero_apply] |
| by_cases hz : v Y=0 |
| · rw [hz,mul_zero,zero_mul] |
| · rw [hY hz,mul_zero] |
|
|
| lemma SmoothMultiplier.energy_insertionJet_local_le_sum {n : ℕ} {L : Length} |
| (f : SmoothMultiplier (n+1) L) (u : Jet n L) |
| (hn : ∀ Y, f.fiberMass Y≤1) |
| (ho : ∀ (i : Fin n) (j : Fin 3), ∀ᵐ Y ∂volume, u.1 Y≠0 → ∫ x : Torus L, |
| conj (f.toFun (Fin.cons x Y))*coordDerivative (n+1) L f.toFun (i.succ,j) (Fin.cons x Y)=0) : |
| energy (f.insertionJet u)≤energy u + ∑ p : Direction (n+1), |
| ‖L2Multiplier.clm _ (f.partial_memLp_top p) (configurationTailCLM n L u.1)‖^2 := by |
| have hz (j : Fin 3) : (f.insertionJet u).2 (0,j)= |
| L2Multiplier.clm _ (f.partial_memLp_top (0,j)) (configurationTailCLM n L u.1) := by |
| change f.insertionScalar 0 + _ = _ |
| rw [map_zero,zero_add] |
| rfl |
| have hs (i : Fin n) (j : Fin 3) : ‖(f.insertionJet u).2 (i.succ,j)‖^2≤ |
| ‖u.2 (i,j)‖^2+ |
| ‖L2Multiplier.clm _ (f.partial_memLp_top (i.succ,j)) (configurationTailCLM n L u.1)‖^2 := by |
| change ‖f.insertionScalar (u.2 (i,j)) + |
| L2Multiplier.clm _ (f.partial_memLp_top (i.succ,j)) (configurationTailCLM n L u.1)‖^2 ≤ _ |
| rw [@norm_add_sq ℂ, f.insertion_cross_zero_local (i.succ,j) (u.2 (i,j)) u.1 (ho i j),map_zero, |
| mul_zero,add_zero] |
| exact add_le_add_left (f.norm_insertionScalar_le hn (u.2 (i,j))) |
| (‖L2Multiplier.clm _ (f.partial_memLp_top (i.succ,j)) (configurationTailCLM n L u.1)‖^2) |
| simp only [energy,Fintype.sum_prod_type] |
| rw [Fin.sum_univ_succ (f := fun i : Fin (n+1) ↦ ∑ j : Fin 3, ‖(f.insertionJet u).2 (i,j)‖^2), |
| Fin.sum_univ_succ (f := fun i : Fin (n+1) ↦ ∑ j : Fin 3, |
| ‖L2Multiplier.clm _ (f.partial_memLp_top (i,j)) (configurationTailCLM n L u.1)‖^2)] |
| simp only [hz] |
| calc |
| _ ≤ (∑ j : Fin 3, ‖L2Multiplier.clm _ (f.partial_memLp_top (0,j)) (configurationTailCLM n L u.1)‖^2)+ |
| ∑ i : Fin n, ∑ j : Fin 3, (‖u.2 (i,j)‖^2+ |
| ‖L2Multiplier.clm _ (f.partial_memLp_top (i.succ,j)) (configurationTailCLM n L u.1)‖^2) := by |
| exact add_le_add_right (Finset.sum_le_sum fun i _ ↦ Finset.sum_le_sum fun j _ ↦ hs i j) _ |
| _ = _ := by simp only [Finset.sum_add_distrib]; ring |
| |
| lemma SmoothMultiplier.energy_insertionJet_local_le {n : ℕ} {L : Length} |
| (f : SmoothMultiplier (n+1) L) (u : Jet n L) |
| (hn : ∀ Y, f.fiberMass Y≤1) |
| (ho : ∀ (i : Fin n) (j : Fin 3), ∀ᵐ Y ∂volume, u.1 Y≠0 → ∫ x : Torus L, |
| conj (f.toFun (Fin.cons x Y))*coordDerivative (n+1) L f.toFun (i.succ,j) (Fin.cons x Y)=0) |
| (C : ℝ) (hC : ∀ᵐ Y ∂volume, u.1 Y≠0 → |
| ∑ p : Direction (n+1), ∫ x : Torus L, ‖coordDerivative (n+1) L f.toFun p (Fin.cons x Y)‖^2≤C) : |
| energy (f.insertionJet u)≤energy u+C*‖u.1‖^2 := by |
| apply (f.energy_insertionJet_local_le_sum u hn ho).trans |
| apply add_le_add_right |
| simp_rw [norm_weightedTail_sq] |
| rw [← integral_finsetSum _ (fun p _ ↦ f.insertion_derivative_integrable u.1 p), |
| IndicatorStrong.norm_sq_integral,← integral_const_mul] |
| apply integral_mono_ae |
| · exact integrable_finsetSum _ (fun p _ ↦ f.insertion_derivative_integrable u.1 p) |
| · exact (Lp.memLp u.1).integrable_norm_pow (by decide : (2:ℕ)≠0) |>.const_mul C |
| · filter_upwards [hC] with Y hY |
| rw [← Finset.mul_sum] |
| by_cases hz : u.1 Y=0 |
| · simp only [hz,norm_zero,zero_pow (by decide : 2≠0),mul_zero,zero_mul,le_refl] |
| · simpa only [mul_comm C] using mul_le_mul_of_nonneg_left (hY hz) (sq_nonneg ‖u.1 Y‖) |
|
|
| lemma SmoothMultiplier.insertion_from_raw_local {n : ℕ} {L : Length} {a C z : ℝ} |
| (f : SmoothMultiplier (n+1) L) (hc : InsertionClearance a f) |
| (hr : ∀ X, conj (f.toFun X)=f.toFun X) (hz : 1/2<z) |
| {u : Jet n L} (hu : u∈dirichletDomain n L a) |
| (hZ : ∀ᵐ Y ∂volume, u.1 Y≠0 → z≤f.fiberMass Y) |
| (hC : ∀ᵐ Y ∂volume, u.1 Y≠0 → |
| ∑ p : Direction (n+1), ∫ x : Torus L, ‖coordDerivative (n+1) L f.toFun p (Fin.cons x Y)‖^2≤C) : |
| ∃ v : Jet (n+1) L, v∈dirichletDomain (n+1) L a ∧ |
| ‖v.1‖=‖u.1‖ ∧ energy v≤energy u+(C/z)*‖u.1‖^2 := by |
| refine ⟨(f.localNormalization hr).insertionJet u,?_,?_,?_⟩ |
| · exact (f.localNormalization hr).insertionJet_mem_domain (f.localNormalization_clearance hr hc) hu |
| · apply (f.localNormalization hr).norm_insertionScalar_local |
| filter_upwards [hZ] with Y hY |
| intro hne |
| exact f.localNormalization_mass_eq hr Y (hz.le.trans (hY hne)) |
| · apply (f.localNormalization hr).energy_insertionJet_local_le u (f.localNormalization_mass_le hr) |
| · intro i j |
| filter_upwards [hZ] with Y hY |
| intro hne |
| exact (f.localNormalization hr).insertion_orthogonal_local (f.localNormalization_real hr) |
| i j Y (f.localNormalization_mass_eventually hr Y (hz.trans_le (hY hne))) |
| · filter_upwards [hZ,hC] with Y hY hCY |
| intro hne |
| have hz0 : 0<z := by linarith |
| rw [le_div_iff₀ hz0,mul_comm] |
| calc |
| z * ∑ p : Direction (n+1), ∫ x : Torus L, |
| ‖coordDerivative (n+1) L (f.localNormalization hr).toFun p (Fin.cons x Y)‖^2 ≤ |
| f.fiberMass Y * ∑ p : Direction (n+1), ∫ x : Torus L, |
| ‖coordDerivative (n+1) L (f.localNormalization hr).toFun p (Fin.cons x Y)‖^2 := by |
| apply mul_le_mul_of_nonneg_right (hY hne) |
| exact Finset.sum_nonneg fun p _ ↦ integral_nonneg fun x ↦ sq_nonneg _ |
| _ ≤ ∑ p : Direction (n+1), ∫ x : Torus L, |
| ‖coordDerivative (n+1) L f.toFun p (Fin.cons x Y)‖^2 := by |
| rw [Finset.mul_sum] |
| exact Finset.sum_le_sum fun p _ ↦ f.localNormalization_derivative_le hr p Y (hz.trans_le (hY hne)) |
| _ ≤ C := hCY hne |
|
|
| end HardSphere |
|
|
| end |
|
|
| end OAI |
|
|
