| import Mathlib |
| import OAI.Geometry.BallPacking.Fredholm.FreeLinearization |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Function Filter |
| section |
| section BilinearLimit |
| variable {T X Y Z : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] |
| [NormedAddCommGroup Y] [NormedSpace ℝ Y] [NormedAddCommGroup Z] [NormedSpace ℝ Z] |
| lemma bilinear_tendsto_zero_of_bounded (B : X →L[ℝ] Y →L[ℝ] Z) {l : Filter T} |
| {A : T → X} (hA : Tendsto A l (𝓝 0)) (V : T → Y) (M : ℝ) (hM : ∀ t, ‖V t‖≤M) : |
| Tendsto (fun t => B (A t) (V t)) l (𝓝 0) := by |
| have hbound (t : T) : ‖B (A t) (V t)‖≤‖B‖*‖A t‖*M := |
| (B.le_opNorm₂ _ _).trans (mul_le_mul_of_nonneg_left (hM t) (by positivity)) |
| have hl : Tendsto (fun t => ‖B‖*‖A t‖*M) l (𝓝 0) := by |
| simpa only [norm_zero,mul_zero,zero_mul] using (tendsto_const_nhds.mul hA.norm).mul_const M |
| exact squeeze_zero_norm hbound hl |
| end BilinearLimit |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance tcInst1 : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance tcInst2 : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace |
| local instance tcInst3 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance tcInst4 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance tcInst5 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance tcInst6 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
| local instance tcInst7 : NormedAddCommGroup (COne ℂ (E →L[ℝ] E)) := inferInstance |
| local instance tcInst8 : NormedSpace ℝ (COne ℂ (E →L[ℝ] E)) := inferInstance |
| local instance tcInst9 : NormedAddCommGroup (HMap ℂ (E →L[ℝ] E)) := inferInstance |
| local instance tcInst10 : NormedSpace ℝ (HMap ℂ (E →L[ℝ] E)) := inferInstance |
|
|
| def translationError (A : COne ℂ (E →L[ℝ] E)) (a : E) (u : COne ℂ E) (t : ℂ) : HMap ℂ E := |
| bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip |
| (holderTranslate t (jetValueCLM _ A)-jetValueCLM _ A) |
| (const _ a+holderTranslate t (jetDirection 1 u)) |
|
|
| omit [CompleteSpace E] in |
| lemma translationError_value [CompleteSpace E] (A : COne ℂ (E →L[ℝ] E)) (a : E) (u : COne ℂ E) (t z : ℂ) : |
| valueCLM _ (translationError A a u t) z = |
| (cValue A (z+t)-cValue A z) (a+cDeriv u (z+t) 1) := rfl |
|
|
| omit [CompleteSpace E] in |
| lemma translation_second_factor_bound [CompleteSpace E] (a : E) (u : COne ℂ E) (t : ℂ) : |
| ‖const (X := ℂ) ((1:ℝ)/3) a+holderTranslate t (jetDirection 1 u)‖ ≤ |
| ‖const (X := ℂ) ((1:ℝ)/3) a‖+‖jetDirection 1 u‖ := by |
| have ht : ‖holderTranslate t (jetDirection 1 u)‖ ≤ ‖jetDirection 1 u‖ := holderTranslate_norm_le t (jetDirection 1 u) |
| exact (norm_add_le (const (X := ℂ) ((1:ℝ)/3) a) (holderTranslate t (jetDirection 1 u))).trans |
| (add_le_add le_rfl ht) |
|
|
| lemma translationError_tendsto (A : COne ℂ (E →L[ℝ] E)) (a : E) (u : COne ℂ E) : |
| Tendsto (translationError A a u) (𝓝 0) (𝓝 0) := by |
| have hA : Tendsto (fun t => holderTranslate t (jetValueCLM _ A)-jetValueCLM _ A) (𝓝 0) (𝓝 0) := by |
| simpa only [sub_self] using (jetValue_translate_tendsto A).sub_const (jetValueCLM _ A) |
| exact bilinear_tendsto_zero_of_bounded |
| (bilinCLM (X := ℂ) (α := (1:ℝ)/3) (ContinuousLinearMap.apply (E := E) ℝ E).flip) hA |
| (fun t => const _ a+holderTranslate t (jetDirection 1 u)) |
| (‖const (X := ℂ) ((1:ℝ)/3) a‖+‖jetDirection 1 u‖) (translation_second_factor_bound a u) |
|
|
| omit [CompleteSpace E] in |
| lemma translation_CR_algebra [CompleteSpace E] (A0 A1 : E →L[ℝ] E) (a dx0 dy0 dx1 dy1 : E) |
| (h0 : Complex.I • a+dy0=A0 (a+dx0)) (h1 : Complex.I • a+dy1=A1 (a+dx1)) : |
| (dy1-dy0)-A0 (dx1-dx0)=(A1-A0) (a+dx1) := by |
| rw [map_sub,sub_apply,map_add,map_add] |
| rw [map_add] at h0 h1 |
| calc |
| _ = (Complex.I • a+dy1)-(Complex.I • a+dy0)-A0 dx1+A0 dx0 := by abel |
| _ = _ := by rw [h1,h0]; abel |
|
|
| variable {R S : ℝ} (hRS : R+1 ≤ S) (a : E) |
| (u : freeModel (E := E) (Metric.closedBall (0:ℂ) R)) |
| (A : COne ℂ (E →L[ℝ] E)) |
| (hA : ∀ z ∉ Metric.closedBall (0:ℂ) S, cValue A z=complexI (E := E)) |
| (hcr : ∀ z, Complex.I • a+cDeriv u.val z Complex.I = cValue A z (a+cDeriv u.val z 1)) |
| local instance tcInst11 : NormedAddCommGroup (freeModel (E := E) (Metric.closedBall (0:ℂ) S)) := inferInstance |
| local instance tcInst12 : NormedSpace ℝ (freeModel (E := E) (Metric.closedBall (0:ℂ) S)) := inferInstance |
| local instance tcInst13 : NormedAddCommGroup (supportedHolder (E := E) (Metric.closedBall (0:ℂ) S)) := inferInstance |
| local instance tcInst14 : NormedSpace ℝ (supportedHolder (E := E) (Metric.closedBall (0:ℂ) S)) := inferInstance |
|
|
| include hcr in |
| lemma freeTranslation_principal_near : |
| ∀ᶠ t in 𝓝 (0:ℂ), |
| (freePrincipal (jetValueCLM _ A) hA (freeTranslation hRS a u t)).val=translationError A a u.val t := by |
| filter_upwards [freeTranslation_near hRS a u] with t ht |
| apply value_ext |
| intro z |
| have hv := freePrincipal_value (jetValueCLM _ A) hA (freeTranslation hRS a u t) z |
| have he : cDeriv (freeTranslation hRS a u t).val z = cDeriv u.val (z+t)-cDeriv u.val z := |
| (congrArg (fun w : COne ℂ E => cDeriv w z) ht).trans (translationVariation_deriv a u.val t z) |
| have hh := congrArg (fun L : ℂ →L[ℝ] E => L Complex.I-cValue A z (L 1)) he |
| apply hv.trans (hh.trans _) |
| exact (translation_CR_algebra (cValue A z) (cValue A (z+t)) a |
| (cDeriv u.val z 1) (cDeriv u.val z Complex.I) |
| (cDeriv u.val (z+t) 1) (cDeriv u.val (z+t) Complex.I) (hcr z) (hcr (z+t))).trans |
| (translationError_value A a u.val t z).symm |
|
|
| include hcr in |
| lemma freeTranslation_principal_tendsto : |
| Tendsto (fun t => freePrincipal (jetValueCLM _ A) hA (freeTranslation hRS a u t)) (𝓝 0) (𝓝 0) := by |
| have heq : (fun t => (freePrincipal (jetValueCLM _ A) hA (freeTranslation hRS a u t)).val) =ᶠ[𝓝 0] |
| translationError A a u.val := freeTranslation_principal_near hRS a u A hA hcr |
| have hh : Tendsto (fun t => (freePrincipal (jetValueCLM _ A) hA (freeTranslation hRS a u t)).val) |
| (𝓝 0) (𝓝 (0 : HMap ℂ E)) := |
| (translationError_tendsto A a u.val).congr' heq.symm |
| exact tendsto_subtype_rng.mpr hh |
|
|
| variable [FiniteDimensional ℝ E] |
| include hcr in |
| lemma elliptic_freeTranslation_continuous |
| (hP : (freePrincipal (jetValueCLM _ A) hA).IsFredholm) : |
| ContinuousAt (freeTranslation hRS a u) 0 := by |
| obtain ⟨s,L,hL⟩ := exists_jet_fredholm_observations |
| (freeModel (E := E) (Metric.closedBall (0:ℂ) S)) (freePrincipal (jetValueCLM _ A) hA) hP |
| have hQ := (freeTranslation_observation_smoothAt hRS a u s).continuousAt |
| have hQt : Tendsto (fun t => subspaceObservations (freeModel (E := E) (Metric.closedBall (0:ℂ) S)) s |
| (freeTranslation hRS a u t)) (𝓝 0) (𝓝 0) := by |
| simpa only [freeTranslation_zero,map_zero] using hQ.tendsto |
| have hb := (freeTranslation_principal_tendsto hRS a u A hA hcr).prodMk_nhds hQt |
| have hh := (L.continuous.tendsto (0,0)).comp hb |
| have he (t : ℂ) : L (freePrincipal (jetValueCLM _ A) hA (freeTranslation hRS a u t), |
| subspaceObservations (freeModel (E := E) (Metric.closedBall (0:ℂ) S)) s (freeTranslation hRS a u t)) = |
| freeTranslation hRS a u t := hL _ |
| change Tendsto (freeTranslation hRS a u) _ _ |
| simpa only [Function.comp_def,he,freeTranslation_zero,Prod.mk_zero_zero,map_zero] using hh |
|
|
| end |
| section |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance teInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance teInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance teInst3 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance teInst4 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
|
|
| omit [CompleteSpace E] in |
| lemma affineCurve_translation [CompleteSpace E] (p a : E) (u : COne ℂ E) (t z : ℂ) : |
| affineCurve p (complexSlope a) (u+translationVariation a u t) z = |
| affineCurve p (complexSlope a) u (z+t) := by |
| change p+z • a+(cValue u z+(t • a+cValue u (z+t)-cValue u z)) = p+(z+t) • a+cValue u (z+t) |
| rw [add_smul] |
| abel |
|
|
| lemma affineCurve_translation_fderiv (p a : E) (u : COne ℂ E) (t z : ℂ) : |
| fderiv ℝ (affineCurve p (complexSlope a) (u+translationVariation a u t)) z = |
| fderiv ℝ (affineCurve p (complexSlope a) u) (z+t) := by |
| rw [affineCurve_fderiv,affineCurve_fderiv] |
| change complexSlope a+(cDeriv u z+cDeriv (translationVariation a u t) z) = _ |
| rw [translationVariation_deriv] |
| abel |
|
|
| lemma affineCurve_translation_CR (J : E → E →L[ℝ] E) (p a : E) (u : COne ℂ E) |
| (hcr : ∀ z, fderiv ℝ (affineCurve p (complexSlope a) u) z Complex.I = |
| J (affineCurve p (complexSlope a) u z) (fderiv ℝ (affineCurve p (complexSlope a) u) z 1)) (t z : ℂ) : |
| fderiv ℝ (affineCurve p (complexSlope a) (u+translationVariation a u t)) z Complex.I = |
| J (affineCurve p (complexSlope a) (u+translationVariation a u t) z) |
| (fderiv ℝ (affineCurve p (complexSlope a) (u+translationVariation a u t)) z 1) := by |
| rw [affineCurve_translation_fderiv,affineCurve_translation] |
| exact hcr (z+t) |
|
|
| variable {J : E → E →L[ℝ] E} (hJ : BoundedCThree J) (b : ContDiffBump (0:ℂ)) (p a : E) |
| local instance teInst5 : NormedAddCommGroup (freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance teInst6 : NormedSpace ℝ (freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| variable (u : freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) {B : ℝ} |
| (hstd : ∀ x, B<‖x‖ → J x=complexI (E := E)) |
| (hesc : ∀ᶠ v in 𝓝 (0 : freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)), |
| ∀ z, b.rIn≤‖z‖ → B<‖affineCurve p (complexSlope a) (u.val+v.val) z‖) |
|
|
| include hstd in |
| lemma freeChart_zero_of_CR (v : freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) |
| (he : ∀ z, b.rIn≤‖z‖ → B<‖affineCurve p (complexSlope a) (u.val+v.val) z‖) |
| (hcr : ∀ z, fderiv ℝ (affineCurve p (complexSlope a) (u.val+v.val)) z Complex.I = |
| J (affineCurve p (complexSlope a) (u.val+v.val) z) |
| (fderiv ℝ (affineCurve p (complexSlope a) (u.val+v.val)) z 1)) : |
| freeChart hJ b p a u v=0 := by |
| apply Subtype.ext |
| apply value_ext |
| intro z |
| have hv := freeChart_true_value hJ b p a u hstd v he z |
| have hzero := (crSection_eq_zero_iff hJ p (complexSlope a) (u.val+v.val)).mpr hcr |
| apply hv.trans |
| rw [hzero] |
| rfl |
|
|
| include hstd hesc in |
| lemma freeChart_translation_zero_near |
| (V : ℂ → freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) |
| (hV : ContinuousAt V 0) (hV0 : V 0=0) |
| (hv : ∀ᶠ t in 𝓝 (0:ℂ), (V t).val=translationVariation a u.val t) |
| (hcr : ∀ z, fderiv ℝ (affineCurve p (complexSlope a) u.val) z Complex.I = |
| J (affineCurve p (complexSlope a) u.val z) (fderiv ℝ (affineCurve p (complexSlope a) u.val) z 1)) : |
| ∀ᶠ t in 𝓝 (0:ℂ), freeChart hJ b p a u (V t)=0 := by |
| have ht : Tendsto V (𝓝 0) (𝓝 0) := by simpa only [hV0] using hV.tendsto |
| filter_upwards [ht.eventually hesc,hv] with t hte htv |
| apply freeChart_zero_of_CR hJ b p a u hstd (V t) hte |
| intro z |
| rw [htv] |
| exact affineCurve_translation_CR J p a u.val hcr t z |
|
|
| omit hJ hstd hesc in |
| lemma source_smooth_of_translation |
| (V : ℂ → freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) |
| (hv : ∀ᶠ t in 𝓝 (0:ℂ), (V t).val=translationVariation a u.val t) |
| (hs : ContDiffAt ℝ ∞ V 0) : ContDiff ℝ ∞ (affineCurve p (complexSlope a) u.val) := by |
| apply contDiff_iff_contDiffAt.mpr |
| intro z |
| let L : freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut) →L[ℝ] E := |
| (jetEval z).comp (freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)).subtypeL |
| have ho : ContDiffAt ℝ ∞ (fun t => affineCurve p (complexSlope a) u.val z+L (V t)) 0 := |
| contDiffAt_const.add (L.contDiff.contDiffAt.comp 0 hs) |
| have heq : (fun t => affineCurve p (complexSlope a) u.val (z+t)) =ᶠ[𝓝 0] |
| (fun t => affineCurve p (complexSlope a) u.val z+L (V t)) := by |
| filter_upwards [hv] with t ht |
| change affineCurve p (complexSlope a) u.val (z+t) = |
| affineCurve p (complexSlope a) u.val z+cValue (V t).val z |
| rw [ht,translationVariation_value] |
| change p+(z+t) • a+cValue u.val (z+t) = |
| (p+z • a+cValue u.val z)+(t • a+cValue u.val (z+t)-cValue u.val z) |
| rw [add_smul] |
| abel |
| have hf := ho.congr_of_eventuallyEq heq |
| have hsub : ContDiffAt ℝ ∞ (fun t : ℂ => t-z) z := contDiffAt_id.sub contDiffAt_const |
| have hf' : ContDiffAt ℝ ∞ (fun t => affineCurve p (complexSlope a) u.val (z+t)) (z-z) := by |
| simpa only [sub_self] using hf |
| have hcomp := hf'.comp (f := fun t : ℂ => t-z) z hsub |
| convert! hcomp using 1 |
| funext t |
| congr 1 |
| simp only |
| abel |
|
|
| end |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance feInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance feInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance feInst3 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance feInst4 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
|
|
| omit [CompleteSpace E] in |
| lemma affine_free_norm_lower [CompleteSpace E] (p a : E) (u v : COne ℂ E) (z : ℂ) : |
| ‖z‖*‖a‖-‖p‖-‖u‖-‖v‖ ≤ ‖affineCurve p (complexSlope a) (u+v) z‖ := by |
| have h : ‖z • a‖ ≤ ‖affineCurve p (complexSlope a) (u+v) z‖+‖p‖+‖cValue u z‖+‖cValue v z‖ := by |
| calc |
| _ = ‖((affineCurve p (complexSlope a) (u+v) z-p)-cValue u z)-cValue v z‖ := by |
| congr 1 |
| change z • a=((p+z • a+(cValue u z+cValue v z)-p)-cValue u z)-cValue v z |
| abel |
| _ ≤ ‖(affineCurve p (complexSlope a) (u+v) z-p)-cValue u z‖+‖cValue v z‖ := norm_sub_le _ _ |
| _ ≤ (‖affineCurve p (complexSlope a) (u+v) z-p‖+‖cValue u z‖)+‖cValue v z‖ := |
| add_le_add (norm_sub_le _ _) le_rfl |
| _ ≤ _ := by linarith [norm_sub_le (affineCurve p (complexSlope a) (u+v) z) p] |
| rw [norm_smul] at h |
| linarith [c_value_bound u z,c_value_bound v z] |
|
|
| lemma exists_free_escape_radius (p a : E) (u : COne ℂ E) (ha : a≠0) (B : ℝ) : |
| ∃ R : ℝ, 0<R ∧ ∀ v : COne ℂ E, ‖v‖<1 → ∀ z : ℂ, R≤‖z‖ → |
| B<‖affineCurve p (complexSlope a) (u+v) z‖ := by |
| let R := (max B 0+‖p‖+‖u‖+2)/‖a‖ |
| have ha' : 0<‖a‖ := norm_pos_iff.mpr ha |
| have hR : 0<R := div_pos (by have := le_max_right B 0; positivity) ha' |
| refine ⟨R,hR,?_⟩ |
| intro v hv z hz |
| have hn : max B 0+‖p‖+‖u‖+2 ≤ ‖z‖*‖a‖ := by |
| have hm := mul_le_mul_of_nonneg_right hz ha'.le |
| dsimp only [R] at hm |
| rwa [div_mul_cancel₀ _ ha'.ne'] at hm |
| exact (show B<‖z‖*‖a‖-‖p‖-‖u‖-‖v‖ by linarith [le_max_left B 0]).trans_le |
| (affine_free_norm_lower p a u v z) |
|
|
| omit [CompleteSpace E] in |
| lemma freeModel_mono [CompleteSpace E] {K L : Set ℂ} (h : K⊆L) : freeModel (E := E) K ≤ freeModel (E := E) L := by |
| intro u hu |
| apply (mem_supportedHolder _ _).mpr |
| intro z hz |
| exact (mem_supportedHolder _ _).mp hu z (fun hK => hz (h hK)) |
|
|
| omit [CompleteSpace E] in |
| lemma freeModel_of_elliptic [CompleteSpace E] {J : E → E →L[ℝ] E} {B R : ℝ} |
| (hstd : ∀ x, B<‖x‖ → J x=complexI (E := E)) |
| (p a : E) (u : COne ℂ E) |
| (hcr : ∀ z, fderiv ℝ (affineCurve p (complexSlope a) u) z Complex.I = |
| J (affineCurve p (complexSlope a) u z) (fderiv ℝ (affineCurve p (complexSlope a) u) z 1)) |
| (he : ∀ z, R≤‖z‖ → B<‖affineCurve p (complexSlope a) u z‖) : |
| u∈freeModel (E := E) (Metric.closedBall (0:ℂ) R) := by |
| apply (mem_supportedHolder _ _).mpr |
| intro z hz |
| have hz' : R≤‖z‖ := (show R<‖z‖ by simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hz).le |
| have hh := hcr z |
| rw [hstd _ (he z hz'),affineCurve_fderiv] at hh |
| change Complex.I • a+cDeriv u z Complex.I=Complex.I • ((1:ℂ) • a+cDeriv u z 1) at hh |
| rw [one_smul,smul_add] at hh |
| have hd := add_left_cancel hh |
| change valueCLM _ (standardJetCR u) z=0 |
| rw [standardJetCR_value] |
| exact sub_eq_zero.mpr hd |
|
|
| variable (b : ContDiffBump (0:ℂ)) |
| local instance feInst5 : NormedAddCommGroup (freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance feInst6 : NormedSpace ℝ (freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
|
|
| def FreeEscapeNeighborhood (p a : E) (u : COne ℂ E) (B : ℝ) : Prop := |
| ∀ᶠ v : freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut) in 𝓝 0, |
| ∀ z, b.rIn≤‖z‖ → B<‖affineCurve p (complexSlope a) (u+v.val) z‖ |
|
|
| omit [CompleteSpace E] in |
| lemma freeEscape_of_radius [CompleteSpace E] (p a : E) (u : COne ℂ E) (B : ℝ) |
| (he : ∀ v : COne ℂ E, ‖v‖<1 → ∀ z : ℂ, b.rIn≤‖z‖ → |
| B<‖affineCurve p (complexSlope a) (u+v) z‖) : FreeEscapeNeighborhood b p a u B := by |
| filter_upwards [Metric.ball_mem_nhds (0 : freeModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) (show (0:ℝ)<1 by norm_num)] with v hv |
| have hv' : ‖v.val‖<1 := by simpa only [Metric.mem_ball,dist_zero_right,Submodule.norm_coe] using hv |
| exact he v.val hv' |
|
|
| end HigherDimensionalBallPacking.Rigidity.HolderCompletion |
|
|
| namespace HigherDimensionalBallPacking.Rigidity |
| open scoped ContDiff Topology |
| open Set Function Filter |
| variable {X E F D : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] |
| [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| [NormedAddCommGroup D] [NormedSpace ℝ D] |
|
|
| lemma nonlinear_stabilized_regularity {f : E → F} (hf : ContDiff ℝ ∞ f) |
| {P : E →L[ℝ] F} {v : X → E} {x : X} (hP : HasFDerivAt f P (v x)) |
| (Q : E →L[ℝ] D) (L : F × D →L[ℝ] E) (hL : LeftInverse L (P.prod Q)) |
| (hv : ContinuousAt v x) (hQ : ContDiffAt ℝ ∞ (fun t => Q (v t)) x) |
| (he : ∀ᶠ t in 𝓝 x, f (v t)=0) : ContDiffAt ℝ ∞ v x := by |
| let G : E → E := fun y => L (f y,Q y) |
| have hG : ContDiff ℝ ∞ G := L.contDiff.comp (hf.prodMk Q.contDiff) |
| have hd : HasFDerivAt G (ContinuousLinearEquiv.refl ℝ E).toContinuousLinearMap (v x) := by |
| have hh := L.hasFDerivAt.comp (v x) (hP.prodMk (Q.hasFDerivAt (x := v x))) |
| have h : L.comp (P.prod Q) = (ContinuousLinearEquiv.refl ℝ E).toContinuousLinearMap := by |
| ext y |
| exact hL y |
| exact h ▸ hh |
| let e := hG.contDiffAt.toOpenPartialHomeomorph G hd (by simp) |
| have hm : v x ∈ e.source := ContDiffAt.mem_toOpenPartialHomeomorph_source hG.contDiffAt hd (by simp) |
| have hs : ContDiffAt ℝ ∞ e.symm (G (v x)) := |
| ContDiffAt.to_localInverse hG.contDiffAt hd (by simp) |
| have hval : G (v x)=L (0,Q (v x)) := by |
| change L (f (v x),Q (v x)) = _ |
| rw [he.self_of_nhds] |
| have hout : ContDiffAt ℝ ∞ (fun t => e.symm (L (0,Q (v t)))) x := by |
| rw [hval] at hs |
| exact hs.comp x (L.contDiff.contDiffAt.comp x (contDiffAt_const.prodMk hQ)) |
| apply hout.congr_of_eventuallyEq |
| have hn : ∀ᶠ t in 𝓝 x, v t∈e.source := hv.eventually (e.open_source.mem_nhds hm) |
| filter_upwards [hn,he] with t ht ht0 |
| have hh := e.left_inv ht |
| change e.symm (G (v t))=v t at hh |
| change v t=e.symm (L (0,Q (v t))) |
| calc |
| v t = e.symm (G (v t)) := hh.symm |
| _ = e.symm (L (0,Q (v t))) := by |
| apply congrArg e.symm |
| change L (f (v t),Q (v t))=L (0,Q (v t)) |
| rw [ht0] |
|
|
| end HigherDimensionalBallPacking.Rigidity |
|
|
| namespace HigherDimensionalBallPacking.Rigidity.HolderCompletion |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Function Filter |
| section |
| variable {n : ℕ} |
| local instance srInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance srInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
| local instance srInst3 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance |
| local instance srInst4 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance |
| local instance srInst5 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance |
| local instance srInst6 : NormedSpace ℝ (HMap ℂ (Phase n)) := inferInstance |
| variable {J : Phase n → End n} (hJ : ContDiff ℝ ∞ J) (hc : ∀ x, Compatible (J x)) {B : ℝ} |
| (hstd : ∀ x, B<‖x‖ → J x=standardJ n) (b : ContDiffBump (0:ℂ)) (p q : Phase n) |
| local instance srInst7 : NormedAddCommGroup (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance srInst8 : NormedSpace ℝ (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance srInst9 : AddCommGroup (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (srInst7 (n := n) b).toAddCommGroup |
| local instance srInst10 : Module ℝ (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (srInst8 (n := n) b).toModule |
| local instance srInst11 : TopologicalSpace (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := |
| (srInst7 (n := n) b).toPseudoMetricSpace.toUniformSpace.toTopologicalSpace |
| variable (w : freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) {R : ℝ} |
| (hRS : R+1≤b.rOut) (hsupp : w.val ∈ freeModel (E := Phase n) (Metric.closedBall (0:ℂ) R)) |
| (hesc : FreeEscapeNeighborhood b p (markedSlope p q w.val) w.val B) |
| (hcr : ∀ z, fderiv ℝ (markedCurve p q w.val) z Complex.I = |
| J (markedCurve p q w.val z) (fderiv ℝ (markedCurve p q w.val) z 1)) |
|
|
| def regularityTranslation : ℂ → freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut) := |
| freeTranslation hRS (markedSlope p q w.val) ⟨w.val,hsupp⟩ |
|
|
| @[simp] lemma regularityTranslation_zero : regularityTranslation b p q w hRS hsupp 0=0 := |
| freeTranslation_zero hRS (markedSlope p q w.val) ⟨w.val,hsupp⟩ |
|
|
| lemma regularityTranslation_near : ∀ᶠ t in 𝓝 (0:ℂ), |
| (regularityTranslation b p q w hRS hsupp t).val=translationVariation (markedSlope p q w.val) w.val t := |
| freeTranslation_near hRS (markedSlope p q w.val) ⟨w.val,hsupp⟩ |
|
|
| include hJ hstd hc hesc hcr hRS hsupp in |
| lemma regularityTranslation_continuous : ContinuousAt (regularityTranslation b p q w hRS hsupp) 0 := by |
| let A := completedStructureJet hJ hstd p q w.val |
| have he := free_escape_base p q b w hesc |
| have hA : ∀ z ∉ Metric.closedBall (0:ℂ) b.rOut, cValue A z=complexI (E := Phase n) := |
| fun z hz => hstd _ (he z hz) |
| have hcr' : ∀ z, Complex.I • markedSlope p q w.val+cDeriv w.val z Complex.I = |
| cValue A z (markedSlope p q w.val+cDeriv w.val z 1) := by |
| intro z |
| simpa only [A,completedStructureJet_value,markedCurve_fderiv,add_apply,complexSlope_apply,one_smul] using hcr z |
| have hp : (freePrincipal (jetValueCLM _ A) hA).IsFredholm := |
| completedFreePrincipal_fredholm hJ hc hstd p q w.val (isCompact_closedBall (0:ℂ) b.rOut) he |
| exact elliptic_freeTranslation_continuous hRS (markedSlope p q w.val) ⟨w.val,hsupp⟩ A hA hcr' hp |
|
|
| include hJ hstd hc hesc hcr hRS hsupp in |
| lemma regularityTranslation_smooth : ContDiffAt ℝ ∞ (regularityTranslation b p q w hRS hsupp) 0 := by |
| let V := regularityTranslation b p q w hRS hsupp |
| let D := fderiv ℝ (actualFreeChart hJ hstd p q b w) 0 |
| have hf := actualFreeChart_contDiff hJ hstd p q b w |
| have hD : D.IsFredholm := actualFreeChart_fderiv_fredholm hJ hc hstd p q b w hesc |
| obtain ⟨s,L,hL⟩ := exists_jet_fredholm_observations |
| (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) D hD |
| have hd : HasFDerivAt (actualFreeChart hJ hstd p q b w) D (V 0) := by |
| change HasFDerivAt _ D (regularityTranslation b p q w hRS hsupp 0) |
| rw [regularityTranslation_zero] |
| exact (hf.differentiable (by simp) 0).hasFDerivAt |
| have hV : ContinuousAt V 0 := regularityTranslation_continuous hJ hc hstd b p q w hRS hsupp hesc hcr |
| have hQ : ContDiffAt ℝ ∞ (fun t => subspaceObservations |
| (freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) s (V t)) 0 := |
| freeTranslation_observation_smoothAt hRS (markedSlope p q w.val) ⟨w.val,hsupp⟩ s |
| have hz : ∀ᶠ t in 𝓝 (0:ℂ), actualFreeChart hJ hstd p q b w (V t)=0 := |
| freeChart_translation_zero_near (actualStructureBound hJ hstd) b p (markedSlope p q w.val) w hstd hesc V hV |
| (regularityTranslation_zero b p q w hRS hsupp) (regularityTranslation_near b p q w hRS hsupp) hcr |
| exact nonlinear_stabilized_regularity hf hd _ L hL hV hQ hz |
|
|
| include hJ hstd hc hesc hcr hRS hsupp in |
| lemma completed_free_source_contDiff : ContDiff ℝ ∞ (markedCurve p q w.val) := by |
| have hs := regularityTranslation_smooth hJ hc hstd b p q w hRS hsupp hesc hcr |
| have hh := source_smooth_of_translation b p (markedSlope p q w.val) w |
| (regularityTranslation b p q w hRS hsupp) (regularityTranslation_near b p q w hRS hsupp) hs |
| exact hh |
|
|
| end |
| section |
| variable {n : ℕ} |
| local instance actFredInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance actFredInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
| local instance actFredInst3 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance |
| local instance actFredInst4 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance |
| local instance actFredInst5 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance |
| local instance actFredInst6 : NormedSpace ℝ (HMap ℂ (Phase n)) := inferInstance |
| variable {J : Phase n → End n} (hJ : ContDiff ℝ ∞ J) (hc : ∀ x, Compatible (J x)) {B : ℝ} |
| (hstd : ∀ x, B < ‖x‖ → J x=standardJ n) (b : ContDiffBump (0:ℂ)) (p q : Phase n) |
| local instance actFredInst7 : NormedAddCommGroup (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance actFredInst8 : NormedSpace ℝ (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance actFredInst9 : AddCommGroup (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (actFredInst7 (n := n) b).toAddCommGroup |
| local instance actFredInst10 : Module ℝ (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (actFredInst8 (n := n) b).toModule |
| local instance actFredInst11 : TopologicalSpace (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := |
| (actFredInst7 (n := n) b).toPseudoMetricSpace.toUniformSpace.toTopologicalSpace |
| local instance actFredInst12 : NormedAddCommGroup (supportedHolder (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance actFredInst13 : NormedSpace ℝ (supportedHolder (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance actFredInst14 : AddCommGroup (supportedHolder (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (actFredInst12 (n := n) b).toAddCommGroup |
| local instance actFredInst15 : Module ℝ (supportedHolder (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := (actFredInst13 (n := n) b).toModule |
| variable (u : markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) |
| (he : ∀ᶠ h in 𝓝 (0 : markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)), |
| ∀ z : ℂ, b.rIn ≤ ‖z‖ → B < ‖markedCurve p q (u.val+h.val) z‖ ∧ |
| B < ‖truncatedCurve b p q u.val h.val z‖) |
|
|
| include he in |
| lemma marked_escape_base : ∀ z ∉ Metric.closedBall (0:ℂ) b.rOut, B < ‖markedCurve p q u.val z‖ := by |
| intro z hz |
| have hz' : b.rIn ≤ ‖z‖ := by |
| have hz'' : b.rOut < ‖z‖ := by simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hz |
| exact (b.rIn_lt_rOut.trans hz'').le |
| have hh := (he.self_of_nhds z hz').1 |
| simpa only [Submodule.coe_zero,add_zero] using hh |
|
|
| lemma actualMarkedChart_derivative_eq_linearized |
| (b₁ : ContDiffBump (0:ℂ)) (hb₁ : Metric.closedBall (0:ℂ) b.rOut ⊆ Metric.closedBall (0:ℂ) b₁.rIn) : |
| fderiv ℝ (actualMarkedChart hJ hstd b p q u) 0 = |
| completedLinearized hJ hstd p q u.val (marked_escape_base b p q u he) b₁ hb₁ := by |
| apply ContinuousLinearMap.ext |
| intro v |
| apply Subtype.ext |
| apply value_ext |
| intro z |
| have hd := congrArg (fun L : markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut) →L[ℝ] Phase n => L v) |
| (actualMarkedChart_fderiv_eval hJ hstd b p q u he z) |
| exact hd.trans (completedLinearized_value hJ hstd p q u.val (marked_escape_base b p q u he) b₁ hb₁ v z).symm |
|
|
| def actualMarkedDerivative := fderiv ℝ (actualMarkedChart hJ hstd b p q u) 0 |
|
|
| def IsIndexZeroFredholm {X Y : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] |
| [NormedAddCommGroup Y] [NormedSpace ℝ Y] (D : X →L[ℝ] Y) : Prop := |
| D.IsFredholm ∧ Module.finrank ℝ D.ker = Module.finrank ℝ (Y ⧸ D.range) |
|
|
| include hc he in |
| lemma actualMarkedChart_derivative_fredholm : |
| IsIndexZeroFredholm (actualMarkedDerivative hJ hstd b p q u) := by |
| obtain ⟨b₁,hb₁⟩ := compact_subset_bump_inner (K := Metric.closedBall (0:ℂ) b.rOut) |
| (isCompact_closedBall (0:ℂ) b.rOut) |
| have hd : actualMarkedDerivative hJ hstd b p q u = |
| completedLinearized hJ hstd p q u.val (marked_escape_base b p q u he) b₁ hb₁ := |
| actualMarkedChart_derivative_eq_linearized hJ hstd b p q u he b₁ hb₁ |
| have hf : IsIndexZeroFredholm |
| (completedLinearized hJ hstd p q u.val (marked_escape_base b p q u he) b₁ hb₁) := |
| completedLinearized_fredholm hJ hc hstd p q u.val (isCompact_closedBall (0:ℂ) b.rOut) |
| (marked_escape_base b p q u he) b₁ hb₁ |
| exact hd ▸ hf |
|
|
| end |
| section |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance chartNbInst1 : NormedAddCommGroup (COne ℂ E) := inferInstance |
| local instance chartNbInst2 : NormedSpace ℝ (COne ℂ E) := inferInstance |
| local instance chartNbInst3 : NormedAddCommGroup (HMap ℂ E) := inferInstance |
| local instance chartNbInst4 : NormedSpace ℝ (HMap ℂ E) := inferInstance |
| local instance chartNbInst5 (K : Set ℂ) : NormedAddCommGroup (markedModel (E := E) K) := inferInstance |
| local instance chartNbInst6 (K : Set ℂ) : NormedSpace ℝ (markedModel (E := E) K) := inferInstance |
| local instance chartNbInst7 (K : Set ℂ) : AddCommGroup (markedModel (E := E) K) := (chartNbInst5 K).toAddCommGroup |
| local instance chartNbInst8 (K : Set ℂ) : Module ℝ (markedModel (E := E) K) := (chartNbInst6 K).toModule |
| local instance chartNbInst9 (K : Set ℂ) : TopologicalSpace (markedModel (E := E) K) := |
| (chartNbInst5 K).toPseudoMetricSpace.toUniformSpace.toTopologicalSpace |
|
|
| omit [CompleteSpace E] in |
| lemma supportedHolder_mono [CompleteSpace E] {K L : Set ℂ} (hKL : K ⊆ L) : |
| supportedHolder (E := E) K ≤ supportedHolder (E := E) L := by |
| intro g hg |
| rw [mem_supportedHolder] at hg ⊢ |
| intro z hz |
| exact hg z (fun hzK => hz (hKL hzK)) |
|
|
| lemma markedModel_mono {K L : Set ℂ} (hKL : K ⊆ L) : |
| markedModel (E := E) K ≤ markedModel (E := E) L := by |
| intro u hu |
| exact ⟨hu.1,supportedHolder_mono hKL hu.2⟩ |
|
|
| def widenMarked {K L : Set ℂ} (hKL : K ⊆ L) (u : markedModel (E := E) K) : markedModel (E := E) L := |
| ⟨u.val,markedModel_mono hKL u.property⟩ |
|
|
| def MarkedEscapeNeighborhood (b : ContDiffBump (0:ℂ)) (p q : E) (u : COne ℂ E) (B : ℝ) : Prop := |
| ∀ᶠ h in 𝓝 (0 : markedModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)), |
| ∀ z : ℂ, b.rIn ≤ ‖z‖ → B < ‖markedCurve p q (u+h.val) z‖ ∧ |
| B < ‖truncatedCurve b p q u h.val z‖ |
|
|
| omit [CompleteSpace E] in |
| lemma markedEscape_of_uniform [CompleteSpace E] (p q : E) (u : COne ℂ E) (B δ R : ℝ) (hδ : 0 < δ) |
| (he : ∀ h : COne ℂ E, ‖h‖ < δ → ∀ z : ℂ, R ≤ ‖z‖ → |
| B < ‖markedCurve p q (u+h) z‖ ∧ ∀ b : ContDiffBump (0:ℂ), B < ‖truncatedCurve b p q u h z‖) |
| (b : ContDiffBump (0:ℂ)) (hR : R ≤ b.rIn) : MarkedEscapeNeighborhood b p q u B := by |
| filter_upwards [Metric.ball_mem_nhds (0 : markedModel (E := E) (Metric.closedBall (0:ℂ) b.rOut)) hδ] with h hh |
| intro z hz |
| have hh' : ‖h.val‖ < δ := by simpa only [Metric.mem_ball,dist_zero_right,Submodule.norm_coe] using hh |
| exact ⟨(he h.val hh' z (hR.trans hz)).1,(he h.val hh' z (hR.trans hz)).2 b⟩ |
|
|
| lemma exists_chart_escape_neighborhood {K : Set ℂ} (hK : IsCompact K) (p q : E) |
| (u : markedModel (E := E) K) (ha : markedSlope p q u.val ≠ 0) {B : ℝ} (hB : 0 ≤ B) : |
| ∃ b : ContDiffBump (0:ℂ), K ⊆ Metric.closedBall (0:ℂ) b.rOut ∧ |
| MarkedEscapeNeighborhood b p q u.val B := by |
| obtain ⟨δ,R,hδ,hR,he⟩ := exists_uniform_escape p q u.val ha hB |
| obtain ⟨S,hS,hKS⟩ := hK.isBounded.exists_pos_norm_le |
| let b : ContDiffBump (0:ℂ) := ⟨max R S,max R S+1,lt_max_iff.mpr (Or.inl hR),by linarith⟩ |
| have hKL : K ⊆ Metric.closedBall (0:ℂ) b.rOut := by |
| intro z hz |
| have hzS := hKS z hz |
| change dist z 0 ≤ max R S+1 |
| rw [dist_zero_right] |
| exact hzS.trans ((le_max_right R S).trans (by linarith)) |
| refine ⟨b,hKL,?_⟩ |
| exact markedEscape_of_uniform p q u.val B δ R hδ he b (le_max_left R S) |
|
|
| end |
| section |
|
|
| lemma realCR_axis_implies_all {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| (A : E →L[ℝ] E) (hA : ∀ v, A (A v) = -v) (L : ℂ →L[ℝ] E) |
| (hL : L Complex.I = A (L 1)) (w : ℂ) : L (Complex.I*w) = A (L w) := by |
| have hw : w = w.re • (1:ℂ)+w.im • Complex.I := by |
| apply Complex.ext <;> simp [Complex.real_smul] |
| have hIw : Complex.I*w = (-w.im) • (1:ℂ)+w.re • Complex.I := by |
| apply Complex.ext <;> simp [Complex.real_smul,Complex.mul_re,Complex.mul_im] |
| calc |
| L (Complex.I*w) = (-w.im) • L 1 + w.re • L Complex.I := by |
| rw [hIw,map_add,map_smul,map_smul] |
| _ = A (w.re • L 1+w.im • L Complex.I) := by |
| rw [map_add,map_smul,map_smul,hL,hA] |
| module |
| _ = A (L w) := congrArg A (by simpa only [map_add,map_smul] using (congrArg L hw).symm) |
|
|
| variable {n : ℕ} |
| local instance chartZeroInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance chartZeroInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
| local instance chartZeroInst3 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance |
| local instance chartZeroInst4 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance |
| local instance chartZeroInst5 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance |
| local instance chartZeroInst6 : NormedSpace ℝ (HMap ℂ (Phase n)) := inferInstance |
| variable {J : Phase n → End n} (hJ : ContDiff ℝ ∞ J) (hc : ∀ x, Compatible (J x)) {B : ℝ} |
| (hstd : ∀ x, B < ‖x‖ → J x=standardJ n) (b : ContDiffBump (0:ℂ)) (p q : Phase n) |
| local instance chartZeroInst7 : NormedAddCommGroup (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance chartZeroInst8 : NormedSpace ℝ (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| variable (u h : markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) |
| (he : ∀ z : ℂ, b.rIn ≤ ‖z‖ → B < ‖markedCurve p q (u.val+h.val) z‖ ∧ |
| B < ‖truncatedCurve b p q u.val h.val z‖) |
|
|
| include hc he in |
| lemma actualMarkedChart_zero_pseudoholomorphic |
| (hz : actualMarkedChart hJ hstd b p q u h = 0) (z : ℂ) : |
| PseudoHolomorphicAt J (markedCurve p q (u.val+h.val)) z := by |
| have hV := actualMarkedChart_value hJ hstd b p q u h he z |
| have hzero : pointMarkedCR J p q u.val z h = 0 := by |
| rw [hz,map_zero] at hV |
| exact hV.symm |
| have haxis : fderiv ℝ (markedCurve p q (u.val+h.val)) z Complex.I = |
| J (markedCurve p q (u.val+h.val) z) (fderiv ℝ (markedCurve p q (u.val+h.val)) z 1) := |
| sub_eq_zero.mp hzero |
| refine ⟨(markedCurve_hasFDerivAt p q (u.val+h.val) z).differentiableAt,?_⟩ |
| exact realCR_axis_implies_all _ (hc _).1 _ haxis |
|
|
| lemma completedMarkedCurve_contDiff_one : ContDiff ℝ 1 (markedCurve p q (u.val+h.val)) := by |
| have hlinear : ContDiff ℝ 1 (fun z : ℂ => p+complexSlope (markedSlope p q (u.val+h.val)) z) := |
| contDiff_const.add (complexSlope _).contDiff |
| exact hlinear.add (contDiff_one (u.val+h.val)) |
|
|
| lemma completedMarkedCurve_marks : markedCurve p q (u.val+h.val) 0=p ∧ |
| markedCurve p q (u.val+h.val) 1=q := by |
| have hz : cValue (u.val+h.val) 0=0 := by |
| change cValue u.val 0+cValue h.val 0=0 |
| have hu0 : cValue u.val 0 = 0 := u.property.1 |
| have hh0 : cValue h.val 0 = 0 := h.property.1 |
| rw [hu0,hh0,add_zero] |
| exact ⟨markedCurve_zero p q hz,markedCurve_one p q _⟩ |
|
|
| lemma completedMarkedCurve_asymptote (ha : markedSlope p q (u.val+h.val) ≠ 0) : |
| ∃ v : Phase n, v ≠ 0 ∧ Tendsto (fun z : ℂ => z⁻¹ • markedCurve p q (u.val+h.val) z) |
| (cocompact ℂ) (𝓝 v) := |
| ⟨markedSlope p q (u.val+h.val),ha,markedCurve_asymptote p q (u.val+h.val)⟩ |
|
|
| end |
| section |
| variable {n : ℕ} |
| local instance azInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance azInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
| local instance azInst3 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance |
| local instance azInst4 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance |
| local instance azInst5 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance |
| local instance azInst6 : NormedSpace ℝ (HMap ℂ (Phase n)) := inferInstance |
| variable {J : Phase n → End n} (hJ : ContDiff ℝ ∞ J) (hc : ∀ x, Compatible (J x)) {B : ℝ} |
| (hstd : ∀ x, B<‖x‖ → J x=standardJ n) (p q : Phase n) |
|
|
| include hJ hc hstd in |
| lemma completed_markedCurve_contDiff (u : COne ℂ (Phase n)) (ha : markedSlope p q u ≠ 0) |
| (hcr : ∀ z, fderiv ℝ (markedCurve p q u) z Complex.I = |
| J (markedCurve p q u z) (fderiv ℝ (markedCurve p q u) z 1)) : |
| ContDiff ℝ ∞ (markedCurve p q u) := by |
| obtain ⟨R,hR,he⟩ := exists_free_escape_radius p (markedSlope p q u) u ha B |
| have he0 : ∀ z, R≤‖z‖ → B<‖affineCurve p (complexSlope (markedSlope p q u)) u z‖ := by |
| intro z hz |
| simpa only [add_zero] using he 0 (by simp) z hz |
| have huR : u∈freeModel (E := Phase n) (Metric.closedBall (0:ℂ) R) := |
| freeModel_of_elliptic hstd p (markedSlope p q u) u hcr he0 |
| let b : ContDiffBump (0:ℂ) := ⟨R,R+2,hR,by linarith⟩ |
| have hRS : R+1≤b.rOut := by change R+1≤R+2; linarith |
| have huS : u∈freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut) := |
| freeModel_mono (Metric.closedBall_subset_closedBall (by change R≤R+2; linarith)) huR |
| let w : freeModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut) := ⟨u,huS⟩ |
| have hesc : FreeEscapeNeighborhood b p (markedSlope p q w.val) w.val B := |
| freeEscape_of_radius b p (markedSlope p q u) u B he |
| exact completed_free_source_contDiff hJ hc hstd b p q w hRS huR hesc hcr |
|
|
| variable (b : ContDiffBump (0:ℂ)) |
| local instance azInst7 : NormedAddCommGroup (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| local instance azInst8 : NormedSpace ℝ (markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) := inferInstance |
| variable (u h : markedModel (E := Phase n) (Metric.closedBall (0:ℂ) b.rOut)) |
| (he : ∀ z : ℂ, b.rIn≤‖z‖ → B<‖markedCurve p q (u.val+h.val) z‖ ∧ |
| B<‖truncatedCurve b p q u.val h.val z‖) |
|
|
| include hc he in |
| lemma actualMarkedChart_zero_affineLine |
| (ha : markedSlope p q (u.val+h.val) ≠ 0) |
| (hz : actualMarkedChart hJ hstd b p q u h=0) : |
| AffineLineCurve J p q (markedCurve p q (u.val+h.val)) := by |
| have hph := actualMarkedChart_zero_pseudoholomorphic hJ hc hstd b p q u h he hz |
| have hcr : ∀ z, fderiv ℝ (markedCurve p q (u.val+h.val)) z Complex.I = |
| J (markedCurve p q (u.val+h.val) z) (fderiv ℝ (markedCurve p q (u.val+h.val)) z 1) := by |
| intro z |
| simpa only [mul_one] using (hph z).2 1 |
| have hm := completedMarkedCurve_marks b p q u h |
| exact ⟨completed_markedCurve_contDiff hJ hc hstd p q _ ha hcr,hph,hm.1,hm.2, |
| completedMarkedCurve_asymptote b p q u h ha⟩ |
|
|
| end |
|
|
| variable {n : ℕ} |
| local instance gcInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance gcInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
| local instance gcInst3 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance |
| local instance gcInst4 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance |
| local instance gcInst5 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance |
| local instance gcInst6 : NormedSpace ℝ (HMap ℂ (Phase n)) := inferInstance |
|
|
| local instance gcInst7 (K : Set ℂ) : NormedAddCommGroup (markedModel (E := Phase n) K) := inferInstance |
| local instance gcInst8 (K : Set ℂ) : NormedSpace ℝ (markedModel (E := Phase n) K) := inferInstance |
| local instance gcInst9 (K : Set ℂ) : NormedAddCommGroup (supportedHolder (E := Phase n) K) := inferInstance |
| local instance gcInst10 (K : Set ℂ) : NormedSpace ℝ (supportedHolder (E := Phase n) K) := inferInstance |
|
|
| def geometricResidual (u : ℂ → Phase n) (z : ℂ) : Phase n := |
| fderiv ℝ u z Complex.I-Complex.I • fderiv ℝ u z 1 |
|
|
| lemma geometricResidual_smooth {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) : |
| ContDiff ℝ ∞ (geometricResidual u) := by |
| have hd := hu.fderiv_right (m := ∞) (by simp) |
| have hx : ContDiff ℝ ∞ (fun z => fderiv ℝ u z 1) := hd.clm_apply contDiff_const |
| have hy : ContDiff ℝ ∞ (fun z => fderiv ℝ u z Complex.I) := hd.clm_apply contDiff_const |
| have hI : ContDiff ℝ ∞ (fun _ : ℂ => Complex.I) := contDiff_const |
| exact hy.sub (hI.smul hx) |
|
|
| lemma geometricResidual_compact {J : Phase n → End n} {p q : Phase n} {u : ℂ → Phase n} |
| (hu : AffineLineCurve J p q u) (hJc : HasCompactSupport (fun x => J x-standardJ n)) : |
| HasCompactSupport (geometricResidual u) := by |
| apply HasCompactSupport.of_support_subset_isCompact (hu.isProperMap.isCompact_preimage hJc) |
| intro z hz |
| by_contra hn |
| have hstd : J (u z)=standardJ n := sub_eq_zero.mp |
| (image_eq_zero_of_notMem_tsupport (f := fun x => J x-standardJ n) hn) |
| have hcr := (hu.2.1 z).2 1 |
| simp only [mul_one,hstd] at hcr |
| apply hz |
| exact sub_eq_zero.mpr hcr |
|
|
| lemma inverse_correction_holomorphic {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) |
| {K : Set ℂ} (hK : IsCompact K) (g : supportedHolder (E := Phase n) K) |
| (hg : ∀ z, valueCLM _ g.val z=geometricResidual u z) : |
| Differentiable ℂ (fun z => u z-cValue (standardHolderInverse hK g) z) := by |
| let v := standardHolderInverse hK g |
| intro z |
| have hd := ((hu.differentiable (by simp)) z).hasFDerivAt.sub (c_hasFDerivAt v z) |
| apply complex_differentiable_of_curl_zero hd.differentiableAt |
| have hres : cDeriv v z Complex.I-Complex.I • cDeriv v z 1=geometricResidual u z := by |
| have he := congrArg (fun w : HMap ℂ (Phase n) => valueCLM _ w z) |
| (standardHolderInverse_residual hK g) |
| simpa only [standardJetCR_value] using he.trans (hg z) |
| rw [hd.fderiv] |
| change Complex.I • (fderiv ℝ u z 1-cDeriv v z 1)- |
| (fderiv ℝ u z Complex.I-cDeriv v z Complex.I)=0 |
| rw [smul_sub] |
| calc |
| _ = (cDeriv v z Complex.I-Complex.I • cDeriv v z 1)-geometricResidual u z := by |
| unfold geometricResidual |
| abel |
| _ = 0 := sub_eq_zero.mpr hres |
|
|
| lemma inverse_correction_asymptote {u : ℂ → Phase n} {a : Phase n} |
| (ha : Tendsto (fun z : ℂ => z⁻¹ • u z) (cocompact ℂ) (𝓝 a)) |
| (v : COne ℂ (Phase n)) : |
| Tendsto (fun z : ℂ => z⁻¹ • (u z-cValue v z)) (cocompact ℂ) (𝓝 a) := by |
| have hi : Tendsto (fun z : ℂ => z⁻¹) (cocompact ℂ) (𝓝 0) := by |
| simpa only [←Metric.cobounded_eq_cocompact] using (tendsto_inv₀_cobounded (α := ℂ)) |
| have hb : IsBoundedUnder (· ≤ ·) (cocompact ℂ) (norm ∘ (cValue v : ℂ → Phase n)) := |
| ⟨‖cValue v‖,eventually_map.mpr (Eventually.of_forall fun z => (cValue v).norm_coe_le_norm z)⟩ |
| simpa only [smul_sub,sub_zero] using ha.sub (hi.zero_smul_isBoundedUnder_le hb) |
|
|
| lemma affine_reconstruction_from_correction {u : ℂ → Phase n} {p a : Phase n} |
| (v : COne ℂ (Phase n)) |
| (hd : Differentiable ℂ (fun z => u z-cValue v z)) |
| (ha : Tendsto (fun z : ℂ => z⁻¹ • (u z-cValue v z)) (cocompact ℂ) (𝓝 a)) |
| (h0 : u 0=p) (hv0 : cValue v 0=0) (z : ℂ) : |
| u z=p+z • a+cValue v z := by |
| have he := entire_affine_of_asymptote hd ha z |
| rw [h0,hv0,sub_zero] at he |
| exact sub_eq_iff_eq_add.mp he |
|
|
| lemma marked_reconstruction_from_correction {u : ℂ → Phase n} {p q a : Phase n} |
| (v : COne ℂ (Phase n)) |
| (hd : Differentiable ℂ (fun z => u z-cValue v z)) |
| (ha : Tendsto (fun z : ℂ => z⁻¹ • u z) (cocompact ℂ) (𝓝 a)) |
| (h0 : u 0=p) (h1 : u 1=q) (hv0 : cValue v 0=0) : |
| markedCurve p q v=u ∧ markedSlope p q v=a := by |
| have hinf := inverse_correction_asymptote ha v |
| have hrec := affine_reconstruction_from_correction v hd hinf h0 hv0 |
| have hslope : markedSlope p q v=a := by |
| have he := hrec 1 |
| rw [h1,one_smul] at he |
| rw [markedSlope,he] |
| abel |
| refine ⟨?_,hslope⟩ |
| funext z |
| rw [markedCurve,hslope] |
| exact (hrec z).symm |
|
|
| lemma affineLineCurve_completed_representation {J : Phase n → End n} {p q : Phase n} |
| {u : ℂ → Phase n} (hu : AffineLineCurve J p q u) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) : |
| ∃ (K : Set ℂ), IsCompact K ∧ ∃ v : markedModel (E := Phase n) K, |
| markedCurve p q v.val=u ∧ markedSlope p q v.val ≠ 0 := by |
| have hr := geometricResidual_compact hu hJc |
| have hG := boundedCThree_of_compactSupport (geometricResidual_smooth hu.1) hr |
| let G : HMap ℂ (Phase n) := jetValueCLM _ (ofBoundedCThree hG) |
| have hGval : ∀ z, valueCLM _ G z=geometricResidual u z := fun _ => rfl |
| let K := tsupport (geometricResidual u) |
| have hK : IsCompact K := hr |
| have hGK : G∈supportedHolder K := by |
| apply (mem_supportedHolder _ _).mpr |
| intro z hz |
| rw [hGval] |
| exact image_eq_zero_of_notMem_tsupport hz |
| let g : supportedHolder (E := Phase n) K := ⟨G,hGK⟩ |
| let w : COne ℂ (Phase n) := standardHolderInverse hK g |
| have hwK : w∈markedModel K := by |
| refine ⟨standardHolderInverse_zero hK g,?_⟩ |
| have he : standardJetCR w=g.val := standardHolderInverse_residual hK g |
| change standardJetCR w ∈ supportedHolder K |
| rw [he] |
| exact g.property |
| let v : markedModel (E := Phase n) K := ⟨w,hwK⟩ |
| have hv0 : cValue v.val 0=0 := standardHolderInverse_zero hK g |
| have hd : Differentiable ℂ (fun z => u z-cValue v.val z) := |
| inverse_correction_holomorphic hu.1 hK g hGval |
| obtain ⟨a,ha,hau⟩ := hu.2.2.2.2 |
| have hf := marked_reconstruction_from_correction v.val hd hau hu.2.2.1 hu.2.2.2.1 hv0 |
| exact ⟨K,hK,v,hf.1,fun h => ha (hf.2.symm.trans h)⟩ |
|
|
| end HigherDimensionalBallPacking.Rigidity.HolderCompletion |
| end |
|
|
| end OAI |
|
|
