| import OAI.Analysis.DirectCrouzeix.PoissonBoundary |
|
|
| namespace OAI |
|
|
| universe u_132 |
|
|
| noncomputable section |
|
|
| open scoped Matrix Matrix.Norms.L2Operator Kronecker |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set Filter Metric |
|
|
| open scoped Topology Interval ENNReal NNReal ComplexConjugate |
|
|
| noncomputable section |
|
|
| open Filter Metric Set |
|
|
| open scoped Topology ComplexConjugate |
|
|
| namespace DirectCrouzeix |
|
|
| namespace Conformal |
|
|
| open Function Complex |
|
|
| open scoped Pointwise |
|
|
| open InnerProductSpace Real |
|
|
| theorem circleAverage_conj {E : Type u_132} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (f : ℂ → E) (R : ℝ) : |
| Real.circleAverage (fun ζ => f (conj ζ)) 0 R = Real.circleAverage f 0 R := by |
| conv_lhs => rw [Real.circleAverage_eq_circleAverage_zero_one] |
| conv_rhs => rw [Real.circleAverage_eq_circleAverage_zero_one] |
| calc |
| Real.circleAverage (fun z => f (conj ((R : ℂ) * z + 0))) 0 1 = |
| Real.circleAverage (fun z => f ((R : ℂ) * z⁻¹ + 0)) 0 1 := by |
| apply Real.circleAverage_congr_sphere |
| intro z hz |
| have hn : ‖z‖ = 1 := by simpa using hz |
| simp [Complex.inv_eq_conj hn] |
| _ = Real.circleAverage (fun z => f ((R : ℂ) * z + 0)) 0 1 := |
| Real.circleAverage_zero_one_congr_inv (f := fun z => f ((R : ℂ) * z + 0)) |
|
|
| theorem poisson_conj (z ζ : ℂ) : |
| poissonKernel 0 (conj z) (conj ζ) = poissonKernel 0 z ζ := by |
| simp only [poissonKernel, sub_zero, Complex.norm_conj, ← map_sub] |
|
|
| theorem poisson_odd {R : ℝ} {u : ℂ → ℝ} |
| (hu : ∀ ζ, u (conj ζ) = -u ζ) (z : ℂ) : |
| poissonExtension R u (conj z) = -poissonExtension R u z := by |
| dsimp [poissonExtension] |
| rw [← circleAverage_conj (fun ζ => poissonKernel 0 (conj z) ζ * u ζ) R] |
| simp_rw [poisson_conj, hu, mul_neg] |
| have he (ζ : ℂ) : -(poissonKernel 0 z ζ * u ζ) = (-1 : ℝ) • (poissonKernel 0 z ζ * u ζ) := by simp |
| simp_rw [he] |
| rw [Real.circleAverage_fun_smul, neg_one_smul] |
|
|
| theorem poisson_real_zero {R : ℝ} {u : ℂ → ℝ} |
| (hu : ∀ ζ, u (conj ζ) = -u ζ) {z : ℂ} (hz : z.im = 0) : |
| poissonExtension R u z = 0 := by |
| have hc : conj z = z := Complex.conj_eq_iff_im.mpr hz |
| have hh := poisson_odd (R := R) hu z |
| rw [hc] at hh |
| linarith |
|
|
| def poissonClosed (R : ℝ) (u : ℂ → ℝ) (z : ℂ) : ℝ := by |
| classical |
| exact if z ∈ ball 0 R then poissonExtension R u z else u z |
|
|
| theorem poissonClosed_continuous {R : ℝ} (hR : 0 < R) {u : ℂ → ℝ} |
| (hu : ContinuousOn u (sphere 0 R)) : |
| ContinuousOn (poissonClosed R u) (closedBall 0 R) := by |
| classical |
| unfold poissonClosed |
| apply ContinuousOn.if' |
| · intro a ha |
| have haS : a ∈ sphere 0 R := by |
| simpa only [Set.ofPred_mem_eq, frontier_ball (0 : ℂ) hR.ne'] using ha.2 |
| have haN : a ∉ ball 0 R := fun h => sphere_disjoint_ball.le_bot ⟨haS, h⟩ |
| simp only [haN, ↓reduceIte] |
| exact (poisson_boundary_limit hR hu haS).mono_left (nhdsWithin_mono _ inter_subset_right) |
| · intro a ha |
| have haS : a ∈ sphere 0 R := by |
| simpa only [Set.ofPred_mem_eq, frontier_ball (0 : ℂ) hR.ne'] using ha.2 |
| have haN : a ∉ ball 0 R := fun h => sphere_disjoint_ball.le_bot ⟨haS, h⟩ |
| simp only [haN, ↓reduceIte] |
| apply (hu a haS).mono |
| intro z hz |
| exact le_antisymm (mem_closedBall.mp hz.1) (not_lt.mp hz.2) |
| · exact (poisson_harmonic hR.le hu).continuousOn.mono inter_subset_right |
| · apply hu.mono |
| intro z hz |
| exact le_antisymm (mem_closedBall.mp hz.1) (not_lt.mp hz.2) |
| |
| def upperBall (R : ℝ) : Set ℂ := ball 0 R ∩ {z | 0 < z.im} |
| |
| def upperClosedBall (R : ℝ) : Set ℂ := closedBall 0 R ∩ {z | 0 ≤ z.im} |
| |
| theorem upperBall_open (R : ℝ) : IsOpen (upperBall R) := |
| isOpen_ball.inter (isOpen_lt continuous_const Complex.continuous_im) |
| |
| theorem upperClosedBall_closed (R : ℝ) : IsClosed (upperClosedBall R) := |
| isClosed_closedBall.inter (isClosed_le continuous_const Complex.continuous_im) |
| |
| theorem closure_upperBall_subset (R : ℝ) : closure (upperBall R) ⊆ upperClosedBall R := by |
| apply closure_minimal _ (upperClosedBall_closed R) |
| intro z hz |
| exact ⟨ball_subset_closedBall hz.1, (show 0 < z.im from hz.2).le⟩ |
| |
| def oddUpper (u : ℂ → ℝ) (z : ℂ) : ℝ := if 0 ≤ z.im then u z else -u (conj z) |
| |
| theorem oddUpper_conj {u : ℂ → ℝ} (hzero : ∀ z, z.im = 0 → u z = 0) |
| (z : ℂ) : oddUpper u (conj z) = -oddUpper u z := by |
| dsimp [oddUpper] |
| rw [Complex.conj_conj] |
| change (if 0 ≤ -z.im then u (conj z) else -u z) = -(if 0 ≤ z.im then u z else -u (conj z)) |
| by_cases hz : z.im = 0 |
| · have hc : conj z = z := Complex.conj_eq_iff_im.mpr hz |
| simp [hz, hc, hzero z hz] |
| · by_cases hh : 0 ≤ z.im |
| · have hn : ¬ 0 ≤ -z.im := fun he => hz (by linarith) |
| rw [ite_eq_right hn, ite_eq_left hh] |
| · rw [ite_eq_left (show 0 ≤ -z.im by linarith), ite_eq_right hh, neg_neg] |
| |
| theorem oddUpper_continuous_circle {R : ℝ} {u : ℂ → ℝ} |
| (hu : ContinuousOn u (upperClosedBall R)) |
| (hzero : ∀ z, z.im = 0 → u z = 0) : |
| ContinuousOn (oddUpper u) (sphere 0 R) := by |
| classical |
| apply ContinuousOn.if |
| · intro z hz |
| have hfr := Complex.continuous_im.frontier_preimage_subset (Ici (0 : ℝ)) hz.2 |
| have hz0 : z.im = 0 := by simpa only [frontier_Ici, mem_preimage, mem_singleton_iff] using hfr |
| have hc : conj z = z := Complex.conj_eq_iff_im.mpr hz0 |
| simp [hc, hzero z hz0] |
| · apply hu.mono |
| intro z hz |
| have hi : 0 ≤ z.im := by |
| exact (closure_minimal (by intro w hw; exact hw) |
| (isClosed_le continuous_const Complex.continuous_im)) hz.2 |
| exact ⟨sphere_subset_closedBall hz.1, hi⟩ |
| · apply ContinuousOn.neg |
| apply hu.comp Complex.continuous_conj.continuousOn |
| intro z hz |
| have hi : z.im ≤ 0 := by |
| exact (closure_minimal (by intro w hw; exact (le_of_not_ge hw)) |
| (isClosed_le Complex.continuous_im continuous_const)) hz.2 |
| exact ⟨by simpa only [mem_closedBall, dist_zero_right, Complex.norm_conj] using |
| sphere_subset_closedBall hz.1, by simpa only [mem_ofPred_eq, Complex.conj_im, neg_nonneg] using hi⟩ |
| |
| theorem harmonic_reflection {R : ℝ} (hR : 0 < R) {u : ℂ → ℝ} |
| (hu : HarmonicOnNhd u (upperBall R)) |
| (huc : ContinuousOn u (upperClosedBall R)) |
| (hzero : ∀ z, z.im = 0 → u z = 0) : |
| EqOn (fun z => (herglotzExtension R (oddUpper u) z).re) u (upperBall R) := by |
| let v := oddUpper u |
| have hvc : ContinuousOn v (sphere 0 R) := oddUpper_continuous_circle huc hzero |
| let w := poissonClosed R v |
| have hwc := poissonClosed_continuous hR hvc |
| have he : EqOn w (poissonExtension R v) (ball 0 R) := by |
| intro z hz |
| simp [w, poissonClosed, hz] |
| have hwh : HarmonicOnNhd w (ball 0 R) := by |
| intro z hz |
| rw [harmonicAt_congr_nhds (he.eventuallyEq_of_mem (isOpen_ball.mem_nhds hz))] |
| exact poisson_harmonic hR.le hvc z hz |
| have hdiff : HarmonicContOnCl (u - w) (upperBall R) := by |
| refine ⟨hu.sub (hwh.mono inter_subset_left), ?_⟩ |
| exact (huc.mono (closure_upperBall_subset R)).sub |
| (hwc.mono ((closure_upperBall_subset R).trans inter_subset_left)) |
| have hbound : EqOn (u - w) 0 (frontier (upperBall R)) := by |
| intro z hz |
| have hzK := closure_upperBall_subset R hz.1 |
| have hn : z ∉ upperBall R := by |
| simpa only [(upperBall_open R).interior_eq] using hz.2 |
| by_cases hzB : z ∈ ball 0 R |
| · have hz0 : z.im = 0 := le_antisymm (le_of_not_gt (fun hi => hn ⟨hzB, hi⟩)) hzK.2 |
| have hw0 : w z = 0 := by |
| rw [he hzB] |
| exact poisson_real_zero (oddUpper_conj hzero) hz0 |
| simp [hzero z hz0, hw0] |
| · have hi : 0 ≤ z.im := hzK.2 |
| simp [w, poissonClosed, hzB, v, oddUpper, hi] |
| have hb : Bornology.IsBounded (upperBall R) := isBounded_ball.subset inter_subset_left |
| have hlo := harmonic_le_boundary (upperBall_open R) hb hdiff (M := 0) |
| (fun z hz => le_of_eq (hbound hz)) |
| have hhi := harmonic_le_boundary (upperBall_open R) hb hdiff.neg (M := 0) |
| (fun z hz => by simp [hbound hz]) |
| intro z hz |
| change (herglotzExtension R v z).re = u z |
| rw [herglotz_re hR.le hvc hz.1, ← he hz.1] |
| have ha := hlo z (subset_closure hz) |
| have hb := hhi z (subset_closure hz) |
| change u z - w z ≤ 0 at ha |
| change -(u z - w z) ≤ 0 at hb |
| linarith |
| |
| end Conformal |
| |
| end DirectCrouzeix |
| |
| end |
| |
| end |
| |
| end |
| |
| end OAI |
| |
