| import Mathlib |
| import OAI.Geometry.CubicTorus.Estimates.CoordinatePlaneRays |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| lemma circle_continuous_integrable {μ : Measure (AddCircle (1 : ℝ))} [IsFiniteMeasure μ] |
| {f : AddCircle (1 : ℝ) → ℝ} (hf : Continuous f) : Integrable f μ := |
| hf.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
|
|
| theorem circle_moment_absolutelyContinuous |
| {A B L : Measure (AddCircle (1 : ℝ))} |
| [IsFiniteMeasure A] [IsFiniteMeasure B] [IsFiniteMeasure L] |
| {H C : ℝ} (hB : B≪L) |
| (he : ∀ (f : ℝ → ℝ), ContDiff ℝ (⊤ : ℕ∞) f → ∀ (hp : Function.Periodic f 1), |
| (∫ x,hp.lift x ∂A)=H*(∫ x,hp.lift x ∂B)+C*(∫ x,hp.lift x ∂L)) : A≪L := by |
| let hp := ENNReal.ofReal (max H 0) |
| let hn := ENNReal.ofReal (max (-H) 0) |
| let cp := ENNReal.ofReal (max C 0) |
| let cn := ENNReal.ofReal (max (-C) 0) |
| have hpos (x : ℝ) : 0 ≤ max x 0 := le_max_right _ _ |
| have hsplit (x : ℝ) : x+max (-x) 0=max x 0 := by |
| rcases le_total 0 x with hx|hx |
| · rw [max_eq_left hx,max_eq_right (by linarith)]; ring |
| · rw [max_eq_right hx,max_eq_left (by linarith)]; ring |
| let : IsFiniteMeasure (hp • B) := B.smul_finite ENNReal.ofReal_ne_top |
| let : IsFiniteMeasure (hn • B) := B.smul_finite ENNReal.ofReal_ne_top |
| let : IsFiniteMeasure (cp • L) := L.smul_finite ENNReal.ofReal_ne_top |
| let : IsFiniteMeasure (cn • L) := L.smul_finite ENNReal.ofReal_ne_top |
| have hbalance : A+hn • B+cn • L=hp • B+cp • L := by |
| apply circle_measure_ext_smooth |
| intro f hf hfper |
| have hc := continuous_periodic_lift hfper hf.continuous |
| have hi (ρ : Measure (AddCircle (1 : ℝ))) [IsFiniteMeasure ρ] : Integrable hfper.lift ρ := |
| circle_continuous_integrable hc |
| rw [integral_add_measure (hi _) (hi _),integral_add_measure (hi _) (hi _), |
| integral_add_measure (hi _) (hi _)] |
| simp only [integral_smul_measure,smul_eq_mul,hp,hn,cp,cn, |
| ENNReal.toReal_ofReal (hpos _)] |
| rw [he f hf hfper] |
| linear_combination (∫ x,hfper.lift x ∂B)*(hsplit H)+ |
| (∫ x,hfper.lift x ∂L)*(hsplit C) |
| intro s hs |
| have hb := hB hs |
| have hh := congrArg (fun ρ : Measure (AddCircle (1 : ℝ)) => ρ s) hbalance |
| simpa only [Measure.add_apply,Measure.smul_apply,hb,hs,smul_eq_mul,mul_zero,add_zero] using hh |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| def axialBundleHeight (i : Fin 3) (z : NormalBundle) : AddCircle (1 : ℝ) := z.1.1 i |
|
|
| def axialCoverHeight (i : Fin 3) (x : Cover) : AddCircle (1 : ℝ) := x i |
|
|
| lemma continuous_axialBundleHeight (i : Fin 3) : Continuous (axialBundleHeight i) := |
| (AddCircle.continuous_mk' (1 : ℝ)).comp |
| ((PiLp.continuous_apply _ _ i).comp (continuous_subtype_val.comp continuous_fst)) |
|
|
| lemma continuous_axialCoverHeight (i : Fin 3) : Continuous (axialCoverHeight i) := |
| (AddCircle.continuous_mk' (1 : ℝ)).comp (PiLp.continuous_apply _ _ i) |
|
|
| def axialWeightedHeight (μ : FiniteMeasure NormalBundle) (i : Fin 3) : Measure (AddCircle (1 : ℝ)) := |
| Measure.map (axialBundleHeight i) |
| ((μ : Measure NormalBundle).withDensity (fun z => ENNReal.ofReal (axialNormalWeight i z))) |
|
|
| instance axialWeightedHeight_finite (μ : FiniteMeasure NormalBundle) (i : Fin 3) : |
| IsFiniteMeasure (axialWeightedHeight μ i) := by |
| let := isFiniteMeasure_withDensity_ofReal (integrable_axialNormalWeight μ i).hasFiniteIntegral |
| unfold axialWeightedHeight |
| infer_instance |
|
|
| def axialVolumeHeight (E : Set Torus) (i : Fin 3) : Measure (AddCircle (1 : ℝ)) := |
| Measure.map (axialCoverHeight i) (volume.restrict (fundamentalCube∩quotientMap ⁻¹' E)) |
|
|
| instance axialVolumeHeight_finite (E : Set Torus) (i : Fin 3) : |
| IsFiniteMeasure (axialVolumeHeight E i) := by |
| unfold axialVolumeHeight |
| infer_instance |
|
|
| lemma axialVolumeHeight_le (E : Set Torus) (i : Fin 3) : |
| axialVolumeHeight E i≤volume := by |
| have hmp := (torus_coordinate_measurePreserving i).comp quotientMap_measurePreserving |
| have he : Measure.map (axialCoverHeight i) (volume.restrict fundamentalCube)=volume := hmp.map_eq |
| rw [← he] |
| exact Measure.map_mono (Measure.restrict_mono_set _ inter_subset_left) |
| (continuous_axialCoverHeight i).measurable |
|
|
| lemma integral_axialWeightedHeight (μ : FiniteMeasure NormalBundle) (i : Fin 3) |
| {f : ℝ → ℝ} (hf : Continuous f) (hp : Function.Periodic f 1) : |
| (∫ x,hp.lift x ∂axialWeightedHeight μ i)= |
| ∫ z,f (z.1.1 i)*axialNormalWeight i z ∂(μ : Measure NormalBundle) := by |
| rw [axialWeightedHeight,integral_map (continuous_axialBundleHeight i).measurable.aemeasurable |
| (continuous_periodic_lift hp hf).aestronglyMeasurable, |
| integral_withDensity_eq_integral_toReal_smul |
| (continuous_axialNormalWeight i).measurable.ennreal_ofReal |
| (Eventually.of_forall fun _ => ENNReal.ofReal_lt_top)] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun z => by |
| dsimp only |
| rw [ENNReal.toReal_ofReal (axialNormalWeight_nonneg i z),smul_eq_mul,mul_comm] |
| rfl |
|
|
| lemma integral_axialVolumeHeight (E : Set Torus) (i : Fin 3) |
| {f : ℝ → ℝ} (hf : Continuous f) (hp : Function.Periodic f 1) : |
| (∫ x,hp.lift x ∂axialVolumeHeight E i)= |
| ∫ x in fundamentalCube∩quotientMap ⁻¹' E,f (x i) := by |
| rw [axialVolumeHeight,integral_map (continuous_axialCoverHeight i).measurable.aemeasurable |
| (continuous_periodic_lift hp hf).aestronglyMeasurable] |
| rfl |
|
|
| theorem axialWeightedHeight_absolutelyContinuous {E : Set Torus} |
| {μ : FiniteMeasure NormalBundle} {H : ℝ} |
| (hH : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D= |
| H*directionalFlux E D.coordinate D.function) (i : Fin 3) : |
| axialWeightedHeight μ i≪volume := by |
| apply circle_moment_absolutelyContinuous |
| (B := axialVolumeHeight E i) (H := H) |
| (C := (∫ z,axialNormalWeight i z ∂(μ : Measure NormalBundle))- |
| H*volume.real (fundamentalCube∩quotientMap ⁻¹' E)) |
| (Measure.absolutelyContinuous_of_le (axialVolumeHeight_le E i)) |
| intro f hf hp |
| rw [integral_axialWeightedHeight μ i hf.continuous hp, |
| integral_axialVolumeHeight E i hf.continuous hp] |
| have hc := AddCircle.intervalIntegral_preimage (1 : ℝ) 0 hp.lift |
| simp only [zero_add,Function.Periodic.lift_coe] at hc |
| rw [← hc] |
| simpa only [mul_comm] using axial_flux_moment hH i hf hp |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma isMinimizerAt_spatialNormalMeasure_noAtoms {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hm : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) : |
| NullSingletonClass (spatialNormalMeasure μ : Measure Torus) := by |
| obtain ⟨R,A,hR,hA,hu⟩ := isMinimizerAt_perimeter_upper_density hV hE hm |
| exact ⟨singleton_null_of_quadratic_upper_density (spatialNormalMeasure μ) hR (hu μ hμ)⟩ |
|
|
| def axialCriticalLift (E : Set Torus) (N : Cover → Cover) (i : Fin 3) : Set Cover := |
| {x | quotientMap x∈frontier (openRepresentative E) ∧ ∀ j : Fin 3,j≠i → N x j=0} |
|
|
| theorem isMinimizerAt_countable_axialCriticalLift {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hm : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) |
| (ha : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) |
| (hs : ∀ i : Fin 3,coordinateReflection i ⁻¹' E =ᵐ[torusVolume] E) |
| {s : Fin 3 → Bool} |
| (hsg : ∀ (x : Cover) (i : Fin 3), |
| quotientMap x∈frontier (openRepresentative E)∩coordinateHalf i (if s i then 0 else 1/2) → 0<N x i) |
| (i : Fin 3) : (axialCriticalLift E N i).Countable := by |
| let a (k : Fin 3 → ℤ) : Cover := WithLp.toLp 2 (fun j => (k j : ℝ)/2) |
| let L (k : Fin 3 → ℤ) (t : ℝ) : Cover := a k+t • EuclideanSpace.single i 1 |
| let T (k : Fin 3 → ℤ) : Set ℝ := {t | quotientMap (L k t)∈frontier (openRepresentative E)} |
| have ht (k) : (T k).Countable := |
| isMinimizerAt_countable_axial_boundary hV hE hm hμ hN hp ha hs hsg (a k) i |
| apply (Set.countable_iUnion (fun k : Fin 3 → ℤ => (ht k).image (L k))).mono |
| intro x hx |
| have hk : ∀ j : Fin 3,∃ k : ℤ,j=i ∨ x j=(k : ℝ)/2 := by |
| intro j |
| by_cases hji : j=i |
| · exact ⟨0,Or.inl hji⟩ |
| have hz : coordinateSine j x=0 := by |
| by_contra hzero |
| exact (isMinimizerAt_normal_nonzero_off_seam hV hE hm hμ hN hp ha hs hsg hx.1 j hzero) (hx.2 j hji) |
| obtain ⟨k,hk⟩ := Real.sin_eq_zero_iff.mp hz |
| refine ⟨k,Or.inr ?_⟩ |
| dsimp [coordinateSine] at hk |
| nlinarith [Real.pi_pos] |
| choose k hk using hk |
| have he : L k (x i-a k i)=x := by |
| ext j |
| change a k j+(x i-a k i)*(EuclideanSpace.single i 1 : Cover) j=x j |
| by_cases hji : j=i |
| · subst j; simp |
| · rw [PiLp.single_apply,ite_eq_right hji,mul_zero,add_zero] |
| exact (hk j).resolve_left hji |>.symm |
| apply mem_iUnion.mpr |
| exact ⟨k,⟨x i-a k i,by change quotientMap (L k (x i-a k i))∈frontier (openRepresentative E); rw [he]; exact hx.1,he⟩⟩ |
|
|
| lemma axialNormalWeight_zero_coordinates (i : Fin 3) (z : NormalBundle) |
| (hz : axialNormalWeight i z=0) : ∀ j : Fin 3,j≠i → (z.2 : Cover) j=0 := by |
| have hn : (∑ j : Fin 3,((z.2 : Cover) j)^2)=1 := by |
| rw [← EuclideanSpace.real_norm_sq_eq,z.2.property,one_pow] |
| have hi : ((z.2 : Cover) i)^2=1 := by dsimp [axialNormalWeight] at hz; linarith |
| intro j hji |
| have hh : ((z.2 : Cover) i)^2+((z.2 : Cover) j)^2≤1 := by |
| apply le_trans (b := ∑ k : Fin 3,((z.2 : Cover) k)^2) ?_ hn.le |
| have he : (∑ k∈({i,j} : Finset (Fin 3)),((z.2 : Cover) k)^2)= |
| ((z.2 : Cover) i)^2+((z.2 : Cover) j)^2 := by simp [Ne.symm hji] |
| rw [← he] |
| exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (fun k _ _ => sq_nonneg _) |
| rw [hi] at hh |
| nlinarith [sq_nonneg ((z.2 : Cover) j)] |
|
|
| theorem isMinimizerAt_axialNormalWeight_pos_ae {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hm : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) |
| (ha : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) |
| (hs : ∀ i : Fin 3,coordinateReflection i ⁻¹' E =ᵐ[torusVolume] E) |
| {s : Fin 3 → Bool} |
| (hsg : ∀ (x : Cover) (i : Fin 3), |
| quotientMap x∈frontier (openRepresentative E)∩coordinateHalf i (if s i then 0 else 1/2) → 0<N x i) |
| (i : Fin 3) : ∀ᵐ z ∂(μ : Measure NormalBundle),0<axialNormalWeight i z := by |
| let K := quotientMap '' axialCriticalLift E N i |
| have hK : K.Countable := |
| (isMinimizerAt_countable_axialCriticalLift hV hE hm hμ hN hp ha hs hsg i).image _ |
| let := isMinimizerAt_spatialNormalMeasure_noAtoms hV hE hm hμ |
| have hz : (spatialNormalMeasure μ : Measure Torus) K=0 := hK.measure_zero _ |
| have hae : ∀ᵐ a ∂(spatialNormalMeasure μ : Measure Torus),a∉K := by |
| rw [ae_iff]; simpa only [not_not,Set.ofPred_mem_eq] using hz |
| have haf := ae_of_ae_map normalProjection_continuous.measurable.aemeasurable hae |
| have hb := normalMeasure_frontier_ae (isOpen_openRepresentative E).measurableSet |
| (hμ.congr_ae (isMinimizerAt_openRepresentative_ae hV hE hm).symm) |
| filter_upwards [haf,ha,hb] with z hz hn hbz |
| apply lt_of_le_of_ne (axialNormalWeight_nonneg i z) |
| intro hzero |
| apply hz |
| refine ⟨z.1,⟨hbz,?_⟩,rfl⟩ |
| intro j hji |
| rw [hn] |
| exact axialNormalWeight_zero_coordinates i z hzero.symm j hji |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| theorem axialHeight_absolutelyContinuous {E : Set Torus} |
| {μ : FiniteMeasure NormalBundle} {H : ℝ} |
| (hH : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D= |
| H*directionalFlux E D.coordinate D.function) (i : Fin 3) |
| (hpos : ∀ᵐ z ∂(μ : Measure NormalBundle),0<axialNormalWeight i z) : |
| Measure.map (axialBundleHeight i) (μ : Measure NormalBundle)≪volume := by |
| have hw : (μ : Measure NormalBundle)≪ |
| (μ : Measure NormalBundle).withDensity (fun z => ENNReal.ofReal (axialNormalWeight i z)) := |
| withDensity_absolutelyContinuous' |
| (continuous_axialNormalWeight i).measurable.ennreal_ofReal.aemeasurable |
| (hpos.mono fun z hz => (ENNReal.ofReal_pos.mpr hz).ne') |
| exact (hw.map (continuous_axialBundleHeight i).measurable).trans |
| (axialWeightedHeight_absolutelyContinuous hH i) |
|
|
| theorem isMinimizerAt_axialHeight_absolutelyContinuous {V : ℝ} (hV : V∈Ioo 0 1) |
| {E : Set Torus} (hE : MeasurableSet E) (hm : IsMinimizerAt V E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) |
| (ha : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) |
| (hs : ∀ i : Fin 3,coordinateReflection i ⁻¹' E =ᵐ[torusVolume] E) |
| {s : Fin 3 → Bool} |
| (hsg : ∀ (x : Cover) (i : Fin 3), |
| quotientMap x∈frontier (openRepresentative E)∩coordinateHalf i (if s i then 0 else 1/2) → 0<N x i) |
| {H : ℝ} (hH : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D= |
| H*directionalFlux E D.coordinate D.function) (i : Fin 3) : |
| Measure.map (axialBundleHeight i) (μ : Measure NormalBundle)≪volume := |
| axialHeight_absolutelyContinuous hH i |
| (isMinimizerAt_axialNormalWeight_pos_ae hV hE hm hμ hN hp ha hs hsg i) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| lemma absolutelyContinuous_congrOn {u w : ℝ → ℝ} {a b : ℝ} |
| (hw : AbsolutelyContinuousOnInterval w a b) (he : EqOn u w (uIcc a b)) : |
| AbsolutelyContinuousOnInterval u a b := by |
| rw [absolutelyContinuousOnInterval_iff] at hw ⊢ |
| intro ε hε |
| obtain ⟨δ,hδ,h⟩ := hw ε hε |
| refine ⟨δ,hδ,?_⟩ |
| intro E hE hlen |
| convert h E hE hlen using 1 |
| apply Finset.sum_congr rfl |
| intro i hi |
| rw [he (hE.1 i hi).1,he (hE.1 i hi).2] |
|
|
| lemma integral_compact_eq_interval {f ψ : ℝ → ℝ} {a b : ℝ} (hab : a≤b) |
| (hs : tsupport ψ ⊆ Ioo a b) : |
| (∫ t in a..b,f t*ψ t)=∫ t,f t*ψ t := by |
| rw [intervalIntegral.integral_of_le hab] |
| apply setIntegral_eq_integral_of_forall_compl_eq_zero |
| intro t ht |
| rw [image_eq_zero_of_notMem_tsupport (fun hx => ht (Ioo_subset_Ioc_self (hs hx))),mul_zero] |
|
|
| theorem absolutelyContinuous_of_integrable_weak_derivative {u v : ℝ → ℝ} |
| (hu : Continuous u) {a b : ℝ} (hab : a<b) |
| (hv : IntegrableOn v (Icc a b)) |
| (hweak : ∀ ψ : ℝ → ℝ,ContDiff ℝ (⊤ : ℕ∞) ψ → tsupport ψ ⊆ Ioo a b → |
| (∫ t,u t*deriv ψ t)=-(∫ t,v t*ψ t)) : |
| AbsolutelyContinuousOnInterval u a b := by |
| let g : ℝ → ℝ := (Icc a b).indicator v |
| have hg : Integrable g := hv.integrable_indicator measurableSet_Icc |
| let F : ℝ → ℝ := fun t => ∫ s in a..t,g s |
| have hF : Continuous F := intervalIntegral.continuous_primitive (fun c d => hg.intervalIntegrable) a |
| have hFac : AbsolutelyContinuousOnInterval F a b := |
| hg.intervalIntegrable.absolutelyContinuousOnInterval_intervalIntegral (by simp) |
| have hd : ∀ᵐ t, t∈uIcc a b → deriv F t=g t := by |
| filter_upwards [hg.intervalIntegrable.ae_hasDerivAt_integral (a := a) (b := b)] with t ht htab |
| exact (ht htab a (by simp)).deriv |
| have hz : ∀ ψ : ℝ → ℝ,ContDiff ℝ (⊤ : ℕ∞) ψ → tsupport ψ ⊆ Ioo a b → |
| (∫ t,(u t-F t)*deriv ψ t)=0 := by |
| intro ψ hψ hs |
| have hsc : HasCompactSupport ψ := isCompact_Icc.of_isClosed_subset isClosed_closure |
| (hs.trans Ioo_subset_Icc_self) |
| have hiu : Integrable (fun t => u t*deriv ψ t) := |
| (hu.mul (hψ.continuous_deriv (by simp))).integrable_of_hasCompactSupport hsc.deriv.mul_left |
| have hiF : Integrable (fun t => F t*deriv ψ t) := |
| (hF.mul (hψ.continuous_deriv (by simp))).integrable_of_hasCompactSupport hsc.deriv.mul_left |
| have hacψ : AbsolutelyContinuousOnInterval ψ a b := |
| (hψ.of_le (by simp)).contDiffOn.absolutelyContinuousOnInterval |
| have hparts := hFac.integral_mul_deriv_eq_deriv_mul hacψ |
| have hψa : ψ a=0 := image_eq_zero_of_notMem_tsupport (fun h => (hs h).1.false) |
| have hψb : ψ b=0 := image_eq_zero_of_notMem_tsupport (fun h => (hs h).2.false) |
| have hsd : tsupport (deriv ψ) ⊆ Ioo a b := (tsupport_deriv_subset (f := ψ)).trans hs |
| rw [hψa,hψb,mul_zero,mul_zero,sub_self,zero_sub, |
| integral_compact_eq_interval hab.le hsd] at hparts |
| have hr : (∫ t in a..b,deriv F t*ψ t)=∫ t,v t*ψ t := by |
| calc |
| _ = ∫ t in a..b,g t*ψ t := by |
| apply intervalIntegral.integral_congr_ae |
| filter_upwards [hd] with t ht htab |
| rw [ht (uIoc_subset_uIcc htab)] |
| _ = ∫ t in a..b,v t*ψ t := by |
| apply intervalIntegral.integral_congr |
| intro t ht |
| change g t*ψ t=v t*ψ t |
| rw [show g t=v t from indicator_of_mem (by simpa [uIcc_of_le hab.le] using ht) v] |
| _ = _ := integral_compact_eq_interval hab.le hs |
| rw [hr] at hparts |
| simp_rw [sub_mul] |
| rw [integral_sub hiu hiF,hweak ψ hψ hs,hparts,sub_self] |
| let c := (a+b)/2 |
| have hc : c∈Ioo a b := by dsimp [c]; constructor <;> linarith |
| have he : EqOn u (fun t => F t+(u c-F c)) (Ioo a b) := by |
| intro t ht |
| have hh := continuous_constant_of_weak_derivative_zero (hu.sub hF) ht hc hz |
| change u t-F t=u c-F c at hh |
| linarith |
| have hec : EqOn u (fun t => F t+(u c-F c)) (Icc a b) := by |
| rw [← closure_Ioo hab.ne] |
| exact he.closure hu (hF.add continuous_const) |
| exact absolutelyContinuous_congrOn |
| (hFac.fun_add (contDiff_const.contDiffOn.absolutelyContinuousOnInterval)) |
| (by simpa [uIcc_of_le hab.le] using hec) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| lemma circlePeriodize_unit_eventuallyEq {f : ℝ → ℝ} |
| (hc : HasCompactSupport f) (hs : tsupport f⊆Ioo (0 : ℝ) 1) |
| {x : ℝ} (hx : x∈Icc (0 : ℝ) 1) : circlePeriodize f =ᶠ[𝓝 x] f := by |
| apply circlePeriodize_eventuallyEq hc (a := 1/2) |
| · convert hs using 1; norm_num |
| · convert hx using 1; norm_num |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| lemma circle_weighted_density_nonneg {α : Type*} [MeasurableSpace α] |
| [TopologicalSpace α] [BorelSpace α] [CompactSpace α] |
| (μ : Measure α) [IsFiniteMeasure μ] |
| {h : α → AddCircle (1 : ℝ)} (hh : Continuous h) |
| (hac : Measure.map h μ≪volume) {w : α → ℝ} (hw : Continuous w) |
| (hw0 : ∀ x,0≤w x) : |
| ∃ g : AddCircle (1 : ℝ) → ℝ,Integrable g ∧ |
| ∀ f : AddCircle (1 : ℝ) → ℝ,Continuous f → |
| (∫ t,g t*f t)=∫ x,w x*f (h x) ∂μ := by |
| let ν := Measure.map h (μ.withDensity (fun x => ENNReal.ofReal (w x))) |
| have hwi : Integrable w μ := hw.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| let := isFiniteMeasure_withDensity_ofReal hwi.hasFiniteIntegral |
| have hν : ν≪volume := |
| ((withDensity_absolutelyContinuous μ (fun x => ENNReal.ofReal (w x))).map hh.measurable).trans hac |
| refine ⟨fun t => (ν.rnDeriv volume t).toReal,Measure.integrable_toReal_rnDeriv,?_⟩ |
| intro f hf |
| rw [integral_toReal_rnDeriv_mul hν] |
| dsimp only [ν] |
| rw [integral_map hh.measurable.aemeasurable hf.aestronglyMeasurable, |
| integral_withDensity_eq_integral_toReal_smul hw.measurable.ennreal_ofReal |
| (Eventually.of_forall fun _ => ENNReal.ofReal_lt_top)] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by |
| dsimp only |
| rw [ENNReal.toReal_ofReal (hw0 x),smul_eq_mul] |
|
|
| theorem circle_weighted_density {α : Type*} [MeasurableSpace α] |
| [TopologicalSpace α] [BorelSpace α] [CompactSpace α] |
| (μ : Measure α) [IsFiniteMeasure μ] |
| {h : α → AddCircle (1 : ℝ)} (hh : Continuous h) |
| (hac : Measure.map h μ≪volume) {w : α → ℝ} (hw : Continuous w) : |
| ∃ g : AddCircle (1 : ℝ) → ℝ,Integrable g ∧ |
| ∀ f : AddCircle (1 : ℝ) → ℝ,Continuous f → |
| (∫ t,g t*f t)=∫ x,w x*f (h x) ∂μ := by |
| obtain ⟨p,hp,hpm⟩ := circle_weighted_density_nonneg μ hh hac |
| (hw.max continuous_const) (fun x => le_max_right (w x) 0) |
| obtain ⟨q,hq,hqm⟩ := circle_weighted_density_nonneg μ hh hac |
| (hw.neg.max continuous_const) (fun x => le_max_right (-w x) 0) |
| refine ⟨fun t => p t-q t,hp.sub hq,?_⟩ |
| intro f hf |
| obtain ⟨M,_,hM⟩ := (isCompact_univ.image hf).isBounded.exists_pos_norm_le |
| have hbound : ∀ᵐ t : AddCircle (1 : ℝ),‖f t‖≤M := |
| Eventually.of_forall fun t => hM _ ⟨t,mem_univ _,rfl⟩ |
| have hip : Integrable (fun t => p t*f t) := hp.mul_bdd hf.aestronglyMeasurable hbound |
| have hiq : Integrable (fun t => q t*f t) := hq.mul_bdd hf.aestronglyMeasurable hbound |
| have hwpf : Integrable (fun x => max (w x) 0*f (h x)) μ := |
| ((hw.max continuous_const).mul (hf.comp hh)).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _) |
| have hwqf : Integrable (fun x => max (-w x) 0*f (h x)) μ := |
| ((hw.neg.max continuous_const).mul (hf.comp hh)).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _) |
| simp_rw [sub_mul] |
| rw [integral_sub hip hiq,hpm f hf,hqm f hf] |
| simp only [Pi.neg_apply] |
| rw [← integral_sub hwpf hwqf] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by |
| dsimp only |
| rw [← sub_mul,show max (w x) 0-max (-w x) 0=w x by |
| rcases le_total 0 (w x) with h|h |
| · rw [max_eq_left h,max_eq_right (neg_nonpos.mpr h),sub_zero] |
| · rw [max_eq_right h,max_eq_left (neg_nonneg.mpr h)]; ring] |
|
|
| lemma circle_integrable_preimage_Icc {g : AddCircle (1 : ℝ) → ℝ} (hg : Integrable g) |
| (a : ℝ) : IntegrableOn (fun t : ℝ => g t) (Icc a (a+1)) := by |
| rw [integrableOn_Icc_iff_integrableOn_Ioc] |
| exact (AddCircle.measurePreserving_mk (1 : ℝ) a).integrable_comp_of_integrable hg |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| lemma circle_weighted_density_nonneg_measurable {α : Type*} [MeasurableSpace α] |
| [TopologicalSpace α] [BorelSpace α] [CompactSpace α] |
| (μ : Measure α) [IsFiniteMeasure μ] |
| {h : α → AddCircle (1 : ℝ)} (hh : Continuous h) |
| (hac : Measure.map h μ≪volume) {w : α → ℝ} (hw : Continuous w) |
| (hw0 : ∀ x,0≤w x) : |
| ∃ g : AddCircle (1 : ℝ) → ℝ,Integrable g ∧ |
| ∀ f : AddCircle (1 : ℝ) → ℝ,Measurable f → |
| (∫ t,g t*f t)=∫ x,w x*f (h x) ∂μ := by |
| let ν := Measure.map h (μ.withDensity (fun x => ENNReal.ofReal (w x))) |
| have hwi : Integrable w μ := hw.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| let := isFiniteMeasure_withDensity_ofReal hwi.hasFiniteIntegral |
| have hν : ν≪volume := |
| ((withDensity_absolutelyContinuous μ (fun x => ENNReal.ofReal (w x))).map hh.measurable).trans hac |
| refine ⟨fun t => (ν.rnDeriv volume t).toReal,Measure.integrable_toReal_rnDeriv,?_⟩ |
| intro f hf |
| rw [integral_toReal_rnDeriv_mul hν] |
| dsimp only [ν] |
| rw [integral_map hh.measurable.aemeasurable hf.aestronglyMeasurable, |
| integral_withDensity_eq_integral_toReal_smul hw.measurable.ennreal_ofReal |
| (Eventually.of_forall fun _ => ENNReal.ofReal_lt_top)] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by |
| dsimp only |
| rw [ENNReal.toReal_ofReal (hw0 x),smul_eq_mul] |
|
|
| theorem circle_weighted_density_bounded {α : Type*} [MeasurableSpace α] |
| [TopologicalSpace α] [BorelSpace α] [CompactSpace α] |
| (μ : Measure α) [IsFiniteMeasure μ] |
| {h : α → AddCircle (1 : ℝ)} (hh : Continuous h) |
| (hac : Measure.map h μ≪volume) {w : α → ℝ} (hw : Continuous w) : |
| ∃ g : AddCircle (1 : ℝ) → ℝ,Integrable g ∧ |
| ∀ f : AddCircle (1 : ℝ) → ℝ,Measurable f → (∃ M : ℝ,∀ t,‖f t‖≤M) → |
| (∫ t,g t*f t)=∫ x,w x*f (h x) ∂μ := by |
| obtain ⟨p,hp,hpm⟩ := circle_weighted_density_nonneg_measurable μ hh hac |
| (hw.max continuous_const) (fun x => le_max_right (w x) 0) |
| obtain ⟨q,hq,hqm⟩ := circle_weighted_density_nonneg_measurable μ hh hac |
| (hw.neg.max continuous_const) (fun x => le_max_right (-w x) 0) |
| refine ⟨fun t => p t-q t,hp.sub hq,?_⟩ |
| intro f hf ⟨M,hM⟩ |
| have hbound : ∀ᵐ t : AddCircle (1 : ℝ),‖f t‖≤M := |
| Eventually.of_forall fun t => hM t |
| have hip : Integrable (fun t => p t*f t) := hp.mul_bdd hf.aestronglyMeasurable hbound |
| have hiq : Integrable (fun t => q t*f t) := hq.mul_bdd hf.aestronglyMeasurable hbound |
| have hwpf : Integrable (fun x => max (w x) 0*f (h x)) μ := |
| ((hw.max continuous_const).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _)).mul_bdd |
| (hf.comp hh.measurable).aestronglyMeasurable (Eventually.of_forall fun x => hM (h x)) |
| have hwqf : Integrable (fun x => max (-w x) 0*f (h x)) μ := |
| ((hw.neg.max continuous_const).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _)).mul_bdd |
| (hf.comp hh.measurable).aestronglyMeasurable (Eventually.of_forall fun x => hM (h x)) |
| simp_rw [sub_mul] |
| rw [integral_sub hip hiq,hpm f hf,hqm f hf] |
| simp only [Pi.neg_apply] |
| rw [← integral_sub hwpf hwqf] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by |
| dsimp only |
| rw [← sub_mul,show max (w x) 0-max (-w x) 0=w x by |
| rcases le_total 0 (w x) with h|h |
| · rw [max_eq_left h,max_eq_right (neg_nonpos.mpr h),sub_zero] |
| · rw [max_eq_right h,max_eq_left (neg_nonneg.mpr h)]; ring] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| lemma circle_integral_withDensity_ofReal {q : AddCircle (1 : ℝ) → ℝ} |
| (hq : Integrable q) (hq0 : ∀ t,0≤q t) (f : AddCircle (1 : ℝ) → ℝ) : |
| (∫ t,f t ∂volume.withDensity (fun t => ENNReal.ofReal (q t)))=∫ t,q t*f t := by |
| rw [integral_withDensity_eq_integral_toReal_smul₀ hq.aemeasurable.ennreal_ofReal |
| (Eventually.of_forall fun _ => ENNReal.ofReal_lt_top)] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun t => by dsimp only; rw [ENNReal.toReal_ofReal (hq0 t),smul_eq_mul] |
|
|
| theorem circle_ae_eq_zero_of_smooth_moments {q : AddCircle (1 : ℝ) → ℝ} |
| (hq : Integrable q) |
| (he : ∀ (f : ℝ → ℝ), ContDiff ℝ (⊤ : ℕ∞) f → ∀ (hp : Function.Periodic f 1), |
| (∫ t,q t*hp.lift t)=0) : q =ᵐ[volume] 0 := by |
| let p := fun t => max (q t) 0 |
| let n := fun t => max (-q t) 0 |
| have hp : Integrable p := hq.pos_part |
| have hn : Integrable n := hq.neg_part |
| have hp0 (t) : 0≤p t := le_max_right _ _ |
| have hn0 (t) : 0≤n t := le_max_right _ _ |
| let P := volume.withDensity (fun t => ENNReal.ofReal (p t)) |
| let N := volume.withDensity (fun t => ENNReal.ofReal (n t)) |
| let : IsFiniteMeasure P := isFiniteMeasure_withDensity_ofReal hp.hasFiniteIntegral |
| let : IsFiniteMeasure N := isFiniteMeasure_withDensity_ofReal hn.hasFiniteIntegral |
| have hsplit (t) : q t+n t=p t := by |
| rcases le_total (q t) 0 with h|h |
| · simp only [n,p,max_eq_left (neg_nonneg.mpr h),max_eq_right h]; ring |
| · simp only [n,p,max_eq_right (neg_nonpos.mpr h),max_eq_left h]; ring |
| have hbal : P=N := by |
| apply circle_measure_ext_smooth |
| intro f hf hper |
| change (∫ t,hper.lift t ∂volume.withDensity (fun t => ENNReal.ofReal (p t)))= |
| ∫ t,hper.lift t ∂volume.withDensity (fun t => ENNReal.ofReal (n t)) |
| rw [circle_integral_withDensity_ofReal hp hp0,circle_integral_withDensity_ofReal hn hn0] |
| have hfc := continuous_periodic_lift hper hf.continuous |
| obtain ⟨M,_,hM⟩ := (isCompact_univ.image hfc).isBounded.exists_pos_norm_le |
| have hb : ∀ᵐ t : AddCircle (1 : ℝ),‖hper.lift t‖≤M := |
| Eventually.of_forall fun t => hM _ ⟨t,mem_univ _,rfl⟩ |
| have hiq := hq.mul_bdd hfc.aestronglyMeasurable hb |
| have hin := hn.mul_bdd hfc.aestronglyMeasurable hb |
| have hi := integral_add hiq hin |
| have hi' : (∫ t,p t*hper.lift t)=(∫ t,q t*hper.lift t)+(∫ t,n t*hper.lift t) := by |
| rw [← hi] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun t => by dsimp only; rw [← add_mul,hsplit] |
| rw [hi',he f hf hper,zero_add] |
| have hae := (withDensity_eq_iff_of_sigmaFinite hp.aemeasurable.ennreal_ofReal |
| hn.aemeasurable.ennreal_ofReal).mp hbal |
| filter_upwards [hae] with t ht |
| have htt := congrArg ENNReal.toReal ht |
| rw [ENNReal.toReal_ofReal (hp0 t),ENNReal.toReal_ofReal (hn0 t)] at htt |
| have hh := hsplit t |
| change q t=0 |
| linarith |
|
|
| lemma circle_ae_eq_of_smooth_moments {p q : AddCircle (1 : ℝ) → ℝ} |
| (hp : Integrable p) (hq : Integrable q) |
| (he : ∀ (f : ℝ → ℝ), ContDiff ℝ (⊤ : ℕ∞) f → ∀ (hper : Function.Periodic f 1), |
| (∫ t,p t*hper.lift t)=(∫ t,q t*hper.lift t)) : p =ᵐ[volume] q := by |
| have hz : (fun t => p t-q t) =ᵐ[volume] 0 := by |
| apply circle_ae_eq_zero_of_smooth_moments (hp.sub hq) |
| intro f hf hper |
| have hfc := continuous_periodic_lift hper hf.continuous |
| obtain ⟨M,_,hM⟩ := (isCompact_univ.image hfc).isBounded.exists_pos_norm_le |
| have hb : ∀ᵐ t : AddCircle (1 : ℝ),‖hper.lift t‖≤M := |
| Eventually.of_forall fun t => hM _ ⟨t,mem_univ _,rfl⟩ |
| change (∫ t,(p t-q t)*hper.lift t)=0 |
| simp_rw [sub_mul] |
| rw [integral_sub (hp.mul_bdd hfc.aestronglyMeasurable hb) |
| (hq.mul_bdd hfc.aestronglyMeasurable hb),he f hf hper,sub_self] |
| exact hz.mono fun t ht => sub_eq_zero.mp ht |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| lemma circle_nonneg_weighted_density {α : Type*} [MeasurableSpace α] |
| [TopologicalSpace α] [BorelSpace α] [CompactSpace α] |
| (μ : Measure α) [IsFiniteMeasure μ] |
| {h : α → AddCircle (1 : ℝ)} (hh : Continuous h) |
| (hac : Measure.map h μ≪volume) {w : α → ℝ} (hw : Continuous w) |
| (hw0 : ∀ x,0≤w x) : |
| ∃ g : AddCircle (1 : ℝ) → ℝ,Integrable g ∧ (∀ t,0≤g t) ∧ |
| ∀ f : AddCircle (1 : ℝ) → ℝ,Measurable f → |
| (∫ t,g t*f t)=∫ x,w x*f (h x) ∂μ := by |
| let ν := Measure.map h (μ.withDensity (fun x => ENNReal.ofReal (w x))) |
| have hwi : Integrable w μ := hw.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| let := isFiniteMeasure_withDensity_ofReal hwi.hasFiniteIntegral |
| have hν : ν≪volume := |
| ((withDensity_absolutelyContinuous μ (fun x => ENNReal.ofReal (w x))).map hh.measurable).trans hac |
| refine ⟨fun t => (ν.rnDeriv volume t).toReal,Measure.integrable_toReal_rnDeriv, |
| fun _ => ENNReal.toReal_nonneg,?_⟩ |
| intro f hf |
| rw [integral_toReal_rnDeriv_mul hν] |
| dsimp only [ν] |
| rw [integral_map hh.measurable.aemeasurable hf.aestronglyMeasurable, |
| integral_withDensity_eq_integral_toReal_smul hw.measurable.ennreal_ofReal |
| (Eventually.of_forall fun _ => ENNReal.ofReal_lt_top)] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by |
| dsimp only |
| rw [ENNReal.toReal_ofReal (hw0 x),smul_eq_mul] |
|
|
| theorem circle_ae_le_of_ordered_weighted_moments {α : Type*} [MeasurableSpace α] |
| [TopologicalSpace α] [BorelSpace α] [CompactSpace α] |
| (μ : Measure α) [IsFiniteMeasure μ] |
| {h : α → AddCircle (1 : ℝ)} (hh : Continuous h) |
| (hac : Measure.map h μ≪volume) |
| {u w : α → ℝ} (hu : Continuous u) (hw : Continuous w) (huw : ∀ x,u x≤w x) |
| {p q : AddCircle (1 : ℝ) → ℝ} (hp : Integrable p) (hq : Integrable q) |
| (hpm : ∀ (f : ℝ → ℝ), ContDiff ℝ (⊤ : ℕ∞) f → ∀ (hper : Function.Periodic f 1), |
| (∫ t,p t*hper.lift t)=∫ x,u x*hper.lift (h x) ∂μ) |
| (hqm : ∀ (f : ℝ → ℝ), ContDiff ℝ (⊤ : ℕ∞) f → ∀ (hper : Function.Periodic f 1), |
| (∫ t,q t*hper.lift t)=∫ x,w x*hper.lift (h x) ∂μ) : p ≤ᵐ[volume] q := by |
| obtain ⟨r,hr,hr0,hrm⟩ := circle_nonneg_weighted_density μ hh hac (hw.sub hu) |
| (fun x => sub_nonneg.mpr (huw x)) |
| have he : (fun t => q t-p t) =ᵐ[volume] r := by |
| apply circle_ae_eq_of_smooth_moments (hq.sub hp) hr |
| intro f hf hper |
| have hfc := continuous_periodic_lift hper hf.continuous |
| obtain ⟨M,_,hM⟩ := (isCompact_univ.image hfc).isBounded.exists_pos_norm_le |
| have hb : ∀ᵐ t : AddCircle (1 : ℝ),‖hper.lift t‖≤M := |
| Eventually.of_forall fun t => hM _ ⟨t,mem_univ _,rfl⟩ |
| change (∫ t,(q t-p t)*hper.lift t)=∫ t,r t*hper.lift t |
| simp_rw [sub_mul] |
| rw [integral_sub (hq.mul_bdd hfc.aestronglyMeasurable hb) |
| (hp.mul_bdd hfc.aestronglyMeasurable hb),hqm f hf hper,hpm f hf hper, |
| hrm hper.lift hfc.measurable] |
| have hiw : Integrable (fun x => w x*hper.lift (h x)) μ := (hw.mul (hfc.comp hh)).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| have hiu : Integrable (fun x => u x*hper.lift (h x)) μ := (hu.mul (hfc.comp hh)).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| rw [← integral_sub hiw hiu] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by dsimp only [Pi.sub_apply]; ring |
| filter_upwards [he] with t ht |
| have hh := hr0 t |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| theorem circle_positive_density_of_smooth_moments |
| {A : Measure (AddCircle (1 : ℝ))} [IsFiniteMeasure A] |
| {q : AddCircle (1 : ℝ) → ℝ} (hq : Continuous q) |
| (he : ∀ (f : ℝ → ℝ), ContDiff ℝ (⊤ : ℕ∞) f → ∀ (hp : Function.Periodic f 1), |
| (∫ t,hp.lift t ∂A)=∫ t,q t*hp.lift t) : |
| (∀ t,0≤q t) ∧ A=volume.withDensity (fun t => ENNReal.ofReal (q t)) := by |
| let p : AddCircle (1 : ℝ) → ℝ := fun t => max (q t) 0 |
| let n : AddCircle (1 : ℝ) → ℝ := fun t => max (-q t) 0 |
| have hp : Continuous p := hq.max continuous_const |
| have hn : Continuous n := hq.neg.max continuous_const |
| have hp0 (t) : 0≤p t := le_max_right _ _ |
| have hn0 (t) : 0≤n t := le_max_right _ _ |
| let P : Measure (AddCircle (1 : ℝ)) := volume.withDensity (fun t => ENNReal.ofReal (p t)) |
| let N : Measure (AddCircle (1 : ℝ)) := volume.withDensity (fun t => ENNReal.ofReal (n t)) |
| let : IsFiniteMeasure P := isFiniteMeasure_withDensity_ofReal |
| (circle_continuous_integrable hp).hasFiniteIntegral |
| let : IsFiniteMeasure N := isFiniteMeasure_withDensity_ofReal |
| (circle_continuous_integrable hn).hasFiniteIntegral |
| have hden {w : AddCircle (1 : ℝ) → ℝ} (hw : Continuous w) (hw0 : ∀ t,0≤w t) |
| (f : AddCircle (1 : ℝ) → ℝ) : |
| (∫ t,f t ∂volume.withDensity (fun t => ENNReal.ofReal (w t)))=∫ t,w t*f t := by |
| rw [integral_withDensity_eq_integral_toReal_smul hw.measurable.ennreal_ofReal |
| (Eventually.of_forall fun _ => ENNReal.ofReal_lt_top)] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun t => by |
| dsimp only |
| rw [ENNReal.toReal_ofReal (hw0 t),smul_eq_mul] |
| have hsplit (t) : q t+n t=p t := by |
| rcases le_total (q t) 0 with h|h |
| · simp only [n,p,max_eq_left (neg_nonneg.mpr h),max_eq_right h]; ring |
| · simp only [n,p,max_eq_right (neg_nonpos.mpr h),max_eq_left h]; ring |
| have hbal : A+N=P := by |
| apply circle_measure_ext_smooth |
| intro f hf hfper |
| have hfc := continuous_periodic_lift hfper hf.continuous |
| rw [integral_add_measure (circle_continuous_integrable hfc) (circle_continuous_integrable hfc),he f hf hfper] |
| change (∫ t,q t*hfper.lift t)+(∫ t,hfper.lift t ∂volume.withDensity (fun t => ENNReal.ofReal (n t)))= |
| ∫ t,hfper.lift t ∂volume.withDensity (fun t => ENNReal.ofReal (p t)) |
| rw [hden hn hn0,hden hp hp0] |
| have hiq : Integrable (fun t => q t*hfper.lift t) := circle_continuous_integrable (hq.mul hfc) |
| have hin : Integrable (fun t => n t*hfper.lift t) := circle_continuous_integrable (hn.mul hfc) |
| have hia := integral_add hiq hin |
| change (∫ t,q t*hfper.lift t+n t*hfper.lift t)= |
| (∫ t,q t*hfper.lift t)+(∫ t,n t*hfper.lift t) at hia |
| rw [← hia] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun t => by dsimp only; rw [← add_mul,hsplit] |
| have hzprod (t) : p t*n t=0 := by |
| rcases le_total (q t) 0 with h|h |
| · simp [p,max_eq_right h] |
| · simp [n,max_eq_right (neg_nonpos.mpr h)] |
| have htest := congrArg (fun ρ : Measure (AddCircle (1 : ℝ)) => ∫ t,n t ∂ρ) hbal |
| rw [integral_add_measure (circle_continuous_integrable hn) (circle_continuous_integrable hn)] at htest |
| change (∫ t,n t ∂A)+(∫ t,n t ∂volume.withDensity (fun t => ENNReal.ofReal (n t)))= |
| ∫ t,n t ∂volume.withDensity (fun t => ENNReal.ofReal (p t)) at htest |
| rw [hden hn hn0,hden hp hp0] at htest |
| simp_rw [hzprod] at htest |
| rw [integral_zero] at htest |
| have hni : 0≤(∫ t,n t ∂A) := integral_nonneg (fun t => hn0 t) |
| have hns : 0≤(∫ t,n t*n t) := integral_nonneg (fun t => mul_self_nonneg (n t)) |
| have hnzero : (∫ t,n t*n t)=0 := by linarith |
| have hnae := (integral_eq_zero_iff_of_nonneg (fun t => mul_self_nonneg (n t)) |
| (circle_continuous_integrable (hn.mul hn))).mp hnzero |
| have hzero : n=fun _ => (0 : ℝ) := |
| Measure.eq_of_ae_eq (hnae.mono fun t ht => mul_self_eq_zero.mp ht) hn continuous_const |
| have hq0 (t) : 0≤q t := by |
| have htt := congrFun hzero t |
| have hh : -q t≤n t := le_max_left _ _ |
| rw [htt] at hh |
| linarith |
| refine ⟨hq0,?_⟩ |
| have hNz : N=0 := by |
| dsimp only [N] |
| simp only [hzero,ENNReal.ofReal_zero] |
| exact withDensity_zero |
| have hP : P=volume.withDensity (fun t => ENNReal.ofReal (q t)) := by |
| dsimp only [P] |
| congr 1 |
| funext t |
| rw [show p t=q t from max_eq_left (hq0 t)] |
| simpa only [hNz,add_zero,hP] using hbal |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| end OAI |
|
|
