| import Mathlib |
| import OAI.Geometry.BallPacking.Necessity.MarkedProfiles |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped ContDiff Topology |
| open Set Function Filter |
| open scoped ContDiff Topology Manifold |
| open Set Function Filter MeasureTheory |
| open Set Function MeasureTheory |
| open Set Function |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl) |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm radiusSq planarArea planarArea_apply) |
| open SymplecticBallPacking.Hamiltonian (Plane planarCurl angularOneForm) |
| open SymplecticBallPacking.Hamiltonian (Plane angularOneForm) |
| open SymplecticBallPacking.Hamiltonian |
| open SymplecticBallPacking.Hamiltonian (Plane) |
| open Set Filter Function |
| open Set Filter MeasureTheory |
| open scoped Topology |
| open Set Filter Finset |
| open scoped ContDiff Topology Classical |
| open Set Filter |
| open scoped BoundedContinuousFunction ContDiff Topology |
| open Set Function Filter Topology |
| open scoped NNReal |
| open scoped ContDiff Topology BoundedContinuousFunction |
|
|
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Function Filter |
| namespace HigherDimensionalBallPacking.Rigidity |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| local instance localChartsInst1 (α : ℝ) : NormedAddCommGroup (HolderSpace ℂ E α) := inferInstance |
| local instance localChartsInst2 (α : ℝ) : NormedSpace ℝ (HolderSpace ℂ E α) := inferInstance |
| local instance localChartsInst3 (α : ℝ) : NormedAddCommGroup (C1HolderSpace E α) := inferInstance |
| local instance localChartsInst4 (α : ℝ) : NormedSpace ℝ (C1HolderSpace E α) := inferInstance |
| local instance localChartsInst5 (R : ℝ) : NormedAddCommGroup (CompactHolderSpace E R) := inferInstance |
| local instance localChartsInst6 (R : ℝ) : NormedSpace ℝ (CompactHolderSpace E R) := inferInstance |
| local instance localChartsInst7 (α : ℝ) : NormedAddCommGroup ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) := inferInstance |
| local instance localChartsInst8 (α : ℝ) : NormedSpace ℝ ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) := inferInstance |
| local instance localChartsInst9 (α : ℝ) : AddCommGroup ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) := |
| (inferInstance : NormedAddCommGroup ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α)).toAddCommGroup |
|
|
| |
| def affineC1Value (α : ℝ) (z : ℂ) : |
| (E × (ℂ →L[ℝ] E)) × C1HolderSpace E α →L[ℝ] E := |
| (ContinuousLinearMap.fst ℝ E (ℂ →L[ℝ] E)).comp (ContinuousLinearMap.fst ℝ _ _) + |
| ((ContinuousLinearMap.apply ℝ E z).comp (ContinuousLinearMap.snd ℝ E (ℂ →L[ℝ] E))).comp |
| (ContinuousLinearMap.fst ℝ _ _) + |
| (c1HolderEval α z).comp (ContinuousLinearMap.snd ℝ _ _) |
|
|
| @[simp] theorem affineC1Value_apply (α : ℝ) (z : ℂ) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) : |
| affineC1Value α z p = c1HolderAffineCurve α p.1.1 p.1.2 p.2 z := rfl |
|
|
| |
| def affineC1Deriv (α : ℝ) (z : ℂ) : |
| (E × (ℂ →L[ℝ] E)) × C1HolderSpace E α →L[ℝ] (ℂ →L[ℝ] E) := |
| (ContinuousLinearMap.snd ℝ E (ℂ →L[ℝ] E)).comp (ContinuousLinearMap.fst ℝ _ _) + |
| ((BoundedContinuousFunction.evalCLM ℝ z).comp ((holderValue α).comp (c1HolderDeriv α))).comp |
| (ContinuousLinearMap.snd ℝ _ _) |
|
|
| @[simp] theorem affineC1Deriv_apply (α : ℝ) (z : ℂ) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) : |
| affineC1Deriv α z p = fderiv ℝ (c1HolderAffineCurve α p.1.1 p.1.2 p.2) z := by |
| rw [c1HolderAffineCurve_fderiv]; rfl |
|
|
| |
| theorem c1HolderCRFamily_fderiv (α : ℝ) (hα₀ : 0≤α) (hα₁ : α≤1) |
| (J : E → E →L[ℝ] E) (J₀ : E →L[ℝ] E) (hJ : ContDiff ℝ ∞ J) |
| (hc : HasCompactSupport (fun x => J x-J₀)) |
| (p h : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) |
| (m : ℝ) (hm : 0 < m) (hA : ∀ z, m*‖z‖≤‖p.1.2 z‖) (z : ℂ) : |
| holderValue α (fderiv ℝ (c1HolderCRFamily α hα₀ hα₁ J J₀ hJ hc) p h) z = |
| linearizedCR J (c1HolderAffineCurve α p.1.1 p.1.2 p.2) |
| (c1HolderAffineCurve α h.1.1 h.1.2 h.2) z := by |
| let : ContinuousSMul ℝ ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) := |
| IsBoundedSMul.continuousSMul |
| let ev := affineC1Value (E := E) α z |
| let dev := affineC1Deriv (E := E) α z |
| have hdJ := ((hJ.differentiable (by simp)) (ev p)).hasFDerivAt.comp p ev.hasFDerivAt |
| have hdI := dev.hasFDerivAt.clm_apply (hasFDerivAt_const Complex.I p) |
| have hd1 := dev.hasFDerivAt.clm_apply (hasFDerivAt_const (1:ℂ) p) |
| have hd := hdI.sub (hdJ.clm_apply hd1) |
| let hev : HolderSpace ℂ E α →L[ℝ] E := |
| (BoundedContinuousFunction.evalCLM ℝ z).comp (holderValue α) |
| have hout := hev.hasFDerivAt.comp p |
| ((c1HolderCRFamily_contDiffAt α hα₀ hα₁ J J₀ hJ hc p m hm hA).differentiableAt |
| (by simp)).hasFDerivAt |
| have heq : (fun q => hev (c1HolderCRFamily α hα₀ hα₁ J J₀ hJ hc q)) = |
| (fun q => dev q Complex.I-J (ev q) (dev q 1)) := by |
| funext q |
| simpa only [hev,ev,dev,ContinuousLinearMap.comp_apply, |
| BoundedContinuousFunction.evalCLM_apply,c1HolderCRFamily,affineC1Value_apply,affineC1Deriv_apply] |
| using c1HolderCR_apply α hα₀ hα₁ J J₀ hJ hc q.1.1 q.1.2 q.2 z |
| change HasFDerivAt (fun q => hev (c1HolderCRFamily α hα₀ hα₁ J J₀ hJ hc q)) _ p at hout |
| rw [heq] at hout |
| have he := congrArg (fun L => L h) (hout.unique hd) |
| simp only [hev,ev,dev,ContinuousLinearMap.comp_apply,BoundedContinuousFunction.evalCLM_apply, |
| sub_apply,add_apply,ContinuousLinearMap.flip_apply,zero_apply,map_zero,zero_add, |
| Function.comp_def,affineC1Value_apply,affineC1Deriv_apply] at he |
| exact he.trans (by unfold linearizedCR; abel) |
|
|
| |
| def markedFramedCR (R : ℝ) (Ainf : E →L[ℝ] E) (P : ℂ → E →L[ℝ] E) |
| (hP : ContDiff ℝ ∞ P) (hPc : HasCompactSupport P) |
| (J : E → E →L[ℝ] E) (J₀ : E →L[ℝ] E) (hJ : ContDiff ℝ ∞ J) |
| (hJc : HasCompactSupport (fun x => J x-J₀)) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3)) |
| (g : CompactHolderSpace E R) : HolderSpace ℂ E ((1:ℝ)/3) := |
| c1HolderCRFamily ((1:ℝ)/3) (by norm_num) (by norm_num) J J₀ hJ hJc |
| (p+markedFramedProfile R Ainf P hP hPc g) |
|
|
| theorem markedFramedCR_contDiffAt_zero (R : ℝ) (Ainf : E →L[ℝ] E) (P : ℂ → E →L[ℝ] E) |
| (hP : ContDiff ℝ ∞ P) (hPc : HasCompactSupport P) |
| (J : E → E →L[ℝ] E) (J₀ : E →L[ℝ] E) (hJ : ContDiff ℝ ∞ J) |
| (hJc : HasCompactSupport (fun x => J x-J₀)) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3)) |
| (m : ℝ) (hm : 0 < m) (hA : ∀ z, m*‖z‖≤‖p.1.2 z‖) : |
| ContDiffAt ℝ ∞ (markedFramedCR R Ainf P hP hPc J J₀ hJ hJc p) 0 := by |
| have hs := c1HolderCRFamily_contDiffAt ((1:ℝ)/3) (by norm_num) (by norm_num) |
| J J₀ hJ hJc p m hm hA |
| have ht : ContDiffAt ℝ ∞ (fun g => p+markedFramedProfile R Ainf P hP hPc g) |
| (0:CompactHolderSpace E R) := |
| (contDiff_const.add (markedFramedProfile R Ainf P hP hPc).contDiff).contDiffAt |
| apply hs.comp_of_eq 0 ht |
| · exact mapsTo_univ _ _ |
| · rw [(markedFramedProfile R Ainf P hP hPc).map_zero,add_zero] |
|
|
| lemma affineC1Curve_profile (R : ℝ) (Ainf : E →L[ℝ] E) (P : ℂ → E →L[ℝ] E) |
| (hP : ContDiff ℝ ∞ P) (hPc : HasCompactSupport P) (g : CompactHolderSpace E R) : |
| let h := markedFramedProfile R Ainf P hP hPc g |
| c1HolderAffineCurve ((1:ℝ)/3) h.1.1 h.1.2 h.2 = fun z => (Ainf+P z) (markedCRInverse R g z) := by |
| funext z |
| exact markedFramedProfile_value R Ainf P hP hPc g z |
|
|
| |
|
|
| theorem markedFramedCR_fderiv_zero (R : ℝ) (Ainf : E →L[ℝ] E) (P : ℂ → E →L[ℝ] E) |
| (hP : ContDiff ℝ ∞ P) (hPc : HasCompactSupport P) |
| (J : E → E →L[ℝ] E) (J₀ : E →L[ℝ] E) (hJ : ContDiff ℝ ∞ J) |
| (hJc : HasCompactSupport (fun x => J x-J₀)) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3)) |
| (m : ℝ) (hm : 0 < m) (hA : ∀ z, m*‖z‖≤‖p.1.2 z‖) |
| (g : CompactHolderSpace E R) (z : ℂ) : |
| holderValue ((1:ℝ)/3) (fderiv ℝ (markedFramedCR R Ainf P hP hPc J J₀ hJ hJc p) 0 g) z = |
| linearizedCR J (c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2) |
| (fun w => (Ainf+P w) (markedCRInverse R g w)) z := by |
| let F := markedFramedProfile R Ainf P hP hPc |
| have hs := (c1HolderCRFamily_contDiffAt ((1:ℝ)/3) (by norm_num) (by norm_num) |
| J J₀ hJ hJc p m hm hA).differentiableAt (by simp) |
| have ht : HasFDerivAt (fun v => p+F v) F (0:CompactHolderSpace E R) := F.hasFDerivAt.const_add p |
| have hs' : HasFDerivAt (c1HolderCRFamily ((1:ℝ)/3) (by norm_num) (by norm_num) J J₀ hJ hJc) |
| (fderiv ℝ (c1HolderCRFamily ((1:ℝ)/3) (by norm_num) (by norm_num) J J₀ hJ hJc) p) (p+F 0) := by |
| rw [F.map_zero,add_zero] |
| exact hs.hasFDerivAt |
| have hd := hs'.comp 0 ht |
| change HasFDerivAt (markedFramedCR R Ainf P hP hPc J J₀ hJ hJc p) _ 0 at hd |
| rw [hd.fderiv,ContinuousLinearMap.comp_apply] |
| rw [c1HolderCRFamily_fderiv _ _ _ _ _ _ _ _ _ m hm hA] |
| rw [affineC1Curve_profile] |
|
|
| end HigherDimensionalBallPacking.Rigidity |
|
|
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Function Filter |
| namespace HigherDimensionalBallPacking.Rigidity |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] [FiniteDimensional ℂ E] |
| local instance localChartsInst10 (α : ℝ) : NormedAddCommGroup (HolderSpace ℂ E α) := inferInstance |
| local instance localChartsInst11 (α : ℝ) : NormedSpace ℝ (HolderSpace ℂ E α) := inferInstance |
| local instance localChartsInst12 (α : ℝ) : NormedAddCommGroup (C1HolderSpace E α) := inferInstance |
| local instance localChartsInst13 (α : ℝ) : NormedSpace ℝ (C1HolderSpace E α) := inferInstance |
| local instance localChartsInst14 (R : ℝ) : NormedAddCommGroup (CompactHolderSpace E R) := inferInstance |
| local instance localChartsInst15 (R : ℝ) : NormedSpace ℝ (CompactHolderSpace E R) := inferInstance |
| local instance localChartsInst16 (α : ℝ) : NormedAddCommGroup ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) := inferInstance |
| local instance localChartsInst17 (α : ℝ) : NormedSpace ℝ ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) := inferInstance |
| local instance localChartsInst18 (α : ℝ) : AddCommGroup ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) := |
| (inferInstance : NormedAddCommGroup ((E × (ℂ →L[ℝ] E)) × C1HolderSpace E α)).toAddCommGroup |
|
|
| |
|
|
| omit [FiniteDimensional ℂ E] in |
| theorem affineC1_uniform_exterior (J : E → E →L[ℝ] E) (B : E →L[ℝ] E) |
| (hc : HasCompactSupport (fun x => J x-B)) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3)) |
| (m : ℝ) (hm : 0 < m) (hA : ∀ z, m*‖z‖ ≤ ‖p.1.2 z‖) : |
| ∃ S : ℝ, 0 < S ∧ ∀ q : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3), |
| ‖q-p‖ < min 1 (m/2) → ∀ z : ℂ, S < ‖z‖ → |
| J (c1HolderAffineCurve ((1:ℝ)/3) q.1.1 q.1.2 q.2 z)=B := by |
| obtain ⟨T,hT,hJT⟩ := compactCoefficient_zero_outside hc |
| let U := ‖p.2‖+1 |
| let S := max 1 (2*(T+‖p.1.1‖+1+U)/m) |
| have hS : 0 < S := lt_of_lt_of_le zero_lt_one (le_max_left _ _) |
| refine ⟨S,hS,?_⟩ |
| intro q hq z hz |
| have hqp₁ : ‖q.1-p.1‖ < min 1 (m/2) := lt_of_le_of_lt (norm_fst_le (q-p)) hq |
| have hd : ‖q.1.1-p.1.1‖ ≤ 1 := |
| ((norm_fst_le (q.1-p.1)).trans hqp₁.le).trans (min_le_left _ _) |
| have hB : ‖q.1.2-p.1.2‖ ≤ m/2 := |
| ((norm_snd_le (q.1-p.1)).trans hqp₁.le).trans (min_le_right _ _) |
| have hq₂ : ‖q.2-p.2‖ ≤ 1 := |
| ((norm_snd_le (q-p)).trans hq.le).trans (min_le_left _ _) |
| have hqU : ‖q.2‖ ≤ U := by |
| have hh : ‖q.2‖ ≤ ‖q.2-p.2‖+‖p.2‖ := norm_le_norm_sub_add _ _ |
| change ‖q.2‖ ≤ ‖p.2‖+1 |
| linarith only [hh,hq₂] |
| have hv := (c1HolderValue_bound ((1:ℝ)/3) q.2 z).trans hqU |
| have hzS : T+‖p.1.1‖+1+U ≤ m/2*‖z‖ := by |
| have hh := (le_max_right 1 (2*(T+‖p.1.1‖+1+U)/m)).trans hz.le |
| have hh' := (div_le_iff₀ hm).mp hh |
| linarith |
| have he := affineProfile_lower_bound p.1.1 (q.1.1-p.1.1) |
| (holderValue ((1:ℝ)/3) (c1HolderValue ((1:ℝ)/3) q.2) z) |
| p.1.2 (q.1.2-p.1.2) m U T 1 hm hA hd hB hv ⟨zero_le_one,le_rfl⟩ z hzS |
| have he' : T ≤ ‖c1HolderAffineCurve ((1:ℝ)/3) q.1.1 q.1.2 q.2 z‖ := by |
| convert he using 1 |
| rw [one_smul,sub_apply] |
| congr 1 |
| unfold c1HolderAffineCurve |
| abel |
| exact sub_eq_zero.mp (hJT _ he') |
|
|
| omit [FiniteDimensional ℂ E] in |
| lemma affineC1Curve_add (α : ℝ) |
| (p q : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E α) : |
| c1HolderAffineCurve α (p+q).1.1 (p+q).1.2 (p+q).2 = |
| fun z => c1HolderAffineCurve α p.1.1 p.1.2 p.2 z+ |
| c1HolderAffineCurve α q.1.1 q.1.2 q.2 z := by |
| funext z |
| exact (affineC1Value α z).map_add p q |
|
|
| |
|
|
| omit [FiniteDimensional ℂ E] in |
| lemma framed_variation_exterior_cr (R : ℝ) (Ainf : E →L[ℝ] E) |
| (hAinf : ∀ v, Ainf (Complex.I • v)=Complex.I • Ainf v) |
| (P : ℂ → E →L[ℝ] E) (_hP : ContDiff ℝ ∞ P) |
| (_hc : HasCompactSupport P) (hPR : ∀ z : ℂ, R < ‖z‖ → P z=0) |
| (g : CompactHolderSpace E R) (z : ℂ) (hz : R < ‖z‖) : |
| crOperator (fun _ => (ContinuousLinearMap.lsmul ℝ ℂ) Complex.I) |
| (fun w => (Ainf+P w) (markedCRInverse R g w)) z=0 := by |
| have hp : ∀ᶠ w in 𝓝 z, P w=0 := by |
| filter_upwards [((isOpen_lt continuous_const continuous_norm).mem_nhds hz)] with w hw |
| exact hPR w hw |
| have he : (fun w => (Ainf+P w) (markedCRInverse R g w)) =ᶠ[𝓝 z] |
| fun w => Ainf (markedCRInverse R g w) := by |
| filter_upwards [hp] with w hw |
| rw [hw,add_zero] |
| have hd := Ainf.hasFDerivAt.comp z (markedCRInverse_differentiable R g z).hasFDerivAt |
| change HasFDerivAt (fun w => Ainf (markedCRInverse R g w)) _ z at hd |
| unfold crOperator |
| rw [he.fderiv_eq,hd.fderiv] |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.lsmul_apply] |
| rw [← hAinf,← map_sub,markedCRInverse_rightInverse] |
| change Ainf (holderValue ((1:ℝ)/3) g.val z)=0 |
| rw [g.property z hz,map_zero] |
|
|
| |
|
|
| omit [FiniteDimensional ℂ E] in |
| theorem markedFramedCR_eventually_compact (Ainf : E →L[ℝ] E) |
| (hAinf : ∀ v, Ainf (Complex.I • v)=Complex.I • Ainf v) |
| (P : ℂ → E →L[ℝ] E) (hP : ContDiff ℝ ∞ P) (hPc : HasCompactSupport P) |
| (J : E → E →L[ℝ] E) (hJ : ContDiff ℝ ∞ J) |
| (hc : HasCompactSupport (fun x => J x-(ContinuousLinearMap.lsmul ℝ ℂ) Complex.I)) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3)) |
| (m : ℝ) (hm : 0 < m) (hA : ∀ z, m*‖z‖ ≤ ‖p.1.2 z‖) |
| (hsol : ∀ z, crOperator J (c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2) z=0) : |
| ∃ S : ℝ, 0 < S ∧ ∀ R : ℝ, S ≤ R → |
| ∀ᶠ g : CompactHolderSpace E R in 𝓝 0, |
| markedFramedCR R Ainf P hP hPc J ((ContinuousLinearMap.lsmul ℝ ℂ) Complex.I) hJ hc p g |
| ∈ compactHolderSubmodule R := by |
| let B : E →L[ℝ] E := (ContinuousLinearMap.lsmul ℝ ℂ) Complex.I |
| obtain ⟨S₀,hS₀,hJS⟩ := affineC1_uniform_exterior J B hc p m hm hA |
| obtain ⟨S₁,hS₁,hPS⟩ := compactCoefficient_zero_outside hPc |
| let S := max S₀ S₁ |
| refine ⟨S,lt_of_lt_of_le hS₀ (le_max_left _ _),?_⟩ |
| intro R hR |
| let F := markedFramedProfile R Ainf P hP hPc |
| have hsmall : ∀ᶠ g : CompactHolderSpace E R in 𝓝 0, ‖F g‖ < min 1 (m/2) := by |
| have ht := (F.continuous.continuousAt (x := 0)).tendsto |
| have hm' : (0:ℝ) < min 1 (m/2) := lt_min zero_lt_one (by linarith) |
| have hh : {q | ‖q‖ < min 1 (m/2)} ∈ 𝓝 (F 0) := by |
| rw [F.map_zero] |
| simpa only [Metric.ball,dist_zero_right] using Metric.ball_mem_nhds (0 : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3)) hm' |
| exact ht.eventually hh |
| filter_upwards [hsmall] with g hg |
| intro z hz |
| let u := c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2 |
| let v := fun w => (Ainf+P w) (markedCRInverse R g w) |
| have hPR : ∀ w : ℂ, R < ‖w‖ → P w=0 := fun w hw => |
| hPS w (((le_max_right _ _).trans hR).trans hw.le) |
| have hJq : J (u z+v z)=B := by |
| have hh := hJS (p+F g) (by simpa only [add_sub_cancel_left] using hg) z |
| (lt_of_le_of_lt ((le_max_left _ _).trans hR) hz) |
| rw [affineC1Curve_add,affineC1Curve_profile] at hh |
| exact hh |
| have hJp : J (u z)=B := hJS p (by simpa only [sub_self,norm_zero] using lt_min zero_lt_one (show (0:ℝ) < m/2 by linarith)) z |
| (lt_of_le_of_lt ((le_max_left _ _).trans hR) hz) |
| have hdu := (c1HolderAffineCurve_hasFDerivAt ((1:ℝ)/3) p.1.1 p.1.2 p.2 z).differentiableAt |
| have hdv : DifferentiableAt ℝ v z := |
| ((contDiff_const.add hP).differentiable (by simp) z).clm_apply |
| (markedCRInverse_differentiable R g z) |
| have hv := framed_variation_exterior_cr R Ainf hAinf P hP hPc hPR g z hz |
| have hu := hsol z |
| change crOperator J u z=0 at hu |
| unfold crOperator at hu hv |
| rw [hJp] at hu |
| change holderValue ((1:ℝ)/3) (c1HolderCRFamily _ _ _ _ _ _ _ (p+F g)) z=0 |
| rw [c1HolderCRFamily,c1HolderCR_apply,affineC1Curve_add,affineC1Curve_profile] |
| change fderiv ℝ (fun w => u w+v w) z Complex.I- |
| J (u z+v z) (fderiv ℝ (fun w => u w+v w) z 1)=0 |
| rw [fderiv_fun_add hdu hdv,hJq] |
| simp only [add_apply,map_add] |
| change fderiv ℝ v z Complex.I-B (fderiv ℝ v z 1)=0 at hv |
| rw [sub_eq_zero] at hu hv ⊢ |
| rw [hu,hv] |
|
|
| end HigherDimensionalBallPacking.Rigidity |
|
|
| |
|
|
| open scoped ContDiff Topology |
| open Set Filter Function |
| namespace HigherDimensionalBallPacking.Rigidity |
| universe u |
| variable {X Y Z : Type u} [NormedAddCommGroup X] [NormedSpace ℝ X] |
| [NormedAddCommGroup Y] [NormedSpace ℝ Y] [CompleteSpace Y] |
| [NormedAddCommGroup Z] [NormedSpace ℝ Z] |
|
|
| lemma linearIsometry_fderiv_mem (e : Y →ₗᵢ[ℝ] Z) (f : X → Y) (x v : X) : |
| fderiv ℝ (e ∘ f) x v ∈ e.toLinearMap.range := by |
| let S := e.toLinearMap.range |
| let : IsClosed (S : Set Z) := e.isometry.isClosedEmbedding.isClosed_range |
| by_cases hd : DifferentiableAt ℝ (e ∘ f) x |
| · have he : (fun y => S.mkQL (e (f y))) = fun _ : X => (0 : Z ⧸ S) := by |
| funext y |
| exact (Submodule.Quotient.mk_eq_zero S).mpr ⟨f y,rfl⟩ |
| have hh := S.mkQL.hasFDerivAt.comp x hd.hasFDerivAt |
| change HasFDerivAt (fun y => S.mkQL (e (f y))) _ x at hh |
| rw [he] at hh |
| have hv := congrArg (fun L : X →L[ℝ] (Z ⧸ S) => L v) |
| (hh.unique (hasFDerivAt_const (0 : Z ⧸ S) x)) |
| exact (Submodule.Quotient.mk_eq_zero S).mp hv |
| · rw [fderiv_zero_of_not_differentiableAt hd] |
| exact S.zero_mem |
|
|
| |
| def reflectedFDeriv (e : Y →ₗᵢ[ℝ] Z) (f : X → Y) (x : X) : X →L[ℝ] Y := |
| e.equivRange.symm.toContinuousLinearEquiv.toContinuousLinearMap.comp |
| ((fderiv ℝ (e ∘ f) x).codRestrict e.toLinearMap.range |
| (linearIsometry_fderiv_mem e f x)) |
|
|
| lemma reflectedFDeriv_comp (e : Y →ₗᵢ[ℝ] Z) (f : X → Y) (x : X) : |
| e.toContinuousLinearMap.comp (reflectedFDeriv e f x) = fderiv ℝ (e ∘ f) x := by |
| ext v |
| exact congrArg Subtype.val (e.equivRange.apply_symm_apply |
| ⟨fderiv ℝ (e ∘ f) x v,linearIsometry_fderiv_mem e f x v⟩) |
|
|
| lemma hasFDerivAt_reflected (e : Y →ₗᵢ[ℝ] Z) (f : X → Y) (x : X) |
| (hd : DifferentiableAt ℝ (e ∘ f) x) : |
| HasFDerivAt f (reflectedFDeriv e f x) x := by |
| have hh := hd.hasFDerivAt |
| rw [← reflectedFDeriv_comp e f x] at hh |
| rw [hasFDerivAt_iff_isLittleO_nhds_zero] at hh ⊢ |
| rw [← Asymptotics.isLittleO_norm_left] at hh ⊢ |
| simpa only [Function.comp_apply,ContinuousLinearMap.comp_apply, |
| LinearIsometry.coe_toContinuousLinearMap,← map_sub,e.norm_map] using hh |
|
|
| lemma fderiv_comp_linearIsometry (e : Y →ₗᵢ[ℝ] Z) (f : X → Y) (x : X) : |
| e.toContinuousLinearMap.comp (fderiv ℝ f x) = fderiv ℝ (e ∘ f) x := by |
| by_cases hd : DifferentiableAt ℝ (e ∘ f) x |
| · rw [(hasFDerivAt_reflected e f x hd).fderiv] |
| exact reflectedFDeriv_comp e f x |
| · have hdf : ¬ DifferentiableAt ℝ f x := by |
| intro hf |
| exact hd (e.toContinuousLinearMap.differentiableAt.comp x hf) |
| rw [fderiv_zero_of_not_differentiableAt hd,fderiv_zero_of_not_differentiableAt hdf] |
| simp |
|
|
| |
| theorem contDiffAt_reflect_isometry_nat (m : ℕ) (e : Y →ₗᵢ[ℝ] Z) (f : X → Y) (x : X) |
| (hf : ContDiffAt ℝ m (e ∘ f) x) : ContDiffAt ℝ m f x := by |
| induction m generalizing Y Z with |
| | zero => |
| obtain ⟨U,hU,hc⟩ := contDiffAt_zero.mp hf |
| apply contDiffAt_zero.mpr |
| refine ⟨U,hU,?_⟩ |
| intro y hy |
| exact e.isEmbedding.isInducing.continuousWithinAt_iff.mpr (hc y hy) |
| | succ m ih => |
| apply contDiffAt_succ_iff_hasFDerivAt.mpr |
| refine ⟨fderiv ℝ f,?_,?_⟩ |
| · have hlocal := hf.eventually (by simp) |
| refine ⟨{y | ContDiffAt ℝ ((m+1 : ℕ) : ℕ∞ω) (e ∘ f) y},hlocal,?_⟩ |
| intro y hy |
| change ContDiffAt ℝ ((m+1 : ℕ) : ℕ∞ω) (e ∘ f) y at hy |
| have hd := (hasFDerivAt_reflected e f y (hy.differentiableAt (by simp))) |
| rw [hd.fderiv] |
| exact hd |
| · let ep : (X →L[ℝ] Y) →ₗᵢ[ℝ] (X →L[ℝ] Z) := e.postcomp |
| apply ih ep (fderiv ℝ f) |
| have he : ep ∘ fderiv ℝ f = fderiv ℝ (e ∘ f) := by |
| funext y |
| exact fderiv_comp_linearIsometry e f y |
| rw [he] |
| exact hf.fderiv_right (by simp) |
|
|
| theorem contDiffAt_reflect_isometry (e : Y →ₗᵢ[ℝ] Z) (f : X → Y) (x : X) |
| (hf : ContDiffAt ℝ ∞ (e ∘ f) x) : ContDiffAt ℝ ∞ f x := |
| contDiffAt_infty.mpr (fun m => contDiffAt_reflect_isometry_nat m e f x |
| (contDiffAt_infty.mp hf m)) |
|
|
| end HigherDimensionalBallPacking.Rigidity |
|
|
| open scoped ContDiff Topology |
| open Set Filter Function |
| namespace HigherDimensionalBallPacking.Rigidity |
| universe u |
| variable {X Y : Type u} [NormedAddCommGroup X] [NormedSpace ℝ X] |
| [NormedAddCommGroup Y] [NormedSpace ℝ Y] [CompleteSpace Y] |
|
|
| |
|
|
| def localCodRestrict (S : Submodule ℝ Y) (f : X → Y) (x : X) : S := by |
| classical |
| exact if h : f x ∈ S then ⟨f x,h⟩ else 0 |
|
|
| omit [NormedAddCommGroup X] [NormedSpace ℝ X] [CompleteSpace Y] in |
| lemma localCodRestrict_eq (S : Submodule ℝ Y) (f : X → Y) {x : X} (h : f x ∈ S) : |
| (localCodRestrict S f x : Y)=f x := by |
| simp only [localCodRestrict,dite_eq_left h] |
|
|
| omit [NormedSpace ℝ X] [CompleteSpace Y] in |
| lemma localCodRestrict_eventually (S : Submodule ℝ Y) (f : X → Y) {x : X} |
| (h : ∀ᶠ y in 𝓝 x, f y ∈ S) : |
| (fun y => (localCodRestrict S f y : Y)) =ᶠ[𝓝 x] f := by |
| filter_upwards [h] with y hy |
| exact localCodRestrict_eq S f hy |
|
|
| def submoduleInclusionIsometry (S : Submodule ℝ Y) : S →ₗᵢ[ℝ] Y where |
| toLinearMap := S.subtype |
| norm_map' := fun _ => rfl |
|
|
| theorem localCodRestrict_contDiffAt (S : Submodule ℝ Y) [IsClosed (S : Set Y)] |
| (f : X → Y) {x : X} (h : ∀ᶠ y in 𝓝 x, f y ∈ S) (hf : ContDiffAt ℝ ∞ f x) : |
| ContDiffAt ℝ ∞ (localCodRestrict S f) x := by |
| let : CompleteSpace S := IsClosed.completeSpace_coe |
| apply contDiffAt_reflect_isometry (submoduleInclusionIsometry S) |
| exact hf.congr_of_eventuallyEq (localCodRestrict_eventually S f h) |
|
|
| theorem localCodRestrict_fderiv (S : Submodule ℝ Y) [IsClosed (S : Set Y)] |
| (f : X → Y) {x : X} (h : ∀ᶠ y in 𝓝 x, f y ∈ S) (v : X) : |
| (fderiv ℝ (localCodRestrict S f) x v : Y)=fderiv ℝ f x v := by |
| let : CompleteSpace S := IsClosed.completeSpace_coe |
| have hh := congrArg (fun L : X →L[ℝ] Y => L v) |
| (fderiv_comp_linearIsometry (submoduleInclusionIsometry S) (localCodRestrict S f) x) |
| change (fderiv ℝ (localCodRestrict S f) x v : Y)= |
| fderiv ℝ (fun y => (localCodRestrict S f y : Y)) x v at hh |
| rw [(localCodRestrict_eventually S f h).fderiv_eq] at hh |
| exact hh |
|
|
| end HigherDimensionalBallPacking.Rigidity |
|
|
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Function Filter |
| namespace HigherDimensionalBallPacking.Rigidity |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] |
| [FiniteDimensional ℂ E] |
| local instance localChartsInst19 (α : ℝ) : NormedAddCommGroup (HolderSpace ℂ E α) := inferInstance |
| local instance localChartsInst20 (α : ℝ) : NormedSpace ℝ (HolderSpace ℂ E α) := inferInstance |
| local instance localChartsInst21 (α : ℝ) : NormedAddCommGroup (C1HolderSpace E α) := inferInstance |
| local instance localChartsInst22 (α : ℝ) : NormedSpace ℝ (C1HolderSpace E α) := inferInstance |
| local instance localChartsInst23 (R : ℝ) : NormedAddCommGroup (CompactHolderSpace E R) := inferInstance |
| local instance localChartsInst24 (R : ℝ) : NormedSpace ℝ (CompactHolderSpace E R) := inferInstance |
|
|
| |
| def compactMarkedCR (R : ℝ) (Ainf : E →L[ℝ] E) (P : ℂ → E →L[ℝ] E) |
| (hP : ContDiff ℝ ∞ P) (hPc : HasCompactSupport P) |
| (J : E → E →L[ℝ] E) (hJ : ContDiff ℝ ∞ J) |
| (hc : HasCompactSupport (fun x => J x-(ContinuousLinearMap.lsmul ℝ ℂ) Complex.I)) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3)) : |
| CompactHolderSpace E R → CompactHolderSpace E R := |
| localCodRestrict (compactHolderSubmodule R) |
| (markedFramedCR R Ainf P hP hPc J ((ContinuousLinearMap.lsmul ℝ ℂ) Complex.I) hJ hc p) |
|
|
| |
|
|
| omit [FiniteDimensional ℂ E] in |
| theorem compactMarkedCR_local_chart (Ainf : E →L[ℝ] E) |
| (hAinf : ∀ v, Ainf (Complex.I • v)=Complex.I • Ainf v) |
| (P : ℂ → E →L[ℝ] E) (hP : ContDiff ℝ ∞ P) (hPc : HasCompactSupport P) |
| (J : E → E →L[ℝ] E) (hJ : ContDiff ℝ ∞ J) |
| (hc : HasCompactSupport (fun x => J x-(ContinuousLinearMap.lsmul ℝ ℂ) Complex.I)) |
| (p : (E × (ℂ →L[ℝ] E)) × C1HolderSpace E ((1:ℝ)/3)) |
| (m : ℝ) (hm : 0 < m) (hA : ∀ z, m*‖z‖ ≤ ‖p.1.2 z‖) |
| (hsol : ∀ z, crOperator J (c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2) z=0) : |
| ∃ S : ℝ, 0 < S ∧ ∀ R : ℝ, S ≤ R → |
| ContDiffAt ℝ ∞ (compactMarkedCR R Ainf P hP hPc J hJ hc p) 0 ∧ |
| (∀ᶠ g : CompactHolderSpace E R in 𝓝 0, ∀ z, |
| compactHolderValue R (compactMarkedCR R Ainf P hP hPc J hJ hc p g) z = |
| crOperator J (fun w => c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2 w+ |
| (Ainf+P w) (markedCRInverse R g w)) z) ∧ |
| ∀ g z, compactHolderValue R (fderiv ℝ (compactMarkedCR R Ainf P hP hPc J hJ hc p) 0 g) z = |
| linearizedCR J (c1HolderAffineCurve ((1:ℝ)/3) p.1.1 p.1.2 p.2) |
| (fun w => (Ainf+P w) (markedCRInverse R g w)) z := by |
| obtain ⟨S,hS,hSR⟩ := markedFramedCR_eventually_compact Ainf hAinf P hP hPc J hJ hc p m hm hA hsol |
| refine ⟨S,hS,?_⟩ |
| intro R hR |
| have he := hSR R hR |
| refine ⟨localCodRestrict_contDiffAt _ _ he |
| (markedFramedCR_contDiffAt_zero R Ainf P hP hPc J _ hJ hc p m hm hA),?_,?_⟩ |
| · filter_upwards [he] with g hg |
| intro z |
| change holderValue ((1:ℝ)/3) (localCodRestrict _ _ g).val z=_ |
| rw [localCodRestrict_eq _ _ hg] |
| unfold markedFramedCR |
| rw [c1HolderCRFamily,c1HolderCR_apply,affineC1Curve_add,affineC1Curve_profile] |
| rfl |
| · intro g z |
| change holderValue ((1:ℝ)/3) |
| (fderiv ℝ (localCodRestrict _ _) 0 g).val z=_ |
| rw [localCodRestrict_fderiv _ _ he] |
| exact markedFramedCR_fderiv_zero R Ainf P hP hPc J _ hJ hc p m hm hA g z |
|
|
| end HigherDimensionalBallPacking.Rigidity |
|
|
| end |
|
|
| end OAI |
|
|
