| import Mathlib |
| import OAI.Geometry.CubicTorus.Reflection.AxialFluxDensity |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma regularizedNormal_norm_le (R : Cover → Cover) (x : Cover) : ‖regularizedNormal R x‖≤1 := by |
| rw [regularizedNormal,norm_smul,Real.norm_eq_abs, |
| abs_of_pos (inv_pos.mpr (Real.sqrt_pos.mpr (regularizedNormal_denom_pos _))), |
| inv_mul_le_iff₀ (Real.sqrt_pos.mpr (regularizedNormal_denom_pos _)),mul_one] |
| apply Real.le_sqrt_of_sq_le |
| linarith [Real.smoothTransition.le_one (4*‖R x‖^2)] |
|
|
| def axialTangentPart (i : Fin 3) (u : Cover) : Cover := u-u i • EuclideanSpace.single i 1 |
|
|
| lemma axialTangentPart_axis (i : Fin 3) (u : Cover) : axialTangentPart i u i=0 := by |
| simp [axialTangentPart] |
|
|
| lemma axialTangentPart_norm_sq (i : Fin 3) (u : Cover) : |
| ‖axialTangentPart i u‖^2=‖u‖^2-(u i)^2 := by |
| rw [axialTangentPart,norm_sub_sq_real,norm_smul,real_inner_smul_right] |
| simp only [PiLp.norm_single,Real.norm_eq_abs,abs_one,mul_one, |
| EuclideanSpace.inner_single_right,conj_trivial] |
| rw [sq_abs] |
| ring |
|
|
| lemma inner_axialTangentPart (i : Fin 3) (u : Cover) : |
| ⟪u,axialTangentPart i u⟫=‖u‖^2-(u i)^2 := by |
| rw [axialTangentPart,inner_sub_right,real_inner_self_eq_norm_sq,real_inner_smul_right] |
| simp only [EuclideanSpace.inner_single_right,conj_trivial] |
| ring |
|
|
| lemma axialTangentPart_contDiff {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) (i : Fin 3) : |
| ContDiff ℝ (⊤ : ℕ∞) (fun x => axialTangentPart i (N x)) := |
| hN.sub (((EuclideanSpace.proj i : Cover →L[ℝ] ℝ).contDiff.comp hN).smul contDiff_const) |
|
|
| def axialNormalCalibration (N : Cover → Cover) (i : Fin 3) : Cover → Cover := |
| regularizedNormal (fun x => axialTangentPart i (N x)) |
|
|
| lemma axialNormalCalibration_admissible {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) (i : Fin 3) : |
| AdmissibleField (axialNormalCalibration N i) := by |
| refine ⟨regularizedNormal_contDiff (axialTangentPart_contDiff hN i),?_,?_⟩ |
| · apply regularizedNormal_periodic |
| intro m x |
| rw [hp] |
| · exact regularizedNormal_norm_le _ |
|
|
| lemma axialNormalCalibration_axis (N : Cover → Cover) (i : Fin 3) (x : Cover) : |
| axialNormalCalibration N i x i=0 := by |
| simp only [axialNormalCalibration,regularizedNormal,PiLp.smul_apply,smul_eq_mul,axialTangentPart_axis,mul_zero] |
|
|
| lemma axialNormalCalibration_quadratic_lower (N : Cover → Cover) (i : Fin 3) (x : Cover) |
| (hu : ‖N x‖=1) : |
| 1-(N x i)^2-⟪N x,axialNormalCalibration N i x⟫≤(N x i)^2 := by |
| let w := 1-(N x i)^2 |
| have hw : ‖axialTangentPart i (N x)‖^2=w := by rw [axialTangentPart_norm_sq,hu,one_pow] |
| have hw0 : 0≤w := by rw [← hw]; positivity |
| have hw1 : w≤1 := by dsimp [w]; linarith [sq_nonneg (N x i)] |
| have hin : ⟪N x,axialTangentPart i (N x)⟫=w := by rw [inner_axialTangentPart,hu,one_pow] |
| have hf0 : 0≤⟪N x,axialNormalCalibration N i x⟫ := by |
| rw [axialNormalCalibration,regularizedNormal,real_inner_smul_right,hin] |
| positivity |
| by_cases hh : 1/4≤w |
| · have hnorm0 : 0<‖axialTangentPart i (N x)‖ := by |
| have hpos : 0<‖axialTangentPart i (N x)‖^2 := by rw [hw]; linarith |
| exact lt_of_le_of_ne (norm_nonneg _) (fun he => by rw [← he] at hpos; norm_num at hpos) |
| have hnorm1 : ‖axialTangentPart i (N x)‖≤1 := by nlinarith [norm_nonneg (axialTangentPart i (N x))] |
| have he : ⟪N x,axialNormalCalibration N i x⟫= |
| w/‖axialTangentPart i (N x)‖ := by |
| rw [axialNormalCalibration,regularizedNormal_eq (by rw [hw]; exact hh),real_inner_smul_right,hin] |
| ring |
| have hge : w≤⟪N x,axialNormalCalibration N i x⟫ := by |
| rw [he,le_div_iff₀ hnorm0] |
| simpa only [mul_one] using mul_le_mul_of_nonneg_left hnorm1 hw0 |
| change w-⟪N x,axialNormalCalibration N i x⟫≤_ |
| linarith [sq_nonneg (N x i)] |
| · change w-⟪N x,axialNormalCalibration N i x⟫≤_ |
| dsimp only [w] at hh ⊢ |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem axial_slice_endpoint_calibration {V : ℝ} {E : Set Torus} |
| (hE : MeasurableSet E) (hvol : torusVolume.real E=V) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {H : ℝ} |
| (hH : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D= |
| H*directionalFlux E D.coordinate D.function) |
| {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)) |
| (i : Fin 3) (hc : Continuous (axialSectionArea E i)) |
| (hcf : Continuous (axialSectionIntegral E i (divergence (axialNormalCalibration N i)))) |
| (a : ℝ) {K : ℝ} (hK : 0≤K) |
| (hR : ∀ᵐ z ∂(μ : Measure NormalBundle),|((z.2 : Cover) i)|≤K*|Real.sin (Real.pi*(z.1.1 i-a))|) : |
| axialSectionIntegral E i (divergence (axialNormalCalibration N i)) a= |
| (μ.mass : ℝ)*axialFluxWeight μ i+H*(axialSectionArea E i a-V) := by |
| let F := axialNormalCalibration N i |
| have hF : AdmissibleField F := axialNormalCalibration_admissible hN hp i |
| have ht : ∀ x,F x i=0 := axialNormalCalibration_axis N i |
| apply le_antisymm (axial_slice_endpoint_bound hE hvol hμ hH hF i ht hc hcf a hK hR) |
| let p := axialSectionIntegral E i (divergence F) |
| let q := fun t => (μ.mass : ℝ)*axialFluxWeight μ i+H*(axialSectionArea E i t-V) |
| have hqc : Continuous q := continuous_const.add (continuous_const.mul (hc.sub continuous_const)) |
| have hpp : Function.Periodic p 1 := axialSectionIntegral_periodic E i (divergence_periodic hF.2.1) |
| have hqp : Function.Periodic q 1 := by |
| intro t |
| dsimp [q] |
| rw [axialSectionArea_periodic E i] |
| suffices h : q a-p a≤0 by dsimp [p,q,F] at h; linarith |
| apply circle_quadratic_contact (hqc.sub hcf) (hqp.sub hpp) a |
| (M := K^2*(μ.mass : ℝ)) (by positivity) |
| intro f hf hfp hf0 hf1 δ hδ hδsupp |
| have hden := axial_density_moment hE hvol hH i hc hf hfp |
| have hflux := axial_slice_flux_moment hE hμ hF i ht hf hfp |
| have hic : (∫ t in Ico (0 : ℝ) 1,p t*f t)=∫ t in (0 : ℝ)..1,p t*f t := by |
| rw [intervalIntegral.integral_of_le (by norm_num : (0 : ℝ)≤1),integral_Ico_eq_integral_Ioc] |
| change (∫ t in Ico (0 : ℝ) 1,p t*f t)=_ at hflux |
| rw [hic] at hflux |
| have hsub : (∫ t in (0 : ℝ)..1,(q t-p t)*f t)= |
| (∫ t in (0 : ℝ)..1,q t*f t)-(∫ t in (0 : ℝ)..1,p t*f t) := by |
| simp_rw [sub_mul] |
| exact intervalIntegral.integral_sub ((hqc.mul hf.continuous).intervalIntegrable _ _) |
| ((hcf.mul hf.continuous).intervalIntegrable _ _) |
| change (∫ t in (0 : ℝ)..1,(q t-p t)*f t)≤_ |
| rw [hsub] |
| change (∫ t in (0 : ℝ)..1,q t*f t)=_ at hden |
| rw [hden,hflux] |
| have hcT : Continuous (fun z : NormalBundle => f (z.1.1 i)) := |
| hf.continuous.comp ((EuclideanSpace.proj i : Cover →L[ℝ] ℝ).continuous.comp |
| (continuous_subtype_val.comp continuous_fst)) |
| have hi1 : Integrable (fun z : NormalBundle => axialNormalWeight i z*f (z.1.1 i)) (μ : Measure NormalBundle) := |
| ((continuous_axialNormalWeight i).mul hcT).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| have hi2 : Integrable (fun z : NormalBundle => f (z.1.1 i)*normalTest F hF.1.continuous z) (μ : Measure NormalBundle) := |
| (hcT.mul (normalTest F hF.1.continuous).continuous).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| rw [← integral_sub hi1 hi2] |
| calc |
| (∫ z,axialNormalWeight i z*f (z.1.1 i)-f (z.1.1 i)*normalTest F hF.1.continuous z ∂(μ : Measure NormalBundle))≤ |
| ∫ _ : NormalBundle,K^2*δ^2 ∂(μ : Measure NormalBundle) := by |
| apply integral_mono_ae (hi1.sub hi2) (integrable_const _) |
| filter_upwards [ha,hR] with z hzn hz |
| have hcal := axialNormalCalibration_quadratic_lower N i z.1 (by rw [hzn]; exact z.2.property) |
| rw [hzn] at hcal |
| have hh := mul_le_mul_of_nonneg_right hcal (hf0 (z.1.1 i)) |
| change axialNormalWeight i z*f (z.1.1 i)-f (z.1.1 i)*normalTest F hF.1.continuous z≤K^2*δ^2 |
| by_cases hzero : f (z.1.1 i)=0 |
| · simp only [hzero,mul_zero,zero_mul,sub_self] |
| positivity |
| · have hn := hz.trans (mul_le_mul_of_nonneg_left (hδsupp _ hzero) hK) |
| have hsq : ((z.2 : Cover) i)^2≤K^2*δ^2 := by |
| have he := (sq_le_sq₀ (abs_nonneg ((z.2 : Cover) i)) (mul_nonneg hK hδ)).mpr hn |
| simpa only [sq_abs,mul_pow] using he |
| have hfa : ((z.2 : Cover) i)^2*f (z.1.1 i)≤((z.2 : Cover) i)^2 := by |
| simpa only [mul_one] using mul_le_mul_of_nonneg_left (hf1 (z.1.1 i)) (sq_nonneg ((z.2 : Cover) i)) |
| change (1-((z.2 : Cover) i)^2)*f (z.1.1 i)-f (z.1.1 i)*⟪(z.2 : Cover),F z.1⟫≤_ |
| dsimp only [F] at ⊢ |
| nlinarith |
| _=K^2*(μ.mass : ℝ)*δ^2 := by |
| simp only [integral_const,smul_eq_mul,Measure.real,← FiniteMeasure.ennreal_mass,ENNReal.coe_toReal] |
| ring |
|
|
| theorem isMinimizerAt_axial_endpoint_calibration {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) (b : Bool) : |
| axialSectionIntegral (openRepresentative E) i (divergence (axialNormalCalibration N i)) (if b then 1/2 else 0)= |
| (μ.mass : ℝ)*axialFluxWeight μ i+ |
| H*(axialSectionArea (openRepresentative E) i (if b then 1/2 else 0)-V) := by |
| have hae := isMinimizerAt_openRepresentative_ae hV hE hm |
| have hμo := hμ.congr_ae hae.symm |
| have hvol : torusVolume.real (openRepresentative E)=V := by |
| rw [Measure.real,measure_congr hae,hm.2.1,ENNReal.toReal_ofReal hV.1.le] |
| have hHo : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D= |
| H*directionalFlux (openRepresentative E) D.coordinate D.function := by |
| intro D |
| rw [directionalFlux_congr_ae hae,hH] |
| have hc := isMinimizerAt_continuous_axial_sections hV hE hm hμ hN hp ha hs hsg i |
| have hF := axialNormalCalibration_admissible hN hp i |
| have hcf := continuous_axialSectionIntegral_of_boundary_null |
| (isOpen_openRepresentative E).measurableSet i |
| (isMinimizerAt_axial_boundary_null hV hE hm hμ hN hp ha hs hsg i) |
| (continuous_divergence hF.1) (divergence_periodic hF.2.1) |
| obtain ⟨K,hK⟩ := isMinimizerAt_normal_reflection_rate hV hE hm hμ hN hp ha hs |
| apply axial_slice_endpoint_calibration (isOpen_openRepresentative E).measurableSet hvol hμo hHo hN hp ha i hc hcf |
| (if b then 1/2 else 0) K.coe_nonneg |
| filter_upwards [normalMeasure_frontier_ae (isOpen_openRepresentative E).measurableSet hμo,ha] with z hz hzn |
| have hh := hK i b z.1 z.1.property hz |
| rw [hzn] at hh |
| exact hh |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def axialSlicePerimeter (E : Set Torus) (i : Fin 3) (t : ℝ) : ℝ≥0∞ := |
| ⨆ (F : Cover → Cover) (_ : AdmissibleField F) (_ : ∀ x,F x i=0), |
| ENNReal.ofReal (axialSectionIntegral E i (divergence F) t) |
|
|
| lemma axialSlicePerimeter_le {E : Set Torus} {i : Fin 3} {t q : ℝ} |
| (hb : ∀ (F : Cover → Cover),AdmissibleField F → (∀ x,F x i=0) → |
| axialSectionIntegral E i (divergence F) t≤q) : |
| axialSlicePerimeter E i t≤ENNReal.ofReal q := by |
| apply iSup_le |
| intro F |
| apply iSup_le |
| intro hF |
| apply iSup_le |
| intro ht |
| exact ENNReal.ofReal_le_ofReal (hb F hF ht) |
|
|
| lemma axialSlicePerimeter_ge {E : Set Torus} {i : Fin 3} {t : ℝ} |
| {F : Cover → Cover} (hF : AdmissibleField F) (ht : ∀ x,F x i=0) : |
| ENNReal.ofReal (axialSectionIntegral E i (divergence F) t)≤axialSlicePerimeter E i t := by |
| exact le_iSup_of_le F (le_iSup_of_le hF (le_iSup_of_le ht le_rfl)) |
|
|
| theorem isMinimizerAt_axial_endpoint_perimeter {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) (b : Bool) : |
| axialSlicePerimeter (openRepresentative E) i (if b then 1/2 else 0)= |
| ENNReal.ofReal ((μ.mass : ℝ)*axialFluxWeight μ i+ |
| H*(axialSectionArea (openRepresentative E) i (if b then 1/2 else 0)-V)) := by |
| apply le_antisymm |
| · apply axialSlicePerimeter_le |
| intro F hF ht |
| exact isMinimizerAt_axial_slice_endpoint_bound hV hE hm hμ hN hp ha hs hsg hH hF i ht b |
| · rw [← isMinimizerAt_axial_endpoint_calibration hV hE hm hμ hN hp ha hs hsg hH i b] |
| exact axialSlicePerimeter_ge (axialNormalCalibration_admissible hN hp i) (axialNormalCalibration_axis N i) |
|
|
| lemma axialSlicePerimeter_periodic (E : Set Torus) (i : Fin 3) : |
| Function.Periodic (axialSlicePerimeter E i) 1 := by |
| intro t |
| unfold axialSlicePerimeter |
| congr 1 |
| funext F |
| congr 1 |
| funext hF |
| congr 1 |
| funext ht |
| rw [axialSectionIntegral_periodic E i (divergence_periodic hF.2.1)] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def axialTangentialSpeed (i : Fin 3) (z : NormalBundle) : ℝ := |
| ‖axialTangentPart i (z.2 : Cover)‖ |
|
|
| lemma continuous_axialTangentialSpeed (i : Fin 3) : Continuous (axialTangentialSpeed i) := by |
| exact (continuous_normalUnit.sub |
| (((EuclideanSpace.proj i : Cover →L[ℝ] ℝ).continuous.comp continuous_normalUnit).smul continuous_const)).norm |
|
|
| lemma axialTangentialSpeed_sq (i : Fin 3) (z : NormalBundle) : |
| (axialTangentialSpeed i z)^2=axialNormalWeight i z := by |
| rw [axialTangentialSpeed,axialTangentPart_norm_sq,z.2.property,one_pow] |
| rfl |
|
|
| lemma normal_tangent_bound {F : Cover → Cover} (hF : AdmissibleField F) |
| (i : Fin 3) (ht : ∀ x,F x i=0) (z : NormalBundle) : |
| normalTest F hF.1.continuous z≤axialTangentialSpeed i z := by |
| have he : ⟪(z.2 : Cover),F z.1⟫=⟪axialTangentPart i (z.2 : Cover),F z.1⟫ := by |
| rw [axialTangentPart,inner_sub_left,real_inner_smul_left] |
| simp only [EuclideanSpace.inner_single_left,conj_trivial,ht,mul_zero,sub_zero] |
| change ⟪(z.2 : Cover),F z.1⟫≤_ |
| rw [he] |
| exact (real_inner_le_norm _ _).trans |
| ((mul_le_mul_of_nonneg_left (hF.2.2 z.1) (norm_nonneg _)).trans_eq (mul_one _)) |
|
|
| def axialCircleFlux (E : Set Torus) (i : Fin 3) (F : Cover → Cover) (hF : AdmissibleField F) : |
| AddCircle (1 : ℝ) → ℝ := |
| (axialSectionIntegral_periodic E i (divergence_periodic hF.2.1)).lift |
|
|
| lemma axialCircleFlux_coe (E : Set Torus) (i : Fin 3) (F : Cover → Cover) (hF : AdmissibleField F) (t : ℝ) : |
| axialCircleFlux E i F hF t=axialSectionIntegral E i (divergence F) t := |
| Function.Periodic.lift_coe _ _ |
|
|
| lemma continuous_axialCircleFlux {E : Set Torus} (hE : MeasurableSet E) (i : Fin 3) |
| (hz : ∀ t : ℝ,volume {y : Plane | quotientMap ((axialSplit i).symm (t,y))∈frontier E}=0) |
| {F : Cover → Cover} (hF : AdmissibleField F) : Continuous (axialCircleFlux E i F hF) := |
| continuous_periodic_lift _ (continuous_axialSectionIntegral_of_boundary_null hE i hz |
| (continuous_divergence hF.1) (divergence_periodic hF.2.1)) |
|
|
| lemma axialCircleFlux_moment {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {F : Cover → Cover} (hF : AdmissibleField F) (i : Fin 3) (ht : ∀ x,F x i=0) |
| {f : ℝ → ℝ} (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hp : Function.Periodic f 1) : |
| (∫ t,axialCircleFlux E i F hF t*hp.lift t)= |
| ∫ z,normalTest F hF.1.continuous z*hp.lift (axialBundleHeight i z) ∂(μ : Measure NormalBundle) := by |
| rw [← AddCircle.intervalIntegral_preimage (1 : ℝ) 0] |
| simp only [zero_add,axialCircleFlux_coe,Function.Periodic.lift_coe,axialBundleHeight] |
| rw [intervalIntegral.integral_of_le (by norm_num : (0 : ℝ)≤1),← integral_Ico_eq_integral_Ioc, |
| axial_slice_flux_moment hE hμ hF i ht hf hp] |
| exact integral_congr_ae (Eventually.of_forall fun z => mul_comm _ _) |
|
|
| lemma axialCircleFlux_le_density_ae {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (i : Fin 3) |
| (hz : ∀ t : ℝ,volume {y : Plane | quotientMap ((axialSplit i).symm (t,y))∈frontier E}=0) |
| (hac : Measure.map (axialBundleHeight i) (μ : Measure NormalBundle)≪volume) |
| {p : AddCircle (1 : ℝ) → ℝ} (hp : Integrable p) |
| (hpm : ∀ (f : ℝ → ℝ), ContDiff ℝ (⊤ : ℕ∞) f → ∀ (hper : Function.Periodic f 1), |
| (∫ t,p t*hper.lift t)=∫ z,axialTangentialSpeed i z*hper.lift (axialBundleHeight i z) ∂(μ : Measure NormalBundle)) |
| {F : Cover → Cover} (hF : AdmissibleField F) (ht : ∀ x,F x i=0) : |
| axialCircleFlux E i F hF ≤ᵐ[volume] p := by |
| apply circle_ae_le_of_ordered_weighted_moments (μ : Measure NormalBundle) |
| (continuous_axialBundleHeight i) hac (normalTest F hF.1.continuous).continuous |
| (continuous_axialTangentialSpeed i) (normal_tangent_bound hF i ht) |
| (circle_continuous_integrable (continuous_axialCircleFlux hE i hz hF)) hp |
| · intro f hf hper |
| exact axialCircleFlux_moment hE hμ hF i ht hf hper |
| · exact hpm |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def axialScaledCalibration (N : Cover → Cover) (i : Fin 3) (n : ℕ) : Cover → Cover := |
| regularizedNormal (fun x => ((n : ℝ)+1) • axialTangentPart i (N x)) |
|
|
| lemma axialScaledCalibration_admissible {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hp : ∀ m x,N (x+latticeVector m)=N x) (i : Fin 3) (n : ℕ) : |
| AdmissibleField (axialScaledCalibration N i n) := by |
| refine ⟨regularizedNormal_contDiff ((contDiff_const : ContDiff ℝ (⊤ : ℕ∞) (fun _ : Cover => (n : ℝ)+1)).smul (axialTangentPart_contDiff hN i)),?_,?_⟩ |
| · apply regularizedNormal_periodic |
| intro m x |
| rw [hp] |
| · exact regularizedNormal_norm_le _ |
|
|
| lemma axialScaledCalibration_axis (N : Cover → Cover) (i : Fin 3) (n : ℕ) (x : Cover) : |
| axialScaledCalibration N i n x i=0 := by |
| simp only [axialScaledCalibration,regularizedNormal,PiLp.smul_apply,smul_eq_mul,axialTangentPart_axis,mul_zero] |
|
|
| lemma axialScaledCalibration_error (N : Cover → Cover) (i : Fin 3) (n : ℕ) (x : Cover) : |
| ‖axialTangentPart i (N x)‖-⟪N x,axialScaledCalibration N i n x⟫≤1/((n : ℝ)+1) := by |
| let c : ℝ := (n : ℝ)+1 |
| let a : ℝ := ‖axialTangentPart i (N x)‖ |
| have hc : 0<c := by dsimp [c]; positivity |
| have ha : 0≤a := norm_nonneg _ |
| have hn : ‖c • axialTangentPart i (N x)‖=c*a := by |
| rw [norm_smul,Real.norm_eq_abs,abs_of_pos hc] |
| have hin : ⟪N x,axialTangentPart i (N x)⟫=a^2 := by |
| rw [inner_axialTangentPart,show a^2=‖N x‖^2-(N x i)^2 from axialTangentPart_norm_sq i (N x)] |
| have hnonneg : 0≤⟪N x,axialScaledCalibration N i n x⟫ := by |
| rw [axialScaledCalibration,regularizedNormal,real_inner_smul_right,real_inner_smul_right,hin] |
| have := regularizedNormal_denom_pos (((n : ℝ)+1) • axialTangentPart i (N x)) |
| positivity |
| change a-⟪N x,axialScaledCalibration N i n x⟫≤1/c |
| by_cases hh : 1/4≤‖c • axialTangentPart i (N x)‖^2 |
| · have ha0 : 0<a := by |
| rw [hn] at hh |
| by_contra h |
| have haz : a=0 := le_antisymm (le_of_not_gt h) ha |
| rw [haz,mul_zero] at hh |
| norm_num at hh |
| have he : ⟪N x,axialScaledCalibration N i n x⟫=a := by |
| change ⟪N x,regularizedNormal (fun y => c • axialTangentPart i (N y)) x⟫=a |
| rw [regularizedNormal_eq (R := fun y => c • axialTangentPart i (N y)) (x := x) hh,real_inner_smul_right,real_inner_smul_right,hin,hn] |
| field_simp [hc.ne',ha0.ne'] |
| rw [he,sub_self] |
| positivity |
| · have hca : c*a≤1 := by |
| rw [hn] at hh |
| have hca0 := mul_nonneg hc.le ha |
| nlinarith |
| have hal : a≤1/c := (le_div_iff₀ hc).mpr (by nlinarith) |
| linarith |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| theorem ae_iSup_le_of_lowerSemicontinuous {X : Type*} {ι : Sort*} |
| [TopologicalSpace X] [SecondCountableTopology X] [MeasurableSpace X] |
| {μ : Measure X} {f : ι → X → ℝ≥0∞} {g : X → ℝ≥0∞} |
| (hc : ∀ i,LowerSemicontinuous (f i)) (hb : ∀ i,f i ≤ᵐ[μ] g) : |
| (fun x => ⨆ i,f i x) ≤ᵐ[μ] g := by |
| have hlub : IsLUB (range f) (fun x => ⨆ i,f i x) := by |
| refine ⟨?_,?_⟩ |
| · rintro v ⟨i,rfl⟩ x |
| exact le_iSup (f := fun i => f i x) i |
| · intro b hbb x |
| exact iSup_le fun i => hbb ⟨i,rfl⟩ x |
| obtain ⟨S,hS,hSc,hSlub⟩ := exists_countable_lowerSemicontinuous_isLUB |
| (fun v hv => by obtain ⟨i,rfl⟩ := hv; exact hc i) hlub |
| have ha : ∀ᵐ x ∂μ,∀ v∈S,v x≤g x := (ae_ball_iff hSc).mpr (by |
| intro v hv |
| obtain ⟨i,rfl⟩ := hS hv |
| exact hb i) |
| filter_upwards [ha] with x hx |
| apply (isLUB_pi.mp hSlub x).2 |
| rintro a ⟨v,hv,rfl⟩ |
| exact hx v hv |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| def axialCirclePerimeter (E : Set Torus) (i : Fin 3) : AddCircle (1 : ℝ) → ℝ≥0∞ := |
| (axialSlicePerimeter_periodic E i).lift |
|
|
| lemma axialCirclePerimeter_coe (E : Set Torus) (i : Fin 3) (t : ℝ) : |
| axialCirclePerimeter E i t=axialSlicePerimeter E i t := |
| Function.Periodic.lift_coe _ _ |
|
|
| lemma axialCirclePerimeter_eq_iSup (E : Set Torus) (i : Fin 3) : |
| axialCirclePerimeter E i=fun t => ⨆ (F : Cover → Cover) (hF : AdmissibleField F) |
| (_ : ∀ x,F x i=0),ENNReal.ofReal (axialCircleFlux E i F hF t) := by |
| funext t |
| induction t using QuotientAddGroup.induction_on with | H u => |
| simp only [axialCirclePerimeter_coe,axialCircleFlux_coe,axialSlicePerimeter] |
|
|
| lemma lowerSemicontinuous_axialCirclePerimeter {E : Set Torus} (hE : MeasurableSet E) (i : Fin 3) |
| (hz : ∀ t : ℝ,volume {y : Plane | quotientMap ((axialSplit i).symm (t,y))∈frontier E}=0) : |
| LowerSemicontinuous (axialCirclePerimeter E i) := by |
| rw [axialCirclePerimeter_eq_iSup] |
| apply lowerSemicontinuous_iSup |
| intro F |
| apply lowerSemicontinuous_iSup |
| intro hF |
| apply lowerSemicontinuous_iSup |
| intro ht |
| exact (ENNReal.continuous_ofReal.comp (continuous_axialCircleFlux hE i hz hF)).lowerSemicontinuous |
|
|
| theorem axialCirclePerimeter_le_density_ae {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (i : Fin 3) |
| (hz : ∀ t : ℝ,volume {y : Plane | quotientMap ((axialSplit i).symm (t,y))∈frontier E}=0) |
| (hac : Measure.map (axialBundleHeight i) (μ : Measure NormalBundle)≪volume) |
| {p : AddCircle (1 : ℝ) → ℝ} (hp : Integrable p) |
| (hpm : ∀ (f : ℝ → ℝ), ContDiff ℝ (⊤ : ℕ∞) f → ∀ (hper : Function.Periodic f 1), |
| (∫ t,p t*hper.lift t)=∫ z,axialTangentialSpeed i z*hper.lift (axialBundleHeight i z) ∂(μ : Measure NormalBundle)) : |
| axialCirclePerimeter E i ≤ᵐ[volume] fun t => ENNReal.ofReal (p t) := by |
| rw [axialCirclePerimeter_eq_iSup] |
| apply ae_iSup_le_of_lowerSemicontinuous |
| · intro F |
| apply lowerSemicontinuous_iSup |
| intro hF |
| apply lowerSemicontinuous_iSup |
| intro ht |
| exact (ENNReal.continuous_ofReal.comp (continuous_axialCircleFlux hE i hz hF)).lowerSemicontinuous |
| intro F |
| apply ae_iSup_le_of_lowerSemicontinuous |
| · intro hF |
| apply lowerSemicontinuous_iSup |
| intro ht |
| exact (ENNReal.continuous_ofReal.comp (continuous_axialCircleFlux hE i hz hF)).lowerSemicontinuous |
| intro hF |
| apply ae_iSup_le_of_lowerSemicontinuous |
| · intro ht |
| exact (ENNReal.continuous_ofReal.comp (continuous_axialCircleFlux hE i hz hF)).lowerSemicontinuous |
| intro ht |
| exact (axialCircleFlux_le_density_ae hE hμ i hz hac hp hpm hF ht).mono |
| fun t ht => ENNReal.ofReal_le_ofReal ht |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| lemma axialScaledCalibration_integral_error {μ : FiniteMeasure NormalBundle} |
| {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)) (i : Fin 3) (n : ℕ) : |
| (∫ z,axialTangentialSpeed i z ∂(μ : Measure NormalBundle))≤ |
| (∫ z,normalTest (axialScaledCalibration N i n) |
| (axialScaledCalibration_admissible hN hp i n).1.continuous z ∂(μ : Measure NormalBundle))+ |
| (μ : Measure NormalBundle).real univ/((n : ℝ)+1) := by |
| let F := axialScaledCalibration N i n |
| have hF : AdmissibleField F := axialScaledCalibration_admissible hN hp i n |
| have hiS : Integrable (axialTangentialSpeed i) (μ : Measure NormalBundle) := |
| (continuous_axialTangentialSpeed i).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| have hiF : Integrable (normalTest F hF.1.continuous) (μ : Measure NormalBundle) := |
| (normalTest F hF.1.continuous).continuous.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| have hb : (∫ z,axialTangentialSpeed i z ∂(μ : Measure NormalBundle))≤ |
| ∫ z,normalTest F hF.1.continuous z+1/((n : ℝ)+1) ∂(μ : Measure NormalBundle) := by |
| apply integral_mono_ae hiS (hiF.add (integrable_const _)) |
| filter_upwards [ha] with z hz |
| have he := axialScaledCalibration_error N i n z.1 |
| rw [hz] at he |
| change ‖axialTangentPart i (z.2 : Cover)‖≤⟪(z.2 : Cover),F z.1⟫+1/((n : ℝ)+1) |
| dsimp only [F] |
| linarith |
| rw [integral_add hiF (integrable_const _),integral_const,smul_eq_mul] at hb |
| simpa only [mul_one_div] using hb |
|
|
| lemma axialCircleFlux_integral {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {F : Cover → Cover} (hF : AdmissibleField F) (i : Fin 3) (ht : ∀ x,F x i=0) : |
| (∫ t,axialCircleFlux E i F hF t)= |
| ∫ z,normalTest F hF.1.continuous z ∂(μ : Measure NormalBundle) := by |
| have hp : Function.Periodic (fun _ : ℝ => (1 : ℝ)) 1 := fun _ => rfl |
| have he := axialCircleFlux_moment hE hμ hF i ht contDiff_const hp |
| have hp1 (t : AddCircle (1 : ℝ)) : hp.lift t=1 := by |
| induction t using QuotientAddGroup.induction_on with | H u => rfl |
| simpa only [hp1,mul_one] using he |
|
|
| lemma axialCircleFlux_le_toReal_ae {E : Set Torus} {i : Fin 3} |
| (hfin : ∀ᵐ t,axialCirclePerimeter E i t≠∞) |
| {F : Cover → Cover} (hF : AdmissibleField F) (ht : ∀ x,F x i=0) : |
| axialCircleFlux E i F hF ≤ᵐ[volume] fun t => (axialCirclePerimeter E i t).toReal := by |
| filter_upwards [hfin] with t htt |
| apply (ENNReal.ofReal_le_iff_le_toReal htt).mp |
| have hsup := congrFun (axialCirclePerimeter_eq_iSup E i) t |
| rw [hsup] |
| exact le_iSup_of_le F (le_iSup_of_le hF (le_iSup_of_le ht le_rfl)) |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology RealInnerProductSpace |
| namespace CubicTorus |
|
|
| theorem axial_bv_coarea {E : Set Torus} (hE : MeasurableSet E) |
| {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) |
| {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N) |
| (hpN : ∀ m x,N (x+latticeVector m)=N x) |
| (ha : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) (i : Fin 3) |
| (hz : ∀ t : ℝ,volume {y : Plane | quotientMap ((axialSplit i).symm (t,y))∈frontier E}=0) |
| (hac : Measure.map (axialBundleHeight i) (μ : Measure NormalBundle)≪volume) : |
| Measurable (axialCirclePerimeter E i) ∧ |
| (∀ᵐ t,axialCirclePerimeter E i t≠∞) ∧ |
| Integrable (fun t => (axialCirclePerimeter E i t).toReal) ∧ |
| ∀ f : AddCircle (1 : ℝ) → ℝ,Measurable f → |
| (∫ t,(axialCirclePerimeter E i t).toReal*f t)= |
| ∫ z,axialTangentialSpeed i z*f (axialBundleHeight i z) ∂(μ : Measure NormalBundle) := by |
| obtain ⟨p,hp,hp0,hpm⟩ := circle_nonneg_weighted_density (μ : Measure NormalBundle) |
| (continuous_axialBundleHeight i) hac (continuous_axialTangentialSpeed i) |
| (fun z => norm_nonneg _) |
| have hb := axialCirclePerimeter_le_density_ae hE hμ i hz hac hp |
| (fun f hf hper => hpm hper.lift (continuous_periodic_lift hper hf.continuous).measurable) |
| have hfin : ∀ᵐ t,axialCirclePerimeter E i t≠∞ := |
| hb.mono fun t ht => ne_top_of_le_ne_top ENNReal.ofReal_ne_top ht |
| have hmeas : Measurable (axialCirclePerimeter E i) := |
| (lowerSemicontinuous_axialCirclePerimeter hE i hz).measurable |
| have hreal : (fun t => (axialCirclePerimeter E i t).toReal) ≤ᵐ[volume] p := by |
| filter_upwards [hb] with t ht |
| have he := ENNReal.toReal_mono ENNReal.ofReal_ne_top ht |
| simpa only [ENNReal.toReal_ofReal (hp0 t)] using he |
| have hPi : Integrable (fun t => (axialCirclePerimeter E i t).toReal) := by |
| apply hp.mono' hmeas.ennreal_toReal.aestronglyMeasurable |
| filter_upwards [hreal] with t ht |
| simpa only [Real.norm_eq_abs,abs_of_nonneg ENNReal.toReal_nonneg] using ht |
| have htot : (∫ t,p t)=∫ z,axialTangentialSpeed i z ∂(μ : Measure NormalBundle) := by |
| simpa only [mul_one] using hpm (fun _ => 1) measurable_const |
| have hlower : (∫ t,p t)≤∫ t,(axialCirclePerimeter E i t).toReal := by |
| have hb_n (n : ℕ) : (∫ t,p t)≤(∫ t,(axialCirclePerimeter E i t).toReal)+ |
| (μ : Measure NormalBundle).real univ/((n : ℝ)+1) := by |
| let F := axialScaledCalibration N i n |
| have hF : AdmissibleField F := axialScaledCalibration_admissible hN hpN i n |
| have ht : ∀ x,F x i=0 := axialScaledCalibration_axis N i n |
| have hl := integral_mono_ae |
| (circle_continuous_integrable (continuous_axialCircleFlux hE i hz hF)) hPi |
| (axialCircleFlux_le_toReal_ae hfin hF ht) |
| rw [axialCircleFlux_integral hE hμ hF i ht] at hl |
| rw [htot] |
| have he := axialScaledCalibration_integral_error hN hpN ha i n |
| change (∫ z,normalTest (axialScaledCalibration N i n) hF.1.continuous z ∂(μ : Measure NormalBundle))≤_ at hl |
| linarith |
| have hlim : Tendsto (fun n : ℕ => (∫ t,(axialCirclePerimeter E i t).toReal)+ |
| (μ : Measure NormalBundle).real univ/((n : ℝ)+1)) atTop |
| (𝓝 (∫ t,(axialCirclePerimeter E i t).toReal)) := by |
| have he := (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ)).const_mul |
| ((μ : Measure NormalBundle).real univ) |
| simpa only [mul_one_div,mul_zero,add_zero] using tendsto_const_nhds.add he |
| exact ge_of_tendsto hlim (Eventually.of_forall hb_n) |
| have heq : (fun t => (axialCirclePerimeter E i t).toReal) =ᵐ[volume] p := |
| (integral_eq_iff_of_ae_le hPi hp hreal).mp |
| (le_antisymm (integral_mono_ae hPi hp hreal) hlower) |
| refine ⟨hmeas,hfin,hPi,?_⟩ |
| intro f hf |
| calc |
| _=∫ t,p t*f t := integral_congr_ae (heq.mono fun t ht => congrArg (fun a => a*f t) ht) |
| _=_ := hpm f hf |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| def CircleSmoothDensity {α : Type*} [MeasurableSpace α] (μ : Measure α) |
| (h : α → AddCircle (1 : ℝ)) (w : α → ℝ) (g : AddCircle (1 : ℝ) → ℝ) : Prop := |
| Integrable g ∧ ∀ (f : ℝ → ℝ),ContDiff ℝ (⊤ : ℕ∞) f → ∀ hp : Function.Periodic f 1, |
| (∫ t,g t*hp.lift t)=∫ x,w x*hp.lift (h x) ∂μ |
|
|
| variable {α : Type*} [MeasurableSpace α] [TopologicalSpace α] [BorelSpace α] [CompactSpace α] |
| {μ : Measure α} [IsFiniteMeasure μ] {h : α → AddCircle (1 : ℝ)} |
|
|
| omit [TopologicalSpace α] [BorelSpace α] [CompactSpace α] [IsFiniteMeasure μ] in |
| lemma CircleSmoothDensity.const_mul {w : α → ℝ} {g : AddCircle (1 : ℝ) → ℝ} |
| (hd : CircleSmoothDensity μ h w g) (c : ℝ) : |
| CircleSmoothDensity μ h (fun x => c*w x) (fun t => c*g t) := by |
| refine ⟨hd.1.const_mul c,?_⟩ |
| intro f hf hp |
| simp_rw [mul_assoc] |
| rw [integral_const_mul,integral_const_mul,hd.2 f hf hp] |
|
|
| lemma CircleSmoothDensity.add {w u : α → ℝ} {g p : AddCircle (1 : ℝ) → ℝ} |
| (hd : CircleSmoothDensity μ h w g) (he : CircleSmoothDensity μ h u p) |
| (hh : Continuous h) (hw : Continuous w) (hu : Continuous u) : |
| CircleSmoothDensity μ h (fun x => w x+u x) (fun t => g t+p t) := by |
| refine ⟨hd.1.add he.1,?_⟩ |
| intro f hf hp |
| have hc := continuous_periodic_lift hp hf.continuous |
| obtain ⟨M,_,hM⟩ := (isCompact_univ.image hc).isBounded.exists_pos_norm_le |
| have hb : ∀ᵐ t : AddCircle (1 : ℝ),‖hp.lift t‖≤M := |
| Eventually.of_forall fun t => hM _ ⟨t,mem_univ _,rfl⟩ |
| have hwi : Integrable (fun x => w x*hp.lift (h x)) μ := |
| (hw.mul (hc.comp hh)).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| have hui : Integrable (fun x => u x*hp.lift (h x)) μ := |
| (hu.mul (hc.comp hh)).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| simp_rw [add_mul] |
| rw [integral_add (hd.1.mul_bdd hc.aestronglyMeasurable hb) |
| (he.1.mul_bdd hc.aestronglyMeasurable hb),integral_add hwi hui,hd.2 f hf hp,he.2 f hf hp] |
|
|
| lemma CircleSmoothDensity.ae_le {w u : α → ℝ} {g p : AddCircle (1 : ℝ) → ℝ} |
| (hd : CircleSmoothDensity μ h w g) (he : CircleSmoothDensity μ h u p) |
| (hh : Continuous h) (hac : Measure.map h μ≪volume) |
| (hw : Continuous w) (hu : Continuous u) (hle : ∀ x,w x≤u x) : g≤ᵐ[volume]p := |
| circle_ae_le_of_ordered_weighted_moments μ hh hac hw hu hle hd.1 he.1 hd.2 he.2 |
|
|
| lemma ae_forall_of_closed_parameters {δ β : Type*} [MeasurableSpace δ] |
| (ν : Measure δ) [TopologicalSpace β] [TopologicalSpace.SeparableSpace β] [Nonempty β] |
| {P : β → δ → Prop} (hc : ∀ x,IsClosed {b | P b x}) |
| (hp : ∀ b,∀ᵐ x ∂ν,P b x) : ∀ᵐ x ∂ν,∀ b,P b x := by |
| have hh : ∀ᵐ x ∂ν,∀ n : ℕ,P (TopologicalSpace.denseSeq β n) x := ae_all_iff.mpr (fun n => hp _) |
| exact hh.mono fun x hx => isClosed_property (TopologicalSpace.denseRange_denseSeq β) (hc x) hx |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Filter |
| open scoped Topology |
| namespace CubicTorus |
|
|
| def sliceHalfAngle (x : ℝ) : ℝ := x/(1+Real.sqrt (1-x^2)) |
| def sliceHalfAngleSlope (x : ℝ) : ℝ := |
| 1/(Real.sqrt (1-x^2)*(1+Real.sqrt (1-x^2))) |
|
|
| lemma sqrt_one_sub_sq_pos {x : ℝ} (hx : x∈Ioo (0 : ℝ) 1) : |
| 0<Real.sqrt (1-x^2) := by |
| apply Real.sqrt_pos.2 |
| nlinarith [hx.1,hx.2] |
|
|
| lemma hasDerivAt_sliceHalfAngle {x : ℝ} (hx : x∈Ioo (0 : ℝ) 1) : |
| HasDerivAt sliceHalfAngle (sliceHalfAngleSlope x) x := by |
| have hs := sqrt_one_sub_sq_pos hx |
| have hsq : (Real.sqrt (1-x^2))^2=1-x^2 := Real.sq_sqrt (by nlinarith [hx.1,hx.2]) |
| have hd := ((hasDerivAt_id x).div |
| ((hasDerivAt_const x (1 : ℝ)).add |
| (((hasDerivAt_const x (1 : ℝ)).sub ((hasDerivAt_id x).pow 2)).sqrt (by dsimp; nlinarith [hx.1,hx.2]))) |
| (by positivity : 1+Real.sqrt (1-x^2)≠0)) |
| convert! hd using 1 |
| dsimp [sliceHalfAngleSlope] |
| field_simp |
| nlinarith |
|
|
| lemma continuous_sliceHalfAngle : Continuous sliceHalfAngle := by |
| exact continuous_id.div (continuous_const.add |
| (Real.continuous_sqrt.comp (continuous_const.sub (continuous_id.pow 2)))) |
| (fun x => by positivity) |
|
|
| lemma convexOn_sliceHalfAngle : ConvexOn ℝ (Icc (0 : ℝ) 1) sliceHalfAngle := by |
| apply MonotoneOn.convexOn_of_deriv (convex_Icc _ _) continuous_sliceHalfAngle.continuousOn |
| (fun x hx => (hasDerivAt_sliceHalfAngle (by simpa using hx)).differentiableAt.differentiableWithinAt) |
| intro x hx y hy hxy |
| have hx' : x∈Ioo (0 : ℝ) 1 := by simpa using hx |
| have hy' : y∈Ioo (0 : ℝ) 1 := by simpa using hy |
| rw [(hasDerivAt_sliceHalfAngle hx').deriv,(hasDerivAt_sliceHalfAngle hy').deriv] |
| have hsx := sqrt_one_sub_sq_pos hx' |
| have hsy := sqrt_one_sub_sq_pos hy' |
| have hs : Real.sqrt (1-y^2)≤Real.sqrt (1-x^2) := Real.sqrt_le_sqrt (by nlinarith [hx'.1]) |
| dsimp [sliceHalfAngleSlope] |
| exact one_div_le_one_div_of_le (by positivity) (by nlinarith) |
|
|
| lemma sliceHalfAngle_support {m x : ℝ} (hm : m∈Ioo (0 : ℝ) 1) |
| (hx : x∈Icc (0 : ℝ) 1) : |
| sliceHalfAngle m+sliceHalfAngleSlope m*(x-m)≤ sliceHalfAngle x := by |
| rcases lt_trichotomy m x with h|h|h |
| · have he := convexOn_sliceHalfAngle.deriv_le_slope ⟨hm.1.le,hm.2.le⟩ hx h |
| (hasDerivAt_sliceHalfAngle hm).differentiableAt |
| rw [(hasDerivAt_sliceHalfAngle hm).deriv,slope_def_field] at he |
| have := (le_div_iff₀ (sub_pos.mpr h)).mp he |
| linarith |
| · subst x |
| simp |
| · have he := convexOn_sliceHalfAngle.slope_le_deriv hx ⟨hm.1.le,hm.2.le⟩ h |
| (hasDerivAt_sliceHalfAngle hm).differentiableAt |
| rw [(hasDerivAt_sliceHalfAngle hm).deriv,slope_def_field] at he |
| have := (div_le_iff₀ (sub_pos.mpr h)).mp he |
| nlinarith |
|
|
| lemma mul_sliceHalfAngle {x : ℝ} (hx : x∈Icc (0 : ℝ) 1) : |
| x*sliceHalfAngle x=1-Real.sqrt (1-x^2) := by |
| have hs : (Real.sqrt (1-x^2))^2=1-x^2 := Real.sq_sqrt (by nlinarith [hx.1,hx.2]) |
| dsimp [sliceHalfAngle] |
| field_simp |
| nlinarith |
|
|
| def sliceSupportC (m J : ℝ) : ℝ := |
| (1-J)*2/m+J*(sliceHalfAngle m-m*sliceHalfAngleSlope m) |
| def sliceSupportD (m J : ℝ) : ℝ := -(1-J)/m^2+J*sliceHalfAngleSlope m |
|
|
| theorem slice_jensen_support {m J x : ℝ} (hm : m∈Ioo (0 : ℝ) 1) |
| (hJ : J∈Icc (0 : ℝ) 1) (hx : x∈Icc (0 : ℝ) 1) : |
| sliceSupportC m J*x+sliceSupportD m J*x^2+J*Real.sqrt (1-x^2)≤1 := by |
| have ht := mul_le_mul_of_nonneg_left (sliceHalfAngle_support hm hx) (mul_nonneg hJ.1 hx.1) |
| have he := mul_sliceHalfAngle hx |
| have hb : (1-J)*(2*x/m-x^2/m^2)≤1-J := by |
| rw [← div_pow] |
| have hz := mul_nonneg (sub_nonneg.mpr hJ.2) (sq_nonneg (x/m-1)) |
| have heq : 2*x/m=2*(x/m) := by ring |
| rw [heq] |
| nlinarith |
| calc |
| _=J*x*(sliceHalfAngle m+sliceHalfAngleSlope m*(x-m))+ |
| (1-J)*(2*x/m-x^2/m^2)+J*Real.sqrt (1-x^2) := by |
| dsimp [sliceSupportC,sliceSupportD] |
| ring |
| _≤J*x*sliceHalfAngle x+(1-J)+J*Real.sqrt (1-x^2) := by linarith |
| _=1 := by rw [mul_assoc,he]; ring |
|
|
| lemma slice_support_contact {m J : ℝ} (hm : m∈Ioo (0 : ℝ) 1) : |
| sliceSupportC m J*m+sliceSupportD m J*m^2=1-J*Real.sqrt (1-m^2) := by |
| have he := mul_sliceHalfAngle ⟨hm.1.le,hm.2.le⟩ |
| have hm0 : m≠0 := ne_of_gt hm.1 |
| dsimp [sliceSupportC,sliceSupportD] |
| field_simp |
| nlinarith [congrArg (fun t : ℝ => J*t) he] |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| end OAI |
|
|
