| import Mathlib |
| import OAI.Geometry.BallPacking.Compactness.MarkedCurves |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace HigherDimensionalBallPacking.Rigidity |
|
|
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| open HolderCompletion |
| variable {n : ℕ} |
| local instance grcInst1 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance |
| local instance grcInst2 : NormedSpace ℝ (HMap ℂ (Phase n)) := inferInstance |
|
|
| def geometricHolder {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) |
| (hc : HasCompactSupport (geometricResidual u)) : HMap ℂ (Phase n) := |
| jetValueCLM _ (ofBoundedCThree (boundedCThree_of_compactSupport (geometricResidual_smooth hu) hc)) |
|
|
| @[simp] lemma geometricHolder_value {u : ℂ → Phase n} (hu : ContDiff ℝ ∞ u) |
| (hc : HasCompactSupport (geometricResidual u)) (z : ℂ) : |
| valueCLM _ (geometricHolder hu hc) z=geometricResidual u z := rfl |
|
|
| lemma affineSource_distance (c x y : ℂ) {r : ℝ} (hr : 0<r) : |
| dist (r⁻¹ • (x-c)) (r⁻¹ • (y-c))=r⁻¹*dist x y := by |
| rw [dist_eq_norm,←smul_sub] |
| have he : (x-c)-(y-c)=x-y := by abel |
| rw [he,norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hr),dist_eq_norm] |
|
|
| lemma residual_difference_pullback {u : ℕ → ℂ → Phase n} (hu : ∀ i,ContDiff ℝ ∞ (u i)) |
| {g : ℕ → HMap ℂ (Phase n)} (hg : ∀ i z,valueCLM _ (g i) z=geometricResidual (u i) z) |
| (c : ℂ) {r : ℝ} (hr : 0<r) (i j : ℕ) {x : ℂ} (hx : dist x c<r/4) : |
| valueCLM _ (g i-g j) x=r⁻¹ • |
| valueCLM _ (localResidual (hu i) c r-localResidual (hu j) c r) (r⁻¹ • (x-c)) := by |
| change valueCLM _ (g i) x-valueCLM _ (g j) x=_ |
| rw [hg,hg,localResidual_at_original (hu i) c hr hx,localResidual_at_original (hu j) c hr hx,←smul_sub] |
| rfl |
|
|
| lemma local_residual_small_differences {u : ℕ → ℂ → Phase n} (hu : ∀ i,ContDiff ℝ ∞ (u i)) |
| {g : ℕ → HMap ℂ (Phase n)} (hg : ∀ i z,valueCLM _ (g i) z=geometricResidual (u i) z) |
| (c : ℂ) {r : ℝ} (hr : 0<r) |
| (hlocal : CauchySeq (fun i => localResidual (hu i) c r)) : |
| ∀ ε : ℝ,0<ε →∃ N : ℕ,∀ i≥N,∀ j≥N, |
| (∀ x,dist x c<r/4 →‖valueCLM _ (g i-g j) x‖≤ε) ∧ |
| (∀ x y,dist x c<r/4 →dist y c<r/4 → |
| ‖valueCLM _ (g i-g j) x-valueCLM _ (g i-g j) y‖≤ε*dist x y^((1:ℝ)/3)) := by |
| intro ε hε |
| let a := r⁻¹ |
| have ha : 0<a := inv_pos.mpr hr |
| have haα : 0<a^((1:ℝ)/3) := Real.rpow_pos_of_pos ha _ |
| let C := a+a*a^((1:ℝ)/3)+1 |
| have hC : 0<C := by dsimp [C]; positivity |
| have hCa : a≤C := by dsimp [C]; nlinarith [mul_nonneg ha.le haα.le] |
| have hCap : a*a^((1:ℝ)/3)≤C := by dsimp [C]; linarith |
| obtain ⟨N,hN⟩ := Metric.cauchySeq_iff.mp hlocal (ε/C) (div_pos hε hC) |
| refine ⟨N,fun i hi j hj => ?_⟩ |
| let v := localResidual (hu i) c r-localResidual (hu j) c r |
| have hv : ‖v‖≤ε/C := by simpa only [dist_eq_norm] using (hN i hi j hj).le |
| have haV : a*‖v‖≤ε := by |
| calc |
| a*‖v‖≤C*‖v‖ := mul_le_mul_of_nonneg_right hCa (norm_nonneg v) |
| _≤C*(ε/C) := mul_le_mul_of_nonneg_left hv hC.le |
| _=ε := mul_div_cancel₀ ε hC.ne' |
| have hapV : (a*a^((1:ℝ)/3))*‖v‖≤ε := by |
| calc |
| (a*a^((1:ℝ)/3))*‖v‖≤C*‖v‖ := mul_le_mul_of_nonneg_right hCap (norm_nonneg v) |
| _≤C*(ε/C) := mul_le_mul_of_nonneg_left hv hC.le |
| _=ε := mul_div_cancel₀ ε hC.ne' |
| refine ⟨?_,?_⟩ |
| · intro x hx |
| rw [residual_difference_pullback hu hg c hr i j hx,norm_smul,Real.norm_eq_abs,abs_of_pos ha] |
| exact (mul_le_mul_of_nonneg_left (norm_value_le v _) ha.le).trans haV |
| · intro x y hx hy |
| rw [residual_difference_pullback hu hg c hr i j hx, |
| residual_difference_pullback hu hg c hr i j hy,←smul_sub,norm_smul,Real.norm_eq_abs,abs_of_pos ha] |
| have hh := norm_sub_value_le v (r⁻¹ • (x-c)) (r⁻¹ • (y-c)) |
| rw [affineSource_distance c x y hr,Real.mul_rpow ha.le dist_nonneg] at hh |
| have hd : 0≤dist x y^((1:ℝ)/3) := Real.rpow_nonneg dist_nonneg _ |
| exact (mul_le_mul_of_nonneg_left hh ha.le).trans ((by |
| nlinarith [mul_le_mul_of_nonneg_right hapV hd] : |
| a*(‖v‖*(a^((1:ℝ)/3)*dist x y^((1:ℝ)/3)))≤ε*dist x y^((1:ℝ)/3))) |
|
|
| lemma geometric_residual_cauchy {u : ℕ → ℂ → Phase n} (hu : ∀ i,ContDiff ℝ ∞ (u i)) |
| {g : ℕ → HMap ℂ (Phase n)} (hg : ∀ i z,valueCLM _ (g i) z=geometricResidual (u i) z) |
| {K : Set ℂ} (hK : IsCompact K) (hsupp : ∀ i z,z∉K → geometricResidual (u i) z=0) |
| {r : ℝ} (hr : 0<r) |
| (hlocal : ∀ c,CauchySeq (fun i => cutoffCurveJet smallDiskBump (markedLocalCurve_smooth (hu i) c r))) : |
| CauchySeq g := by |
| apply compact_local_holder_cauchy hK (div_pos hr (by norm_num : (0:ℝ)<4)) |
| · intro i z hz |
| rw [hg,hsupp i z hz] |
| · intro c |
| exact local_residual_small_differences hu hg c hr (localResidual_cauchy hu c r (hlocal c)) |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| open HolderCompletion |
| variable {n : ℕ} |
| local instance clcInst1 : NormedAddCommGroup (End n) := ContinuousLinearMap.toNormedAddCommGroup |
| local instance clcInst2 : NormedSpace ℝ (End n) := ContinuousLinearMap.toNormedSpace |
| local instance clcInst3 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance |
| local instance clcInst4 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance |
|
|
| lemma compact_structure_norm_standard {J : Phase n → End n} |
| (hc : HasCompactSupport (fun x => J x-standardJ n)) : |
| ∃ B : ℝ,∀ x,B<‖x‖ →J x=standardJ n := by |
| obtain ⟨B,hB⟩ := hc.exists_bound_of_continuousOn (f := fun x : Phase n => x) continuous_id.continuousOn |
| refine ⟨B,fun x hx => ?_⟩ |
| exact sub_eq_zero.mp (image_eq_zero_of_notMem_tsupport (f := fun x => J x-standardJ n) (fun hh => (not_le_of_gt hx) (hB x hh))) |
|
|
| lemma marked_value_continuous (p q : Phase n) (z : ℂ) : |
| Continuous (fun w : COne ℂ (Phase n) => markedCurve p q w z) := |
| (continuous_const.add ((markedSlope_continuous p q).const_smul z)).add (jetEval z).continuous |
|
|
| lemma cDeriv_eval_continuous (z h : ℂ) : |
| Continuous (fun w : COne ℂ (Phase n) => cDeriv w z h) := by |
| have hc : Continuous (fun w : COne ℂ (Phase n) => cDeriv w z) := |
| ((BoundedContinuousFunction.evalCLM ℝ z).continuous.comp |
| ((valueCLM ((1:ℝ)/3)).continuous.comp (jetDerivCLM ((1:ℝ)/3)).continuous)) |
| exact hc.clm_apply continuous_const |
|
|
| lemma marked_derivative_eval_continuous (p q : Phase n) (z h : ℂ) : |
| Continuous (fun w : COne ℂ (Phase n) => fderiv ℝ (markedCurve p q w) z h) := by |
| simp only [markedCurve_fderiv,add_apply,complexSlope_apply] |
| exact ((markedSlope_continuous p q).const_smul h).add (cDeriv_eval_continuous z h) |
|
|
| lemma represented_line_slope_nonzero {J : Phase n → End n} {p q : Phase n} |
| (w : COne ℂ (Phase n)) (hu : AffineLineCurve J p q (markedCurve p q w)) : |
| markedSlope p q w≠0 := by |
| obtain ⟨a,ha,hlim⟩ := hu.2.2.2.2 |
| have he := tendsto_nhds_unique (markedCurve_asymptote p q w) hlim |
| exact fun hz => ha (he ▸ hz) |
|
|
| lemma completed_line_cr_closed {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| {t : ℕ → ℝ} {s : ℝ} (hsI : s∈Icc (0:ℝ) 1) (hs : Tendsto t atTop (𝓝 s)) |
| {p q : Phase n} {w : ℕ → COne ℂ (Phase n)} {v : COne ℂ (Phase n)} |
| (hw : Tendsto w atTop (𝓝 v)) |
| (hu : ∀ i,AffineLineCurve (lineHomotopy J (t i)) p q (markedCurve p q (w i))) : |
| ∀ z,fderiv ℝ (markedCurve p q v) z Complex.I= |
| lineHomotopy J s (markedCurve p q v z) (fderiv ℝ (markedCurve p q v) z 1) := by |
| intro z |
| have hz := ((marked_value_continuous p q z).tendsto v).comp hw |
| have hd1 := ((marked_derivative_eval_continuous p q z 1).tendsto v).comp hw |
| have hdI := ((marked_derivative_eval_continuous p q z Complex.I).tendsto v).comp hw |
| have hA := (lineHomotopy_joint_contDiffAt hJs hJ (v := (s,markedCurve p q v z)) hsI).continuousAt.tendsto.comp |
| (hs.prodMk_nhds hz) |
| have hAp : Continuous (fun v : End n × Phase n => v.1 v.2) := continuous_fst.clm_apply continuous_snd |
| have hR := ((hAp.tendsto _).comp (hA.prodMk_nhds hd1)) |
| have he (i : ℕ) := (hu i).2.1 z |
| apply tendsto_nhds_unique hdI |
| convert hR using 1 |
| funext i |
| simpa only [mul_one,Function.comp_def] using (he i).2 1 |
|
|
| lemma completed_line_slope_limit_nonzero {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) |
| {S T : ℝ} (hST : S<T) (hT : T<1) (hout : ∀ x,S<capacity x →J x=standardJ n) |
| {p q : Phase n} (hpq : p≠q) {t : ℕ → ℝ} (ht : ∀ i,t i∈Icc (0:ℝ) 1) |
| {w : ℕ → COne ℂ (Phase n)} {v : COne ℂ (Phase n)} (hw : Tendsto w atTop (𝓝 v)) |
| (hu : ∀ i,AffineLineCurve (lineHomotopy J (t i)) p q (markedCurve p q (w i))) : |
| markedSlope p q v≠0 := by |
| obtain ⟨d,hd,hlo⟩ := exact_line_slope_lower_bound hJs hJ hJc hST hT hout hpq |
| have hsl := ((markedSlope_continuous p q).tendsto v).comp hw |
| have hdotc : Continuous (fun a : Phase n => stdDot n a a) := (stdDot n).continuous.clm_apply continuous_id |
| have hdot := (hdotc.tendsto _).comp hsl |
| have hle : d ≤ stdDot n (markedSlope p q v) (markedSlope p q v) := by |
| apply ge_of_tendsto hdot |
| exact Eventually.of_forall fun i => hlo (t i) (ht i) _ (hu i) _ |
| (represented_line_slope_nonzero (w i) (hu i)) (markedCurve_asymptote p q (w i)) |
| intro hz |
| simp only [hz,map_zero] at hle |
| exact (not_le_of_gt hd) hle |
|
|
| lemma completed_line_closed {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) |
| {S T : ℝ} (hST : S<T) (hT : T<1) (hout : ∀ x,S<capacity x →J x=standardJ n) |
| {p q : Phase n} (hpq : p≠q) {t : ℕ → ℝ} (ht : ∀ i,t i∈Icc (0:ℝ) 1) |
| {s : ℝ} (hs : Tendsto t atTop (𝓝 s)) |
| {w : ℕ → COne ℂ (Phase n)} {v : COne ℂ (Phase n)} (hw : Tendsto w atTop (𝓝 v)) |
| (hw0 : ∀ i,cValue (w i) 0=0) |
| (hu : ∀ i,AffineLineCurve (lineHomotopy J (t i)) p q (markedCurve p q (w i))) : |
| AffineLineCurve (lineHomotopy J s) p q (markedCurve p q v) := by |
| have hsI : s∈Icc (0:ℝ) 1 := isClosed_Icc.mem_of_tendsto hs (Eventually.of_forall ht) |
| have hv0 : cValue v 0=0 := tendsto_nhds_unique (((jetEval 0).continuous.tendsto v).comp hw) |
| (by simpa only [Function.comp_def,jetEval_apply,hw0] using (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:Phase n)) atTop (𝓝 0))) |
| have ha := completed_line_slope_limit_nonzero hJs hJ hJc hST hT hout hpq ht hw hu |
| have hcr := completed_line_cr_closed hJs hJ hsI hs hw hu |
| obtain ⟨B,hB⟩ := compact_structure_norm_standard (lineHomotopy_compact hJc hsI) |
| have hcomp := lineHomotopy_compatible hJ hsI |
| refine ⟨completed_markedCurve_contDiff (lineHomotopy_slice_contDiff hJs hJ hsI) hcomp hB p q v ha hcr, |
| ?_,markedCurve_zero p q hv0,markedCurve_one p q v,markedSlope p q v,ha,markedCurve_asymptote p q v⟩ |
| intro z |
| exact ⟨(markedCurve_hasFDerivAt p q v z).differentiableAt, |
| realCR_axis_implies_all _ (hcomp _).1 _ (hcr z)⟩ |
|
|
|
|
| end |
| section |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| open HolderCompletion |
| variable {n : ℕ} |
| local instance eccInst1 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance |
| local instance eccInst2 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance |
| local instance eccInst3 : NormedAddCommGroup (HMap ℂ (Phase n)) := inferInstance |
| local instance eccInst4 : NormedSpace ℝ (HMap ℂ (Phase n)) := inferInstance |
| local instance eccInst5 (K : Set ℂ) : NormedAddCommGroup (supportedHolder (E := Phase n) K) := inferInstance |
| local instance eccInst6 (K : Set ℂ) : NormedSpace ℝ (supportedHolder (E := Phase n) K) := inferInstance |
|
|
| lemma represented_line_by_inverse {J : Phase n → End n} {p q : Phase n} {u : ℂ → Phase n} |
| (hu : AffineLineCurve J p q u) {K : Set ℂ} (hK : IsCompact K) |
| (g : supportedHolder (E := Phase n) K) (hg : ∀ z,valueCLM _ g.val z=geometricResidual u z) : |
| markedCurve p q (standardHolderInverse hK g)=u := by |
| obtain ⟨a,_,ha⟩ := hu.2.2.2.2 |
| exact (marked_reconstruction_from_correction (standardHolderInverse hK g) |
| (inverse_correction_holomorphic hu.1 hK g hg) ha hu.2.2.1 hu.2.2.2.1 |
| (standardHolderInverse_zero hK g)).1 |
|
|
| lemma subtype_cauchySeq_of_val {X : Type*} [PseudoMetricSpace X] {A : Set X} {g : ℕ → A} |
| (hg : CauchySeq (fun i => (g i).val)) : CauchySeq g := by |
| rw [Metric.cauchySeq_iff] at hg ⊢ |
| exact hg |
|
|
| theorem exact_marked_completed_convergence {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) |
| {S T : ℝ} (hST : S<T) (hT : T<1) (hout : ∀ x,S<capacity x →J x=standardJ n) |
| {p q : Phase n} (hpq : p≠q) {t : ℕ → ℝ} (ht : ∀ i,t i∈Icc (0:ℝ) 1) |
| {s : ℝ} (hs : Tendsto t atTop (𝓝 s)) |
| {u : ℕ → ℂ → Phase n} (hu : ∀ i,AffineLineCurve (lineHomotopy J (t i)) p q (u i)) |
| {v : ℂ → Phase n} (hv : ∀ K : Set ℂ,IsCompact K →TendstoUniformlyOn u v atTop K) : |
| ∃ (w : ℕ → COne ℂ (Phase n)) (a : COne ℂ (Phase n)), |
| (∀ i,markedCurve p q (w i)=u i ∧ cValue (w i) 0=0) ∧ |
| Tendsto w atTop (𝓝 a) ∧ markedCurve p q a=v ∧ |
| AffineLineCurve (lineHomotopy J s) p q v := by |
| obtain ⟨R,hR,hsupp⟩ := exact_marked_line_uniform_defect_support hJs hJ hJc hST hT hout p q hpq |
| let K := Metric.closedBall (0:ℂ) R |
| have hK : IsCompact K := isCompact_closedBall _ _ |
| have hc (i : ℕ) : HasCompactSupport (geometricResidual (u i)) := |
| geometricResidual_compact (hu i) (lineHomotopy_compact hJc (ht i)) |
| let G : ℕ → HMap ℂ (Phase n) := fun i => geometricHolder (hu i).1 (hc i) |
| have hG (i : ℕ) (z : ℂ) : valueCLM _ (G i) z=geometricResidual (u i) z := rfl |
| have hsupp' (i : ℕ) (z : ℂ) (hz : z∉K) : geometricResidual (u i) z=0 := by |
| have hz' : R<‖z‖ := by simpa only [K,Metric.mem_closedBall,dist_zero_right,not_le] using hz |
| exact (hsupp (t i) (ht i) (u i) (hu i) z hz').2 |
| have hGK (i : ℕ) : G i∈supportedHolder K := by |
| apply (mem_supportedHolder _ _).mpr |
| intro z hz |
| rw [hG,hsupp' i z hz] |
| let g : ℕ → supportedHolder (E := Phase n) K := fun i => ⟨G i,hGK i⟩ |
| obtain ⟨r,hr,_,hlocal⟩ := exact_marked_local_jet_cauchy hJs hJ hJc hST hT hout ht hs hu hv |
| have hGC : CauchySeq G := geometric_residual_cauchy (fun i => (hu i).1) hG hK hsupp' hr hlocal |
| have hgC : CauchySeq g := subtype_cauchySeq_of_val hGC |
| obtain ⟨g₀,hg₀⟩ := cauchySeq_tendsto_of_complete hgC |
| let w := fun i => standardHolderInverse hK (g i) |
| let a := standardHolderInverse hK g₀ |
| have hw : Tendsto w atTop (𝓝 a) := ((standardHolderInverse hK).continuous.tendsto g₀).comp hg₀ |
| have hrec (i : ℕ) : markedCurve p q (w i)=u i := represented_line_by_inverse (hu i) hK (g i) (hG i) |
| have hw0 (i : ℕ) : cValue (w i) 0=0 := standardHolderInverse_zero hK (g i) |
| have hline (i : ℕ) : AffineLineCurve (lineHomotopy J (t i)) p q (markedCurve p q (w i)) := by |
| rw [hrec i] |
| exact hu i |
| have haline := completed_line_closed hJs hJ hJc hST hT hout hpq ht hs hw hw0 hline |
| have hav : markedCurve p q a=v := by |
| funext z |
| have hpoint := ((marked_value_continuous p q z).tendsto a).comp hw |
| have huv := (hv {z} isCompact_singleton).tendsto_at (mem_singleton z) |
| apply tendsto_nhds_unique hpoint |
| simpa only [Function.comp_def,hrec] using huv |
| exact ⟨w,a,fun i => ⟨hrec i,hw0 i⟩,hw,hav,hav ▸ haline⟩ |
|
|
| theorem exact_marked_completed_compactness {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) |
| {S T : ℝ} (hST : S<T) (hT : T<1) (hout : ∀ x,S<capacity x →J x=standardJ n) |
| {p q : Phase n} (hpq : p≠q) {t : ℕ → ℝ} (ht : ∀ i,t i∈Icc (0:ℝ) 1) |
| {s : ℝ} (hs : Tendsto t atTop (𝓝 s)) |
| {u : ℕ → ℂ → Phase n} (hu : ∀ i,AffineLineCurve (lineHomotopy J (t i)) p q (u i)) : |
| ∃ (φ : ℕ → ℕ),StrictMono φ ∧ ∃ (w : ℕ → COne ℂ (Phase n)) (a : COne ℂ (Phase n)), |
| (∀ i,markedCurve p q (w i)=u (φ i) ∧ cValue (w i) 0=0) ∧ |
| Tendsto w atTop (𝓝 a) ∧ AffineLineCurve (lineHomotopy J s) p q (markedCurve p q a) := by |
| obtain ⟨v,_,_,φ,hφ,hsub⟩ := exact_marked_line_czero_compactness hJs hJ hJc hST hT hout ht hu |
| obtain ⟨w,a,hrec,hw,hav,haline⟩ := exact_marked_completed_convergence hJs hJ hJc hST hT hout hpq |
| (fun i => ht (φ i)) (hs.comp hφ.tendsto_atTop) (fun i => hu (φ i)) hsub |
| exact ⟨φ,hφ,w,a,hrec,hw,hav.symm ▸ haline⟩ |
|
|
|
|
| end |
| open scoped ContDiff Topology BoundedContinuousFunction |
| open Set Filter |
| open HolderCompletion |
| variable {n : ℕ} |
| local instance empInst1 : NormedAddCommGroup (COne ℂ (Phase n)) := inferInstance |
| local instance empInst2 : NormedSpace ℝ (COne ℂ (Phase n)) := inferInstance |
|
|
| lemma markedCurve_injective (p q : Phase n) : Function.Injective (markedCurve p q) := by |
| intro v w hvw |
| have hs : markedSlope p q v=markedSlope p q w := by |
| apply tendsto_nhds_unique (markedCurve_asymptote p q v) |
| rw [hvw] |
| exact markedCurve_asymptote p q w |
| apply cValue_ext |
| intro z |
| have hz := congrFun hvw z |
| change p+z • markedSlope p q v+cValue v z=p+z • markedSlope p q w+cValue w z at hz |
| rw [hs] at hz |
| exact add_left_cancel hz |
|
|
| def exactMarkedZeroSet (J : Phase n → End n) (p q : Phase n) : Set (ℝ × COne ℂ (Phase n)) := |
| {v | v.1∈Icc (0:ℝ) 1 ∧ cValue v.2 0=0 ∧ |
| AffineLineCurve (lineHomotopy J v.1) p q (markedCurve p q v.2)} |
|
|
| lemma correction_limit_zero {w : ℕ → COne ℂ (Phase n)} {v : COne ℂ (Phase n)} |
| (hw : Tendsto w atTop (𝓝 v)) (hw0 : ∀ i,cValue (w i) 0=0) : cValue v 0=0 := by |
| have hh := ((jetEval (E := Phase n) 0).continuous.tendsto v).comp hw |
| apply tendsto_nhds_unique hh |
| simpa only [Function.comp_def,jetEval_apply,hw0] using |
| (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:Phase n)) atTop (𝓝 0)) |
|
|
| theorem exact_marked_zeroSet_compact {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) |
| {S T : ℝ} (hST : S<T) (hT : T<1) (hout : ∀ x,S<capacity x →J x=standardJ n) |
| {p q : Phase n} (hpq : p≠q) : IsCompact (exactMarkedZeroSet J p q) := by |
| apply IsSeqCompact.isCompact |
| intro x hx |
| obtain ⟨s,hsI,ψ,hψ,hs⟩ := isCompact_Icc.isSeqCompact (fun i => (hx i).1) |
| have htime : Tendsto (fun i => (x (ψ i)).1) atTop (𝓝 s) := hs |
| obtain ⟨φ,hφ,w,a,hrec,hwa,haline⟩ := exact_marked_completed_compactness hJs hJ hJc hST hT hout hpq |
| (fun i => (hx (ψ i)).1) htime (fun i => (hx (ψ i)).2.2) |
| have he (i : ℕ) : w i=(x (ψ (φ i))).2 := markedCurve_injective p q (hrec i).1 |
| have ha0 : cValue a 0=0 := correction_limit_zero hwa (fun i => (hrec i).2) |
| refine ⟨(s,a),⟨hsI,ha0,haline⟩,ψ ∘ φ,hψ.comp hφ,?_⟩ |
| have htend := htime.comp hφ.tendsto_atTop |
| have hw' : Tendsto (fun i => (x (ψ (φ i))).2) atTop (𝓝 a) := by |
| have hew : w=(fun i => (x (ψ (φ i))).2) := funext he |
| rw [hew] at hwa |
| exact hwa |
| exact htend.prodMk_nhds hw' |
|
|
| theorem exact_marked_existence_parameters_closed {J : Phase n → End n} |
| (hJs : ContDiff ℝ ∞ J) (hJ : ∀ x,Compatible (J x)) |
| (hJc : HasCompactSupport (fun x => J x-standardJ n)) |
| {S T : ℝ} (hST : S<T) (hT : T<1) (hout : ∀ x,S<capacity x →J x=standardJ n) |
| {p q : Phase n} (hpq : p≠q) : IsClosed (Prod.fst '' exactMarkedZeroSet J p q) := |
| ((exact_marked_zeroSet_compact hJs hJ hJc hST hT hout hpq).image continuous_fst).isClosed |
|
|
|
|
|
|
| end HigherDimensionalBallPacking.Rigidity |
| end |
|
|
| end OAI |
|
|
