| import OAI.Analysis.IntegralMeans.TransportBoxes |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Set MeasureTheory Filter Function InnerProductSpace |
| open scoped Topology ComplexConjugate Manifold NNReal ENNReal InnerProductSpace Classical |
| open MeasureTheory Function |
| open Set Filter |
| open Set MeasureTheory Filter Function |
| open Set MeasureTheory Filter Function InnerProductSpace |
| open TopologicalSpace |
| open scoped CompactlySupported |
| open scoped ENNReal |
| open scoped Manifold |
| open scoped Topology CompactlySupported ComplexConjugate |
| open scoped Topology ComplexConjugate Manifold NNReal ENNReal InnerProductSpace Classical |
| open scoped Topology ENNReal NNReal |
| namespace Brennan |
|
|
| attribute [local irreducible] classWeight |
| attribute [local irreducible] classFun |
|
|
| def halfMul (z w : halfPlane) : halfPlane := ⟨affine z w,affine_mem z.2 w.2⟩ |
|
|
| def halfPoint (x y : ℝ) (hy : 0 < y) : halfPlane := |
| ⟨(x : ℂ)+(y : ℂ)*Complex.I,by simpa [halfPlane]⟩ |
|
|
| def horizontal (x : ℝ) : halfPlane := halfPoint x 1 zero_lt_one |
|
|
| lemma halfPoint_mul (x y u v : ℝ) (hy : 0 < y) (hv : 0 < v) : |
| halfMul (halfPoint x y hy) (halfPoint u v hv) = halfPoint (x+y*u) (y*v) (mul_pos hy hv) := by |
| apply Subtype.ext |
| apply Complex.ext <;> simp [halfMul,halfPoint,affine] |
|
|
| lemma halfMul_assoc (z w u : halfPlane) : halfMul (halfMul z w) u = halfMul z (halfMul w u) := |
| Subtype.ext (affine_assoc z w u) |
|
|
| lemma halfOne_mul (z : halfPlane) : halfMul halfOne z = z := Subtype.ext (I_affine z) |
|
|
| lemma halfMul_one (z : halfPlane) : halfMul z halfOne = z := Subtype.ext (affine_I z) |
|
|
| lemma continuous_halfPoint.{u_1} {Y : Type u_1} [TopologicalSpace Y] {x y : Y → ℝ} |
| (hx : Continuous x) (hy : Continuous y) (hp : ∀ a, 0 < y a) : |
| Continuous (fun a => halfPoint (x a) (y a) (hp a)) := |
| ((Complex.continuous_ofReal.comp hx).add ((Complex.continuous_ofReal.comp hy).mul continuous_const)).subtype_mk _ |
|
|
| lemma rerootClass_one (g : DiskClass) : rerootClass g halfOne = g := by |
| apply class_ext |
| intro z hz |
| rw [classFun_rerootClass _ _ hz] |
| simp [reroot,halfOne,(classFun_schlicht g).2.1,(classFun_schlicht g).2.2] |
|
|
| lemma classWeight_one (g : DiskClass) : classWeight g halfOne = 1 := by |
| simp [classWeight,reciprocalDeriv,halfOne,(classFun_schlicht g).2.2] |
|
|
| attribute [local irreducible] rerootClass |
|
|
| def weightAt (z : halfPlane) : C(DiskClass,ℝ) := |
| ⟨fun g => classWeight g z,by |
| have hc : Continuous (fun g : DiskClass => (g,z)) := continuous_id.prodMk continuous_const |
| exact continuous_classWeight.comp hc⟩ |
|
|
| def actionAt (z : halfPlane) : C(DiskClass,DiskClass) := |
| ⟨fun g => rerootClass g z,by |
| have hc : Continuous (fun g : DiskClass => (g,z)) := continuous_id.prodMk continuous_const |
| exact continuous_rerootClass.comp hc⟩ |
|
|
| def affineOperator (z : halfPlane) : C(DiskClass,ℝ) →L[ℝ] C(DiskClass,ℝ) := |
| (ContinuousLinearMap.mul ℝ C(DiskClass,ℝ) (weightAt z)).comp (ContinuousMap.compCLM ℝ ℝ (actionAt z)) |
|
|
| lemma affineOperator_apply (z : halfPlane) (f : C(DiskClass,ℝ)) (g : DiskClass) : |
| affineOperator z f g = classWeight g z * f (rerootClass g z) := rfl |
|
|
| lemma affineOperator_pos (z : halfPlane) (f : C(DiskClass,ℝ)) (hf : 0 ≤ f) : |
| 0 ≤ affineOperator z f := fun g => mul_nonneg (classWeight_pos g z).le (hf _) |
|
|
| lemma affineOperator_mul (z w : halfPlane) : |
| affineOperator z * affineOperator w = affineOperator (halfMul z w) := by |
| ext f g |
| change classWeight g z * (classWeight (rerootClass g z) w * f (rerootClass (rerootClass g z) w)) = _ |
| rw [← mul_assoc,classWeight_cocycle,rerootClass_comp] |
| rfl |
|
|
| lemma affineOperator_one : affineOperator halfOne = 1 := by |
| ext f g |
| simp only [affineOperator_apply,classWeight_one,rerootClass_one,one_mul] |
| rfl |
|
|
| lemma continuous_affineOperator_apply (f : C(DiskClass,ℝ)) : |
| Continuous (fun z : halfPlane => affineOperator z f) := by |
| apply ContinuousMap.continuous_of_continuous_uncurry |
| have hw : Continuous (fun p : halfPlane × DiskClass => classWeight p.2 p.1) := |
| continuous_classWeight.comp (continuous_swap : Continuous (Prod.swap : halfPlane × DiskClass → DiskClass × halfPlane)) |
| have ht : Continuous (fun p : halfPlane × DiskClass => rerootClass p.2 p.1) := |
| continuous_rerootClass.comp (continuous_swap : Continuous (Prod.swap : halfPlane × DiskClass → DiskClass × halfPlane)) |
| exact hw.mul (f.continuous.comp ht) |
|
|
| lemma affineOperator_norm_le {z : halfPlane} {B : ℝ} (hB : 0 ≤ B) |
| (hw : ∀ g : DiskClass, classWeight g z ≤ B) : ‖affineOperator z‖ ≤ B := by |
| apply (affineOperator z).opNorm_le_bound hB |
| intro f |
| apply (ContinuousMap.norm_le _ (mul_nonneg hB (norm_nonneg f))).mpr |
| intro g |
| rw [affineOperator_apply,norm_mul,Real.norm_of_nonneg (classWeight_pos g z).le] |
| exact mul_le_mul (hw g) (ContinuousMap.norm_coe_le_norm f _) (norm_nonneg _) hB |
|
|
| lemma classFun_identityClass : EqOn (classFun identityClass) identityHalf halfPlane := |
| classFun_classOfHalf identityHalf_schlicht |
|
|
| lemma classWeight_identityClass (z : halfPlane) : classWeight identityClass z = 1 := by |
| have hd := classFun_identityClass.deriv isOpen_halfPlane z.2 |
| have hi : deriv identityHalf z = 1 := ((hasDerivAt_id (z : ℂ)).sub_const Complex.I).deriv |
| simp [classWeight,reciprocalDeriv,hd,hi] |
|
|
| lemma reroot_identityClass (z : halfPlane) : rerootClass identityClass z = identityClass := by |
| apply class_ext |
| intro w hw |
| rw [classFun_rerootClass _ _ hw,reroot_congr classFun_identityClass z.2 hw,classFun_identityClass hw] |
| have hd : deriv identityHalf z = 1 := ((hasDerivAt_id (z : ℂ)).sub_const Complex.I).deriv |
| have he : (z.val.re : ℂ)+(z.val.im : ℂ)*Complex.I = z := by apply Complex.ext <;> simp |
| dsimp [reroot,identityHalf,affine] |
| rw [hd,mul_one] |
| apply (div_eq_iff (Complex.ofReal_ne_zero.mpr (ne_of_gt z.2))).mpr |
| linear_combination he |
|
|
| def dyadicLeft : halfPlane := halfPoint (-1/2) (1/2) (by norm_num) |
|
|
| def dyadicRight : halfPlane := halfPoint (1/2) (1/2) (by norm_num) |
|
|
| def transferOperator : C(DiskClass,ℝ) →L[ℝ] C(DiskClass,ℝ) := |
| (1/2 : ℝ) • (affineOperator dyadicLeft+affineOperator dyadicRight) |
|
|
| lemma transferOperator_pos (f : C(DiskClass,ℝ)) (hf : 0 ≤ f) : 0 ≤ transferOperator f := by |
| intro g |
| change 0 ≤ (1/2 : ℝ)*(affineOperator dyadicLeft f g+affineOperator dyadicRight f g) |
| exact mul_nonneg (by norm_num) (add_nonneg (affineOperator_pos _ f hf g) (affineOperator_pos _ f hf g)) |
|
|
| lemma transferOperator_identityClass (f : C(DiskClass,ℝ)) : transferOperator f identityClass = f identityClass := by |
| change (1/2 : ℝ)*(affineOperator dyadicLeft f identityClass+affineOperator dyadicRight f identityClass) = _ |
| simp only [affineOperator_apply,classWeight_identityClass,reroot_identityClass,one_mul] |
| ring |
|
|
| lemma transferOperator_pow_identityClass (n : ℕ) : (transferOperator^n) 1 identityClass = 1 := by |
| induction n with |
| | zero => rfl |
| | succ n ih => simpa only [pow_succ',mul_apply_eq_comp,transferOperator_identityClass] using ih |
|
|
| lemma transferOperator_pow_norm_ge_one (n : ℕ) : 1 ≤ ‖transferOperator^n‖ := by |
| have hv := (ContinuousMap.norm_coe_le_norm ((transferOperator^n) 1) identityClass).trans |
| ((transferOperator^n).le_opNorm 1) |
| simpa only [transferOperator_pow_identityClass,norm_one,mul_one] using hv |
|
|
| lemma diskCayley_norm_sq_identity {z : ℂ} (hz : z ∈ halfPlane) : |
| (1-‖diskCayley z‖^2)*‖z+Complex.I‖^2 = 4*z.im := by |
| have hd : ‖z+Complex.I‖ ≠ 0 := norm_ne_zero_iff.mpr (cayley_den_ne_zero hz) |
| rw [diskCayley,norm_div,div_pow] |
| field_simp |
| rw [Complex.sq_norm,Complex.sq_norm] |
| simp [Complex.normSq_apply] |
| ring |
|
|
| lemma classFun_deriv_norm (g : DiskClass) (z : halfPlane) : |
| ‖deriv (classFun g) z‖ = 4*‖deriv (diskExtend g.1) (diskCayley z)‖/‖z.val+Complex.I‖^2 := by |
| have hd := (hasDerivAt_diskToHalf g.2.1.1 z.2).deriv |
| rw [classFun] |
| rw [hd,norm_div,norm_mul,norm_neg,norm_pow] |
| norm_num |
|
|
| lemma classFun_reciprocal_norm (g : DiskClass) (z : halfPlane) : |
| ‖reciprocalDeriv (classFun g) z‖ = ‖z.val+Complex.I‖^2/ |
| (4*‖deriv (diskExtend g.1) (diskCayley z)‖) := by |
| rw [reciprocalDeriv,norm_inv,classFun_deriv_norm,inv_div] |
|
|
| lemma classFun_reciprocal_bound (g : DiskClass) (z : halfPlane) : |
| ‖reciprocalDeriv (classFun g) z‖ ≤ ‖z.val+Complex.I‖^4/z.val.im := by |
| let r := ‖diskCayley z‖ |
| let D := ‖z.val+Complex.I‖^2 |
| let a := ‖deriv (diskExtend g.1) (diskCayley z)‖ |
| have hr0 : 0 ≤ r := norm_nonneg _ |
| have hr1 : r < 1 := by simpa [r,disk] using diskCayley_maps z.2 |
| have hD0 : 0 < D := sq_pos_of_ne_zero (norm_ne_zero_iff.mpr (cayley_den_ne_zero z.2)) |
| have ha0 : 0 < a := norm_pos_iff.mpr (univalent_deriv_ne_zero Metric.isOpen_ball g.2.1 (diskCayley_maps z.2)) |
| have he : (1-r^2)*D = 4*z.val.im := diskCayley_norm_sq_identity z.2 |
| have hlo : (1-r)/(1+r)^3 ≤ a := (schlicht_deriv_bounds g.2 (diskCayley_maps z.2)).1 |
| have hden : 0 < (1+r)^3 := pow_pos (by linarith) 3 |
| have h8 : (1+r)^3 ≤ 8 := by nlinarith [sq_nonneg (1-r),sq_nonneg r,mul_nonneg hr0 (sq_nonneg (1-r))] |
| have hl : 1-r ≤ 8*a := by |
| have hh := (div_le_iff₀ hden).mp hlo |
| nlinarith [mul_le_mul_of_nonneg_left h8 ha0.le] |
| have hD : 2*z.val.im ≤ (1-r)*D := by |
| have hh : (1-r^2) ≤ 2*(1-r) := by nlinarith [sq_nonneg (1-r)] |
| nlinarith [mul_le_mul_of_nonneg_right hh hD0.le] |
| have hDa : z.val.im ≤ 4*a*D := by |
| have hh := mul_le_mul_of_nonneg_right hl hD0.le |
| nlinarith |
| rw [classFun_reciprocal_norm] |
| change D/(4*a) ≤ ‖z.val+Complex.I‖^4/z.val.im |
| rw [div_le_div_iff₀ (by positivity : 0 < 4*a) z.2] |
| have hh := mul_le_mul_of_nonneg_right hDa hD0.le |
| dsimp [D] at * |
| nlinarith |
|
|
| lemma classFun_strip_bound (g : DiskClass) {C₀ : ℝ} (hC : 0 ≤ C₀) (z : halfPlane) |
| (hx : |z.val.re| ≤ C₀) (hy : z.val.im ≤ 1) : |
| ‖reciprocalDeriv (classFun g) z‖ ≤ (C₀^2+4)^2/z.val.im := by |
| apply (classFun_reciprocal_bound g z).trans |
| apply div_le_div_of_nonneg_right _ z.2.le |
| have hD : ‖z.val+Complex.I‖^2 = z.val.re^2+(z.val.im+1)^2 := by |
| rw [Complex.sq_norm] |
| simp [Complex.normSq_apply] |
| ring |
| have hxr : z.val.re^2 ≤ C₀^2 := by nlinarith [sq_abs z.val.re,(sq_le_sq₀ (abs_nonneg _) hC).mpr hx] |
| have hDle : ‖z.val+Complex.I‖^2 ≤ C₀^2+4 := by |
| have hz0 : 0 < z.val.im := z.2 |
| rw [hD] |
| nlinarith [mul_nonneg hz0.le (sub_nonneg.mpr hy)] |
| nlinarith [sq_nonneg (‖z.val+Complex.I‖^2-(C₀^2+4))] |
|
|
| lemma classFun_strip_bound_two (g : DiskClass) (z : halfPlane) |
| (hx : |z.val.re| ≤ 2) (hy : z.val.im ≤ 1) : |
| ‖reciprocalDeriv (classFun g) z‖ ≤ 64/z.val.im := by |
| convert classFun_strip_bound g (by norm_num : (0 : ℝ) ≤ 2) z hx hy using 1 |
| norm_num |
|
|
| end Brennan |
|
|
| end |
|
|
| end OAI |
|
|
