| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open MeasureTheory Set |
| open scoped ENNReal |
|
|
| namespace CubicTorus |
|
|
| end CubicTorus |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Complex |
| open scoped ENNReal Real |
| namespace CubicTorus |
|
|
| theorem periodic_wirtinger {f g : ℝ → ℂ} |
| (hf : ∀ x ∈ Icc (0 : ℝ) 1, HasDerivAt f (g x) x) |
| (hg : IntervalIntegrable g volume 0 1) |
| (hf2 : MemLp f 2 (volume.restrict (Ioc (0 : ℝ) 1))) |
| (hg2 : MemLp g 2 (volume.restrict (Ioc (0 : ℝ) 1))) |
| (hp : f 1=f 0) (hm : ∫ x in (0 : ℝ)..1,f x=0) : |
| 4*Real.pi^2*(∫ x in (0 : ℝ)..1,‖f x‖^2) ≤ ∫ x in (0 : ℝ)..1,‖g x‖^2 := by |
| have h01 : (0 : ℝ)<1 := by norm_num |
| have hcf0 : fourierCoeffOn h01 f 0=0 := by |
| rw [fourierCoeffOn_eq_integral] |
| simpa using hm |
| have hcoef (n : ℤ) : |
| 4*Real.pi^2*‖fourierCoeffOn h01 f n‖^2 ≤ ‖fourierCoeffOn h01 g n‖^2 := by |
| by_cases hn : n=0 |
| · subst n |
| rw [hcf0] |
| simp |
| have he := fourierCoeffOn_of_hasDerivAt h01 hn (by simpa using hf) hg |
| have he' : fourierCoeffOn h01 g n= |
| (2*(Real.pi : ℂ)*Complex.I*(n : ℂ))*fourierCoeffOn h01 f n := by |
| simp only [hp,sub_self,mul_zero,sub_zero,zero_sub,Complex.ofReal_one,Complex.ofReal_zero,sub_zero,one_mul] at he |
| have hp0 : (Real.pi : ℂ)≠0 := by exact_mod_cast Real.pi_ne_zero |
| have hn0 : (n : ℂ)≠0 := by exact_mod_cast hn |
| field_simp at he |
| linear_combination -he |
| have hen := congrArg (fun z : ℂ => ‖z‖^2) he' |
| simp only [norm_mul,Complex.norm_ofNat,Complex.norm_real,Real.norm_eq_abs, |
| abs_of_pos Real.pi_pos,Complex.norm_I,mul_one,Complex.norm_intCast] at hen |
| have hn1 : (1 : ℝ)≤|(n : ℝ)| := by |
| exact_mod_cast (Int.one_le_abs hn) |
| have hsq : 1≤|(n : ℝ)|^2 := by nlinarith [sq_nonneg (|(n : ℝ)|-1)] |
| nlinarith [mul_nonneg (sq_nonneg (2*Real.pi*‖fourierCoeffOn h01 f n‖)) |
| (sub_nonneg.mpr hsq)] |
| have hfs := hasSum_sq_fourierCoeffOn h01 hf2 |
| have hgs := hasSum_sq_fourierCoeffOn h01 hg2 |
| have hle := hasSum_le hcoef (hfs.mul_left (4*Real.pi^2)) hgs |
| simpa using hle |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Complex |
| open scoped ENNReal Real |
| namespace CubicTorus |
|
|
| theorem mean_zero_curve_area_energy {f g : ℝ → ℂ} |
| (hf : ∀ x ∈ Icc (0 : ℝ) 1, HasDerivAt f (g x) x) |
| (hg : IntervalIntegrable g volume 0 1) |
| (hf2 : MemLp f 2 (volume.restrict (Ioc (0 : ℝ) 1))) |
| (hg2 : MemLp g 2 (volume.restrict (Ioc (0 : ℝ) 1))) |
| (hp : f 1=f 0) (hm : ∫ x in (0 : ℝ)..1,f x=0) : |
| 2*Real.pi*|∫ x in (0 : ℝ)..1,(star (f x)*g x).im| ≤ |
| ∫ x in (0 : ℝ)..1,‖g x‖^2 := by |
| have hw := periodic_wirtinger hf hg hf2 hg2 hp hm |
| have hfs := hf2.integrable_norm_pow (by norm_num : (2 : ℕ)≠0) |
| have hgs := hg2.integrable_norm_pow (by norm_num : (2 : ℕ)≠0) |
| have hmul : Integrable (fun x => (star (f x)*g x).im) |
| (volume.restrict (Ioc (0 : ℝ) 1)) := (hf2.star.integrable_mul hg2).im |
| have hyp (x : ℝ) : 4*Real.pi*|(star (f x)*g x).im| ≤ |
| 4*Real.pi^2*‖f x‖^2+‖g x‖^2 := by |
| have hi := Complex.abs_im_le_norm (star (f x)*g x) |
| simp only [norm_mul,norm_star] at hi |
| have hi' := mul_le_mul_of_nonneg_left hi (by positivity : 0≤4*Real.pi) |
| nlinarith [sq_nonneg (2*Real.pi*‖f x‖-‖g x‖)] |
| have hle := integral_mono (hmul.abs.const_mul (4*Real.pi)) |
| ((hfs.const_mul (4*Real.pi^2)).add hgs) hyp |
| have habs := norm_integral_le_integral_norm (μ := volume.restrict (Ioc (0 : ℝ) 1)) |
| (fun x => (star (f x)*g x).im) |
| simp only [Real.norm_eq_abs] at habs |
| simp only [Pi.add_apply] at hle |
| rw [integral_const_mul,integral_add (hfs.const_mul _) hgs,integral_const_mul] at hle |
| simp only [intervalIntegral.integral_of_le (by norm_num : (0 : ℝ)≤1)] at hw ⊢ |
| have hh := mul_le_mul_of_nonneg_left habs (by positivity : 0≤4*Real.pi) |
| linarith |
| |
| theorem closed_curve_area_energy {f g : ℝ → ℂ} |
| (hf : ∀ x ∈ Icc (0 : ℝ) 1, HasDerivAt f (g x) x) |
| (hg : IntervalIntegrable g volume 0 1) |
| (hf2 : MemLp f 2 (volume.restrict (Ioc (0 : ℝ) 1))) |
| (hg2 : MemLp g 2 (volume.restrict (Ioc (0 : ℝ) 1))) |
| (hp : f 1=f 0) : |
| 4*Real.pi*|(1/2 : ℝ)*(∫ x in (0 : ℝ)..1,(star (f x)*g x).im)| ≤ |
| ∫ x in (0 : ℝ)..1,‖g x‖^2 := by |
| let c : ℂ := ∫ x in (0 : ℝ)..1,f x |
| let F : ℝ → ℂ := fun x => f x-c |
| have hF : ∀ x ∈ Icc (0 : ℝ) 1,HasDerivAt F (g x) x := |
| fun x hx => (hf x hx).sub_const c |
| have hfi : IntervalIntegrable f volume 0 1 := by |
| apply ContinuousOn.intervalIntegrable |
| simpa only [uIcc_of_le (by norm_num : (0 : ℝ)≤1)] using |
| (show ContinuousOn f (Icc (0 : ℝ) 1) from fun x hx => (hf x hx).continuousAt.continuousWithinAt) |
| have hmean : ∫ x in (0 : ℝ)..1,F x=0 := by |
| rw [show F=(fun x => f x-c) from rfl,intervalIntegral.integral_sub hfi intervalIntegrable_const] |
| simp [c] |
| have hFp : F 1=F 0 := by simp only [F,hp] |
| have hF2 : MemLp F 2 (volume.restrict (Ioc (0 : ℝ) 1)) := hf2.sub (memLp_const c) |
| have hg0 : ∫ x in (0 : ℝ)..1,g x=0 := by |
| rw [intervalIntegral.integral_eq_sub_of_hasDerivAt (by simpa using hf) hg,hp,sub_self] |
| have htrans : (∫ x in (0 : ℝ)..1,(star (F x)*g x).im)= |
| ∫ x in (0 : ℝ)..1,(star (f x)*g x).im := by |
| have hmi := hf2.star.integrable_mul hg2 |
| have hgi : Integrable g (volume.restrict (Ioc (0 : ℝ) 1)) := hg.1 |
| simp only [intervalIntegral.integral_of_le (by norm_num : (0 : ℝ)≤1)] at hg0 ⊢ |
| have hA := integral_im (hF2.star.integrable_mul hg2) |
| have hB := integral_im hmi |
| change (∫ x in Ioc (0 : ℝ) 1,(star (F x)*g x).im)= |
| (∫ x in Ioc (0 : ℝ) 1,star (F x)*g x).im at hA |
| change (∫ x in Ioc (0 : ℝ) 1,(star (f x)*g x).im)= |
| (∫ x in Ioc (0 : ℝ) 1,star (f x)*g x).im at hB |
| rw [hA,hB] |
| congr 1 |
| simp only [F,star_sub,sub_mul] |
| change Integrable (fun x => star (f x)*g x) (volume.restrict (Ioc (0 : ℝ) 1)) at hmi |
| rw [integral_sub hmi (hgi.const_mul _),integral_const_mul,hg0,mul_zero,sub_zero] |
| have hh := mean_zero_curve_area_energy hF hg hF2 hg2 hFp hmean |
| rw [htrans] at hh |
| rw [abs_mul,abs_of_pos (by norm_num : (0 : ℝ)<1/2)] |
| nlinarith only [hh] |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped Topology Real |
| namespace CubicTorus |
| |
| theorem positive_periodic_primitive_inverse {h : ℝ → ℝ} (hc : Continuous h) |
| (hp : Function.Periodic h 1) (hpos : ∀ x,0<h x) : |
| ∃ e : ℝ ≃o ℝ, (∀ x,e x=∫ t in (0 : ℝ)..x,h t) ∧ |
| (∀ x,HasDerivAt e (h x) x) ∧ |
| (∀ x,HasDerivAt e.symm (h (e.symm x))⁻¹ x) := by |
| let A : ℝ → ℝ := fun x => ∫ t in (0 : ℝ)..x,h t |
| have hA (x : ℝ) : HasDerivAt A (h x) x := (hc.integral_hasStrictDerivAt 0 x).hasDerivAt |
| have hAc : Continuous A := continuous_iff_continuousAt.mpr fun x => (hA x).continuousAt |
| have hmon : StrictMono A := strictMono_of_deriv_pos fun x => by rw [(hA x).deriv]; exact hpos x |
| have hsurj : Function.Surjective A := hAc.surjective |
| (hp.tendsto_atTop_intervalIntegral_of_pos' (hc.intervalIntegrable 0 1) hpos (by norm_num)) |
| (hp.tendsto_atBot_intervalIntegral_of_pos' (hc.intervalIntegrable 0 1) hpos (by norm_num)) |
| let e : ℝ ≃o ℝ := hmon.orderIsoOfSurjective A hsurj |
| refine ⟨e,fun _ => rfl,hA,?_⟩ |
| intro x |
| exact HasDerivAt.of_local_left_inverse e.symm.continuous.continuousAt (hA (e.symm x)) |
| (hpos _).ne' (Eventually.of_forall fun y => e.apply_symm_apply y) |
|
|
| theorem positive_periodic_arclength_parameter {h : ℝ → ℝ} (hc : Continuous h) |
| (hp : Function.Periodic h 1) (hpos : ∀ x,0<h x) : |
| ∃ q d : ℝ → ℝ, Continuous q ∧ Continuous d ∧ StrictMono q ∧ |
| (∀ x,HasDerivAt q (d x) x) ∧ q 0=0 ∧ q 1=1 ∧ |
| (∀ x,0<d x) ∧ (∀ x,d x*h (q x)=∫ t in (0 : ℝ)..1,h t) := by |
| obtain ⟨e,he,heD,heI⟩ := positive_periodic_primitive_inverse hc hp hpos |
| let L : ℝ := ∫ t in (0 : ℝ)..1,h t |
| have hL : 0<L := intervalIntegral.intervalIntegral_pos_of_pos (hc.intervalIntegrable 0 1) hpos (by norm_num) |
| let q : ℝ → ℝ := fun x => e.symm (L*x) |
| let d : ℝ → ℝ := fun x => L/h (q x) |
| have hqc : Continuous q := e.symm.continuous.comp (continuous_const.mul continuous_id) |
| have hdc : Continuous d := continuous_const.div (hc.comp hqc) (fun x => (hpos _).ne') |
| have hqD (x : ℝ) : HasDerivAt q (d x) x := by |
| simpa only [Function.comp_def,mul_one,one_mul,d,q,div_eq_mul_inv,mul_comm] using |
| (heI (L*x)).comp x ((hasDerivAt_id x).const_mul L) |
| have hq0 : q 0=0 := by |
| apply e.injective |
| change e (e.symm (L*0))=e 0 |
| rw [e.apply_symm_apply,he] |
| simp |
| have hq1 : q 1=1 := by |
| apply e.injective |
| change e (e.symm (L*1))=e 1 |
| rw [e.apply_symm_apply,he] |
| simp [L] |
| refine ⟨q,d,hqc,hdc,?_,hqD,hq0,hq1,fun x => div_pos hL (hpos _),?_⟩ |
| · intro x y hxy |
| exact e.symm.strictMono (mul_lt_mul_of_pos_left hxy hL) |
| · intro x |
| dsimp [d] |
| exact div_mul_cancel₀ L (hpos _).ne' |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Complex |
| open scoped ENNReal Real |
| namespace CubicTorus |
|
|
| lemma continuous_memLp_two_Ioc {f : ℝ → ℂ} (hf : Continuous f) : |
| MemLp f 2 (volume.restrict (Ioc (0 : ℝ) 1)) := by |
| apply (memLp_two_iff_integrable_sq_norm hf.aestronglyMeasurable).2 |
| exact ((hf.norm.pow 2).continuousOn.integrableOn_compact isCompact_Icc).mono_set Ioc_subset_Icc_self |
|
|
| theorem planar_curve_isoperimetric {f g : ℝ → ℂ} |
| (hf : ∀ x,HasDerivAt f (g x) x) (hgc : Continuous g) |
| (hp : Function.Periodic f 1) (hreg : ∀ x,g x≠0) : |
| 4*Real.pi*|(1/2 : ℝ)*(∫ x in (0 : ℝ)..1,(star (f x)*g x).im)| ≤ |
| (∫ x in (0 : ℝ)..1,‖g x‖)^2 := by |
| have hfc : Continuous f := continuous_iff_continuousAt.mpr fun x => (hf x).continuousAt |
| have hgp : Function.Periodic g 1 := by |
| intro x |
| have hd : HasDerivAt f (g (x+1)) x := by |
| have hh := (hf (x+1)).scomp x ((hasDerivAt_id x).add_const 1) |
| have hpeq : (fun x => f (x+1))=f := funext hp |
| simpa only [Function.comp_def,id_eq,hpeq,one_smul] using hh |
| exact hd.unique (hf x) |
| have hspeedp : Function.Periodic (fun x => ‖g x‖) 1 := fun x => congrArg norm (hgp x) |
| obtain ⟨q,d,hqc,hdc,hmon,hqD,hq0,hq1,hdpos,hsp⟩ := |
| positive_periodic_arclength_parameter hgc.norm hspeedp (fun x => norm_pos_iff.mpr (hreg x)) |
| let F : ℝ → ℂ := f ∘ q |
| let G : ℝ → ℂ := fun t => d t • g (q t) |
| have hF : ∀ x,HasDerivAt F (G x) x := fun x => (hf (q x)).scomp x (hqD x) |
| have hFc : Continuous F := hfc.comp hqc |
| have hGc : Continuous G := hdc.smul (hgc.comp hqc) |
| have hFp : F 1=F 0 := by simpa only [F,Function.comp_def,hq0,hq1,zero_add] using hp 0 |
| have hW := closed_curve_area_energy (fun x _ => hF x) (hGc.intervalIntegrable 0 1) |
| (continuous_memLp_two_Ioc hFc) (continuous_memLp_two_Ioc hGc) hFp |
| have hnG (x : ℝ) : ‖G x‖=(∫ t in (0 : ℝ)..1,‖g t‖) := by |
| dsimp only [G] |
| rw [norm_smul,Real.norm_eq_abs,abs_of_pos (hdpos x)] |
| exact hsp x |
| have henergy : (∫ x in (0 : ℝ)..1,‖G x‖^2)=(∫ t in (0 : ℝ)..1,‖g t‖)^2 := by |
| simp only [hnG,intervalIntegral.integral_const,sub_zero,one_smul] |
| have harea : (∫ x in (0 : ℝ)..1,(star (F x)*G x).im)= |
| ∫ x in (0 : ℝ)..1,(star (f x)*g x).im := by |
| have hareaC : Continuous (fun x => (star (f x)*g x).im) := |
| Complex.continuous_im.comp (hfc.star.mul hgc) |
| have hsub := intervalIntegral.integral_deriv_smul_comp |
| (fun x (_ : x∈uIcc (0 : ℝ) 1) => hqD x) hdc.continuousOn hareaC |
| rw [hq0,hq1] at hsub |
| convert hsub using 1 |
| apply intervalIntegral.integral_congr |
| intro x hx |
| simp only [F,G,Function.comp_def,Complex.real_smul,smul_eq_mul] |
| simp |
| ring |
| rwa [henergy,harea] at hW |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Complex |
| open scoped ENNReal Real |
| namespace CubicTorus |
|
|
| def unitAngle (t : ℝ) : ℂ := Complex.exp ((2*Real.pi*t : ℝ)*Complex.I) |
|
|
| lemma unitAngle_norm (t : ℝ) : ‖unitAngle t‖=1 := by simp [unitAngle,Complex.norm_exp] |
|
|
| lemma unitAngle_periodic : Function.Periodic unitAngle 1 := by |
| intro x |
| change Complex.exp ((2*Real.pi*(x+1) : ℝ)*Complex.I)=_ |
| rw [show ((2*Real.pi*(x+1) : ℝ) : ℂ)*Complex.I= |
| ((2*Real.pi*x : ℝ) : ℂ)*Complex.I+2*(Real.pi : ℂ)*Complex.I by push_cast; ring] |
| exact Complex.exp_periodic _ |
|
|
| lemma unitAngle_deriv (t : ℝ) : |
| HasDerivAt unitAngle (((2*Real.pi : ℝ)*Complex.I)*unitAngle t) t := by |
| have hd := ((((hasDerivAt_id t).const_mul (2*Real.pi)).ofReal_comp).mul_const Complex.I).cexp |
| convert! hd using 1 |
| simp [unitAngle,id_eq,mul_comm] |
|
|
| lemma unitAngle_continuous : Continuous unitAngle := |
| continuous_iff_continuousAt.mpr fun t => (unitAngle_deriv t).continuousAt |
|
|
| def radialCurve (r : ℝ → ℝ) (t : ℝ) : ℂ := (r t : ℂ)*unitAngle t |
|
|
| def radialVelocity (r dr : ℝ → ℝ) (t : ℝ) : ℂ := |
| ((dr t : ℂ)+(2*Real.pi*r t : ℝ)*Complex.I)*unitAngle t |
|
|
| lemma radialCurve_deriv {r dr : ℝ → ℝ} (hr : ∀ t,HasDerivAt r (dr t) t) (t : ℝ) : |
| HasDerivAt (radialCurve r) (radialVelocity r dr t) t := by |
| convert! ((hr t).ofReal_comp).mul (unitAngle_deriv t) using 1 |
| simp only [radialVelocity,Complex.ofReal_mul] |
| ring |
|
|
| lemma radialVelocity_norm_sq (r dr : ℝ → ℝ) (t : ℝ) : |
| ‖radialVelocity r dr t‖^2=(dr t)^2+(2*Real.pi*r t)^2 := by |
| rw [radialVelocity,norm_mul,unitAngle_norm,mul_one,Complex.sq_norm] |
| simp [Complex.normSq_apply,pow_two] |
|
|
| lemma radialCurve_area_integrand (r dr : ℝ → ℝ) (t : ℝ) : |
| (star (radialCurve r t)*radialVelocity r dr t).im=2*Real.pi*(r t)^2 := by |
| have hu : star (unitAngle t)*unitAngle t=1 := by |
| rw [Complex.star_def,Complex.conj_mul',unitAngle_norm] |
| norm_num |
| have he : star (radialCurve r t)*radialVelocity r dr t= |
| (r t : ℂ)*((dr t : ℂ)+(2*Real.pi*r t : ℝ)*Complex.I) := by |
| simp only [radialCurve,radialVelocity,star_mul,Complex.star_def,Complex.conj_ofReal] |
| calc |
| _ = (r t : ℂ)*((dr t : ℂ)+(2*Real.pi*r t : ℝ)*Complex.I)* |
| (star (unitAngle t)*unitAngle t) := by simp only [Complex.star_def]; ring |
| _ = _ := by rw [hu,mul_one] |
| rw [he] |
| simp only [Complex.mul_im,Complex.ofReal_re,Complex.add_im,Complex.ofReal_im, |
| Complex.I_re,Complex.I_im,mul_zero,zero_mul,zero_add,mul_one,add_zero] |
| ring |
| |
| theorem radial_curve_isoperimetric {r dr : ℝ → ℝ} |
| (hr : ∀ t,HasDerivAt r (dr t) t) (hdc : Continuous dr) |
| (hp : Function.Periodic r 1) (hpos : ∀ t,0<r t) : |
| 4*Real.pi^2*(∫ t in (0 : ℝ)..1,(r t)^2) ≤ |
| (∫ t in (0 : ℝ)..1,Real.sqrt ((dr t)^2+(2*Real.pi*r t)^2))^2 := by |
| have hrc : Continuous r := continuous_iff_continuousAt.mpr fun t => (hr t).continuousAt |
| have hvc : Continuous (radialVelocity r dr) := by |
| exact ((Complex.continuous_ofReal.comp hdc).add |
| ((Complex.continuous_ofReal.comp (continuous_const.mul hrc)).mul continuous_const)).mul unitAngle_continuous |
| have hreg (t : ℝ) : radialVelocity r dr t≠0 := by |
| intro hz |
| have hn := radialVelocity_norm_sq r dr t |
| rw [hz,norm_zero,zero_pow (by norm_num : (2 : ℕ)≠0)] at hn |
| have hrt := hpos t |
| have hh : 0<(2*Real.pi*r t)^2 := sq_pos_of_pos (by positivity) |
| nlinarith [sq_nonneg (dr t)] |
| have hperiod : Function.Periodic (radialCurve r) 1 := by |
| intro x; simp only [radialCurve,hp x,unitAngle_periodic x] |
| have hh := planar_curve_isoperimetric (radialCurve_deriv hr) hvc hperiod hreg |
| have hspeed (t : ℝ) : ‖radialVelocity r dr t‖= |
| Real.sqrt ((dr t)^2+(2*Real.pi*r t)^2) := by |
| rw [← radialVelocity_norm_sq,Real.sqrt_sq (norm_nonneg _)] |
| simp only [radialCurve_area_integrand,hspeed] at hh |
| rw [intervalIntegral.integral_const_mul] at hh |
| have hi : 0≤∫ t in (0 : ℝ)..1,(r t)^2 := |
| intervalIntegral.integral_nonneg (by norm_num) (fun t _ => sq_nonneg (r t)) |
| rw [abs_of_nonneg (by positivity)] at hh |
| nlinarith |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open Set Complex |
| open scoped Topology Real |
| namespace CubicTorus |
| |
| def complexSquareGauge (z : ℂ) : ℝ := max |z.re| |z.im| |
| def complexFold (z : ℂ) : ℂ := ⟨|z.re|,|z.im|⟩ |
| def unitSquareScale (t : ℝ) : ℝ := 1/(2*complexSquareGauge (unitAngle t)) |
| def unitSquareEnd (t : ℝ) : ℂ := unitSquareScale t • complexFold (unitAngle t) |
| |
| lemma complexSquareGauge_pos {z : ℂ} (hz : z≠0) : 0<complexSquareGauge z := by |
| by_contra hh |
| have hl : max |z.re| |z.im|≤0 := le_of_not_gt hh |
| have h1 : z.re=0 := abs_eq_zero.mp (le_antisymm ((le_max_left _ _).trans hl) (abs_nonneg _)) |
| have h2 : z.im=0 := abs_eq_zero.mp (le_antisymm ((le_max_right _ _).trans hl) (abs_nonneg _)) |
| exact hz (Complex.ext h1 h2) |
| |
| lemma unitAngle_ne_zero (t : ℝ) : unitAngle t≠0 := by |
| intro hz |
| have hh := unitAngle_norm t |
| simp [hz] at hh |
| |
| lemma unitSquareScale_pos (t : ℝ) : 0<unitSquareScale t := |
| one_div_pos.mpr (mul_pos (by norm_num) (complexSquareGauge_pos (unitAngle_ne_zero t))) |
| |
| lemma complexSquareGauge_continuous : Continuous complexSquareGauge := |
| Complex.continuous_re.abs.max Complex.continuous_im.abs |
| |
| lemma complexFold_continuous : Continuous complexFold := by |
| exact Complex.equivRealProdCLM.symm.continuous.comp (Complex.continuous_re.abs.prodMk Complex.continuous_im.abs) |
| |
| lemma unitSquareScale_continuous : Continuous unitSquareScale := |
| continuous_const.div (continuous_const.mul (complexSquareGauge_continuous.comp unitAngle_continuous)) |
| (fun t => (mul_pos (by norm_num) (complexSquareGauge_pos (unitAngle_ne_zero t))).ne') |
|
|
| lemma unitSquareEnd_continuous : Continuous unitSquareEnd := |
| unitSquareScale_continuous.smul (complexFold_continuous.comp unitAngle_continuous) |
|
|
| lemma unitSquareScale_periodic : Function.Periodic unitSquareScale 1 := by |
| intro t |
| simp only [unitSquareScale,unitAngle_periodic t] |
|
|
| lemma unitSquareEnd_periodic : Function.Periodic unitSquareEnd 1 := by |
| intro t |
| simp only [unitSquareEnd,unitSquareScale_periodic t,unitAngle_periodic t] |
|
|
| lemma complexFold_smul {r : ℝ} (hr : 0≤r) (z : ℂ) : complexFold (r • z)=r • complexFold z := by |
| apply Complex.ext <;> simp [complexFold,abs_mul,abs_of_nonneg hr] |
|
|
| lemma complexSquareGauge_smul {r : ℝ} (hr : 0≤r) (z : ℂ) : |
| complexSquareGauge (r • z)=r*complexSquareGauge z := by |
| simp only [complexSquareGauge,Complex.smul_re,Complex.smul_im,smul_eq_mul,abs_mul,abs_of_nonneg hr] |
| exact (mul_max_of_nonneg _ _ hr).symm |
|
|
| lemma unitSquareEnd_gauge (t : ℝ) : complexSquareGauge (unitSquareEnd t)=1/2 := by |
| rw [unitSquareEnd,complexSquareGauge_smul (unitSquareScale_pos t).le] |
| have he : complexSquareGauge (complexFold (unitAngle t))=complexSquareGauge (unitAngle t) := by |
| simp [complexFold,complexSquareGauge] |
| rw [he,unitSquareScale] |
| field_simp [(complexSquareGauge_pos (unitAngle_ne_zero t)).ne'] |
| |
| lemma unitSquareEnd_coordinates (t : ℝ) : |
| 0≤(unitSquareEnd t).re ∧ 0≤(unitSquareEnd t).im ∧ |
| (unitSquareEnd t).re≤1/2 ∧ (unitSquareEnd t).im≤1/2 ∧ |
| ((unitSquareEnd t).re=1/2 ∨ (unitSquareEnd t).im=1/2) := by |
| have h0 : 0≤(unitSquareEnd t).re := by |
| simp only [unitSquareEnd,Complex.smul_re,smul_eq_mul,complexFold] |
| exact mul_nonneg (unitSquareScale_pos t).le (abs_nonneg _) |
| have h1 : 0≤(unitSquareEnd t).im := by |
| simp only [unitSquareEnd,Complex.smul_im,smul_eq_mul,complexFold] |
| exact mul_nonneg (unitSquareScale_pos t).le (abs_nonneg _) |
| have hg := unitSquareEnd_gauge t |
| rw [complexSquareGauge,abs_of_nonneg h0,abs_of_nonneg h1] at hg |
| refine ⟨h0,h1,?_,?_,?_⟩ |
| · exact (le_max_left _ _).trans_eq hg |
| · exact (le_max_right _ _).trans_eq hg |
| · rcases le_total (unitSquareEnd t).re (unitSquareEnd t).im with h|h |
| · exact Or.inr (by rwa [max_eq_right h] at hg) |
| · exact Or.inl (by rwa [max_eq_left h] at hg) |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set |
| open scoped ENNReal |
| |
| namespace CubicTorus |
| |
| end CubicTorus |
| end |
| |
| section |
| |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Interval |
| namespace CubicTorus |
| |
| lemma integral_square_le_mass {X : Type*} [MeasurableSpace X] |
| {μ : Measure X} [IsFiniteMeasure μ] {f : X → ℝ} |
| (hf : Integrable f μ) (hfsq : Integrable (fun x ↦ f x ^ 2) μ) : |
| (∫ x, f x ∂μ) ^ 2 ≤ μ.real univ * ∫ x, f x ^ 2 ∂μ := by |
| let m := μ.real univ |
| let q := ∫ x, f x ∂μ |
| have hm : 0 ≤ m := measureReal_nonneg |
| by_cases hm0 : m = 0 |
| · have hμ0 : μ = 0 := by |
| apply Measure.measure_univ_eq_zero.mp |
| exact (ENNReal.toReal_eq_zero_iff _).mp hm0 |>.resolve_right (measure_ne_top μ univ) |
| simp [hμ0] |
| have hmpos : 0 < m := lt_of_le_of_ne hm (Ne.symm hm0) |
| have hi : Integrable (fun x ↦ f x ^ 2 - (2 * (q / m)) * f x) μ := |
| hfsq.sub (hf.const_mul _) |
| have hp : 0 ≤ ∫ x, f x ^ 2 - (2 * (q / m)) * f x + (q / m) ^ 2 ∂μ := by |
| apply integral_nonneg |
| intro x |
| change 0 ≤ f x ^ 2 - 2 * (q / m) * f x + (q / m) ^ 2 |
| nlinarith [sq_nonneg (f x - q / m)] |
| rw [integral_add hi (integrable_const ((q / m) ^ 2)), |
| integral_sub hfsq (hf.const_mul (2 * (q / m))), integral_const_mul, integral_const, |
| smul_eq_mul] at hp |
| change 0 ≤ (∫ x, f x ^ 2 ∂μ) - 2 * (q / m) * q + m * (q / m) ^ 2 at hp |
| have heq : (∫ x, f x ^ 2 ∂μ) - 2 * (q / m) * q + m * (q / m) ^ 2 = |
| (∫ x, f x ^ 2 ∂μ) - q ^ 2 / m := by field_simp; ring |
| rw [heq] at hp |
| exact (div_le_iff₀ hmpos).mp (by linarith : q ^ 2 / m ≤ ∫ x, f x ^ 2 ∂μ) |>.trans_eq (mul_comm _ _) |
| |
| lemma lipschitz_deriv_sq_integrableOn {f : ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) (a b : ℝ) : |
| IntegrableOn (fun x ↦ deriv f x ^ 2) (Icc a b) := by |
| apply (integrable_const ((K : ℝ) ^ 2)).mono' |
| · exact (aestronglyMeasurable_deriv f (volume.restrict (Icc a b))).pow 2 |
| · exact ae_of_all _ fun x ↦ by |
| rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)] |
| have h := norm_deriv_le_of_lipschitz hf (x₀ := x) |
| rw [Real.norm_eq_abs] at h |
| nlinarith [sq_abs (deriv f x), abs_nonneg (deriv f x), NNReal.coe_nonneg K] |
|
|
| lemma lipschitz_sq_sub_le_interval_energy {f : ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) {a b : ℝ} (hab : a ≤ b) : |
| (f b - f a) ^ 2 ≤ (b - a) * ∫ x in Icc a b, deriv f x ^ 2 := by |
| have hAC := hf.lipschitzOnWith.absolutelyContinuousOnInterval (a := a) (b := b) |
| have hid : IntegrableOn (deriv f) (Icc a b) := by |
| rw [integrableOn_Icc_iff_integrableOn_Ioc] |
| exact hAC.intervalIntegrable_deriv.1 |
| have hcs := integral_square_le_mass hid (lipschitz_deriv_sq_integrableOn hf a b) |
| have hFTC : (∫ x in Icc a b, deriv f x) = f b - f a := by |
| rw [integral_Icc_eq_integral_Ioc] |
| rw [← intervalIntegral.integral_of_le hab] |
| exact hAC.integral_deriv_eq_sub |
| simpa only [hFTC, Measure.restrict_apply_univ, measureReal_def, |
| Real.volume_Icc, ENNReal.toReal_ofReal (sub_nonneg.mpr hab)] using hcs |
|
|
| lemma integrable_square_sub_const {X : Type*} [MeasurableSpace X] |
| {μ : Measure X} [IsFiniteMeasure μ] {f : X → ℝ} |
| (hf : Integrable f μ) (hfsq : Integrable (fun x ↦ f x ^ 2) μ) (c : ℝ) : |
| Integrable (fun x ↦ (c - f x) ^ 2) μ := by |
| have h : (fun x ↦ (c - f x) ^ 2) = |
| (fun x ↦ c ^ 2 - (2 * c) * f x + f x ^ 2) := by funext x; ring |
| rw [h] |
| exact ((integrable_const _).sub (hf.const_mul _)).add hfsq |
|
|
| lemma square_sub_average_le {X : Type*} [MeasurableSpace X] |
| {μ : Measure X} [IsFiniteMeasure μ] {f : X → ℝ} |
| (hm : 0 < μ.real univ) (hf : Integrable f μ) |
| (hfsq : Integrable (fun x ↦ f x ^ 2) μ) (c : ℝ) : |
| (c - (∫ x, f x ∂μ) / μ.real univ) ^ 2 ≤ |
| (∫ x, (c - f x) ^ 2 ∂μ) / μ.real univ := by |
| have hcs := integral_square_le_mass hf hfsq |
| have hi : Integrable (fun x ↦ c ^ 2 - (2 * c) * f x) μ := |
| (integrable_const _).sub (hf.const_mul _) |
| have he : (∫ x, (c - f x) ^ 2 ∂μ) = |
| μ.real univ * c ^ 2 - (2 * c) * (∫ x, f x ∂μ) + ∫ x, f x ^ 2 ∂μ := by |
| calc |
| _ = ∫ x, c ^ 2 - (2 * c) * f x + f x ^ 2 ∂μ := integral_congr_ae (ae_of_all _ fun x ↦ by ring) |
| _ = _ := by |
| rw [integral_add hi hfsq, integral_sub (integrable_const (c ^ 2)) (hf.const_mul (2 * c)), |
| integral_const, integral_const_mul, smul_eq_mul] |
| rw [he] |
| have halg : (μ.real univ * c ^ 2 - (2 * c) * (∫ x, f x ∂μ) + ∫ x, f x ^ 2 ∂μ) / |
| μ.real univ - (c - (∫ x, f x ∂μ) / μ.real univ) ^ 2 = |
| (μ.real univ * (∫ x, f x ^ 2 ∂μ) - (∫ x, f x ∂μ) ^ 2) / (μ.real univ) ^ 2 := by |
| field_simp |
| ring |
| have hnonneg : 0 ≤ (μ.real univ * (∫ x, f x ^ 2 ∂μ) - (∫ x, f x ∂μ) ^ 2) / |
| (μ.real univ) ^ 2 := div_nonneg (sub_nonneg.mpr hcs) (sq_nonneg _) |
| linarith |
|
|
| lemma lipschitz_sq_sub_le_common_interval_energy {f : ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) {a b u v : ℝ} (hu : u ∈ Icc a b) (hv : v ∈ Icc a b) : |
| (f u - f v) ^ 2 ≤ (b - a) * ∫ x in Icc a b, deriv f x ^ 2 := by |
| have hab : a ≤ b := hu.1.trans hu.2 |
| have he (u v : ℝ) (hu : u ∈ Icc a b) (hv : v ∈ Icc a b) (huv : u ≤ v) : |
| (f v - f u) ^ 2 ≤ (b - a) * ∫ x in Icc a b, deriv f x ^ 2 := by |
| apply (lipschitz_sq_sub_le_interval_energy hf huv).trans |
| apply mul_le_mul (by linarith [hu.1, hv.2] : v - u ≤ b - a) |
| (setIntegral_mono_set (lipschitz_deriv_sq_integrableOn hf a b) |
| (ae_of_all _ fun x ↦ sq_nonneg (deriv f x)) (ae_of_all _ fun _ hx ↦ Icc_subset_Icc hu.1 hv.2 hx)) |
| (integral_nonneg fun x ↦ sq_nonneg _) (sub_nonneg.mpr hab) |
| rcases le_total u v with huv | hvu |
| · simpa only [show (f v - f u) ^ 2 = (f u - f v) ^ 2 by ring] using he u v hu hv huv |
| · exact he v u hv hu hvu |
|
|
| lemma lipschitz_interval_poincare {f : ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) {a b : ℝ} (hab : a < b) : |
| (∫ x in Icc a b, (f x - (∫ y in Icc a b, f y) / (b - a)) ^ 2) ≤ |
| (b - a) ^ 2 * ∫ x in Icc a b, deriv f x ^ 2 := by |
| have hmass : (volume.restrict (Icc a b)).real univ = b - a := by |
| simp [measureReal_def, Real.volume_Icc, hab.le] |
| have hi : IntegrableOn f (Icc a b) := hf.continuous.continuousOn.integrableOn_Icc |
| have hi₂ : IntegrableOn (fun x ↦ f x ^ 2) (Icc a b) := |
| (hf.continuous.pow 2).continuousOn.integrableOn_Icc |
| have hpoint (x : ℝ) (hx : x ∈ Icc a b) : |
| (f x - (∫ y in Icc a b, f y) / (b - a)) ^ 2 ≤ |
| (b - a) * ∫ y in Icc a b, deriv f y ^ 2 := by |
| have hj := square_sub_average_le (by rw [hmass]; linarith) hi hi₂ (f x) |
| rw [hmass] at hj |
| apply hj.trans |
| apply (div_le_iff₀ (sub_pos.mpr hab)).mpr |
| calc |
| _ ≤ ∫ _y in Icc a b, (b - a) * ∫ z in Icc a b, deriv f z ^ 2 := by |
| apply setIntegral_mono_on (integrable_square_sub_const hi hi₂ _) (integrable_const _) |
| measurableSet_Icc |
| intro y hy |
| exact lipschitz_sq_sub_le_common_interval_energy hf hx hy |
| _ = _ := by rw [integral_const, smul_eq_mul, hmass]; ring |
| calc |
| _ ≤ ∫ _x in Icc a b, (b - a) * ∫ y in Icc a b, deriv f y ^ 2 := by |
| apply setIntegral_mono_on |
| (((hf.continuous.sub continuous_const).pow 2).continuousOn.integrableOn_Icc) |
| (integrable_const _) measurableSet_Icc hpoint |
| _ = _ := by rw [integral_const, smul_eq_mul, hmass]; ring |
|
|
| end CubicTorus |
|
|
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology |
| namespace CubicTorus |
|
|
| lemma variance_le_separated_pairwise {X : Type*} [MeasurableSpace X] |
| {μ : Measure X} [IsFiniteMeasure μ] {f A B : X → ℝ} |
| (hm : 0 < μ.real univ) (hf : Integrable f μ) |
| (hfsq : Integrable (fun x ↦ f x ^ 2) μ) (hA : Integrable A μ) (hB : Integrable B μ) |
| (hpair : ∀ᵐ x ∂μ, ∀ᵐ y ∂μ, (f x - f y) ^ 2 ≤ A x + B y) : |
| (∫ x, (f x - (∫ y, f y ∂μ) / μ.real univ) ^ 2 ∂μ) ≤ |
| (∫ x, A x ∂μ) + ∫ y, B y ∂μ := by |
| let m := (∫ y, f y ∂μ) / μ.real univ |
| have hpoint : ∀ᵐ x ∂μ, (f x - m) ^ 2 ≤ A x + (∫ y, B y ∂μ) / μ.real univ := by |
| filter_upwards [hpair] with x hx |
| have hj := square_sub_average_le hm hf hfsq (f x) |
| apply hj.trans |
| apply (div_le_iff₀ hm).mpr |
| calc |
| _ ≤ ∫ y, A x + B y ∂μ := |
| integral_mono_ae (integrable_square_sub_const hf hfsq _) ((integrable_const _).add hB) hx |
| _ = (A x + (∫ y, B y ∂μ) / μ.real univ) * μ.real univ := by |
| rw [integral_add (integrable_const _) hB, integral_const, smul_eq_mul] |
| field_simp |
| have hisq : Integrable (fun x ↦ (f x - m) ^ 2) μ := by |
| convert integrable_square_sub_const hf hfsq m using 1 |
| funext x |
| ring |
| have hh := integral_mono_ae hisq |
| (hA.add (integrable_const ((∫ y, B y ∂μ) / μ.real univ))) hpoint |
| change (∫ x, (f x - m) ^ 2 ∂μ) ≤ ∫ x, A x + (∫ y, B y ∂μ) / μ.real univ ∂μ at hh |
| rw [integral_add hA (integrable_const _), integral_const, smul_eq_mul, |
| mul_div_cancel₀ _ (ne_of_gt hm)] at hh |
| exact hh |
|
|
| lemma lipschitz_product_partial_measurable {f : ℝ × ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) : |
| Measurable (fun p : ℝ × ℝ ↦ deriv (fun x ↦ f (x, p.2)) p.1) ∧ |
| Measurable (fun p : ℝ × ℝ ↦ deriv (fun y ↦ f (p.1, y)) p.2) := by |
| constructor |
| · exact (measurable_deriv_with_param (f := fun y x ↦ f (x, y)) |
| (hf.continuous.comp continuous_swap)).comp measurable_swap |
| · exact measurable_deriv_with_param (f := fun x y ↦ f (x, y)) hf.continuous |
|
|
| lemma lipschitz_product_partial_integrable {f : ℝ × ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) (a b : ℝ) : |
| Integrable (fun p : ℝ × ℝ ↦ deriv (fun x ↦ f (x, p.2)) p.1 ^ 2) |
| ((volume.restrict (Icc a b)).prod (volume.restrict (Icc a b))) ∧ |
| Integrable (fun p : ℝ × ℝ ↦ deriv (fun y ↦ f (p.1, y)) p.2 ^ 2) |
| ((volume.restrict (Icc a b)).prod (volume.restrict (Icc a b))) := by |
| have hm := lipschitz_product_partial_measurable hf |
| constructor |
| · apply (integrable_const ((K : ℝ) ^ 2)).mono' (hm.1.pow_const 2).aestronglyMeasurable |
| exact ae_of_all _ fun p ↦ by |
| have hl : LipschitzWith K (fun x ↦ f (x, p.2)) := by simpa only [Function.comp_def, mul_one] using hf.comp (LipschitzWith.prodMk_right p.2) |
| have hb := norm_deriv_le_of_lipschitz hl (x₀ := p.1) |
| rw [Real.norm_eq_abs] at hb ⊢ |
| rw [abs_of_nonneg (sq_nonneg _)] |
| nlinarith [sq_abs (deriv (fun x ↦ f (x, p.2)) p.1), NNReal.coe_nonneg K, abs_nonneg (deriv (fun x ↦ f (x, p.2)) p.1)] |
| · apply (integrable_const ((K : ℝ) ^ 2)).mono' (hm.2.pow_const 2).aestronglyMeasurable |
| exact ae_of_all _ fun p ↦ by |
| have hl : LipschitzWith K (fun y ↦ f (p.1, y)) := by simpa only [Function.comp_def, mul_one] using hf.comp (LipschitzWith.prodMk_left p.1) |
| have hb := norm_deriv_le_of_lipschitz hl (x₀ := p.2) |
| rw [Real.norm_eq_abs] at hb ⊢ |
| rw [abs_of_nonneg (sq_nonneg _)] |
| nlinarith [sq_abs (deriv (fun y ↦ f (p.1, y)) p.2), NNReal.coe_nonneg K, abs_nonneg (deriv (fun y ↦ f (p.1, y)) p.2)] |
|
|
| theorem lipschitz_box_poincare {f : ℝ × ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) {a b : ℝ} (hab : a < b) : |
| let μ := (volume.restrict (Icc a b)).prod (volume.restrict (Icc a b)) |
| (∫ p, (f p - (∫ q, f q ∂μ) / (b - a) ^ 2) ^ 2 ∂μ) ≤ |
| 2 * (b - a) ^ 2 * |
| ((∫ p, deriv (fun x ↦ f (x, p.2)) p.1 ^ 2 ∂μ) + |
| ∫ p, deriv (fun y ↦ f (p.1, y)) p.2 ^ 2 ∂μ) := by |
| dsimp only |
| let ν : Measure ℝ := volume.restrict (Icc a b) |
| let μ := ν.prod ν |
| let Ex : ℝ → ℝ := fun y ↦ ∫ x, deriv (fun t ↦ f (t, y)) x ^ 2 ∂ν |
| let Ey : ℝ → ℝ := fun x ↦ ∫ y, deriv (fun t ↦ f (x, t)) y ^ 2 ∂ν |
| have hν : ν.real univ = b - a := by simp [ν, measureReal_def, Real.volume_Icc, hab.le] |
| have hμ : μ.real univ = (b - a) ^ 2 := by |
| change ((ν.prod ν) univ).toReal = _ |
| rw [← Set.univ_prod_univ, Measure.prod_prod, ENNReal.toReal_mul] |
| change ν.real univ * ν.real univ = _ |
| rw [hν] |
| ring |
| have hi : Integrable f μ := by |
| rw [show μ = volume.restrict (Icc a b ×ˢ Icc a b) from by |
| simp only [μ, ν, Measure.prod_restrict, ← Measure.volume_eq_prod]] |
| exact ContinuousOn.integrableOn_compact (isCompact_Icc.prod isCompact_Icc) hf.continuous.continuousOn |
| have hisq : Integrable (fun p ↦ f p ^ 2) μ := by |
| rw [show μ = volume.restrict (Icc a b ×ˢ Icc a b) from by |
| simp only [μ, ν, Measure.prod_restrict, ← Measure.volume_eq_prod]] |
| exact ContinuousOn.integrableOn_compact (isCompact_Icc.prod isCompact_Icc) (hf.continuous.pow 2).continuousOn |
| have hip := lipschitz_product_partial_integrable hf a b |
| have hiEx : Integrable Ex ν := hip.1.integral_prod_right |
| have hiEy : Integrable Ey ν := hip.2.integral_prod_left |
| have hmem : ∀ᵐ p ∂μ, p.1 ∈ Icc a b ∧ p.2 ∈ Icc a b := by |
| rw [show μ = volume.restrict (Icc a b ×ˢ Icc a b) from by |
| simp only [μ, ν, Measure.prod_restrict, ← Measure.volume_eq_prod]] |
| exact ae_restrict_mem (measurableSet_Icc.prod measurableSet_Icc) |
| have hpair : ∀ᵐ p ∂μ, ∀ᵐ q ∂μ, |
| (f p - f q) ^ 2 ≤ 2 * (b - a) * Ex p.2 + 2 * (b - a) * Ey q.1 := by |
| filter_upwards [hmem] with p hp |
| filter_upwards [hmem] with q hq |
| have hx : (f p - f (q.1, p.2)) ^ 2 ≤ (b - a) * Ex p.2 := |
| lipschitz_sq_sub_le_common_interval_energy (by |
| simpa using hf.comp (LipschitzWith.prodMk_right p.2)) hp.1 hq.1 |
| have hy : (f (q.1, p.2) - f q) ^ 2 ≤ (b - a) * Ey q.1 := |
| lipschitz_sq_sub_le_common_interval_energy (by |
| simpa using hf.comp (LipschitzWith.prodMk_left q.1)) hp.2 hq.2 |
| nlinarith [sq_nonneg (f p - 2 * f (q.1, p.2) + f q)] |
| have hh := variance_le_separated_pairwise (μ := μ) (by rw [hμ]; positivity) hi hisq |
| ((hiEx.comp_snd ν).const_mul (2 * (b - a))) |
| ((hiEy.comp_fst ν).const_mul (2 * (b - a))) hpair |
| rw [hμ] at hh |
| have hex : (∫ p, Ex p.2 ∂μ) = (b - a) * ∫ y, Ex y ∂ν := by |
| rw [integral_prod _ (hiEx.comp_snd ν)] |
| simp only [integral_const, smul_eq_mul, hν] |
| have hey : (∫ p, Ey p.1 ∂μ) = (b - a) * ∫ x, Ey x ∂ν := by |
| rw [integral_prod _ (hiEy.comp_fst ν)] |
| simp only [integral_const, smul_eq_mul, hν, integral_const_mul] |
| have hEx : (∫ y, Ex y ∂ν) = ∫ p, deriv (fun x ↦ f (x, p.2)) p.1 ^ 2 ∂μ := |
| (integral_prod_symm _ hip.1).symm |
| have hEy : (∫ x, Ey x ∂ν) = ∫ p, deriv (fun y ↦ f (p.1, y)) p.2 ^ 2 ∂μ := |
| (integral_prod _ hip.2).symm |
| rw [integral_const_mul, integral_const_mul, hex, hey, hEx, hEy] at hh |
| convert hh using 1 |
| ring |
|
|
| lemma differentiableAt_partial_sq_le {f : ℝ × ℝ → ℝ} {p : ℝ × ℝ} |
| (hf : DifferentiableAt ℝ f p) : |
| deriv (fun x ↦ f (x, p.2)) p.1 ^ 2 + deriv (fun y ↦ f (p.1, y)) p.2 ^ 2 ≤ |
| 2 * ‖fderiv ℝ f p‖ ^ 2 := by |
| have hx : deriv (fun x ↦ f (x, p.2)) p.1 = fderiv ℝ f p (1, 0) := by |
| exact (hf.hasFDerivAt.comp_hasDerivAt p.1 |
| ((hasDerivAt_id p.1).prodMk (hasDerivAt_const p.1 p.2))).deriv |
| have hy : deriv (fun y ↦ f (p.1, y)) p.2 = fderiv ℝ f p (0, 1) := by |
| exact (hf.hasFDerivAt.comp_hasDerivAt p.2 |
| ((hasDerivAt_const p.2 p.1).prodMk (hasDerivAt_id p.2))).deriv |
| rw [hx, hy] |
| have hb₁ : |fderiv ℝ f p (1, 0)| ≤ ‖fderiv ℝ f p‖ := by |
| simpa [Prod.norm_def] using (fderiv ℝ f p).le_opNorm (1, 0) |
| have hb₂ : |fderiv ℝ f p (0, 1)| ≤ ‖fderiv ℝ f p‖ := by |
| simpa [Prod.norm_def] using (fderiv ℝ f p).le_opNorm (0, 1) |
| nlinarith [sq_abs (fderiv ℝ f p (1, 0)), sq_abs (fderiv ℝ f p (0, 1)), |
| abs_nonneg (fderiv ℝ f p (1, 0)), abs_nonneg (fderiv ℝ f p (0, 1))] |
|
|
| lemma lipschitz_fderiv_sq_integrable {X : Type*} [NormedAddCommGroup X] |
| [NormedSpace ℝ X] [MeasurableSpace X] [OpensMeasurableSpace X] |
| {μ : Measure X} [IsFiniteMeasure μ] {f : X → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) : Integrable (fun x ↦ ‖fderiv ℝ f x‖ ^ 2) μ := by |
| apply (integrable_const ((K : ℝ) ^ 2)).mono' |
| ((measurable_fderiv ℝ f).norm.pow_const 2).aestronglyMeasurable |
| exact ae_of_all _ fun x ↦ by |
| rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)] |
| have hh := norm_fderiv_le_of_lipschitz ℝ hf (x₀ := x) |
| nlinarith [norm_nonneg (fderiv ℝ f x), NNReal.coe_nonneg K] |
| |
| theorem lipschitz_box_poincare_fderiv {f : ℝ × ℝ → ℝ} {K : ℝ≥0} |
| (hf : LipschitzWith K f) {a b : ℝ} (hab : a < b) : |
| let μ := (volume.restrict (Icc a b)).prod (volume.restrict (Icc a b)) |
| (∫ p, (f p - (∫ q, f q ∂μ) / (b - a) ^ 2) ^ 2 ∂μ) ≤ |
| 4 * (b - a) ^ 2 * (∫ p, ‖fderiv ℝ f p‖ ^ 2 ∂μ) := by |
| dsimp only |
| let μ := (volume.restrict (Icc a b)).prod (volume.restrict (Icc a b)) |
| have hdiff : ∀ᵐ p ∂μ, DifferentiableAt ℝ f p := by |
| rw [show μ = volume.restrict (Icc a b ×ˢ Icc a b) from by |
| simp only [μ, Measure.prod_restrict, ← Measure.volume_eq_prod]] |
| exact ae_restrict_of_ae hf.ae_differentiableAt |
| have hip := lipschitz_product_partial_integrable hf a b |
| have hb := integral_mono_ae (hip.1.add hip.2) |
| ((lipschitz_fderiv_sq_integrable (μ := μ) hf).const_mul 2) |
| (hdiff.mono fun _ h ↦ differentiableAt_partial_sq_le h) |
| change (∫ p, deriv (fun x ↦ f (x, p.2)) p.1 ^ 2 + |
| deriv (fun y ↦ f (p.1, y)) p.2 ^ 2 ∂μ) ≤ ∫ p, 2 * ‖fderiv ℝ f p‖ ^ 2 ∂μ at hb |
| rw [integral_add hip.1 hip.2, integral_const_mul] at hb |
| apply (lipschitz_box_poincare hf hab).trans |
| have hh := mul_le_mul_of_nonneg_left hb (by positivity : 0 ≤ 2 * (b - a) ^ 2) |
| convert hh using 1 |
| ring |
| |
| end CubicTorus |
| |
| end |
| end |
| |
| end |
| |
| end OAI |
| |
