Download data/lean/OAI/Geometry/Kahler/BaseLogTests.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 8.35 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/Kahler/BaseLogTests.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/Kahler/BaseLogTests.lean
-
curl -L -o BaseLogTests.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/Kahler/BaseLogTests.lean
8.35 kB
| import OAI.Geometry.Kahler.HartogsTransferTools | |
| namespace OAI | |
| open scoped ContDiff | |
| open Complex | |
| open scoped ContDiff Matrix Matrix.Norms.Elementwise | |
| open Set Filter Topology | |
| open scoped ContDiff Matrix Matrix.Norms.Elementwise ComplexOrder | |
| noncomputable section | |
| open Set Filter Topology MeasureTheory | |
| open scoped ContDiff ComplexOrder | |
| namespace PinchedHartogs | |
| namespace BaseConstruction | |
| abbrev Sphere := Metric.sphere (0 : Base) 1 | |
| def bracket (z p : Base) : β := inner β p z | |
| def peakPolynomial (P : Finset Sphere) (k : β) (z : Base) : β := | |
| β p β P, bracket z p ^ k | |
| def regularizedLog (a Ξ΅ : β) (v : β) : β := | |
| Real.log ((β1-(a:β)*vβ^2+Ξ΅^2)/(1+Ξ΅^2)) | |
| def logarithmicTest (a Ξ΅ : β) (P : Finset Sphere) (k : β) (z : Base) : β := | |
| regularizedLog a Ξ΅ (peakPolynomial P k z) | |
| def basePotential (P : β β Finset Sphere) (a Ξ΅ L : β) (Q : β) (z : Base) : β := | |
| psi z + L * β' j : β, logarithmicTest a Ξ΅ (P (Q^(j+1))) (Q^(j+1)) z | |
| lemma bracket_analytic (p : Base) : AnalyticOnNhd β (fun z => bracket z p) univ := | |
| fun z _ => (innerSL β p).analyticAt z | |
| lemma peakPolynomial_analytic (P : Finset Sphere) (k : β) : | |
| AnalyticOnNhd β (peakPolynomial P k) univ := by | |
| intro z hz | |
| apply Finset.analyticAt_fun_sum | |
| intro p hp | |
| exact (bracket_analytic p z (mem_univ _)).pow k | |
| lemma regularizedLog_eq (a Ξ΅ : β) (v : β) (hΞ΅ : Ξ΅ β 0) : | |
| regularizedLog a Ξ΅ v = Real.log (β1-(a:β)*vβ^2+Ξ΅^2)-Real.log (1+Ξ΅^2) := by | |
| apply Real.log_div <;> positivity | |
| @[simp] lemma regularizedLog_zero (a Ξ΅ : β) : regularizedLog a Ξ΅ 0 = 0 := by | |
| simp [regularizedLog] | |
| lemma regularizedLog_contDiff (a : β) {Ξ΅ : β} (hΞ΅ : Ξ΅ β 0) : | |
| ContDiff β β (regularizedLog a Ξ΅) := by | |
| have hn : ContDiff β β (fun v : β => β1-(a:β)*vβ^2+Ξ΅^2) := | |
| ((contDiff_norm_sq β).comp (contDiff_const.sub (contDiff_const.mul contDiff_id))).add contDiff_const | |
| have hh : ContDiff β β (fun v : β => Real.log (β1-(a:β)*vβ^2+Ξ΅^2)-Real.log (1+Ξ΅^2)) := | |
| (hn.log (fun v => by positivity)).sub contDiff_const | |
| have he : regularizedLog a Ξ΅ = (fun v : β => Real.log (β1-(a:β)*vβ^2+Ξ΅^2)-Real.log (1+Ξ΅^2)) := | |
| funext (fun v => regularizedLog_eq a Ξ΅ v hΞ΅) | |
| rw [he] | |
| exact hh | |
| lemma logarithmicTest_contDiff (a : β) {Ξ΅ : β} (hΞ΅ : Ξ΅ β 0) (P : Finset Sphere) (k : β) : | |
| ContDiff β β (logarithmicTest a Ξ΅ P k) := by | |
| apply contDiff_iff_contDiffAt.mpr | |
| intro z | |
| exact (regularizedLog_contDiff a hΞ΅).contDiffAt.comp z | |
| (((peakPolynomial_analytic P k) z (mem_univ _)).contDiffAt.restrict_scalars β) | |
| lemma peakPolynomial_zero (P : Finset Sphere) {k : β} (hk : k β 0) : | |
| peakPolynomial P k 0 = 0 := by simp [peakPolynomial,bracket,hk] | |
| lemma logarithmicTest_zero (a Ξ΅ : β) (P : Finset Sphere) {k : β} (hk : k β 0) : | |
| logarithmicTest a Ξ΅ P k 0 = 0 := by simp [logarithmicTest,peakPolynomial_zero P hk] | |
| lemma peakPolynomial_homogeneous (P : Finset Sphere) (k : β) (c : β) (z : Base) : | |
| peakPolynomial P k (c β’ z) = c^k * peakPolynomial P k z := by | |
| simp only [peakPolynomial,bracket, inner_smul_right,mul_pow,Finset.mul_sum] | |
| lemma regularizedLog_lipschitz_bound (a : β) {Ξ΅ : β} (hΞ΅ : Ξ΅ β 0) {A : β} (hA : 0 β€ A) : | |
| β C : β, 0 β€ C β§ β v : β, βvβ β€ A β |regularizedLog a Ξ΅ v| β€ C*βvβ := by | |
| have hs := regularizedLog_contDiff a hΞ΅ | |
| have hc : Continuous (fderiv β (regularizedLog a Ξ΅)) := hs.continuous_fderiv (by norm_num) | |
| obtain β¨C,hCβ© := (isCompact_closedBall (0:β) A).bddAbove_image hc.norm.continuousOn | |
| refine β¨max C 0, le_max_right _ _, ?_β© | |
| intro v hv | |
| have hbound : β x β Metric.closedBall (0:β) A, βfderiv β (regularizedLog a Ξ΅) xβ β€ max C 0 := by | |
| intro x hx | |
| exact (hC (mem_image_of_mem _ hx)).trans (le_max_left _ _) | |
| have hm := (convex_closedBall (0:β) A).norm_image_sub_le_of_norm_fderiv_le | |
| (fun x _ => hs.differentiable (by norm_num) x) hbound | |
| (show (0:β) β Metric.closedBall 0 A by simpa using hA) | |
| (show v β Metric.closedBall 0 A by simpa using hv) | |
| simpa [Real.norm_eq_abs] using hm | |
| private def regularizedFiberLog (Ξ΅ : β) (q : Ambient) : β := | |
| Real.log (βq.2β^2+Ξ΅^2)-Real.log (1+Ξ΅^2) | |
| private lemma regularizedFiberLog_contDiff {Ξ΅ : β} (hΞ΅ : Ξ΅ β 0) : | |
| ContDiff β β (regularizedFiberLog Ξ΅) := by | |
| have he := sq_pos_of_ne_zero hΞ΅ | |
| have hn : ContDiff β β (fun q : Ambient => βq.2β^2+Ξ΅^2) := | |
| ((contDiff_norm_sq β).comp contDiff_snd).add contDiff_const | |
| exact (hn.log (fun q => ne_of_gt (add_pos_of_nonneg_of_pos (sq_nonneg _) he))).sub contDiff_const | |
| private lemma regularizedFiberLog_hessian {Ξ΅ : β} (hΞ΅ : Ξ΅ β 0) (q : Ambient) (i j : Fin 3) : | |
| complexHessian (regularizedFiberLog Ξ΅) q i j = | |
| ((Ξ΅^2/(βq.2β^2+Ξ΅^2)^2 : β):β) * (if i=2 then 1 else 0)*(if j=2 then 1 else 0) := by | |
| have hden : βq.2β^2+Ξ΅^2 β 0 := by positivity | |
| have hΟ : βαΆ y in π (βq.2β^2), | |
| HasDerivAt (fun s => Real.log (s+Ξ΅^2)-Real.log (1+Ξ΅^2)) ((y+Ξ΅^2)β»ΒΉ) y := by | |
| filter_upwards [(continuousAt_id.add continuousAt_const).eventually_ne hden] with y hy | |
| simpa [one_div] using (((hasDerivAt_id y).add_const (Ξ΅^2)).log hy).sub_const (Real.log (1+Ξ΅^2)) | |
| have hΟ' : HasDerivAt (fun s : β => (s+Ξ΅^2)β»ΒΉ) (-( (βq.2β^2+Ξ΅^2)^2)β»ΒΉ) (βq.2β^2) := by | |
| convert ((hasDerivAt_id (βq.2β^2)).add_const (Ξ΅^2)).inv hden using 1 <;> try rfl | |
| simp [one_div, neg_div] | |
| have hh := complexHessian_real_comp | |
| (((contDiff_norm_sq β).comp contDiff_snd).contDiffAt : ContDiffAt β 2 (fun p : Ambient => βp.2β^2) q) | |
| hΟ hΟ' i j | |
| dsimp only [Function.comp_def] at hh | |
| rw [complexHessian_fiber_norm_sq,dz_fiber_norm_sq,dbar_fiber_norm_sq] at hh | |
| change complexHessian (regularizedFiberLog Ξ΅) q i j = _ at hh | |
| rw [hh] | |
| have hn : star q.2 * q.2 = (βq.2β^2 : β) := by | |
| rw [Complex.star_def, β Complex.normSq_eq_conj_mul_self, Complex.normSq_eq_norm_sq] | |
| push_cast | |
| by_cases hi : i=2 <;> by_cases hj : j=2 <;> simp [hi,hj] | |
| rw [mul_assoc, β Complex.star_def, hn] | |
| have hd : (ββq.2β^2 + (Ξ΅:β)^2) β 0 := by exact_mod_cast hden | |
| field_simp | |
| ; push_cast; ring | |
| lemma regularizedLog_holomorphic_psh (a : β) {Ξ΅ : β} (he : Ξ΅ β 0) | |
| {f : Base β β} {z : Base} (hf : AnalyticAt β f z) (v : Base) : | |
| 0 β€ (β i, β j, baseHessian (regularizedLog a Ξ΅ β f) z i j * v i * star (v j)).re := by | |
| let F : Ambient β Ambient := fun q => (q.1,1-(a:β)*f q.1) | |
| have hF : AnalyticAt β F (z,0) := | |
| ((ContinuousLinearMap.fst β Base β).analyticAt _).prod | |
| (analyticAt_const.sub (analyticAt_const.mul (hf.comp ((ContinuousLinearMap.fst β Base β).analyticAt _)))) | |
| have hfc : ContDiffAt β 2 (regularizedLog a Ξ΅ β f) z := | |
| ((regularizedLog_contDiff a he).contDiffAt.comp z (hf.contDiffAt.restrict_scalars β)).of_le (WithTop.coe_le_coe.mpr le_top) | |
| have heq : regularizedFiberLog Ξ΅ β F = fun q : Ambient => (regularizedLog a Ξ΅ β f) q.1 := by | |
| funext q | |
| exact (regularizedLog_eq a Ξ΅ (f q.1) he).symm | |
| have hh := congrArg (fun A => (hermitianValue A (v,0) (v,0)).re) | |
| (complexHessian_pullback ((regularizedFiberLog_contDiff he).contDiffAt.of_le (WithTop.coe_le_coe.mpr le_top)) hF) | |
| rw [heq,hermitianValue_lift_base hfc,hermitianValue_pullback] at hh | |
| rw [hh] | |
| let u := fderiv β F (z,0) (v,0) | |
| change 0 β€ (hermitianValue (complexHessian (regularizedFiberLog Ξ΅) (F (z,0))) u u).re | |
| simp only [hermitianValue,regularizedFiberLog_hessian he,Fin.sum_univ_three] | |
| simp only [Fin.reduceEq,ite_false,ite_true,mul_zero,zero_mul,zero_add,add_zero] | |
| have hu : u.2*star u.2 = (βu.2β^2:β) := by | |
| rw [Complex.star_def,Complex.mul_conj,Complex.normSq_eq_norm_sq] | |
| change 0 β€ (((Ξ΅^2/(β(F (z,0)).2β^2+Ξ΅^2)^2:β):β)*1*1*u.2*star u.2).re | |
| rw [mul_one,mul_one,mul_assoc,hu] | |
| simp only [β Complex.ofReal_mul,Complex.ofReal_re] | |
| positivity | |
| lemma logarithmicTest_psh (a : β) {Ξ΅ : β} (he : Ξ΅ β 0) (P : Finset Sphere) | |
| (k : β) (z v : Base) : | |
| 0 β€ (β i, β j, baseHessian (logarithmicTest a Ξ΅ P k) z i j * v i * star (v j)).re := | |
| regularizedLog_holomorphic_psh a he (peakPolynomial_analytic P k z (mem_univ _)) v | |
| end BaseConstruction | |
| end PinchedHartogs | |
| end | |
| end OAI | |