Download data/lean/OAI/Analysis/HotSpots/ClosedChart.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 69.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/HotSpots/ClosedChart.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/HotSpots/ClosedChart.lean
-
curl -L -o ClosedChart.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/HotSpots/ClosedChart.lean
69.1 kB
import OAI.Analysis.HotSpots.Riemann
import OAI.Analysis.HotSpots.Trace
namespace OAI
section RollingBallTaylor
noncomputable section
open Set Metric Filter
open scoped Topology NNReal
namespace StrictHotSpots.Rolling
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
lemma taylor_quadratic {f : E → ℝ} {U : Set E} {K : ℝ≥0}
(hU : Convex ℝ U) (hd : ∀ x ∈ U, DifferentiableAt ℝ f x)
(hL : LipschitzOnWith K (fderiv ℝ f) U) {p x : E} (hp : p ∈ U) (hx : x ∈ U) :
‖f x-f p-fderiv ℝ f p (x-p)‖ ≤ (K:ℝ)*‖x-p‖^2 := by
have hs : segment ℝ p x ⊆ U := hU.segment_subset hp hx
have H := (convex_segment p x).norm_image_sub_le_of_norm_fderiv_le'
(fun y hy => hd y (hs hy))
(φ := fderiv ℝ f p) (C := (K:ℝ)*‖x-p‖)
(fun y hy => (hL.norm_sub_le (hs hy) hp).trans
(mul_le_mul_of_nonneg_left (norm_sub_le_of_mem_segment hy) K.coe_nonneg))
(left_mem_segment ℝ p x) (right_mem_segment ℝ p x)
simpa only [pow_two,mul_assoc] using H
lemma norm_sub_smul_sq (y n : E) (r : ℝ) :
‖y-r•n‖^2 = ‖y‖^2 - 2*r*inner ℝ y n + r^2*‖n‖^2 := by
rw [norm_sub_sq_real,real_inner_smul_right,norm_smul,Real.norm_eq_abs,
mul_pow,sq_abs]
ring
lemma tangent_ball_linear {p n x : E} {r : ℝ} (hn : ‖n‖ = 1) (hr : 0 < r)
(hx : x ∈ ball (p+r•n) r) :
‖x-p‖^2 < 2*r*inner ℝ (x-p) n := by
have hh : ‖(x-p)-r•n‖ < r := by
simpa only [mem_ball,dist_eq_norm,sub_add_eq_sub_sub] using hx
have hh2 := (sq_lt_sq₀ (norm_nonneg _) hr.le).mpr hh
rw [norm_sub_smul_sq,hn,one_pow,mul_one] at hh2
linarith
lemma balls_of_taylor {f : E → ℝ} {p n : E} {U : Set E} {a K r : ℝ}
(hn : ‖n‖ = 1) (ha : 0 < a) (hr : 0 < r)
(hsmall : 2*r*K ≤ a) (hzero : f p = 0)
(hD : ∀ v, fderiv ℝ f p v = a*inner ℝ n v)
(hB : ball p (2*r) ⊆ U)
(hT : ∀ x ∈ U, ‖f x-f p-fderiv ℝ f p (x-p)‖ ≤ K*‖x-p‖^2) :
ball (p-r•n) r ⊆ {x | f x < 0} ∧
ball (p+r•n) r ⊆ {x | 0 < f x} := by
have hside (N : E) (hN : ‖N‖ = 1) (x : E) (hx : x ∈ ball (p+r•N) r) :
x ∈ U ∧ ‖x-p‖^2 < 2*r*inner ℝ (x-p) N := by
refine ⟨hB ?_,tangent_ball_linear hN hr hx⟩
have hd : dist (p+r•N) p = r := by
simp [dist_eq_norm,norm_smul,hN,abs_of_pos hr]
calc
dist x p ≤ dist x (p+r•N)+dist (p+r•N) p := dist_triangle _ _ _
_ < r+r := add_lt_add_of_lt_of_le hx (le_of_eq hd)
_ = 2*r := by ring
constructor
· intro x hx
have hx' : x ∈ ball (p+r•(-n)) r := by simpa [smul_neg,sub_eq_add_neg] using hx
obtain ⟨hxU,hx2⟩ := hside (-n) (by simpa using hn) x hx'
rw [inner_neg_right,real_inner_comm n (x-p)] at hx2
have ht := hT x hxU
rw [hzero,sub_zero,hD,Real.norm_eq_abs] at ht
have he := (le_abs_self (f x-a*inner ℝ n (x-p))).trans ht
have hk := mul_le_mul_of_nonneg_right hsmall (sq_nonneg ‖x-p‖)
have hstrict := mul_lt_mul_of_pos_left hx2 ha
have hmul := mul_le_mul_of_nonneg_left he (mul_pos (by norm_num : (0:ℝ)<2) hr).le
change f x < 0
nlinarith only [hmul,hstrict,hk,hr]
· intro x hx
obtain ⟨hxU,hx2⟩ := hside n hn x hx
rw [real_inner_comm n (x-p)] at hx2
have ht := hT x hxU
rw [hzero,sub_zero,hD,Real.norm_eq_abs] at ht
have he' : -(K*‖x-p‖^2) ≤ f x-a*inner ℝ n (x-p) := by
have hh := neg_abs_le (f x-a*inner ℝ n (x-p))
linarith [ht]
have hk := mul_le_mul_of_nonneg_right hsmall (sq_nonneg ‖x-p‖)
have hstrict := mul_lt_mul_of_pos_left hx2 ha
have hmul := mul_le_mul_of_nonneg_left he' (mul_pos (by norm_num : (0:ℝ)<2) hr).le
change 0 < f x
nlinarith only [hmul,hstrict,hk,hr]
end StrictHotSpots.Rolling
end
end RollingBallTaylor
section RollingBallMetric
noncomputable section
open Set Metric Filter
open scoped Topology
namespace StrictHotSpots.Rolling
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
lemma tangent_ball_mono {p n : E} {s r : ℝ} (hn : ‖n‖ = 1)
(hsr : s ≤ r) : ball (p+s•n) s ⊆ ball (p+r•n) r := by
intro x hx
have hd : dist (p+s•n) (p+r•n) = r-s := by
rw [dist_eq_norm,show (p+s•n)-(p+r•n) = (s-r)•n by module,norm_smul,hn,mul_one,
Real.norm_eq_abs,abs_of_nonpos (sub_nonpos.mpr hsr)]
ring
calc
dist x (p+r•n) ≤ dist x (p+s•n)+dist (p+s•n) (p+r•n) := dist_triangle _ _ _
_ < s+(r-s) := add_lt_add_of_lt_of_le hx (le_of_eq hd)
_ = r := by ring
lemma nearest_normal_of_balls {Ω : Set E} {x p n : E} {r : ℝ}
(hn : ‖n‖ = 1) (hr : 0 < r) (hxp : x ≠ p)
(hin : ball x (dist x p) ⊆ Ω)
(hout : ball (p+r•n) r ⊆ Ωᶜ) : x = p-dist x p • n := by
let δ := dist x p
have hδ : 0 < δ := dist_pos.mpr hxp
have hdisj : Disjoint (ball x δ) (ball (p+r•n) r) := by
refine disjoint_left.mpr (fun y hy₁ hy₂ => ?_)
exact hout hy₂ (hin hy₁)
have hd : δ+r ≤ ‖(x-p)-r•n‖ := by
simpa only [dist_eq_norm,sub_add_eq_sub_sub] using
(disjoint_ball_ball_iff hδ hr).mp hdisj
have hnorm : ‖x-p‖ = δ := (dist_eq_norm _ _).symm
have hd2 := (sq_le_sq₀ (by positivity : 0 ≤ δ+r) (norm_nonneg _)).mpr hd
rw [norm_sub_smul_sq,hn,one_pow,mul_one,hnorm] at hd2
have hi : inner ℝ (x-p) n ≤ -δ := by nlinarith only [hd2,hr]
have hi' := mul_le_mul_of_nonneg_left hi hδ.le
have he : ‖(x-p)+δ•n‖^2 = 0 := by
have hnn := sq_nonneg ‖(x-p)+δ•n‖
rw [norm_add_sq_real,hnorm,real_inner_smul_right,norm_smul,
Real.norm_eq_abs,abs_of_pos hδ,hn,mul_one] at hnn ⊢
nlinarith only [hi',hnn]
have hz : (x-p)+δ•n = 0 := norm_eq_zero.mp (sq_eq_zero_iff.mp he)
dsimp [δ] at hz
calc
x = (x-p)+p := by abel
_ = -(dist x p•n)+p := congrArg (fun a => a+p) (eq_neg_of_add_eq_zero_left hz)
_ = p-dist x p•n := by abel
lemma near_interior_ball {Ω : Set E} {x p n : E} {r : ℝ}
(hn : ‖n‖ = 1) (hr : 0 < r) (hxp : x ≠ p)
(hin : ball x (dist x p) ⊆ Ω) (hout : ball (p+r•n) r ⊆ Ωᶜ)
(hnear : dist x p < r) :
dist x (p-r•n) = r-dist x p ∧ x ∈ ball (p-r•n) r := by
have he := nearest_normal_of_balls hn hr hxp hin hout
have heq : x-(p-r•n) = (r-dist x p) • n := by
calc
_ = (p-dist x p•n)-(p-r•n) := congrArg (fun a => a-(p-r•n)) he
_ = _ := by module
have hd : dist x (p-r•n) = r-dist x p := by
rw [dist_eq_norm,heq,norm_smul,hn,mul_one,Real.norm_eq_abs,
abs_of_pos (sub_pos.mpr hnear)]
refine ⟨hd,?_⟩
change dist x (p-r•n) < r
rw [hd]
linarith [dist_pos.mpr hxp]
end StrictHotSpots.Rolling
end
end RollingBallMetric
section RollingBallNormals
noncomputable section
open Set Metric
open scoped Topology
namespace StrictHotSpots.Rolling
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
lemma normals_bound {U : Set E} {p q n m : E} {r : ℝ} (hr : 0 < r)
(hn : ‖n‖ = 1) (hm : ‖m‖ = 1)
(hip : ball (p-r•n) r ⊆ U) (hop : ball (p+r•n) r ⊆ Uᶜ)
(hiq : ball (q-r•m) r ⊆ U) (hoq : ball (q+r•m) r ⊆ Uᶜ) :
r*‖n-m‖ ≤ dist p q := by
have hd₁ : Disjoint (ball (p-r•n) r) (ball (q+r•m) r) :=
disjoint_left.mpr (fun x h₁ h₂ => hoq h₂ (hip h₁))
have hd₂ : Disjoint (ball (p+r•n) r) (ball (q-r•m) r) :=
disjoint_left.mpr (fun x h₁ h₂ => hop h₁ (hiq h₂))
have h₁ : 2*r ≤ ‖(p-q)-r•(n+m)‖ := by
have h := (disjoint_ball_ball_iff hr hr).mp hd₁
simpa only [dist_eq_norm,show (p-r•n)-(q+r•m)=(p-q)-r•(n+m) by module,two_mul] using h
have h₂ : 2*r ≤ ‖(p-q)+r•(n+m)‖ := by
have h := (disjoint_ball_ball_iff hr hr).mp hd₂
simpa only [dist_eq_norm,show (p+r•n)-(q-r•m)=(p-q)+r•(n+m) by module,two_mul] using h
have h₁sq := (sq_le_sq₀ (by positivity : 0 ≤ 2*r) (norm_nonneg _)).mpr h₁
have h₂sq := (sq_le_sq₀ (by positivity : 0 ≤ 2*r) (norm_nonneg _)).mpr h₂
have hp := parallelogram_law_with_norm ℝ (p-q) (r•(n+m))
have hn' := parallelogram_law_with_norm ℝ n m
rw [norm_smul,Real.norm_eq_abs,abs_of_pos hr] at hp
rw [hn,hm] at hn'
have hsq : (r*‖n-m‖)^2 ≤ ‖p-q‖^2 := by
nlinarith only [h₁sq,h₂sq,hp,hn',sq_nonneg r]
rw [dist_eq_norm]
exact (sq_le_sq₀ (by positivity) (norm_nonneg _)).mp hsq
lemma interior_centers_bound {U : Set E} {p q n m : E} {r : ℝ} (hr : 0 < r)
(hn : ‖n‖ = 1) (hm : ‖m‖ = 1)
(hip : ball (p-r•n) r ⊆ U) (hop : ball (p+r•n) r ⊆ Uᶜ)
(hiq : ball (q-r•m) r ⊆ U) (hoq : ball (q+r•m) r ⊆ Uᶜ) :
dist (p-r•n) (q-r•m) ≤ 2*dist p q := by
have H := normals_bound hr hn hm hip hop hiq hoq
rw [dist_eq_norm,show (p-r•n)-(q-r•m)=(p-q)-r•(n-m) by module]
calc
_ ≤ ‖p-q‖+‖r•(n-m)‖ := norm_sub_le _ _
_ = dist p q+r*‖n-m‖ := by rw [norm_smul,Real.norm_eq_abs,abs_of_pos hr,dist_eq_norm]
_ ≤ 2*dist p q := by linarith
end StrictHotSpots.Rolling
end
end RollingBallNormals
section RiemannBoundaryCompatible
noncomputable section
section SmoothBoundaryGeometryCompatibleLayer
open Set Filter Metric
open scoped Topology ContDiff
namespace StrictHotSpots
lemma HasFDerivAt.eventually_lt_along_ray {f : Plane → ℝ} {D : Plane →L[ℝ] ℝ}
{p v : Plane} (hf : HasFDerivAt f D p) (hv : D v < 0) :
∀ᶠ t in 𝓝[>] (0 : ℝ), f (p + t • v) < f p := by
have hl : HasDerivAt (fun t : ℝ => p + t • v) v 0 := by
simpa using ((hasDerivAt_id (0 : ℝ)).smul_const v).const_add p
have hh : HasDerivAt (fun t : ℝ => f (p + t • v)) (D v) 0 := by
exact (show HasFDerivAt f D (p + (0 : ℝ) • v) by simpa using hf).comp_hasDerivAt 0 hl
have ht := (HasDerivAt.tendsto_slope_zero_right hh).eventually (gt_mem_nhds hv)
filter_upwards [ht,self_mem_nhdsWithin] with t ht htp
simp only [zero_add,zero_smul,add_zero,smul_eq_mul,inv_mul_eq_div] at ht
have hh : f (p + t • v) - f p < 0 := by
have := (div_lt_iff₀ htp).mp ht
simpa only [zero_mul] using this
exact sub_neg.mp hh
lemma regular_level_uniqueDiffWithinAt {Ω U : Set Plane} {ρ : Plane → ℝ} {p : Plane}
(hU : IsOpen U) (hpU : p ∈ U) (hρ : DifferentiableAt ℝ ρ p)
(hD : fderiv ℝ ρ p ≠ 0) (hp : ρ p = 0)
(hlevel : Ω ∩ U = {x | ρ x < 0} ∩ U) (hpcl : p ∈ closure Ω) :
UniqueDiffWithinAt ℝ (closure Ω) p := by
have hopen : IsOpen {v : Plane | fderiv ℝ ρ p v < 0} :=
isOpen_lt (fderiv ℝ ρ p).continuous continuous_const
have hne : {v : Plane | fderiv ℝ ρ p v < 0}.Nonempty := by
have hn : ∃ v, fderiv ℝ ρ p v ≠ 0 := by
by_contra hh
apply hD
ext v
simpa using not_exists.mp hh v
obtain ⟨v,hv⟩ := hn
rcases lt_or_gt_of_ne hv with hv | hv
· exact ⟨v,hv⟩
· refine ⟨-v,?_⟩
change fderiv ℝ ρ p (-v) < 0
rw [map_neg]
linarith
have hsub : {v : Plane | fderiv ℝ ρ p v < 0} ⊆ tangentConeAt ℝ Ω p := by
intro v hv
apply mem_tangentConeAt_of_add_smul_mem (c := fun t : ℝ => t)
(tendsto_id'.mpr (nhdsGT_le_nhdsNE (0 : ℝ)))
have ht : Tendsto (fun t : ℝ => p + t • v) (𝓝[>] 0) (𝓝 p) := by
simpa using tendsto_const_nhds.add ((tendsto_id'.mpr (nhdsWithin_le_nhds : 𝓝[>] (0 : ℝ) ≤ 𝓝 0)).smul_const v)
filter_upwards [HasFDerivAt.eventually_lt_along_ray hρ.hasFDerivAt hv,ht (hU.mem_nhds hpU)] with t hneg htU
have hh : p + t • v ∈ {x | ρ x < 0} ∩ U := ⟨by change ρ (p + t • v) < 0; simpa only [hp] using hneg,htU⟩
rw [← hlevel] at hh
exact hh.1
have hspan : Submodule.span ℝ (tangentConeAt ℝ Ω p) = ⊤ := by
apply Submodule.eq_top_of_nonempty_interior'
obtain ⟨v,hv⟩ := hne
refine ⟨v,?_⟩
exact interior_mono (hsub.trans Submodule.subset_span) (hopen.interior_eq.symm ▸ hv)
rw [uniqueDiffWithinAt_iff,tangentConeAt_closure,hspan]
exact ⟨by simp,subset_closure hpcl⟩
lemma SmoothBoundary.uniqueDiffOn_closure {Ω : Set Plane} (hs : SmoothBoundary Ω)
(hΩ : IsOpen Ω) : UniqueDiffOn ℝ (closure Ω) := by
intro p hp
by_cases hpi : p ∈ Ω
· exact (hΩ.uniqueDiffOn p hpi).mono subset_closure
· have hpf : p ∈ frontier Ω := ⟨hp,by simpa only [hΩ.interior_eq] using hpi⟩
obtain ⟨U,ρ,hU,hpU,hρ,hD,hpρ,hlevel⟩ := hs p hpf
exact regular_level_uniqueDiffWithinAt hU hpU
((hρ p hpU).contDiffAt (hU.mem_nhds hpU) |>.differentiableAt (by simp))
hD hpρ hlevel hp
lemma SmoothBoundary.exterior_ball_in_neighborhood {Ω B : Set Plane}
(hs : SmoothBoundary Ω) {p : Plane} (hp : p ∈ frontier Ω)
(hB : IsOpen B) (hpB : p ∈ B) :
∃ a ∈ B, ∃ ε > 0, ball a ε ⊆ Ωᶜ := by
obtain ⟨U,ρ,hU,hpU,hρ,hD,hpρ,hlevel⟩ := hs p hp
have hdρ : DifferentiableAt ℝ ρ p :=
((hρ p hpU).contDiffAt (hU.mem_nhds hpU)).differentiableAt (by simp)
obtain ⟨v,hv⟩ : ∃ v, 0 < fderiv ℝ ρ p v := by
have hn : ∃ v, fderiv ℝ ρ p v ≠ 0 := by
by_contra hh
apply hD
ext v
simpa using not_exists.mp hh v
obtain ⟨v,hv⟩ := hn
rcases lt_or_gt_of_ne hv with hv | hv
· exact ⟨-v,by rw [map_neg]; linarith⟩
· exact ⟨v,hv⟩
have hray := HasFDerivAt.eventually_lt_along_ray hdρ.hasFDerivAt.neg
(show (-fderiv ℝ ρ p) v < 0 by simpa using hv)
have ht : Tendsto (fun t : ℝ => p + t • v) (𝓝[>] 0) (𝓝 p) := by
simpa using tendsto_const_nhds.add ((tendsto_id'.mpr
(nhdsWithin_le_nhds : 𝓝[>] (0 : ℝ) ≤ 𝓝 0)).smul_const v)
have hbt : ∀ᶠ t in 𝓝[>] (0 : ℝ), p+t•v ∈ B := ht (hB.mem_nhds hpB)
have hut : ∀ᶠ t in 𝓝[>] (0 : ℝ), p+t•v ∈ U := ht (hU.mem_nhds hpU)
obtain ⟨t,htρ,htB,htU⟩ := (hray.and (hbt.and hut)).exists
have htpos : 0 < ρ (p+t•v) := by simpa only [Pi.neg_apply,hpρ,neg_zero,neg_lt_zero] using htρ
have hopen : IsOpen (U ∩ {x | 0 < ρ x}) :=
hρ.continuousOn.isOpen_inter_preimage hU isOpen_Ioi
obtain ⟨ε,hε,hεS⟩ := Metric.isOpen_iff.mp hopen (p+t•v) ⟨htU,htpos⟩
refine ⟨p+t•v,htB,ε,hε,?_⟩
intro y hy hyΩ
have hyS := hεS hy
have hy' : y ∈ Ω ∩ U := ⟨hyΩ,hyS.1⟩
rw [hlevel] at hy'
exact lt_asymm (show ρ y < 0 from hy'.1) (show 0 < ρ y from hyS.2)
end StrictHotSpots
end SmoothBoundaryGeometryCompatibleLayer
section SmoothRollingBallsCompatibleLayer
open Set Metric Filter
open scoped Topology ContDiff NNReal
namespace StrictHotSpots
lemma boundary_level_zero {Ω U : Set Plane} {ρ : Plane → ℝ} {q : Plane}
(ho : IsOpen Ω) (hU : IsOpen U) (hq : q ∈ frontier Ω) (hqU : q ∈ U)
(hc : ContinuousAt ρ q) (hlevel : Ω ∩ U = {x | ρ x < 0} ∩ U) : ρ q = 0 := by
have hnonneg : 0 ≤ ρ q := by
by_contra hh
have hmem : q ∈ Ω ∩ U := hlevel ▸ ⟨lt_of_not_ge hh,hqU⟩
exact hq.2 (ho.interior_eq.symm ▸ hmem.1)
apply le_antisymm _ hnonneg
by_contra hh
have hp : 0 < ρ q := lt_of_not_ge hh
have hnh : U ∩ ρ ⁻¹' Ioi 0 ∈ 𝓝 q :=
inter_mem (hU.mem_nhds hqU) (hc.preimage_mem_nhds (Ioi_mem_nhds hp))
obtain ⟨x,⟨hxU,hxρ⟩,hxΩ⟩ := mem_closure_iff_nhds.mp hq.1 _ hnh
have hx : x ∈ {x | ρ x < 0} ∩ U := hlevel ▸ ⟨hxΩ,hxU⟩
exact lt_asymm (show ρ x < 0 from hx.1) (show 0 < ρ x from hxρ)
lemma SmoothBoundary.local_rolling_balls {Ω : Set Plane} (hs : SmoothBoundary Ω)
(ho : IsOpen Ω) {p : Plane} (hp : p ∈ frontier Ω) :
∃ (V : Set Plane), IsOpen V ∧ p ∈ V ∧ ∃ r > 0,
∀ q ∈ frontier Ω ∩ V, ∃ n : Plane, ‖n‖ = 1 ∧
ball (q-r•n) r ⊆ Ω ∧ ball (q+r•n) r ⊆ Ωᶜ := by
obtain ⟨U,ρ,hU,hpU,hρ,hD,hpρ,hlevel⟩ := hs p hp
have hc : ContDiffAt ℝ ∞ ρ p := (hρ p hpU).contDiffAt (hU.mem_nhds hpU)
have hdc : ContDiffAt ℝ 1 (fderiv ℝ ρ) p := hc.fderiv_right (by exact WithTop.coe_le_coe.mpr le_top)
obtain ⟨K,A,hA,hL⟩ := hdc.exists_lipschitzOnWith
let a : ℝ := ‖fderiv ℝ ρ p‖/2
have ha : 0 < a := half_pos (norm_pos_iff.mpr hD)
have han : a < ‖fderiv ℝ ρ p‖ := by dsimp [a]; linarith [norm_pos_iff.mpr hD]
have hAn : {x | a < ‖fderiv ℝ ρ x‖} ∈ 𝓝 p :=
hdc.continuousAt.norm.preimage_mem_nhds (Ioi_mem_nhds han)
obtain ⟨R,hR,hsub⟩ := Metric.mem_nhds_iff.mp
(inter_mem (hU.mem_nhds hpU) (inter_mem hA hAn))
let r : ℝ := min (R/8) (a/(4*((K:ℝ)+1)))
have hr : 0 < r := lt_min (by positivity) (by positivity)
have hrR : 2*r ≤ R/4 := by have := min_le_left (R/8) (a/(4*((K:ℝ)+1))); dsimp [r]; linarith
have hrK : 2*r*(K:ℝ) ≤ a := by
have hh : r ≤ a/(4*((K:ℝ)+1)) := min_le_right _ _
have hc' : 0 < 4*((K:ℝ)+1) := by positivity
have hh' := (le_div_iff₀ hc').mp hh
nlinarith [K.coe_nonneg]
refine ⟨ball p (R/4),isOpen_ball,mem_ball_self (by positivity),r,hr,?_⟩
intro q hq
have hqR : q ∈ ball p R := ball_subset_ball (by linarith : R/4 ≤ R) hq.2
have hqU := (hsub hqR).1
have hqρ : ρ q = 0 := boundary_level_zero ho hU hq.1 hqU
((hρ q hqU).contDiffAt (hU.mem_nhds hqU)).continuousAt hlevel
let g := gradient ρ q
have hg : ‖g‖ = ‖fderiv ℝ ρ q‖ := by simp [g,gradient]
have hga : a < ‖g‖ := by rw [hg]; exact (hsub hqR).2.2
have hgpos : 0 < ‖g‖ := ha.trans hga
let n : Plane := ‖g‖⁻¹ • g
have hn : ‖n‖ = 1 := by simp [n,norm_smul,ne_of_gt hgpos]
have hDq (v : Plane) : fderiv ℝ ρ q v = ‖g‖*inner ℝ n v := by
rw [show n = ‖g‖⁻¹ • g from rfl,real_inner_smul_left,
← mul_assoc,mul_inv_cancel₀ hgpos.ne',one_mul]
exact inner_gradient_left.symm
have hball : ball q (2*r) ⊆ ball p R := by
intro x hx
calc
dist x p ≤ dist x q + dist q p := dist_triangle _ _ _
_ < 2*r+R/4 := add_lt_add hx hq.2
_ < R := by linarith
have hT (x : Plane) (hx : x ∈ ball p R) :
‖ρ x-ρ q-fderiv ℝ ρ q (x-q)‖ ≤ (K:ℝ)*‖x-q‖^2 :=
Rolling.taylor_quadratic (convex_ball p R)
(fun y hy => ((hρ y (hsub hy).1).contDiffAt
(hU.mem_nhds (hsub hy).1)).differentiableAt (by simp))
(hL.mono (fun _ hy => (hsub hy).2.1)) hqR hx
obtain ⟨hin,hout⟩ := Rolling.balls_of_taylor hn hgpos hr
(hrK.trans hga.le) hqρ hDq hball hT
refine ⟨n,hn,?_,?_⟩
· intro x hx
have hxR : x ∈ ball p R := hball (by
have hh : dist x q < 2*r := by
have hd : dist (q-r•n) q = r := by
simp [norm_smul,hn,abs_of_pos hr]
calc
dist x q ≤ dist x (q-r•n)+dist (q-r•n) q := dist_triangle _ _ _
_ < r+r := add_lt_add_of_lt_of_le hx (le_of_eq hd)
_ = 2*r := by ring
exact hh)
have hh : x ∈ Ω ∩ U := hlevel ▸ ⟨hin hx,(hsub hxR).1⟩
exact hh.1
· intro x hx hxΩ
have hxU : x ∈ U := (hsub (hball (by
have hd : dist (q+r•n) q = r := by
simp [dist_eq_norm,norm_smul,hn,abs_of_pos hr]
calc
dist x q ≤ dist x (q+r•n)+dist (q+r•n) q := dist_triangle _ _ _
_ < r+r := add_lt_add_of_lt_of_le hx (le_of_eq hd)
_ = 2*r := by ring))).1
have hh : x ∈ {x | ρ x < 0} ∩ U := hlevel ▸ ⟨hxΩ,hxU⟩
exact lt_asymm (show 0 < ρ x from hout hx) (show ρ x < 0 from hh.1)
end StrictHotSpots
end SmoothRollingBallsCompatibleLayer
section UniformRollingBallsCompatibleLayer
open Set Metric Filter
open scoped Topology
namespace StrictHotSpots
lemma finite_positive_lower {α : Type*} (s : Finset α) (f : α → ℝ)
(hf : ∀ a ∈ s, 0 < f a) : ∃ r > 0, ∀ a ∈ s, r ≤ f a := by
classical
induction s using Finset.induction_on with
| empty => exact ⟨1,by norm_num,by simp⟩
| @insert a s hmem ih =>
obtain ⟨r,hr,hR⟩ := ih (fun b hb => hf b (Finset.mem_insert_of_mem hb))
refine ⟨min r (f a),lt_min hr (hf a (Finset.mem_insert_self _ _)),?_⟩
intro b hb
rcases Finset.mem_insert.mp hb with rfl | hb
· exact min_le_right _ _
· exact (min_le_left _ _).trans (hR b hb)
theorem SmoothBoundary.uniform_rolling_balls {Ω : Set Plane} (hs : SmoothBoundary Ω)
(ho : IsOpen Ω) (hb : Bornology.IsBounded Ω) :
∃ r > 0, ∀ p ∈ frontier Ω, ∃ n : Plane, ‖n‖ = 1 ∧
ball (p-r•n) r ⊆ Ω ∧ ball (p+r•n) r ⊆ Ωᶜ := by
classical
have hlocal (p : frontier Ω) := hs.local_rolling_balls ho p.property
choose V hVo hpV r hr hballs using hlocal
have hc : IsCompact (frontier Ω) :=
hb.isCompact_closure.of_isClosed_subset isClosed_frontier frontier_subset_closure
have hcover : frontier Ω ⊆ ⋃ p : frontier Ω, V p := by
intro p hp
exact mem_iUnion.mpr ⟨⟨p,hp⟩,hpV ⟨p,hp⟩⟩
obtain ⟨s,hcov⟩ := hc.elim_finite_subcover V hVo hcover
obtain ⟨R,hR,hRs⟩ := finite_positive_lower s r (fun p _ => hr p)
refine ⟨R,hR,?_⟩
intro p hp
obtain ⟨q,hq⟩ := mem_iUnion.mp (hcov hp)
obtain ⟨hqs,hpV⟩ := mem_iUnion.mp hq
obtain ⟨n,hn,hin,hout⟩ := hballs q p ⟨hp,hpV⟩
refine ⟨n,hn,?_,?_⟩
· have hmono := Rolling.tangent_ball_mono (p := p) (n := -n)
(by simpa only [norm_neg] using hn) (hRs q hqs)
have hmono' : ball (p-R•n) R ⊆ ball (p-r q•n) (r q) := by
simpa only [smul_neg,← sub_eq_add_neg] using hmono
exact hmono'.trans hin
· exact (Rolling.tangent_ball_mono hn (hRs q hqs)).trans hout
end StrictHotSpots
end UniformRollingBallsCompatibleLayer
section RiemannBoundaryGeometryCompatibleLayer
open Set Metric Filter
open scoped Topology
namespace StrictHotSpots
theorem SmoothBoundary.complex_rolling_balls {Ω : Set Plane} (hs : SmoothBoundary Ω)
(ho : IsOpen Ω) (hb : Bornology.IsBounded Ω) :
∃ r > 0, ∀ p ∈ frontier (Conformal.coordinate ⁻¹' Ω), ∃ n : ℂ, ‖n‖ = 1 ∧
ball (p-r•n) r ⊆ Conformal.coordinate ⁻¹' Ω ∧
ball (p+r•n) r ⊆ (Conformal.coordinate ⁻¹' Ω)ᶜ := by
obtain ⟨r,hr,hR⟩ := hs.uniform_rolling_balls ho hb
refine ⟨r,hr,?_⟩
intro p hp
have hp' : Conformal.coordinate p ∈ frontier Ω := by
change p ∈ Conformal.coordinate.toHomeomorph ⁻¹' frontier Ω
rw [Conformal.coordinate.toHomeomorph.preimage_frontier]
exact hp
obtain ⟨n,hn,hin,hout⟩ := hR _ hp'
refine ⟨Conformal.coordinate.symm n,by simpa using hn,?_,?_⟩
· intro x hx
apply hin
simpa only [mem_ball,← Conformal.coordinate.dist_map x (p-r•Conformal.coordinate.symm n),
map_sub,map_smul,LinearIsometryEquiv.apply_symm_apply] using hx
· intro x hx
apply hout
simpa only [mem_ball,← Conformal.coordinate.dist_map x (p+r•Conformal.coordinate.symm n),
map_add,map_smul,LinearIsometryEquiv.apply_symm_apply] using hx
namespace Riemann
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [ProperSpace E]
omit [NormedSpace ℝ E] [ProperSpace E] in
lemma boundary_distance_pos {U : Set E} (ho : IsOpen U) (hc : Uᶜ.Nonempty)
{x : E} (hx : x ∈ U) : 0 < infDist x Uᶜ := by
apply (infDist_pos_iff_notMem_closure hc).mp
rwa [ho.isClosed_compl.closure_eq,mem_compl_iff,not_not]
lemma nearest_frontier {U : Set E} (ho : IsOpen U) (hc : Uᶜ.Nonempty)
{x : E} (hx : x ∈ U) :
∃ p ∈ frontier U, dist x p = infDist x Uᶜ ∧ x ≠ p ∧
ball x (dist x p) ⊆ U := by
obtain ⟨p,hp,he⟩ := ho.isClosed_compl.exists_infDist_eq_dist hc x
have hδ := boundary_distance_pos ho hc hx
have hball : ball x (dist x p) ⊆ U := by
rw [← he]
exact ball_infDist_compl_subset
have hpcl : p ∈ closure U := by
have hpc : p ∈ closedBall x (dist x p) := by simp [dist_comm]
rw [← closure_ball x (by linarith : dist x p ≠ 0)] at hpc
exact closure_mono hball hpc
refine ⟨p,?_,he.symm,?_,hball⟩
· rw [frontier_eq_closure_inter_closure,ho.isClosed_compl.closure_eq]
exact ⟨hpcl,hp⟩
· exact dist_ne_zero.mp (by linarith)
omit [NormedSpace ℝ E] in
lemma compact_core {U : Set E} (hb : Bornology.IsBounded U) {r : ℝ} (hr : 0 < r) :
IsCompact {x | x ∈ closure U ∧ r ≤ infDist x Uᶜ} ∧
{x | x ∈ closure U ∧ r ≤ infDist x Uᶜ} ⊆ U := by
have hclosed : IsClosed {x : E | r ≤ infDist x Uᶜ} :=
isClosed_le continuous_const (continuous_infDist_pt Uᶜ)
refine ⟨hb.isCompact_closure.inter_right hclosed,?_⟩
intro x hx
by_contra hnot
have hz : infDist x Uᶜ = 0 := infDist_zero_of_mem hnot
linarith [hx.2]
end Riemann
end StrictHotSpots
end RiemannBoundaryGeometryCompatibleLayer
section RiemannBoundaryDistanceCompatibleLayer
open Set Metric Filter
open scoped Topology
namespace StrictHotSpots.Riemann
lemma compact_disk_separation {U K : Set ℂ} (hK : IsCompact K) (hKU : K ⊆ U)
{f : ℂ → ℂ} (hf : ContinuousOn f U) (hm : MapsTo f U (ball 0 1)) :
∃ m : ℝ, 0 ≤ m ∧ m < 1 ∧ ∀ x ∈ K, ‖f x‖ ≤ m := by
rcases K.eq_empty_or_nonempty with rfl | hne
· exact ⟨0,le_rfl,by norm_num,by simp⟩
obtain ⟨a,ha,hmax⟩ := hK.exists_isMaxOn hne (hf.norm.mono hKU)
exact ⟨‖f a‖,norm_nonneg _,mem_ball_zero_iff.mp (hm (hKU ha)),hmax⟩
lemma core_of_ball_subset {U : Set ℂ} (hc : Uᶜ.Nonempty) {c : ℂ} {r : ℝ}
(hr : 0 < r) (hin : ball c r ⊆ U) :
c ∈ {x | x ∈ closure U ∧ r ≤ infDist x Uᶜ} := by
refine ⟨subset_closure (hin (mem_ball_self hr)),(le_infDist hc).mpr ?_⟩
intro y hy
by_contra h
exact hy (hin (by simpa only [mem_ball,dist_comm] using lt_of_not_ge h))
theorem domain_distance_le_disk_distance {U : Set ℂ} (ho : IsOpen U)
(hb : Bornology.IsBounded U) (hc : Uᶜ.Nonempty)
{r : ℝ} (hr : 0 < r)
(hroll : ∀ p ∈ frontier U, ∃ n : ℂ, ‖n‖ = 1 ∧
ball (p-r•n) r ⊆ U ∧ ball (p+r•n) r ⊆ Uᶜ)
{f : ℂ → ℂ} (hd : DifferentiableOn ℂ f U) (hm : MapsTo f U (ball 0 1)) :
∃ C > 0, ∀ x ∈ U, infDist x Uᶜ ≤ C*(1-‖f x‖) := by
let K : Set ℂ := {x | x ∈ closure U ∧ r ≤ infDist x Uᶜ}
have hK := compact_core hb hr
obtain ⟨m,hm0,hm1,hfm⟩ := compact_disk_separation hK.1 hK.2 hd.continuousOn hm
obtain ⟨M,hM⟩ := (hb.isCompact_closure.image (continuous_infDist_pt Uᶜ)).bddAbove
let C := max (2*r/(1-m)^2) ((|M|+1)/(1-m))
have hp : 0 < 1-m := sub_pos.mpr hm1
have hpp : 0 < (1-m)^2 := sq_pos_of_pos hp
have hC : 0 < C := lt_of_lt_of_le (by positivity : 0 < 2*r/(1-m)^2) (le_max_left _ _)
refine ⟨C,hC,?_⟩
intro x hx
have hfx : 0 < 1-‖f x‖ := sub_pos.mpr (mem_ball_zero_iff.mp (hm hx))
by_cases hnear : infDist x Uᶜ < r
· obtain ⟨p,hpfr,hpd,hxp,hball⟩ := nearest_frontier ho hc hx
obtain ⟨n,hn,hin,hout⟩ := hroll p hpfr
obtain ⟨hdist,hxin⟩ := Rolling.near_interior_ball hn hr hxp hball hout (by rwa [hpd])
have hcenter : p-r•n ∈ K := core_of_ball_subset hc hr hin
have hh := disk_distance_from_interior_ball (hd.mono hin) (hm.mono_left hin)
hxin hm1 (hfm _ hcenter)
rw [hdist] at hh
have hh' : infDist x Uᶜ ≤ (2*r/(1-m)^2)*(1-‖f x‖) := by
rw [div_mul_eq_mul_div]
apply (le_div_iff₀ hpp).mpr
nlinarith only [hh,hpd]
exact hh'.trans (mul_le_mul_of_nonneg_right (le_max_left _ _) hfx.le)
· have hxK : x ∈ K := ⟨subset_closure hx,le_of_not_gt hnear⟩
have hnorm := hfm x hxK
have hxm : infDist x Uᶜ ≤ M := hM ⟨x,subset_closure hx,rfl⟩
have hxm' : infDist x Uᶜ ≤ |M|+1 := hxm.trans (by linarith [le_abs_self M])
have hh : infDist x Uᶜ ≤ ((|M|+1)/(1-m))*(1-‖f x‖) := by
calc
_ ≤ |M|+1 := hxm'
_ = ((|M|+1)/(1-m))*(1-m) := by field_simp
_ ≤ _ := mul_le_mul_of_nonneg_left (by linarith) (by positivity)
exact hh.trans (mul_le_mul_of_nonneg_right (le_max_right _ _) hfx.le)
end StrictHotSpots.Riemann
end RiemannBoundaryDistanceCompatibleLayer
section RiemannDerivativeBoundCompatibleLayer
open Set Metric Filter _root_.Complex _root_.OAI.Complex
open scoped Topology
namespace StrictHotSpots.Riemann
lemma exterior_ball_distance {U : Set ℂ} (ho : IsOpen U) (hc : Uᶜ.Nonempty)
{r : ℝ} (hr : 0 < r) {b y : ℂ} (hout : ball b r ⊆ Uᶜ) (hy : y ∈ U) :
r+infDist y Uᶜ ≤ dist y b := by
have hδ := boundary_distance_pos ho hc hy
have hdisj : Disjoint (ball y (infDist y Uᶜ)) (ball b r) := by
refine disjoint_left.mpr (fun a ha ha' => ?_)
exact hout ha' (ball_infDist_compl_subset ha)
simpa only [add_comm] using (disjoint_ball_ball_iff hδ hr).mp hdisj
theorem schwarz_exterior_ball {F : ℂ → ℂ} (hd : DifferentiableOn ℂ F (ball 0 1))
{b : ℂ} {r : ℝ} (hr : 0 < r)
(hout : ∀ z ∈ ball (0:ℂ) 1, r < dist (F z) b)
{z : ℂ} (hz : z ∈ ball (0:ℂ) 1) :
r*‖deriv F z‖*(1-‖z‖^2) ≤ dist (F z) b ^2-r^2 := by
let f : ℂ → ℂ := fun w => (r:ℂ)/(F w-b)
have hne (w : ℂ) (hw : w ∈ ball (0:ℂ) 1) : F w-b ≠ 0 := by
apply norm_ne_zero_iff.mp
have hh := hout w hw
rw [dist_eq_norm] at hh
linarith
have hf (w : ℂ) (hw : w ∈ ball (0:ℂ) 1) :
HasDerivAt f (-(r:ℂ)*deriv F w/(F w-b)^2) w := by
simpa only [f,zero_mul,zero_sub,neg_mul] using
(hasDerivAt_const w (r:ℂ)).fun_div
(((hd w hw).differentiableAt (isOpen_ball.mem_nhds hw)).hasDerivAt.sub_const b) (hne w hw)
have hm : MapsTo f (ball 0 1) (ball 0 1) := by
intro w hw
rw [mem_ball_zero_iff]
dsimp [f]
rw [norm_div,norm_real,Real.norm_of_nonneg hr.le]
exact (div_lt_one (by simpa only [dist_eq_norm] using hr.trans (hout w hw))).mpr
(by simpa only [dist_eq_norm] using hout w hw)
have hh := schwarz_pick_deriv (fun w hw => (hf w hw).differentiableAt.differentiableWithinAt) hm hz
rw [(hf z hz).deriv,norm_div,norm_mul,norm_neg,norm_real,Real.norm_of_nonneg hr.le,
norm_pow] at hh
have he : ‖f z‖ = r/dist (F z) b := by
dsimp [f]
rw [norm_div,norm_real,Real.norm_of_nonneg hr.le,dist_eq_norm]
rw [he,← dist_eq_norm,div_pow] at hh
have hp : 0 < dist (F z) b ^2 := sq_pos_of_pos (hr.trans (hout z hz))
have hh' := mul_le_mul_of_nonneg_right hh hp.le
have hc₁ : (r*‖deriv F z‖/dist (F z) b ^2*(1-‖z‖^2))*dist (F z) b ^2 =
r*‖deriv F z‖*(1-‖z‖^2) := by field_simp [(hr.trans (hout z hz)).ne']
have hc₂ : (1-r^2/dist (F z) b ^2)*dist (F z) b ^2 = dist (F z) b ^2-r^2 := by field_simp [(hr.trans (hout z hz)).ne']
rwa [hc₁,hc₂] at hh'
theorem bounded_deriv_of_rolling_balls (e : OpenPartialHomeomorph ℂ ℂ)
(hes : e.source = ball 0 1)
(hd : DifferentiableOn ℂ e (ball 0 1))
(hdi : DifferentiableOn ℂ e.symm e.target)
(hb : Bornology.IsBounded e.target)
(hc : e.targetᶜ.Nonempty)
{r : ℝ} (hr : 0 < r)
(hroll : ∀ p ∈ frontier e.target, ∃ n : ℂ, ‖n‖ = 1 ∧
ball (p-r•n) r ⊆ e.target ∧ ball (p+r•n) r ⊆ e.targetᶜ) :
∃ B > 0, ∀ z ∈ ball (0:ℂ) 1, ‖deriv e z‖ ≤ B := by
have hmi : MapsTo e.symm e.target (ball 0 1) := by simpa only [← hes] using e.mapsTo_symm
obtain ⟨C,hC,hδ⟩ := domain_distance_le_disk_distance e.open_target hb hc hr hroll hdi hmi
obtain ⟨M,hM⟩ := (hb.isCompact_closure.image (continuous_infDist_pt e.targetᶜ)).bddAbove
let L := 2*r+|M|+1
have hL : 0 < L := by dsimp [L]; positivity
refine ⟨C*L/r,by positivity,?_⟩
intro z hz
have hzs : z ∈ e.source := hes.symm ▸ hz
have hx : e z ∈ e.target := e.map_source hzs
have hδz : infDist (e z) e.targetᶜ ≤ C*(1-‖z‖) := by
simpa only [e.left_inv hzs] using hδ (e z) hx
have hδM : infDist (e z) e.targetᶜ ≤ M := hM ⟨e z,subset_closure hx,rfl⟩
obtain ⟨p,hp,hpd,hxp,hball⟩ := nearest_frontier e.open_target hc hx
obtain ⟨n,hn,hin,hout⟩ := hroll p hp
have hnormal := Rolling.nearest_normal_of_balls hn hr hxp hball hout
have hdist : dist (e z) (p+r•n) = r+infDist (e z) e.targetᶜ := by
rw [dist_eq_norm,show e z-(p+r•n) = -(r+dist (e z) p)•n by
calc
_ = (p-dist (e z) p•n)-(p+r•n) := congrArg (fun a => a-(p+r•n)) hnormal
_ = _ := by module,
norm_smul,hn,mul_one,Real.norm_eq_abs,abs_neg,abs_of_pos (by positivity),hpd]
have hbound := schwarz_exterior_ball hd hr (fun w hw =>
lt_of_lt_of_le (by linarith [boundary_distance_pos e.open_target hc (e.map_source (hes.symm ▸ hw))] :
r < r+infDist (e w) e.targetᶜ)
(exterior_ball_distance e.open_target hc hr hout (e.map_source (hes.symm ▸ hw)))) hz
rw [hdist] at hbound
have hleft : r*‖deriv e z‖*(1-‖z‖) ≤ r*‖deriv e z‖*(1-‖z‖^2) := by
apply mul_le_mul_of_nonneg_left _ (by positivity)
have hz' := mem_ball_zero_iff.mp hz
nlinarith [norm_nonneg z]
have hright : (r+infDist (e z) e.targetᶜ)^2-r^2 ≤ L*(C*(1-‖z‖)) := by
calc
_ = (2*r+infDist (e z) e.targetᶜ)*infDist (e z) e.targetᶜ := by ring
_ ≤ L*(C*(1-‖z‖)) := mul_le_mul (by dsimp [L]; linarith [le_abs_self M]) hδz
infDist_nonneg hL.le
have hzz : 0 < 1-‖z‖ := sub_pos.mpr (mem_ball_zero_iff.mp hz)
have hh : r*‖deriv e z‖ ≤ L*C := (mul_le_mul_iff_left₀ hzz).mp (by
simpa only [mul_assoc,mul_comm,mul_left_comm] using hleft.trans (hbound.trans hright))
apply (le_div_iff₀ hr).mpr
nlinarith only [hh]
end StrictHotSpots.Riemann
end RiemannDerivativeBoundCompatibleLayer
section RiemannInverseBoundCompatibleLayer
open Set Metric Filter _root_.Complex _root_.OAI.Complex
open scoped Topology ComplexConjugate
namespace StrictHotSpots.Riemann
lemma schwarz_pick_center {f : ℂ → ℂ} {c : ℂ} {r : ℝ} (hr : 0 < r)
(hd : DifferentiableOn ℂ f (ball c r)) (hm : MapsTo f (ball c r) (ball 0 1)) :
r*‖deriv f c‖ ≤ 1-‖f c‖^2 := by
have hc : c ∈ ball c r := mem_ball_self hr
have hfc : ‖f c‖ < 1 := mem_ball_zero_iff.mp (hm hc)
let g := fun y => mobius (f c) (f y)
have hg0 : g c = 0 := mobius_self _
have hgd : DifferentiableOn ℂ g (ball c r) := by
intro y hy
exact ((hasDerivAt_mobius hfc (mem_ball_zero_iff.mp (hm hy))).differentiableAt.comp y
((hd y hy).differentiableAt (isOpen_ball.mem_nhds hy))).differentiableWithinAt
have hgm : MapsTo g (ball c r) (closedBall (g c) 1) := by
intro y hy
rw [hg0,mem_closedBall_zero_iff]
exact (norm_mobius_lt hfc (mem_ball_zero_iff.mp (hm hy))).le
have hle := Complex.norm_deriv_le_div_of_mapsTo_ball hgd hgm hr
have hder := (hasDerivAt_mobius hfc hfc).comp c
((hd c hc).differentiableAt (isOpen_ball.mem_nhds hc)).hasDerivAt
change HasDerivAt g (((1-conj (f c)*f c)/(1-conj (f c)*f c)^2)*deriv f c) c at hder
rw [hder.deriv,norm_mul,norm_mobius_self_deriv hfc] at hle
have hpos : 0 < 1-‖f c‖^2 := by nlinarith [norm_nonneg (f c)]
have hh : ‖deriv f c‖/(1-‖f c‖^2) ≤ 1/r := by simpa only [one_div,div_eq_mul_inv,mul_comm,one_mul] using hle
have hh' := (div_le_div_iff₀ hpos hr).mp hh
nlinarith only [hh']
theorem disk_distance_le_domain_distance (e : OpenPartialHomeomorph ℂ ℂ)
(hes : e.source = ball 0 1) (hd : DifferentiableOn ℂ e (ball 0 1))
(hc : e.targetᶜ.Nonempty) {r : ℝ} (hr : 0 < r)
(hroll : ∀ p ∈ frontier e.target, ∃ n : ℂ, ‖n‖ = 1 ∧
ball (p-r•n) r ⊆ e.target ∧ ball (p+r•n) r ⊆ e.targetᶜ) :
∃ A > 0, ∀ z ∈ ball (0:ℂ) 1, 1-‖z‖ ≤ A*infDist (e z) e.targetᶜ := by
have h0 : (0:ℂ) ∈ e.source := by rw [hes]; exact mem_ball_self (by norm_num)
have hδ0 := boundary_distance_pos e.open_target hc (e.map_source h0)
let m := r/(r+infDist (e 0) e.targetᶜ)
have hm : m < 1 := (div_lt_one (by positivity)).mpr (by linarith only [hδ0])
have hpos : 0 < (1-m)^2 := sq_pos_of_pos (sub_pos.mpr hm)
refine ⟨2/(r*(1-m)^2),by positivity,?_⟩
intro z hz
have hzs : z ∈ e.source := hes.symm ▸ hz
have hx := e.map_source hzs
have hδ := boundary_distance_pos e.open_target hc hx
obtain ⟨p,hp,hpd,hxp,hball⟩ := nearest_frontier e.open_target hc hx
obtain ⟨n,hn,hin,hout⟩ := hroll p hp
let b := p+r•n
have hnormal := Rolling.nearest_normal_of_balls hn hr hxp hball hout
have hdist : dist (e z) b = r+infDist (e z) e.targetᶜ := by
rw [dist_eq_norm,show e z-b = -(r+dist (e z) p)•n by
calc
_ = (p-dist (e z) p•n)-(p+r•n) := congrArg (fun a => a-(p+r•n)) hnormal
_ = _ := by module,
norm_smul,hn,mul_one,Real.norm_eq_abs,abs_neg,abs_of_pos (by positivity),hpd]
have hsep (w : ℂ) (hw : w ∈ ball (0:ℂ) 1) : r < dist (e w) b := by
have hδw := boundary_distance_pos e.open_target hc (e.map_source (hes.symm ▸ hw))
exact lt_of_lt_of_le (by linarith) (exterior_ball_distance e.open_target hc hr hout
(e.map_source (hes.symm ▸ hw)))
let f := fun w : ℂ => (r:ℂ)/(e w-b)
have hf : DifferentiableOn ℂ f (ball 0 1) := by
intro w hw
apply DifferentiableWithinAt.fun_div (differentiableWithinAt_const (r:ℂ)) ((hd w hw).sub_const b)
apply norm_ne_zero_iff.mp
have h := hr.trans (hsep w hw)
simpa only [dist_eq_norm] using h.ne'
have hnorm (w : ℂ) : ‖f w‖ = r/dist (e w) b := by
dsimp [f]
rw [norm_div,norm_real,Real.norm_of_nonneg hr.le,dist_eq_norm]
have hfm : MapsTo f (ball 0 1) (ball 0 1) := by
intro w hw
rw [mem_ball_zero_iff,hnorm]
exact (div_lt_one (hr.trans (hsep w hw))).mpr (hsep w hw)
have hfc : ‖f 0‖ ≤ m := by
rw [hnorm]
exact div_le_div_of_nonneg_left hr.le (by positivity)
(exterior_ball_distance e.open_target hc hr hout (e.map_source h0))
have hh := disk_distance_from_interior_ball hf hfm hz hm hfc
rw [dist_zero_right,hnorm,hdist] at hh
have hright : r*(1-r/(r+infDist (e z) e.targetᶜ)) ≤ infDist (e z) e.targetᶜ := by
have hsum : 0 < r+infDist (e z) e.targetᶜ := by positivity
apply (mul_le_mul_iff_left₀ hsum).mp
field_simp
nlinarith [sq_nonneg (infDist (e z) e.targetᶜ)]
have hh' := mul_le_mul_of_nonneg_left hh hr.le
rw [div_mul_eq_mul_div]
apply (le_div_iff₀ (mul_pos hr hpos)).mpr
nlinarith only [hh',hright]
theorem bounded_inverse_deriv_of_rolling_balls (e : OpenPartialHomeomorph ℂ ℂ)
(hes : e.source = ball 0 1) (hd : DifferentiableOn ℂ e (ball 0 1))
(hdi : DifferentiableOn ℂ e.symm e.target)
(hc : e.targetᶜ.Nonempty) {r : ℝ} (hr : 0 < r)
(hroll : ∀ p ∈ frontier e.target, ∃ n : ℂ, ‖n‖ = 1 ∧
ball (p-r•n) r ⊆ e.target ∧ ball (p+r•n) r ⊆ e.targetᶜ) :
∃ B > 0, ∀ x ∈ e.target, ‖deriv e.symm x‖ ≤ B := by
obtain ⟨A,hA,hδ⟩ := disk_distance_le_domain_distance e hes hd hc hr hroll
refine ⟨2*A,by positivity,?_⟩
intro x hx
have hδx := boundary_distance_pos e.open_target hc hx
have hin : ball x (infDist x e.targetᶜ) ⊆ e.target := ball_infDist_compl_subset
have hmi : MapsTo e.symm e.target (ball 0 1) := by
simpa only [← hes] using e.mapsTo_symm
have hh := schwarz_pick_center hδx (hdi.mono hin) (hmi.mono_left hin)
have hz : e.symm x ∈ ball (0:ℂ) 1 := hmi hx
have H : 1-‖e.symm x‖ ≤ A*infDist x e.targetᶜ := by
simpa only [e.right_inv hx] using hδ (e.symm x) hz
have H' : 1-‖e.symm x‖^2 ≤ 2*(A*infDist x e.targetᶜ) := by
have hsq := sq_nonneg (1-‖e.symm x‖)
nlinarith only [hsq,H]
exact (mul_le_mul_iff_right₀ hδx).mp (by
simpa only [mul_comm,mul_left_comm,mul_assoc] using hh.trans H')
end StrictHotSpots.Riemann
end RiemannInverseBoundCompatibleLayer
section RiemannClosedExtensionCompatibleLayer
open Set Metric Filter _root_.Complex _root_.OAI.Complex
open scoped Topology NNReal
namespace StrictHotSpots.Riemann
lemma complex_lipschitz_extension {f : ℂ → ℂ} {U : Set ℂ} {K : ℝ≥0}
(hf : LipschitzOnWith K f U) :
∃ (F : ℂ → ℂ) (B : ℝ≥0), LipschitzWith B F ∧ EqOn f F U := by
obtain ⟨a,ha,hea⟩ := (Complex.reCLM.lipschitzWith.comp_lipschitzOnWith hf).extend_real
obtain ⟨b,hb,heb⟩ := (Complex.imCLM.lipschitzWith.comp_lipschitzOnWith hf).extend_real
let F : ℂ → ℂ := fun z => (a z:ℂ)+(b z:ℂ)*I
refine ⟨F,‖Complex.reCLM‖₊*K+‖Complex.imCLM‖₊*K,?_,?_⟩
· apply LipschitzWith.of_dist_le_mul
intro x y
have h₁ := ha.dist_le_mul x y
have h₂ := hb.dist_le_mul x y
have hh := norm_le_abs_re_add_abs_im (F x-F y)
have hre : |(F x-F y).re| = dist (a x) (a y) := by simp [F,Real.dist_eq]
have him : |(F x-F y).im| = dist (b x) (b y) := by simp [F,Real.dist_eq]
rw [hre,him] at hh
simpa only [dist_eq_norm,NNReal.coe_add,NNReal.coe_mul,add_mul,mul_assoc] using
hh.trans (add_le_add h₁ h₂)
· intro x hx
apply Complex.ext
· simpa [F] using hea hx
· simpa [F] using heb hx
theorem closed_disk_extension (e : OpenPartialHomeomorph ℂ ℂ)
(hes : e.source = ball 0 1) (hd : DifferentiableOn ℂ e (ball 0 1))
{B : ℝ} (hB : 0 ≤ B) (hbound : ∀ z ∈ ball (0:ℂ) 1, ‖deriv e z‖ ≤ B) :
∃ (F : ℂ → ℂ) (L : ℝ≥0), LipschitzWith L F ∧ EqOn e F (ball 0 1) ∧
F '' closedBall 0 1 = closure e.target := by
have hLip : LipschitzOnWith ⟨B,hB⟩ e (ball 0 1) :=
(convex_ball (0:ℂ) 1).lipschitzOnWith_of_nnnorm_deriv_le
(fun z hz => (hd z hz).differentiableAt (isOpen_ball.mem_nhds hz)) hbound
obtain ⟨F,L,hF,he⟩ := complex_lipschitz_extension hLip
have him : F '' ball (0:ℂ) 1 = e.target := by
calc
F '' ball (0:ℂ) 1 = e '' ball (0:ℂ) 1 := image_congr he.symm
_ = e.target := by rw [← hes,e.image_source_eq_target]
refine ⟨F,L,hF,he,?_⟩
apply Subset.antisymm
· rw [← closure_ball (0:ℂ) (by norm_num : (1:ℝ) ≠ 0)]
simpa only [him] using image_closure_subset_closure_image (s := ball (0:ℂ) 1) hF.continuous
· have hclosed : IsClosed (F '' closedBall (0:ℂ) 1) :=
((isCompact_closedBall (0:ℂ) 1).image hF.continuous).isClosed
apply closure_minimal _ hclosed
rw [← him]
exact image_mono ball_subset_closedBall
end StrictHotSpots.Riemann
end RiemannClosedExtensionCompatibleLayer
section RiemannGlobalInverseCompatibleLayer
open Set Metric Filter _root_.Complex _root_.OAI.Complex
open scoped Topology NNReal
namespace StrictHotSpots.Riemann
lemma dist_image_le_on_ball {U : Set ℂ} (ho : IsOpen U) {f : ℂ → ℂ}
(hd : DifferentiableOn ℂ f U) {B : ℝ} (hB : ∀ z ∈ U, ‖deriv f z‖ ≤ B)
{c : ℂ} {r : ℝ} (hin : ball c r ⊆ U) {x y : ℂ}
(hx : x ∈ ball c r) (hy : y ∈ ball c r) :
dist (f x) (f y) ≤ B*dist x y := by
simpa only [dist_eq_norm] using (convex_ball c r).norm_image_sub_le_of_norm_deriv_le
(fun z hz => (hd z (hin hz)).differentiableAt (ho.mem_nhds (hin hz)))
(fun z hz => hB z (hin hz)) hy hx
theorem lipschitz_of_rolling_balls {U : Set ℂ} (ho : IsOpen U) (hc : Uᶜ.Nonempty)
{r : ℝ} (hr : 0 < r)
(hroll : ∀ p ∈ frontier U, ∃ n : ℂ, ‖n‖ = 1 ∧
ball (p-r•n) r ⊆ U ∧ ball (p+r•n) r ⊆ Uᶜ)
{f : ℂ → ℂ} (hd : DifferentiableOn ℂ f U)
(hm : MapsTo f U (ball 0 1)) {B : ℝ} (hB : 0 < B)
(hbound : ∀ x ∈ U, ‖deriv f x‖ ≤ B) :
∃ L : ℝ≥0, LipschitzOnWith L f U := by
let L : ℝ := 40*B+40/r
have hL : 0 < L := by dsimp [L]; positivity
refine ⟨⟨L,hL.le⟩,LipschitzOnWith.of_dist_le_mul ?_⟩
intro x hx y hy
change dist (f x) (f y) ≤ L*dist x y
have hδx := boundary_distance_pos ho hc hx
have hδy := boundary_distance_pos ho hc hy
have hLB : B ≤ L := by
dsimp [L]
have := div_pos (by norm_num : (0:ℝ)<40) hr
linarith
by_cases hdirect : dist x y < infDist x Uᶜ
· have hh := dist_image_le_on_ball ho hd hbound (ball_infDist_compl_subset (s := U) (x := x))
(mem_ball_self hδx) (by simpa only [mem_ball,dist_comm] using hdirect)
exact hh.trans (mul_le_mul_of_nonneg_right hLB dist_nonneg)
by_cases hnear : dist x y < r/10
· let d := dist x y
have hd0 : 0 < d := hδx.trans_le (le_of_not_gt hdirect)
have hdx : infDist x Uᶜ ≤ d := le_of_not_gt hdirect
have hdy : infDist y Uᶜ ≤ 2*d := by
have hh : infDist y Uᶜ ≤ infDist x Uᶜ+dist y x := infDist_le_infDist_add_dist
rw [dist_comm y x] at hh
linarith
obtain ⟨p,hp,hpx,hxp,hballx⟩ := nearest_frontier ho hc hx
obtain ⟨q,hq,hqy,hyq,hbally⟩ := nearest_frontier ho hc hy
obtain ⟨n,hn,hip,hop⟩ := hroll p hp
obtain ⟨m,hnm,hiq,hoq⟩ := hroll q hq
have hxpball : x ∈ ball (p-r•n) r :=
(Rolling.near_interior_ball hn hr hxp hballx hop (by rw [hpx]; dsimp [d] at hdx; linarith)).2
have hyqball : y ∈ ball (q-r•m) r :=
(Rolling.near_interior_ball hnm hr hyq hbally hoq (by rw [hqy]; dsimp [d] at hdy; linarith)).2
have hpq : dist p q ≤ 4*d := by
have hh := dist_triangle4 p x y q
rw [dist_comm p x,hpx,hqy] at hh
dsimp [d] at *
linarith
have hcc : dist (p-r•n) (q-r•m) ≤ 8*d :=
(Rolling.interior_centers_bound hr hn hnm hip hop hiq hoq).trans (by linarith)
let a := p-(9*d)•n
have ht : 9*d < r := by dsimp [d]; linarith
have hap : dist a p = 9*d := by
simp [a,hn,abs_of_pos hd0]
have hac : dist a (p-r•n) = r-9*d := by
rw [dist_eq_norm,show a-(p-r•n)=(r-9*d)•n by
dsimp only [a]
rw [sub_smul]
abel,
norm_smul,hn,mul_one,Real.norm_eq_abs,abs_of_pos (sub_pos.mpr ht)]
have ha₁ : a ∈ ball (p-r•n) r := by rw [mem_ball,hac]; linarith
have ha₂ : a ∈ ball (q-r•m) r := by
have hh := dist_triangle a (p-r•n) (q-r•m)
rw [hac] at hh
change dist a (q-r•m) < r
linarith
have hxa : dist x a ≤ 10*d := by
have hh := dist_triangle x p a
rw [hpx,dist_comm p a,hap] at hh
linarith
have hay : dist a y ≤ 11*d := by
have hh := dist_triangle a x y
rw [dist_comm a x] at hh
dsimp [d] at *
linarith
have h₁ := dist_image_le_on_ball ho hd hbound hip hxpball ha₁
have h₂ := dist_image_le_on_ball ho hd hbound hiq ha₂ hyqball
calc
_ ≤ dist (f x) (f a)+dist (f a) (f y) := dist_triangle _ _ _
_ ≤ B*(dist x a+dist a y) := by nlinarith only [h₁,h₂]
_ ≤ B*(21*d) := mul_le_mul_of_nonneg_left (by linarith) hB.le
_ ≤ L*d := by dsimp [L]; nlinarith [div_pos (by norm_num : (0:ℝ)<40) hr]
· have hfar : r/10 ≤ dist x y := le_of_not_gt hnear
have hdist : dist (f x) (f y) ≤ 2 := by
have hh := dist_triangle (f x) 0 (f y)
rw [dist_zero_right,dist_zero_left] at hh
linarith [mem_ball_zero_iff.mp (hm hx),mem_ball_zero_iff.mp (hm hy)]
apply hdist.trans
have hpos := div_mul_cancel₀ (40:ℝ) hr.ne'
have hh := mul_le_mul_of_nonneg_left hfar (show 0 ≤ 40/r by positivity)
dsimp [L]
nlinarith [mul_nonneg hB.le (dist_nonneg (x:=x) (y:=y))]
end StrictHotSpots.Riemann
end RiemannGlobalInverseCompatibleLayer
section RiemannClosedBiholomorphicCompatibleLayer
open Set Metric Filter _root_.Complex _root_.OAI.Complex
open scoped Topology NNReal
namespace StrictHotSpots.Riemann
theorem closed_bilipschitz_extension (e : OpenPartialHomeomorph ℂ ℂ)
(hes : e.source = ball 0 1) (hd : DifferentiableOn ℂ e (ball 0 1))
(hdi : DifferentiableOn ℂ e.symm e.target)
(hb : Bornology.IsBounded e.target) (hc : e.targetᶜ.Nonempty)
{r : ℝ} (hr : 0 < r)
(hroll : ∀ p ∈ frontier e.target, ∃ n : ℂ, ‖n‖ = 1 ∧
ball (p-r•n) r ⊆ e.target ∧ ball (p+r•n) r ⊆ e.targetᶜ) :
∃ (F G : ℂ → ℂ) (L M : ℝ≥0),
LipschitzWith L F ∧ LipschitzWith M G ∧
EqOn e F (ball 0 1) ∧ EqOn e.symm G e.target ∧
F '' closedBall 0 1 = closure e.target ∧
G '' closure e.target = closedBall 0 1 ∧
(∀ z ∈ closedBall 0 1, G (F z) = z) ∧
(∀ x ∈ closure e.target, F (G x) = x) := by
obtain ⟨B,hB,hbound⟩ := bounded_deriv_of_rolling_balls e hes hd hdi hb hc hr hroll
obtain ⟨F,L,hF,he,himage⟩ := closed_disk_extension e hes hd hB.le hbound
obtain ⟨C,hC,hcbound⟩ := bounded_inverse_deriv_of_rolling_balls e hes hd hdi hc hr hroll
have hmi : MapsTo e.symm e.target (ball 0 1) := by simpa only [← hes] using e.mapsTo_symm
obtain ⟨K,hK⟩ := lipschitz_of_rolling_balls e.open_target hc hr hroll hdi hmi hC hcbound
obtain ⟨G,M,hG,hi⟩ := complex_lipschitz_extension hK
have hleft₀ : EqOn (G ∘ F) id (ball (0:ℂ) 1) := by
intro z hz
change G (F z) = z
rw [← he hz,← hi (e.map_source (hes.symm ▸ hz)),e.left_inv (hes.symm ▸ hz)]
have hleft : ∀ z ∈ closedBall (0:ℂ) 1, G (F z) = z := by
have hh := hleft₀.closure (hG.continuous.comp hF.continuous) continuous_id
rwa [closure_ball (0:ℂ) (by norm_num : (1:ℝ) ≠ 0)] at hh
have hright₀ : EqOn (F ∘ G) id e.target := by
intro x hx
change F (G x) = x
rw [← hi hx,← he (hmi hx),e.right_inv hx]
have hright : ∀ x ∈ closure e.target, F (G x) = x :=
hright₀.closure (hF.continuous.comp hG.continuous) continuous_id
refine ⟨F,G,L,M,hF,hG,he,hi,himage,?_,hleft,hright⟩
rw [← himage,image_image]
exact image_congr hleft |>.trans (image_id _)
def closedHomeomorph {F G : ℂ → ℂ} (hF : Continuous F) (hG : Continuous G)
{U : Set ℂ} (hf : MapsTo F (closedBall 0 1) (closure U))
(hg : MapsTo G (closure U) (closedBall 0 1))
(hl : ∀ z ∈ closedBall 0 1, G (F z) = z)
(hr : ∀ x ∈ closure U, F (G x) = x) :
(closedBall (0:ℂ) 1) ≃ₜ closure U where
toFun z := ⟨F z,hf z.property⟩
invFun x := ⟨G x,hg x.property⟩
left_inv z := Subtype.ext (hl z z.property)
right_inv x := Subtype.ext (hr x x.property)
continuous_toFun := hF.continuousOn.domRestrict.codRestrict _
continuous_invFun := hG.continuousOn.domRestrict.codRestrict _
lemma closed_extension_frontier (e : OpenPartialHomeomorph ℂ ℂ)
(hes : e.source = ball 0 1) {F G : ℂ → ℂ}
(_he : EqOn e F (ball 0 1)) (hi : EqOn e.symm G e.target)
(hf : MapsTo F (closedBall 0 1) (closure e.target))
(hl : ∀ z ∈ closedBall 0 1, G (F z) = z) :
MapsTo F (sphere 0 1) (frontier e.target) := by
intro z hz
rw [mem_sphere,dist_zero_right] at hz
have hzcl : z ∈ closedBall (0:ℂ) 1 := by simp only [mem_closedBall_zero_iff,hz,le_refl]
rw [e.open_target.frontier_eq]
refine ⟨hf hzcl,?_⟩
intro hmem
have him : G (F z) ∈ ball (0:ℂ) 1 := by
rw [← hi hmem,← hes]
exact e.map_target hmem
rw [hl z hzcl,mem_ball_zero_iff,hz] at him
exact lt_irrefl _ him
end StrictHotSpots.Riemann
end RiemannClosedBiholomorphicCompatibleLayer
end
end RiemannBoundaryCompatible
section ActualClosedConformal
noncomputable section
open Set Filter Metric MeasureTheory
open scoped Topology ContDiff NNReal
namespace StrictHotSpots.Conformal
structure ClosedDiskChart (Ω : Set Plane) where
e : OpenPartialHomeomorph Plane Plane
d : Plane → ℂ
d' : Plane → ℂ
source_eq : e.source = DiskH10.disk
target_eq : e.target = Ω
smooth : ContDiffOn ℝ ∞ e e.source
inverse_smooth : ContDiffOn ℝ ∞ e.symm e.target
deriv : ∀ x ∈ e.source, HasFDerivAt e (planeMul (d x)) x
inverse_deriv : ∀ y ∈ e.target, HasFDerivAt e.symm (planeMul (d' y)) y
nonzero : ∀ x ∈ e.source, d x ≠ 0
inverse_nonzero : ∀ y ∈ e.target, d' y ≠ 0
bound : ℝ
inverse_bound : ℝ
bound_pos : 0 < bound
inverse_bound_pos : 0 < inverse_bound
bounded_deriv : ∀ x ∈ e.source, ‖d x‖ ≤ bound
bounded_inverse_deriv : ∀ y ∈ e.target, ‖d' y‖ ≤ inverse_bound
F : Plane → Plane
G : Plane → Plane
Lip : ℝ≥0
InvLip : ℝ≥0
lipschitz : LipschitzWith Lip F
inverse_lipschitz : LipschitzWith InvLip G
agrees : EqOn e F e.source
inverse_agrees : EqOn e.symm G e.target
maps_closure : MapsTo F (closure e.source) (closure Ω)
inverse_maps_closure : MapsTo G (closure Ω) (closure e.source)
left_inverse : ∀ z ∈ closure e.source, G (F z) = z
right_inverse : ∀ x ∈ closure Ω, F (G x) = x
theorem exists_closed_disk_chart {Ω : Set Plane} (hΩ : AdmissibleDomain Ω) :
Nonempty (ClosedDiskChart Ω) := by
let U : Set ℂ := coordinate ⁻¹' Ω
have ho : IsOpen U := hΩ.2.1.preimage coordinate.continuous
have hs : IsSimplyConnected U := coordinate.toHomeomorph.isSimplyConnected_preimage.mpr hΩ.2.2.2.1
have hne : U.Nonempty := by
obtain ⟨x,hx⟩ := hΩ.1
exact ⟨coordinate.symm x,by simpa [U] using hx⟩
have hb : Bornology.IsBounded U := by
have he : U = coordinate.symm '' Ω := by
ext z
constructor
· intro hz
exact ⟨coordinate z,hz,coordinate.symm_apply_apply z⟩
· rintro ⟨x,hx,rfl⟩
simpa [U] using hx
rw [he]
exact coordinate.symm.lipschitz.isBounded_image hΩ.2.2.1
have hproper : U ≠ univ := fun hh => NormedSpace.unbounded_univ ℝ ℂ (hh ▸ hb)
have hc : Uᶜ.Nonempty := nonempty_compl.mpr hproper
obtain ⟨Φ,hΦs,hΦt,hΦ,hΦi,hn,hn'⟩ := Riemann.exists_disk_biholomorphism ho hs hne hproper
obtain ⟨r,hr,hroll⟩ := hΩ.2.2.2.2.complex_rolling_balls hΩ.2.1 hΩ.2.2.1
have hroll' : ∀ p ∈ frontier Φ.target, ∃ n : ℂ, ‖n‖=1 ∧
ball (p-r•n) r ⊆ Φ.target ∧ ball (p+r•n) r ⊆ Φ.targetᶜ := by
simpa only [hΦt] using hroll
have hb' : Bornology.IsBounded Φ.target := hΦt.symm ▸ hb
have hc' : Φ.targetᶜ.Nonempty := hΦt.symm ▸ hc
obtain ⟨B,hB,hbd⟩ := Riemann.bounded_deriv_of_rolling_balls Φ hΦs hΦ
(hΦt.symm ▸ hΦi) hb' hc' hr hroll'
obtain ⟨C,hC,hcd⟩ := Riemann.bounded_inverse_deriv_of_rolling_balls Φ hΦs hΦ
(hΦt.symm ▸ hΦi) hc' hr hroll'
obtain ⟨F,G,L,M,hF,hG,he,hi,himage,himage',hl,hright⟩ :=
Riemann.closed_bilipschitz_extension Φ hΦs hΦ (hΦt.symm ▸ hΦi) hb' hc' hr hroll'
let e := planeChart Φ
have hes : e.source = DiskH10.disk := by
rw [planeChart_source,hΦs]
ext x
simp only [mem_preimage,mem_ball,dist_zero_right,coordinate.symm.norm_map,DiskH10.disk]
have het : e.target = Ω := by
rw [planeChart_target,hΦt]
ext x
simp [U]
have hsrc (x : Plane) (hx : x ∈ e.source) : coordinate.symm x ∈ ball (0:ℂ) 1 := by
rwa [planeChart_source,hΦs] at hx
have htgt (x : Plane) (hx : x ∈ e.target) : coordinate.symm x ∈ U := by
rwa [planeChart_target,hΦt] at hx
have hsrccl (x : Plane) (hx : x ∈ closure e.source) : coordinate.symm x ∈ closedBall (0:ℂ) 1 := by
have hsball : e.source = ball (0:Plane) 1 := by
rw [hes]
rfl
rw [hsball,closure_ball (0:Plane) (by norm_num : (1:ℝ) ≠ 0)] at hx
simpa only [mem_closedBall_zero_iff,coordinate.symm.norm_map] using hx
have htgtcl (x : Plane) (hx : x ∈ closure Ω) : coordinate.symm x ∈ closure Φ.target := by
rw [hΦt]
change coordinate.symm x ∈ closure (coordinate.toHomeomorph ⁻¹' Ω)
rw [← coordinate.toHomeomorph.preimage_closure]
simpa using hx
let f : Plane → Plane := fun x => coordinate (F (coordinate.symm x))
let g : Plane → Plane := fun x => coordinate (G (coordinate.symm x))
have hf : LipschitzWith L f := by
apply LipschitzWith.of_dist_le_mul
intro x y
simpa only [f,coordinate.dist_map,coordinate.symm.dist_map] using hF.dist_le_mul (coordinate.symm x) (coordinate.symm y)
have hg : LipschitzWith M g := by
apply LipschitzWith.of_dist_le_mul
intro x y
simpa only [g,coordinate.dist_map,coordinate.symm.dist_map] using hG.dist_le_mul (coordinate.symm x) (coordinate.symm y)
refine ⟨{
e := e
d := fun x => deriv Φ (coordinate.symm x)
d' := fun x => deriv Φ.symm (coordinate.symm x)
source_eq := hes
target_eq := het
smooth := ?_
inverse_smooth := ?_
deriv := ?_
inverse_deriv := ?_
nonzero := ?_
inverse_nonzero := ?_
bound := B
inverse_bound := C
bound_pos := hB
inverse_bound_pos := hC
bounded_deriv := ?_
bounded_inverse_deriv := ?_
F := f
G := g
Lip := L
InvLip := M
lipschitz := hf
inverse_lipschitz := hg
agrees := ?_
inverse_agrees := ?_
maps_closure := ?_
inverse_maps_closure := ?_
left_inverse := ?_
right_inverse := ?_ }⟩
· change ContDiffOn ℝ ∞ (fun x => coordinate (Φ (coordinate.symm x))) _
rw [planeChart_source,hΦs]
exact conjugate_contDiffOn isOpen_ball hΦ
· change ContDiffOn ℝ ∞ (fun x => coordinate (Φ.symm (coordinate.symm x))) _
rw [planeChart_target,hΦt]
exact conjugate_contDiffOn ho hΦi
· intro x hx
exact conjugate_hasFDerivAt ((hΦ _ (hsrc x hx)).differentiableAt (isOpen_ball.mem_nhds (hsrc x hx)))
· intro x hx
exact conjugate_hasFDerivAt ((hΦi _ (htgt x hx)).differentiableAt (ho.mem_nhds (htgt x hx)))
· intro x hx
exact hn _ (hsrc x hx)
· intro x hx
exact hn' _ (htgt x hx)
· intro x hx
exact hbd _ (hsrc x hx)
· intro x hx
exact hcd _ (hΦt.symm ▸ htgt x hx)
· intro x hx
exact congrArg coordinate (he (hsrc x hx))
· intro x hx
change coordinate (Φ.symm (coordinate.symm x)) = coordinate (G (coordinate.symm x))
have hm : coordinate.symm x ∈ Φ.target := by rw [hΦt]; exact htgt x hx
exact congrArg coordinate (hi hm)
· intro x hx
have hh : F (coordinate.symm x) ∈ closure Φ.target := himage ▸ mem_image_of_mem F (hsrccl x hx)
rw [hΦt] at hh
change coordinate (F (coordinate.symm x)) ∈ closure Ω
change F (coordinate.symm x) ∈ closure (coordinate.toHomeomorph ⁻¹' Ω) at hh
rwa [← coordinate.toHomeomorph.preimage_closure] at hh
· intro x hx
have hh : G (coordinate.symm x) ∈ closedBall (0:ℂ) 1 := himage' ▸ mem_image_of_mem G (htgtcl x hx)
have hsball : e.source = ball (0:Plane) 1 := by rw [hes]; rfl
rw [hsball,closure_ball (0:Plane) (by norm_num : (1:ℝ) ≠ 0)]
simpa only [g,mem_closedBall_zero_iff,coordinate.norm_map] using hh
· intro x hx
simpa only [f,g,coordinate.symm_apply_apply,coordinate.apply_symm_apply] using congrArg coordinate (hl _ (hsrccl x hx))
· intro x hx
simpa only [f,g,coordinate.symm_apply_apply,coordinate.apply_symm_apply] using congrArg coordinate (hright _ (htgtcl x hx))
end StrictHotSpots.Conformal
end
end ActualClosedConformal
section ClosedConformalData
noncomputable section
open Set Filter Metric
open scoped ContDiff NNReal
namespace StrictHotSpots.Conformal.ClosedDiskChart
variable {Ω : Set Plane} (c : ClosedDiskChart Ω)
def diskMap : OpenPartialHomeomorph Plane Plane where
toFun := c.e
invFun := c.e.symm
source := DiskH10.disk
target := Ω
map_source' := fun _ hx => c.target_eq.subset (c.e.map_source (c.source_eq.symm.subset hx))
map_target' := fun _ hy => c.source_eq.subset (c.e.map_target (c.target_eq.symm.subset hy))
left_inv' := fun _ hx => c.e.left_inv (c.source_eq.symm ▸ hx)
right_inv' := fun _ hy => c.e.right_inv (c.target_eq.symm ▸ hy)
open_source := PlaneGreen.diskOpen
open_target := c.target_eq ▸ c.e.open_target
continuousOn_toFun := c.source_eq ▸ c.e.continuousOn
continuousOn_invFun := c.e.continuousOn_symm.mono c.target_eq.symm.subset
lemma diskMap_eq : c.diskMap = c.e := by
apply OpenPartialHomeomorph.ext c.diskMap c.e (fun _ => rfl) (fun _ => rfl)
exact c.source_eq.symm
lemma diskMap_smooth : ContDiffOn ℝ ∞ c.diskMap DiskH10.disk := by
change ContDiffOn ℝ ∞ c.e DiskH10.disk
exact c.source_eq ▸ c.smooth
lemma diskMap_inverse_smooth : ContDiffOn ℝ ∞ c.diskMap.symm Ω := by
change ContDiffOn ℝ ∞ c.e.symm Ω
exact c.inverse_smooth.mono c.target_eq.symm.subset
lemma diskMap_deriv : ∀ x ∈ DiskH10.disk, HasFDerivAt c.diskMap (planeMul (c.d x)) x :=
fun x hx => c.deriv x (c.source_eq.symm ▸ hx)
lemma diskMap_inverse_deriv : ∀ y ∈ Ω, HasFDerivAt c.diskMap.symm (planeMul (c.d' y)) y :=
fun y hy => c.inverse_deriv y (c.target_eq.symm ▸ hy)
lemma continuous_closed : ContinuousOn c.F (closure DiskH10.disk) := c.lipschitz.continuous.continuousOn
lemma maps_closed : MapsTo c.F (closure DiskH10.disk) (closure Ω) := c.source_eq ▸ c.maps_closure
lemma inverse_maps_closed : MapsTo c.G (closure Ω) (closure DiskH10.disk) :=
c.source_eq ▸ c.inverse_maps_closure
lemma diskMap_agrees : EqOn c.diskMap c.F DiskH10.disk := fun _ hx => c.agrees (c.source_eq.symm ▸ hx)
lemma diskMap_inverse_agrees : EqOn c.diskMap.symm c.G Ω := fun _ hy => c.inverse_agrees (c.target_eq.symm ▸ hy)
lemma maps_boundary : MapsTo c.F (frontier DiskH10.disk) (frontier Ω) := by
intro x hx
refine ⟨c.maps_closed hx.1,?_⟩
rw [(show IsOpen Ω from c.target_eq ▸ c.e.open_target).interior_eq]
intro hy
have hg : c.G (c.F x) ∈ DiskH10.disk := by
rw [← c.diskMap_inverse_agrees hy]
exact c.diskMap.map_target hy
have hi := c.left_inverse x (c.source_eq.symm ▸ hx.1)
rw [hi] at hg
exact hx.2 ((show IsOpen DiskH10.disk from PlaneGreen.diskOpen).interior_eq.symm ▸ hg)
lemma inverse_maps_boundary : MapsTo c.G (frontier Ω) (frontier DiskH10.disk) := by
intro x hx
refine ⟨c.inverse_maps_closed hx.1,?_⟩
rw [(show IsOpen DiskH10.disk from PlaneGreen.diskOpen).interior_eq]
intro hy
have hg : c.F (c.G x) ∈ Ω := by
rw [← c.diskMap_agrees hy]
exact c.diskMap.map_source hy
rw [c.right_inverse x hx.1] at hg
exact hx.2 ((show IsOpen Ω from c.target_eq ▸ c.e.open_target).interior_eq.symm ▸ hg)
def boundaryHomeomorph : frontier DiskH10.disk ≃ₜ frontier Ω where
toFun x := ⟨c.F x,c.maps_boundary x.property⟩
invFun y := ⟨c.G y,c.inverse_maps_boundary y.property⟩
left_inv x := Subtype.ext (c.left_inverse x (c.source_eq.symm ▸ x.property.1))
right_inv y := Subtype.ext (c.right_inverse y y.property.1)
continuous_toFun := (c.lipschitz.continuous.comp continuous_subtype_val).subtype_mk _
continuous_invFun := (c.inverse_lipschitz.continuous.comp continuous_subtype_val).subtype_mk _
end StrictHotSpots.Conformal.ClosedDiskChart
end
end ClosedConformalData
section ClosedSmoothData
noncomputable section
open Set MeasureTheory Filter
open scoped ContDiff InnerProductSpace Topology
namespace StrictHotSpots
def closedGradient (Ω : Set Plane) (u : Plane → ℝ) (x : Plane) : Plane :=
(InnerProductSpace.toDual ℝ Plane).symm (fderivWithin ℝ u (closure Ω) x)
lemma closedGradient_eq {Ω : Set Plane} {u : Plane → ℝ} (ho : IsOpen Ω) {x : Plane}
(hx : x ∈ Ω) : closedGradient Ω u x = gradient u x := by
unfold closedGradient gradient
rw [fderivWithin_of_mem_nhds (mem_of_superset (ho.mem_nhds hx) subset_closure)]
lemma closedGradient_continuous {Ω : Set Plane} {u : Plane → ℝ} (ho : IsOpen Ω)
(hs : SmoothBoundary Ω) (hu : ContDiffOn ℝ ∞ u (closure Ω)) :
ContinuousOn (closedGradient Ω u) (closure Ω) :=
(InnerProductSpace.toDual ℝ Plane).symm.continuous.comp_continuousOn
(hu.continuousOn_fderivWithin (hs.uniqueDiffOn_closure ho) (by simp))
lemma continuous_closure_memLp {Ω : Set Plane} {F : Type*} [NormedAddCommGroup F]
{f : Plane → F} (ho : IsOpen Ω) (hb : Bornology.IsBounded Ω)
(hf : ContinuousOn f (closure Ω)) : MemLp f 2 (volume.restrict Ω) := by
let : IsFiniteMeasure (volume.restrict Ω) := isFiniteMeasure_restrict.mpr hb.measure_lt_top.ne
obtain ⟨C,hC⟩ := hb.isCompact_closure.exists_bound_of_continuousOn hf
apply MemLp.of_bound ((hf.mono subset_closure).aestronglyMeasurable ho.measurableSet) C
filter_upwards [ae_restrict_mem ho.measurableSet] with x hx
exact hC x (subset_closure hx)
lemma smooth_closure_H1 {Ω : Set Plane} {u : Plane → ℝ}
(ho : IsOpen Ω) (hb : Bornology.IsBounded Ω) (hs : SmoothBoundary Ω)
(hu : ContDiffOn ℝ ∞ u (closure Ω)) : HasH1Gradient Ω u (gradient u) := by
apply HasH1Gradient.of_contDiffOn ho (hu.mono subset_closure)
(continuous_closure_memLp ho hb hu.continuousOn)
apply MemLp.ae_eq _ (continuous_closure_memLp ho hb (closedGradient_continuous ho hs hu))
filter_upwards [ae_restrict_mem ho.measurableSet] with x hx
exact closedGradient_eq ho hx
lemma smooth_closure_zero_H10 {Ω : Set Plane} {u : Plane → ℝ}
(ho : IsOpen Ω) (hb : Bornology.IsBounded Ω) (hs : SmoothBoundary Ω)
(hu : ContDiffOn ℝ ∞ u (closure Ω)) (hz : ∀ x ∈ frontier Ω, u x = 0) :
(smooth_closure_H1 ho hb hs hu).toH1 ∈ h10Submodule ho :=
smooth_zero_trace_memH10 ho hu (smooth_closure_H1 ho hb hs hu) hb hz
lemma closure_directional_smooth {Ω : Set Plane} {u : Plane → ℝ}
(ho : IsOpen Ω) (hs : SmoothBoundary Ω)
(hu : ContDiffOn ℝ ∞ u (closure Ω)) (e : Plane) :
ContDiffOn ℝ ∞ (fun x => fderivWithin ℝ u (closure Ω) x e) (closure Ω) :=
(hu.fderivWithin (hs.uniqueDiffOn_closure ho) (by simp)).clm_apply contDiffOn_const
end StrictHotSpots
namespace StrictHotSpots.Conformal.ClosedDiskChart
open Set Filter Metric MeasureTheory
open scoped ContDiff InnerProductSpace NNReal
open DiskH10 PlaneGreen
variable {Ω : Set Plane} (c : ClosedDiskChart Ω)
def pullDatum (w : Plane → ℝ) : Plane → ℝ := w ∘ c.F
lemma pullDatum_continuous {w : Plane → ℝ} (hw : ContinuousOn w (closure Ω)) :
ContinuousOn (c.pullDatum w) (closure disk) := hw.comp c.continuous_closed c.maps_closed
lemma pullDatum_eq_inner {w : Plane → ℝ} : EqOn (c.pullDatum w) (w ∘ c.diskMap) disk :=
fun _ hx => congrArg w (c.diskMap_agrees hx).symm
lemma pullDatum_smooth {w : Plane → ℝ} (hw : ContDiffOn ℝ ∞ w Ω) :
ContDiffOn ℝ ∞ (c.pullDatum w) disk :=
(hw.comp c.diskMap_smooth c.diskMap.mapsTo).congr c.pullDatum_eq_inner
lemma pullDatum_grad_norm {w : Plane → ℝ} (hw : DifferentiableOn ℝ w Ω)
{x : Plane} (hx : x ∈ disk) :
‖gradient (c.pullDatum w) x‖ = ‖c.d x‖ * ‖gradient w (c.diskMap x)‖ := by
have he : c.pullDatum w =ᶠ[nhds x] w ∘ c.diskMap :=
eventually_of_mem (diskOpen.mem_nhds hx) (fun _ hy => c.pullDatum_eq_inner hy)
have hg : gradient (c.pullDatum w) x = gradient (w ∘ c.diskMap) x := by
unfold gradient
rw [he.fderiv_eq]
rw [hg]
exact plane_norm_gradient_comp (c.diskMap_deriv x hx)
((hw _ (c.diskMap.map_source hx)).differentiableAt
(c.diskMap.open_target.mem_nhds (c.diskMap.map_source hx)))
lemma pullDatum_bounded_gradient (hb : Bornology.IsBounded Ω) (hs : SmoothBoundary Ω)
{w : Plane → ℝ} (hw : ContDiffOn ℝ ∞ w (closure Ω)) :
∃ B : ℝ≥0, ∀ x ∈ disk, ‖gradient (c.pullDatum w) x‖ ≤ B := by
obtain ⟨C,hC⟩ := hb.isCompact_closure.exists_bound_of_continuousOn
(closedGradient_continuous c.diskMap.open_target hs hw)
let B : ℝ≥0 := ⟨c.bound * max C 0,mul_nonneg c.bound_pos.le (le_max_right _ _)⟩
refine ⟨B,fun x hx => ?_⟩
rw [c.pullDatum_grad_norm ((hw.mono subset_closure).differentiableOn (by simp)) hx]
have ht := c.diskMap.map_source hx
have hcg := hC (c.diskMap x) (subset_closure ht)
rw [closedGradient_eq (Ω := Ω) (show IsOpen Ω from c.diskMap.open_target) ht] at hcg
exact mul_le_mul (c.bounded_deriv x (c.source_eq.symm.subset hx))
(hcg.trans (le_max_left _ _)) (norm_nonneg _) c.bound_pos.le
lemma pullDatum_lipschitz (hb : Bornology.IsBounded Ω) (hs : SmoothBoundary Ω)
{w : Plane → ℝ} (hw : ContDiffOn ℝ ∞ w (closure Ω)) :
∃ B : ℝ≥0, LipschitzOnWith B (c.pullDatum w) (closure disk) := by
obtain ⟨B,hB⟩ := c.pullDatum_bounded_gradient hb hs hw
have hsm := c.pullDatum_smooth (hw.mono subset_closure)
have hd (x : Plane) (hx : x ∈ disk) : DifferentiableAt ℝ (c.pullDatum w) x :=
((hsm.differentiableOn (by simp)) x hx).differentiableAt (diskOpen.mem_nhds hx)
have hf (x : Plane) (hx : x ∈ disk) : ‖fderiv ℝ (c.pullDatum w) x‖₊ ≤ B := by
change ‖fderiv ℝ (c.pullDatum w) x‖ ≤ (B : ℝ)
simpa only [gradient,LinearIsometryEquiv.norm_map] using hB x hx
exact ⟨B,LipschitzOnWith.closure (c.pullDatum_continuous hw.continuousOn)
((convex_ball (0 : Plane) 1).lipschitzOnWith_of_nnnorm_fderiv_le hd hf)⟩
lemma pullDatum_H1 (hb : Bornology.IsBounded Ω) (hs : SmoothBoundary Ω)
{w : Plane → ℝ} (hw : ContDiffOn ℝ ∞ w (closure Ω)) :
HasH1Gradient disk (c.pullDatum w) (gradient (c.pullDatum w)) := by
have hsm := c.pullDatum_smooth (hw.mono subset_closure)
apply HasH1Gradient.of_contDiffOn diskOpen hsm
(continuous_closure_memLp diskOpen diskBounded (c.pullDatum_continuous hw.continuousOn))
let : IsFiniteMeasure (volume.restrict disk) := isFiniteMeasure_restrict.mpr diskBounded.measure_lt_top.ne
obtain ⟨B,hB⟩ := c.pullDatum_bounded_gradient hb hs hw
have hc : ContinuousOn (gradient (c.pullDatum w)) disk :=
(InnerProductSpace.toDual ℝ Plane).symm.continuous.comp_continuousOn
(hsm.continuousOn_fderiv_of_isOpen diskOpen (by simp))
apply MemLp.of_bound (hc.aestronglyMeasurable diskOpen.measurableSet) B
filter_upwards [ae_restrict_mem diskOpen.measurableSet] with x hx
exact hB x hx
end StrictHotSpots.Conformal.ClosedDiskChart
end
end ClosedSmoothData
end OAI
import OAI.Analysis.HotSpots.Riemann
import OAI.Analysis.HotSpots.Trace
namespace OAI
section RollingBallTaylor
noncomputable section
open Set Metric Filter
open scoped Topology NNReal
namespace StrictHotSpots.Rolling
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
lemma taylor_quadratic {f : E → ℝ} {U : Set E} {K : ℝ≥0}
(hU : Convex ℝ U) (hd : ∀ x ∈ U, DifferentiableAt ℝ f x)
(hL : LipschitzOnWith K (fderiv ℝ f) U) {p x : E} (hp : p ∈ U) (hx : x ∈ U) :
‖f x-f p-fderiv ℝ f p (x-p)‖ ≤ (K:ℝ)*‖x-p‖^2 := by
have hs : segment ℝ p x ⊆ U := hU.segment_subset hp hx
have H := (convex_segment p x).norm_image_sub_le_of_norm_fderiv_le'
(fun y hy => hd y (hs hy))
(φ := fderiv ℝ f p) (C := (K:ℝ)*‖x-p‖)
(fun y hy => (hL.norm_sub_le (hs hy) hp).trans
(mul_le_mul_of_nonneg_left (norm_sub_le_of_mem_segment hy) K.coe_nonneg))
(left_mem_segment ℝ p x) (right_mem_segment ℝ p x)
simpa only [pow_two,mul_assoc] using H
lemma norm_sub_smul_sq (y n : E) (r : ℝ) :
‖y-r•n‖^2 = ‖y‖^2 - 2*r*inner ℝ y n + r^2*‖n‖^2 := by
rw [norm_sub_sq_real,real_inner_smul_right,norm_smul,Real.norm_eq_abs,
mul_pow,sq_abs]
ring
lemma tangent_ball_linear {p n x : E} {r : ℝ} (hn : ‖n‖ = 1) (hr : 0 < r)
(hx : x ∈ ball (p+r•n) r) :
‖x-p‖^2 < 2*r*inner ℝ (x-p) n := by
have hh : ‖(x-p)-r•n‖ < r := by
simpa only [mem_ball,dist_eq_norm,sub_add_eq_sub_sub] using hx
have hh2 := (sq_lt_sq₀ (norm_nonneg _) hr.le).mpr hh
rw [norm_sub_smul_sq,hn,one_pow,mul_one] at hh2
linarith
lemma balls_of_taylor {f : E → ℝ} {p n : E} {U : Set E} {a K r : ℝ}
(hn : ‖n‖ = 1) (ha : 0 < a) (hr : 0 < r)
(hsmall : 2*r*K ≤ a) (hzero : f p = 0)
(hD : ∀ v, fderiv ℝ f p v = a*inner ℝ n v)
(hB : ball p (2*r) ⊆ U)
(hT : ∀ x ∈ U, ‖f x-f p-fderiv ℝ f p (x-p)‖ ≤ K*‖x-p‖^2) :
ball (p-r•n) r ⊆ {x | f x < 0} ∧
ball (p+r•n) r ⊆ {x | 0 < f x} := by
have hside (N : E) (hN : ‖N‖ = 1) (x : E) (hx : x ∈ ball (p+r•N) r) :
x ∈ U ∧ ‖x-p‖^2 < 2*r*inner ℝ (x-p) N := by
refine ⟨hB ?_,tangent_ball_linear hN hr hx⟩
have hd : dist (p+r•N) p = r := by
simp [dist_eq_norm,norm_smul,hN,abs_of_pos hr]
calc
dist x p ≤ dist x (p+r•N)+dist (p+r•N) p := dist_triangle _ _ _
_ < r+r := add_lt_add_of_lt_of_le hx (le_of_eq hd)
_ = 2*r := by ring
constructor
· intro x hx
have hx' : x ∈ ball (p+r•(-n)) r := by simpa [smul_neg,sub_eq_add_neg] using hx
obtain ⟨hxU,hx2⟩ := hside (-n) (by simpa using hn) x hx'
rw [inner_neg_right,real_inner_comm n (x-p)] at hx2
have ht := hT x hxU
rw [hzero,sub_zero,hD,Real.norm_eq_abs] at ht
have he := (le_abs_self (f x-a*inner ℝ n (x-p))).trans ht
have hk := mul_le_mul_of_nonneg_right hsmall (sq_nonneg ‖x-p‖)
have hstrict := mul_lt_mul_of_pos_left hx2 ha
have hmul := mul_le_mul_of_nonneg_left he (mul_pos (by norm_num : (0:ℝ)<2) hr).le
change f x < 0
nlinarith only [hmul,hstrict,hk,hr]
· intro x hx
obtain ⟨hxU,hx2⟩ := hside n hn x hx
rw [real_inner_comm n (x-p)] at hx2
have ht := hT x hxU
rw [hzero,sub_zero,hD,Real.norm_eq_abs] at ht
have he' : -(K*‖x-p‖^2) ≤ f x-a*inner ℝ n (x-p) := by
have hh := neg_abs_le (f x-a*inner ℝ n (x-p))
linarith [ht]
have hk := mul_le_mul_of_nonneg_right hsmall (sq_nonneg ‖x-p‖)
have hstrict := mul_lt_mul_of_pos_left hx2 ha
have hmul := mul_le_mul_of_nonneg_left he' (mul_pos (by norm_num : (0:ℝ)<2) hr).le
change 0 < f x
nlinarith only [hmul,hstrict,hk,hr]
end StrictHotSpots.Rolling
end
end RollingBallTaylor
section RollingBallMetric
noncomputable section
open Set Metric Filter
open scoped Topology
namespace StrictHotSpots.Rolling