| import Mathlib |
| import OAI.Analysis.HardSphere.Geometry.SubsetPointLinear |
|
|
| 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 |
| open MeasureTheory Filter Set |
| open scoped ENNReal Topology |
| open MeasureTheory Set |
| open scoped ENNReal |
| open MeasureTheory Filter Set |
| open scoped ENNReal Topology BigOperators |
| namespace HardSphere.SphericalCoordinates |
| open scoped BigOperators |
|
|
| lemma sector_active_capacity {n : ℕ} {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {F : (Fin n → Point) → E} (hF : ContDiff ℝ 1 F) |
| {r l : ℝ} (hr : 0<r) (hl : 0≤l) {ι : Type*} [Fintype ι] |
| (b : ι → Point) (σ : Fin n → ι) |
| (hz : ∀X a c, a≠c → sqRadius (X a-X c)≤r^2 → F X=0) : |
| ((activeLabels σ).card : ℝ≥0∞)* |
| (∫⁻ X, ENNReal.ofReal (‖F X‖^2) ∂Measure.pi (fun a ↦ volume.restrict (cube (b (σ a)) l))) ≤ |
| ENNReal.ofReal (Real.sqrt 3*l^3/r)* |
| ∑ i, (∫⁻ X, ENNReal.ofReal (particleGradSq F i X) |
| ∂Measure.pi (fun a ↦ volume.restrict (cube (b (σ a)) l))) := by |
| classical |
| cases n with |
| | zero => simp [activeLabels] |
| | succ n => |
| let μ := Measure.pi (fun a ↦ volume.restrict (cube (b (σ a)) l)) |
| let M := ∫⁻ X, ENNReal.ofReal (‖F X‖^2) ∂μ |
| let G := fun i ↦ ∫⁻ X, ENNReal.ofReal (particleGradSq F i X) ∂μ |
| let C := ENNReal.ofReal (Real.sqrt 3*l^3/r) |
| have hi (i : Fin (n+1)) (hi : i∈activeLabels σ) : M≤C*G i := by |
| obtain ⟨j,hji,hs⟩ := (mem_activeLabels σ i).mp hi |
| obtain ⟨k,rfl⟩ := Fin.exists_succAbove_eq hji |
| exact sector_coordinate_capacity hF hr hl (fun a ↦ b (σ a)) i k (congrArg b hs) hz |
| calc |
| _ = ∑ _ ∈ activeLabels σ, M := by simp only [Finset.sum_const,nsmul_eq_mul]; rfl |
| _ ≤ ∑ i ∈ activeLabels σ, C*G i := Finset.sum_le_sum hi |
| _ = C*∑ i ∈ activeLabels σ, G i := (Finset.mul_sum _ _ _).symm |
| _ ≤ C*∑ i, G i := by gcongr; exact Finset.subset_univ _ |
| _ = _ := rfl |
|
|
| lemma activeLabels_reindex_card {I J C : Type*} [Fintype I] [Fintype J] |
| (e : I ≃ J) (σ : I → C) : (activeLabels (σ ∘ e.symm)).card=(activeLabels σ).card := by |
| classical |
| have he : (activeLabels (σ ∘ e.symm)).map e.symm.toEmbedding=activeLabels σ := by |
| ext i |
| simp only [Finset.mem_map,Equiv.toEmbedding_apply,mem_activeLabels,Function.comp_apply] |
| constructor |
| · rintro ⟨j,⟨k,hkj,hσ⟩,rfl⟩ |
| exact ⟨e.symm k,fun h ↦ hkj (e.symm.injective h),hσ⟩ |
| · rintro ⟨k,hki,hσ⟩ |
| refine ⟨e i,⟨e k,fun h ↦ hki (e.injective h),?_⟩,e.symm_apply_apply i⟩ |
| simpa only [Equiv.symm_apply_apply] using hσ |
| rw [←he,Finset.card_map] |
|
|
| lemma finite_sector_active_capacity {I C : Type*} [Fintype I] [Fintype C] [DecidableEq I] |
| {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {F : (I → Point) → E} (hF : ContDiff ℝ 1 F) |
| {r l : ℝ} (hr : 0<r) (hl : 0≤l) (b : C → Point) (σ : I → C) |
| (hz : ∀X a c, a≠c → sqRadius (X a-X c)≤r^2 → F X=0) : |
| ((activeLabels σ).card : ℝ≥0∞)* |
| (∫⁻ X, ENNReal.ofReal (‖F X‖^2) ∂Measure.pi (fun a ↦ volume.restrict (cube (b (σ a)) l))) ≤ |
| ENNReal.ofReal (Real.sqrt 3*l^3/r)* |
| ∑ i, (∫⁻ X, ENNReal.ofReal (indexGradSq F i X) |
| ∂Measure.pi (fun a ↦ volume.restrict (cube (b (σ a)) l))) := by |
| let e := Fintype.equivFin I |
| let T := reindexPoint e |
| have h := sector_active_capacity (hF.comp T.contDiff) hr hl b (σ ∘ e.symm) (F := F ∘ T) (by |
| intro X a c hac hd |
| apply hz (T X) (e.symm a) (e.symm c) (fun h ↦ hac (e.symm.injective h)) |
| simpa only [T,reindexPoint_apply,Equiv.apply_symm_apply] using hd) |
| rw [activeLabels_reindex_card] at h |
| let μ := fun i ↦ volume.restrict (cube (b (σ i)) l) |
| have hp := reindexPoint_preserving e μ |
| have hm : Measurable (fun X ↦ ENNReal.ofReal (‖F X‖^2)) := by |
| simpa only [Pi.pow_apply] using (hF.continuous.norm.pow 2).measurable.ennreal_ofReal |
| have hn : (∫⁻ X,ENNReal.ofReal (‖(F ∘ T) X‖^2) ∂Measure.pi (fun j ↦ μ (e.symm j)))= |
| ∫⁻ X,ENNReal.ofReal (‖F X‖^2) ∂Measure.pi μ := hp.lintegral_comp hm |
| change _ * (∫⁻ X,ENNReal.ofReal (‖(F ∘ T) X‖^2) ∂Measure.pi (fun j ↦ μ (e.symm j))) ≤ _ at h |
| rw [hn] at h |
| apply h.trans_eq |
| congr 1 |
| calc |
| _ = ∑ j,∫⁻ X,ENNReal.ofReal (indexGradSq F (e.symm j) X) ∂Measure.pi μ := by |
| apply Finset.sum_congr rfl |
| intro j _ |
| change (∫⁻ X,ENNReal.ofReal (indexGradSq (F ∘ T) j X) ∂Measure.pi (fun j ↦ μ (e.symm j)))=_ |
| dsimp only [T] |
| simp_rw [indexGradSq_reindex hF] |
| exact hp.lintegral_comp (continuous_indexGradSq hF _).measurable.ennreal_ofReal |
| _ = _ := Fintype.sum_equiv e.symm _ _ (fun _ ↦ rfl) |
|
|
| lemma selected_sector_active_capacity {I C : Type*} [Fintype I] [Fintype C] [DecidableEq I] |
| {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {F : (I → Point) → E} (hF : ContDiff ℝ 1 F) (p : I → Prop) [DecidablePred p] |
| {r l : ℝ} (hr : 0<r) (hl : 0≤l) (b : C → Point) (σ : I → C) |
| (hz : ∀X a c, a≠c → sqRadius (X a-X c)≤r^2 → F X=0) : |
| ((activeLabels (fun i : {i // p i} ↦ σ i.val)).card : ℝ≥0∞)* |
| (∫⁻ X, ENNReal.ofReal (‖F X‖^2) ∂Measure.pi (fun i ↦ volume.restrict (cube (b (σ i)) l))) ≤ |
| ENNReal.ofReal (Real.sqrt 3*l^3/r)* |
| ∑ i : {i |
| ∂Measure.pi (fun i ↦ volume.restrict (cube (b (σ i)) l))) := by |
| let μ := fun i ↦ (volume : Measure Point).restrict (cube (b (σ i)) l) |
| have hslice (Y : {i |
| (hF.comp (contDiff_subsetPointFill p Y)) hr hl b (fun i : {i // p i} ↦ σ i.val) |
| (F := F ∘ subsetPointFill p Y) (by |
| intro X a c hac hd |
| apply hz (subsetPointFill p Y X) a.val c.val (fun h ↦ hac (Subtype.ext h)) |
| simpa only [subsetPointFill,dite_eq_left a.property,dite_eq_left c.property] using hd) |
| have hm : Measurable (fun X ↦ ENNReal.ofReal (‖F X‖^2)) := by |
| simpa only [Pi.pow_apply] using (hF.continuous.norm.pow 2).measurable.ennreal_ofReal |
| have hn := lintegral_subsetPointFill μ p (fun X ↦ ENNReal.ofReal (‖F X‖^2)) hm |
| rw [hn,← lintegral_const_mul' _ _ (by simp)] |
| have hi := lintegral_mono hslice (μ := Measure.pi (fun i : {i // ¬p i} ↦ μ i.val)) |
| simp only [Function.comp_apply,indexGradSq_subset hF] at hi |
| apply hi.trans_eq |
| rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top,lintegral_finsetSum] |
| · congr 1 |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact (lintegral_subsetPointFill μ p _ |
| (continuous_indexGradSq hF i.val).measurable.ennreal_ofReal).symm |
| · intro i _ |
| have he := (MeasurableEquiv.piEquivPiSubtypeProd (fun _ : I ↦ Point) p).symm.measurable |
| exact (((continuous_indexGradSq hF i.val).measurable.ennreal_ofReal.comp he).lintegral_prod_left') |
| |
| lemma selected_subdivided_active_capacity {n j : ℕ} |
| {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {F : (Fin n → Point) → E} (hF : ContDiff ℝ 1 F) (p : Fin n → Prop) [DecidablePred p] |
| {r l : ℝ} (hr : 0<r) (hl : 0≤l) (b : Point) |
| (hz : ∀X a c, a≠c → sqRadius (X a-X c)≤r^2 → F X=0) : |
| (∑ σ : Fin n → (Fin j × Fin j × Fin j), |
| ((activeLabels (fun i : {i // p i} ↦ σ i.val)).card : ℝ≥0∞)* |
| (∫⁻ X, ENNReal.ofReal (‖F X‖^2) |
| ∂Measure.pi (fun i ↦ volume.restrict (cube (subcubeBase b l (σ i)) l)))) ≤ |
| ENNReal.ofReal (Real.sqrt 3*l^3/r)* |
| ∑ i : {i // p i}, ∫⁻ X,ENNReal.ofReal (particleGradSq F i.val X) |
| ∂Measure.pi (fun _ ↦ volume.restrict (cube b ((j:ℝ)*l))) := by |
| have h := Finset.sum_le_sum (s := (Finset.univ : Finset (Fin n → (Fin j × Fin j × Fin j)))) |
| (fun σ _ ↦ selected_sector_active_capacity hF p hr hl (subcubeBase b l) σ hz) |
| apply h.trans_eq |
| rw [← Finset.mul_sum,Finset.sum_comm] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [cube_configuration_subdivision b hl,Measure.sum_fintype,MeasureTheory.lintegral_finsetSum_measure] |
| rfl |
| |
| end HardSphere.SphericalCoordinates |
| |
| open Set Function MeasureTheory |
| open scoped ENNReal |
| |
| end |
| |
| end OAI |
| |
