Download data/lean/OAI/Analysis/DirectCrouzeix/DiskMapping.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/DirectCrouzeix/DiskMapping.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/DirectCrouzeix/DiskMapping.lean
-
curl -L -o DiskMapping.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/DirectCrouzeix/DiskMapping.lean
12.2 kB
| import OAI.Analysis.DirectCrouzeix.ExtremalEmbedding | |
| namespace OAI | |
| 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 | |
| def diskMobius (a z : β) : β := (z - a) / (1 - conj a * z) | |
| theorem diskMobius_den_ne_zero {a z : β} (ha : βaβ < 1) (hz : βzβ β€ 1) : | |
| 1 - conj a * z β 0 := by | |
| intro he | |
| have hh := congrArg norm (sub_eq_zero.mp he) | |
| rw [norm_one, norm_mul, norm_conj] at hh | |
| have hp := mul_le_mul_of_nonneg_left hz (norm_nonneg a) | |
| nlinarith | |
| theorem diskMobius_difference (a z : β) : | |
| β1 - conj a * zβ ^ 2 - βz - aβ ^ 2 = (1 - βaβ ^ 2) * (1 - βzβ ^ 2) := by | |
| simp only [β Complex.normSq_eq_norm_sq, Complex.normSq_apply, Complex.sub_re, | |
| Complex.sub_im, Complex.mul_re, Complex.mul_im, Complex.conj_re, Complex.conj_im, | |
| Complex.one_re, Complex.one_im] | |
| ring | |
| theorem diskMobius_mapsTo {a : β} (ha : βaβ < 1) : | |
| MapsTo (diskMobius a) (ball 0 1) (ball 0 1) := by | |
| intro z hz | |
| have hz' : βzβ < 1 := mem_ball_zero_iff.mp hz | |
| rw [mem_ball_zero_iff, diskMobius, norm_div, | |
| div_lt_oneβ (norm_pos_iff.mpr (diskMobius_den_ne_zero ha hz'.le))] | |
| have hd := diskMobius_difference a z | |
| have hp : 0 < (1 - βaβ ^ 2) * (1 - βzβ ^ 2) := mul_pos | |
| (by nlinarith [norm_nonneg a]) (by nlinarith [norm_nonneg z]) | |
| nlinarith [norm_nonneg (z - a), norm_nonneg (1 - conj a * z)] | |
| theorem diskMobius_hasDerivAt {a z : β} (ha : βaβ < 1) (hz : βzβ β€ 1) : | |
| HasDerivAt (diskMobius a) ((1 - conj a * a) / (1 - conj a * z) ^ 2) z := by | |
| have hh := ((hasDerivAt_id z).sub_const a).fun_div | |
| ((hasDerivAt_const z (1 : β)).sub ((hasDerivAt_id z).const_mul (conj a))) | |
| (diskMobius_den_ne_zero ha hz) | |
| change HasDerivAt (diskMobius a) | |
| ((1 * (1 - conj a * z) - (z - a) * (0 - conj a * 1)) / (1 - conj a * z) ^ 2) z at hh | |
| convert hh using 1 | |
| congr 1 | |
| ring | |
| theorem diskMobius_deriv_ne_zero {a z : β} (ha : βaβ < 1) (hz : βzβ β€ 1) : | |
| deriv (diskMobius a) z β 0 := by | |
| rw [(diskMobius_hasDerivAt ha hz).deriv] | |
| exact div_ne_zero (diskMobius_den_ne_zero ha ha.le) | |
| (pow_ne_zero _ (diskMobius_den_ne_zero ha hz)) | |
| theorem diskMobius_injOn {a : β} (ha : βaβ < 1) : | |
| InjOn (diskMobius a) (ball 0 1) := by | |
| intro z hz w hw he | |
| have hz' := (mem_ball_zero_iff.mp hz).le | |
| have hw' := (mem_ball_zero_iff.mp hw).le | |
| have hd := (div_eq_div_iff (diskMobius_den_ne_zero ha hz') | |
| (diskMobius_den_ne_zero ha hw')).mp he | |
| have hprod : (1 - conj a * a) * (z - w) = 0 := by | |
| linear_combination hd | |
| exact sub_eq_zero.mp ((mul_eq_zero.mp hprod).resolve_left (diskMobius_den_ne_zero ha ha.le)) | |
| @[simp] theorem diskMobius_self (a : β) : diskMobius a a = 0 := by simp [diskMobius] | |
| @[simp] theorem diskMobius_zero (a : β) : diskMobius a 0 = -a := by simp [diskMobius] | |
| theorem diskMobius_norm_deriv {a z : β} (ha : βaβ < 1) (hz : βzβ β€ 1) : | |
| βderiv (diskMobius a) zβ = (1 - βaβ ^ 2) / β1 - conj a * zβ ^ 2 := by | |
| rw [(diskMobius_hasDerivAt ha hz).deriv, norm_div, norm_pow] | |
| congr 1 | |
| rw [mul_comm (conj a), Complex.mul_conj, Complex.normSq_eq_norm_sq, | |
| β Complex.ofReal_one, β Complex.ofReal_sub, Complex.norm_real, Real.norm_eq_abs, | |
| abs_of_pos (by nlinarith [norm_nonneg a] : 0 < 1 - βaβ ^ 2)] | |
| theorem diskMobius_norm_deriv_zero {a : β} (ha : βaβ < 1) : | |
| βderiv (diskMobius a) 0β = 1 - βaβ ^ 2 := by | |
| rw [diskMobius_norm_deriv ha (by simp)] | |
| simp | |
| theorem diskMobius_norm_deriv_self {a : β} (ha : βaβ < 1) : | |
| βderiv (diskMobius a) aβ = (1 - βaβ ^ 2)β»ΒΉ := by | |
| rw [diskMobius_norm_deriv ha ha.le] | |
| have hd : β1 - conj a * aβ = 1 - βaβ ^ 2 := by | |
| rw [mul_comm (conj a), Complex.mul_conj, Complex.normSq_eq_norm_sq, | |
| β Complex.ofReal_one, β Complex.ofReal_sub, Complex.norm_real, Real.norm_eq_abs, | |
| abs_of_pos (by nlinarith [norm_nonneg a] : 0 < 1 - βaβ ^ 2)] | |
| rw [hd] | |
| field_simp | |
| theorem hasDerivAt_squareRoot {g F : β β β} {x d : β} | |
| (hg : ContinuousAt g x) (hg0 : g x β 0) (hF : HasDerivAt F d x) | |
| (he : β z, g z ^ 2 = F z) : HasDerivAt g (d / (2 * g x)) x := by | |
| have hn : g x + g x β 0 := by simpa [β two_mul] using mul_ne_zero (by norm_num : (2 : β) β 0) hg0 | |
| have ht := hF.tendsto_slope.div | |
| ((hg.add_const (g x)).tendsto.mono_left nhdsWithin_le_nhds) hn | |
| rw [hasDerivAt_iff_tendsto_slope] | |
| convert ht.congr' ?_ using 1 | |
| Β· congr 1 | |
| ring | |
| have hnear : βαΆ z in π[β ] x, g z + g x β 0 := | |
| ((hg.add_const (g x)).eventually_ne hn).filter_mono nhdsWithin_le_nhds | |
| filter_upwards [hnear] with z hz | |
| simp only [Pi.div_apply, slope, smul_eq_mul, vsub_eq_sub] | |
| rw [β he z, β he x] | |
| field_simp [hz] | |
| ring | |
| theorem improve_embedding {U : Set β} (hU : IsOpen U) | |
| (hUc : IsSimplyConnected U) {a : β} (ha : a β U) | |
| {f : β β β} (hf : NormalizedEmbedding U a f) | |
| {b : β} (hb : βbβ < 1) (hmiss : b β f '' U) : | |
| β G, NormalizedEmbedding U a G β§ βderiv f aβ < βderiv G aβ := by | |
| have hfb : β z β U, f z β b := by | |
| intro z hz he | |
| exact hmiss β¨z, hz, heβ© | |
| let H : β β β := diskMobius b β f | |
| have hH' (z : β) (hz : z β U) : | |
| HasDerivAt H (deriv (diskMobius b) (f z) * deriv f z) z := | |
| ((diskMobius_hasDerivAt hb (mem_ball_zero_iff.mp (hf.disk hz)).le).differentiableAt.hasDerivAt).comp z | |
| (hf.holomorphic.hasDerivAt (hU.mem_nhds hz)) | |
| have hHd : DifferentiableOn β H U := fun z hz => | |
| (hH' z hz).differentiableAt.differentiableWithinAt | |
| have hHdisk : MapsTo H U (ball 0 1) := (diskMobius_mapsTo hb).comp hf.disk | |
| have hHi : InjOn H U := (diskMobius_injOn hb).comp hf.injective hf.disk | |
| have hH0 : β z β U, H z β 0 := by | |
| intro z hz | |
| dsimp [H, diskMobius, Function.comp_def] | |
| exact div_ne_zero (sub_ne_zero.mpr (hfb z hz)) | |
| (diskMobius_den_ne_zero hb (mem_ball_zero_iff.mp (hf.disk hz)).le) | |
| obtain β¨g, hgc, hgeβ© := Complex.exists_continuousOn_pow_eq hUc hU hHd.continuousOn | |
| (by rintro β¨z, hz, heβ©; exact hH0 z hz he) (by norm_num : (2 : β) β 0) | |
| have hg0 : β z β U, g z β 0 := by | |
| intro z hz he | |
| have ht := hge z | |
| simp only [he, zero_pow (by norm_num : (2 : β) β 0)] at ht | |
| exact hH0 z hz ht.symm | |
| have hgd (z : β) (hz : z β U) : | |
| HasDerivAt g (deriv H z / (2 * g z)) z := | |
| hasDerivAt_squareRoot (hgc.continuousAt (hU.mem_nhds hz)) (hg0 z hz) | |
| (hHd.hasDerivAt (hU.mem_nhds hz)) hge | |
| have hgi : InjOn g U := by | |
| intro z hz w hw he | |
| apply hHi hz hw | |
| rw [β hge z, β hge w, he] | |
| have hgb : MapsTo g U (ball 0 1) := by | |
| intro z hz | |
| rw [mem_ball_zero_iff] | |
| have hn := congrArg norm (hge z) | |
| rw [norm_pow] at hn | |
| have ht : βH zβ < 1 := mem_ball_zero_iff.mp (hHdisk hz) | |
| nlinarith [sq_nonneg (βg zβ - 1)] | |
| have hgne (z : β) (hz : z β U) : deriv g z β 0 := by | |
| rw [(hgd z hz).deriv, (hH' z hz).deriv] | |
| exact div_ne_zero (mul_ne_zero | |
| (diskMobius_deriv_ne_zero hb (mem_ball_zero_iff.mp (hf.disk hz)).le) | |
| (hf.derivative z hz)) (mul_ne_zero (by norm_num) (hg0 z hz)) | |
| have hr : βg aβ < 1 := mem_ball_zero_iff.mp (hgb ha) | |
| have hr0 : 0 < βg aβ := norm_pos_iff.mpr (hg0 a ha) | |
| let G : β β β := diskMobius (g a) β g | |
| have hG' (z : β) (hz : z β U) : | |
| HasDerivAt G (deriv (diskMobius (g a)) (g z) * deriv g z) z := | |
| ((diskMobius_hasDerivAt hr (mem_ball_zero_iff.mp (hgb hz)).le).differentiableAt.hasDerivAt).comp z | |
| (hgd z hz).differentiableAt.hasDerivAt | |
| have hGN : NormalizedEmbedding U a G := by | |
| refine β¨fun z hz => (hG' z hz).differentiableAt.differentiableWithinAt, | |
| (diskMobius_mapsTo hr).comp hgb, (diskMobius_injOn hr).comp hgi hgb, ?_, ?_β© | |
| Β· intro z hz | |
| rw [(hG' z hz).deriv] | |
| exact mul_ne_zero (diskMobius_deriv_ne_zero hr (mem_ball_zero_iff.mp (hgb hz)).le) | |
| (hgne z hz) | |
| Β· exact diskMobius_self _ | |
| refine β¨G, hGN, ?_β© | |
| have hab : βg aβ ^ 2 = βbβ := by | |
| have ht := congrArg norm (hge a) | |
| simpa only [norm_pow, H, Function.comp_apply, hf.normalized, diskMobius_zero, norm_neg] using ht | |
| have hval : βderiv G aβ = (1 - βg aβ ^ 2)β»ΒΉ * | |
| ((1 - βbβ ^ 2) * βderiv f aβ / (2 * βg aβ)) := by | |
| rw [(hG' a ha).deriv, norm_mul, diskMobius_norm_deriv_self hr, | |
| (hgd a ha).deriv, norm_div, (hH' a ha).deriv, norm_mul, hf.normalized, | |
| diskMobius_norm_deriv_zero hb, norm_mul] | |
| norm_num | |
| rw [hval] | |
| have hp : 0 < βderiv f aβ := norm_pos_iff.mpr (hf.derivative a ha) | |
| have h1 : 0 < 1 - βg aβ ^ 2 := by nlinarith | |
| have he : (1 - βg aβ ^ 2)β»ΒΉ * | |
| ((1 - βbβ ^ 2) * βderiv f aβ / (2 * βg aβ)) = | |
| ((1 + βg aβ ^ 2) / (2 * βg aβ)) * βderiv f aβ := by | |
| rw [β hab] | |
| field_simp | |
| ring | |
| rw [he] | |
| have hc : 1 < (1 + βg aβ ^ 2) / (2 * βg aβ) := by | |
| rw [lt_div_iffβ (by positivity)] | |
| nlinarith [sq_pos_of_pos (sub_pos.mpr hr)] | |
| nlinarith | |
| theorem exists_riemannMap {U : Set β} (hU : IsOpen U) | |
| (hUc : IsSimplyConnected U) (hproper : U β univ) {a : β} (ha : a β U) : | |
| β f, NormalizedEmbedding U a f β§ f '' U = ball 0 1 := by | |
| obtain β¨f, hf, hmaxβ© := exists_extremalEmbedding hU hUc hproper ha | |
| refine β¨f, hf, Subset.antisymm (by simpa using hf.disk.image_subset) ?_β© | |
| intro b hb | |
| by_contra hmiss | |
| obtain β¨G, hG, hltβ© := improve_embedding hU hUc ha hf (mem_ball_zero_iff.mp hb) hmiss | |
| exact (not_lt_of_ge (hmax G hG)) hlt | |
| theorem inverse_hasStrictDerivAt {U : Set β} (hU : IsOpen U) | |
| {f : β β β} (hf : DifferentiableOn β f U) (hi : InjOn f U) | |
| {z : β} (hz : z β U) (hd : deriv f z β 0) : | |
| HasStrictDerivAt (Function.invFunOn f U) (deriv f z)β»ΒΉ (f z) := by | |
| apply ((hf.analyticOnNhd hU) z hz).hasStrictDerivAt.to_local_left_inverse hd | |
| filter_upwards [hU.mem_nhds hz] with w hw | |
| exact hi.leftInvOn_invFunOn hw | |
| theorem inverse_holomorphic {U : Set β} (hU : IsOpen U) | |
| {a : β} {f : β β β} (hf : NormalizedEmbedding U a f) : | |
| DifferentiableOn β (Function.invFunOn f U) (f '' U) := by | |
| rintro y β¨z, hz, rflβ© | |
| exact (inverse_hasStrictDerivAt hU hf.holomorphic hf.injective hz (hf.derivative z hz)).hasDerivAt.differentiableAt.differentiableWithinAt | |
| theorem compact_inverse_disk {U : Set β} (hU : IsOpen U) | |
| {a : β} {f : β β β} (hf : NormalizedEmbedding U a f) | |
| (hs : f '' U = ball 0 1) {r : β} (hr : r < 1) : | |
| IsCompact (Function.invFunOn f U '' closedBall 0 r) β§ | |
| Function.invFunOn f U '' closedBall 0 r β U := by | |
| have hsub : closedBall (0 : β) r β f '' U := by | |
| rw [hs] | |
| apply closedBall_subset_ball | |
| exact hr | |
| refine β¨(isCompact_closedBall (0 : β) r).image_of_continuousOn | |
| ((inverse_holomorphic hU hf).continuousOn.mono hsub), ?_β© | |
| rintro z β¨w, hw, rflβ© | |
| exact Function.invFunOn_mem (hsub hw) | |
| theorem norm_tendsto_one_boundary {U : Set β} (hU : IsOpen U) | |
| {a : β} {f : β β β} (hf : NormalizedEmbedding U a f) | |
| (hs : f '' U = ball 0 1) {p : β} (hp : p β U) : | |
| Tendsto (fun z => βf zβ) (π[U] p) (π 1) := by | |
| rw [tendsto_order] | |
| constructor | |
| Β· intro r hr | |
| have hc := compact_inverse_disk hU hf hs hr | |
| have hpn : p β Function.invFunOn f U '' closedBall 0 r := fun h => hp (hc.2 h) | |
| have he : βαΆ z in π p, z β Function.invFunOn f U '' closedBall 0 r := | |
| hc.1.isClosed.isOpen_compl.mem_nhds hpn | |
| filter_upwards [he.filter_mono nhdsWithin_le_nhds, self_mem_nhdsWithin] with z hz hzU | |
| by_contra hn | |
| apply hz | |
| refine β¨f z, ?_, hf.injective.leftInvOn_invFunOn hzUβ© | |
| simpa using le_of_not_gt hn | |
| Β· intro r hr | |
| filter_upwards [self_mem_nhdsWithin] with z hz | |
| exact (mem_ball_zero_iff.mp (hf.disk hz)).trans hr | |
| open InnerProductSpace Real | |
| end Conformal | |
| end DirectCrouzeix | |
| end | |
| end | |
| end | |
| end OAI | |