| import Mathlib | |
| import OAI.Geometry.BallPacking.Degree.ChartFormZeroExtension | |
| namespace OAI | |
| noncomputable section | |
| namespace HigherDimensionalBallPacking.Rigidity.Degree | |
| section | |
| open scoped ContDiff Topology | |
| open Set Filter MeasureTheory | |
| variable {m : ℕ} | |
| theorem finite_box_continuation | |
| {F : CoordinateSpace (m+1) → CoordinateSpace m} (hF : ContDiff ℝ ∞ F) | |
| {R : ℝ} (hR : 0<R) (hinit : ∀ y,F (timeFace 0 y)=y) | |
| (hside : ∀ t∈Icc (0:ℝ) 1,∀ y∈spatialBox R,∀ i : Fin m, | |
| y i= -R ∨ y i=R → F (timeFace t y)≠0) : | |
| ∃ y∈spatialBox R,F (timeFace 1 y)=0 := by | |
| by_contra hn | |
| push Not at hn | |
| have havoid (v : CoordinateSpace (m+1)) (hv : v∈exitFaces R) : F v≠0 := by | |
| have ht := time_mem_interval hv.1 | |
| have hy := tail_mem_spatialBox hv.1 | |
| have he : timeFace (v 0) (Fin.tail v)=v := Fin.cons_self_tail v | |
| rcases hv.2 with hend|hsidev | |
| · have hh := hn (Fin.tail v) hy | |
| have he1 : timeFace 1 (Fin.tail v)=v := by rwa [hend] at he | |
| rwa [he1] at hh | |
| · obtain ⟨i,hi⟩ := mem_iUnion.mp hsidev | |
| have hh := hside (v 0) ht (Fin.tail v) hy i hi | |
| rwa [he] at hh | |
| let K := F '' exitFaces (m := m) R | |
| have hK : IsCompact K := (exitFaces_compact R).image hF.continuous | |
| have h0 : (0:CoordinateSpace m)∉K := by | |
| rintro ⟨v,hv,he⟩ | |
| exact havoid v hv he | |
| obtain ⟨b,hb,hbz⟩ := separating_bump hK h0 hR | |
| have hwb (x : CoordinateSpace m) (hx : x∈K) : weightedVolume b x=0 := | |
| weightedVolume_zero (hbz x hx) | |
| have hboundary : ∀ i : Fin (m+1),i≠0 → | |
| ∀ y∈Icc (lowerCorner R ∘ i.succAbove) (upperCorner R ∘ i.succAbove), | |
| weightedVolume b (F (i.insertNth (upperCorner R i) y))=0 ∧ | |
| weightedVolume b (F (i.insertNth (lowerCorner R i) y))=0 := by | |
| intro i hi y hy | |
| have hh := sideFace_mem_exit R hR.le i hi hy | |
| exact ⟨hwb _ (mem_image_of_mem F hh.1),hwb _ (mem_image_of_mem F hh.2)⟩ | |
| have hinitial : (∫ y in Icc (lowerCorner R ∘ (0:Fin (m+1)).succAbove) | |
| (upperCorner R ∘ (0:Fin (m+1)).succAbove), | |
| formFlux (pullTopForm F (weightedVolume b)) 0 ((0:Fin (m+1)).insertNth (lowerCorner (m := m) R 0) y))≠0 := by | |
| simp only [lowerCorner,Fin.cons_zero,initial_weighted_flux hF 0 hinit] | |
| change (∫ y in spatialBox R,b y)≠0 | |
| exact (bump_initial_integral_pos b hb.le).ne' | |
| obtain ⟨y,hy,hny⟩ := finite_homotopy_support_endpoint hF | |
| (weightedVolume_differentiable ((b.contDiff (n := (⊤ : ℕ∞))).differentiable (by simp))) | |
| (lowerCorner R) (upperCorner R) (corners_le hR.le) hboundary hinitial | |
| apply hny | |
| apply hwb | |
| apply mem_image_of_mem | |
| have hy' : y∈spatialBox R := (initialFace_box R) ▸ hy | |
| rw [Fin.insertNth_zero'] | |
| change Fin.cons 1 y∈exitFaces R | |
| exact ⟨timeFace_mem_box (by constructor <;> norm_num) hy',Or.inl (by simp)⟩ | |
| end | |
| section | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter MeasureTheory | |
| variable {m : ℕ} | |
| lemma compact_smooth_plateau {K U : Set (CoordinateSpace m)} (hK : IsCompact K) | |
| (hU : IsOpen U) (hKU : K⊆U) : | |
| ∃ χ : CoordinateSpace m → ℝ,ContDiff ℝ ∞ χ ∧ HasCompactSupport χ ∧ tsupport χ⊆U ∧ | |
| (∀ x,0≤χ x ∧ χ x≤1) ∧ ∃ V : Set (CoordinateSpace m),IsOpen V ∧ K⊆V ∧ EqOn χ (fun _ => 1) V := by | |
| obtain ⟨r,hr,hrU⟩ := hK.exists_cthickening_subset_open hU hKU | |
| let O := Metric.thickening r K | |
| let T := Metric.cthickening (r/2) K | |
| have hTO : T⊆O := Metric.cthickening_subset_thickening (δ₁ := ⟨r/2,(half_pos hr).le⟩) (half_lt_self hr) K | |
| obtain ⟨χ,hχ,hχr,hχs,hχ1⟩ := exists_contMDiff_support_eq_eq_one_iff | |
| (I := 𝓘(ℝ,CoordinateSpace m)) (n := (⊤ : ℕ∞)) Metric.isOpen_thickening Metric.isClosed_cthickening hTO | |
| have hχc : ContDiff ℝ ∞ χ := hχ.contDiff | |
| have hs : tsupport χ⊆Metric.cthickening r K := by | |
| rw [tsupport,hχs] | |
| exact closure_minimal (Metric.thickening_subset_cthickening r K) Metric.isClosed_cthickening | |
| refine ⟨χ,hχc,(hK.cthickening).of_isClosed_subset (isClosed_tsupport χ) hs,hs.trans hrU,?_, | |
| Metric.thickening (r/2) K,Metric.isOpen_thickening,Metric.self_subset_thickening (half_pos hr) K,?_⟩ | |
| · intro x | |
| exact hχr (mem_range_self x) | |
| · intro x hx | |
| exact (hχ1 x).mp (Metric.thickening_subset_cthickening (r/2) K hx) | |
| def finiteTimeFreeze (F : CoordinateSpace (m+1) → CoordinateSpace m) | |
| (v : CoordinateSpace (m+1)) : CoordinateSpace m := | |
| F (timeFace (Real.smoothTransition (v 0)) (Fin.tail v)) | |
| lemma finiteTimeFreeze_smooth {F : CoordinateSpace (m+1) → CoordinateSpace m} | |
| (hF : ContDiff ℝ ∞ F) : ContDiff ℝ ∞ (finiteTimeFreeze F) := by | |
| apply hF.comp | |
| apply contDiff_pi.mpr | |
| intro i | |
| refine Fin.cases ?_ (fun j => ?_) i | |
| · exact (show ContDiff ℝ ∞ Real.smoothTransition from contDiff_infty.mpr (fun _ => Real.smoothTransition.contDiff)).comp (contDiff_pi.mp contDiff_id 0) | |
| · exact contDiff_pi.mp contDiff_id j.succ | |
| lemma finiteTimeFreeze_zero {F : CoordinateSpace (m+1) → CoordinateSpace m} (y : CoordinateSpace m) : | |
| finiteTimeFreeze F (timeFace 0 y)=F (timeFace 0 y) := by | |
| simp only [finiteTimeFreeze,timeFace,Fin.cons_zero,Fin.tail_cons,Real.smoothTransition.zero] | |
| lemma finiteTimeFreeze_one {F : CoordinateSpace (m+1) → CoordinateSpace m} (y : CoordinateSpace m) : | |
| finiteTimeFreeze F (timeFace 1 y)=F (timeFace 1 y) := by | |
| simp only [finiteTimeFreeze,timeFace,Fin.cons_zero,Fin.tail_cons,Real.smoothTransition.one] | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Filter MeasureTheory | |
| variable {m : ℕ} | |
| def cutoffPullTopForm (χ : CoordinateSpace m → ℝ) | |
| (F : CoordinateSpace (m+1) → CoordinateSpace m) | |
| (b : CoordinateSpace m → ℝ) (v : CoordinateSpace (m+1)) : | |
| CoordinateSpace (m+1) [⋀^Fin m]→L[ℝ] ℝ := | |
| χ (Fin.tail v) • pullTopForm F (weightedVolume b) v | |
| lemma tail_smooth : ContDiff ℝ ∞ (Fin.tail : CoordinateSpace (m+1) → CoordinateSpace m) := by | |
| exact contDiff_pi.mpr (fun i => contDiff_pi.mp contDiff_id i.succ) | |
| lemma cutoffPullTopForm_differentiable {χ : CoordinateSpace m → ℝ} | |
| {F : CoordinateSpace (m+1) → CoordinateSpace m} {b : CoordinateSpace m → ℝ} | |
| (hχ : ContDiff ℝ ∞ χ) (hF : ContDiff ℝ ∞ F) (hb : ContDiff ℝ ∞ b) : | |
| Differentiable ℝ (cutoffPullTopForm χ F b) := | |
| ((hχ.comp tail_smooth).differentiable (by simp)).smul | |
| (pullTopForm_differentiable hF (weightedVolume_differentiable (hb.differentiable (by simp)))) | |
| lemma extDeriv_constant_zero (v : CoordinateSpace (m+1)) : | |
| extDeriv (fun _ : CoordinateSpace (m+1) => (0 : CoordinateSpace (m+1) [⋀^Fin m]→L[ℝ] ℝ)) v=0 := by | |
| ext u | |
| rw [extDeriv_apply (differentiableAt_const _)] | |
| simp | |
| lemma cutoffPullTopForm_closed {χ : CoordinateSpace m → ℝ} | |
| {F : CoordinateSpace (m+1) → CoordinateSpace m} {b : CoordinateSpace m → ℝ} | |
| (hF : ContDiff ℝ ∞ F) (hb : ContDiff ℝ ∞ b) | |
| {V : Set (CoordinateSpace m)} (hV : IsOpen V) (hχ1 : EqOn χ (fun _ => 1) V) | |
| (hcover : ∀ v : CoordinateSpace (m+1),Fin.tail v∈V ∨ | |
| Fin.tail v∉tsupport χ ∨ F v∉tsupport b) (v : CoordinateSpace (m+1)) : | |
| extDeriv (cutoffPullTopForm χ F b) v=0 := by | |
| rcases hcover v with h|h|h | |
| · have he : cutoffPullTopForm χ F b =ᶠ[𝓝 v] pullTopForm F (weightedVolume b) := by | |
| filter_upwards [tail_smooth.continuous.continuousAt (hV.mem_nhds h)] with y hy | |
| simp only [cutoffPullTopForm,hχ1 hy,one_smul] | |
| rw [he.extDeriv_eq] | |
| exact pullTopForm_closed hF (weightedVolume_differentiable (hb.differentiable (by simp))) v | |
| · have he : cutoffPullTopForm χ F b =ᶠ[𝓝 v] (fun _ => 0) := by | |
| filter_upwards [tail_smooth.continuous.continuousAt ((isClosed_tsupport χ).isOpen_compl.mem_nhds h)] with y hy | |
| simp only [cutoffPullTopForm,image_eq_zero_of_notMem_tsupport hy,zero_smul] | |
| rw [he.extDeriv_eq] | |
| exact extDeriv_constant_zero v | |
| · have he : cutoffPullTopForm χ F b =ᶠ[𝓝 v] (fun _ => 0) := by | |
| filter_upwards [hF.continuous.continuousAt ((isClosed_tsupport b).isOpen_compl.mem_nhds h)] with y hy | |
| have hz := pullTopForm_zero (F := F) (weightedVolume_zero (image_eq_zero_of_notMem_tsupport hy)) | |
| simp only [cutoffPullTopForm,hz,smul_zero] | |
| rw [he.extDeriv_eq] | |
| exact extDeriv_constant_zero v | |
| lemma separating_bump_support {K : Set (CoordinateSpace m)} (hK : IsCompact K) | |
| (h0 : (0:CoordinateSpace m)∉K) {R : ℝ} (hR : 0<R) : | |
| ∃ b : ContDiffBump (0:CoordinateSpace m),b.rOut<R ∧ ∀ x∈K,x∉tsupport (b : CoordinateSpace m → ℝ) := by | |
| obtain ⟨ε,hε,hball⟩ := Metric.isOpen_iff.mp hK.isClosed.isOpen_compl 0 h0 | |
| let r := min ε R/2 | |
| have hr : 0<r := div_pos (lt_min hε hR) (by norm_num) | |
| let b : ContDiffBump (0:CoordinateSpace m) := ⟨r/2,r,by positivity,by linarith⟩ | |
| have hrε : r<ε := (half_lt_self (lt_min hε hR)).trans_le (min_le_left _ _) | |
| have hrR : r<R := (half_lt_self (lt_min hε hR)).trans_le (min_le_right _ _) | |
| refine ⟨b,hrR,?_⟩ | |
| intro x hx hb | |
| rw [b.tsupport_eq,Metric.mem_closedBall] at hb | |
| exact hball (show x∈Metric.ball 0 ε from lt_of_le_of_lt hb hrε) hx | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {m : ℕ} | |
| def tailCLM (m : ℕ) : CoordinateSpace (m+1) →L[ℝ] CoordinateSpace m := | |
| ContinuousLinearMap.pi (fun i => ContinuousLinearMap.proj i.succ) | |
| lemma tailCLM_apply (v : CoordinateSpace (m+1)) : tailCLM m v=Fin.tail v := rfl | |
| lemma tail_coordinate_zero : tailCLM m (coordinateVector 0)=0 := by | |
| ext i | |
| simp [tailCLM,coordinateVector] | |
| lemma tail_coordinate_succ (i : Fin m) : tailCLM m (coordinateVector i.succ)=coordinateVector i := by | |
| ext j | |
| simp [tailCLM,coordinateVector,Pi.single_apply] | |
| def collarVolumeForm (θ : ℝ → ℝ) (ρ : CoordinateSpace m → ℝ) (v : CoordinateSpace (m+1)) : | |
| CoordinateSpace (m+1) [⋀^Fin m]→L[ℝ] ℝ := | |
| (θ (v 0)*ρ (Fin.tail v)) • (coordinateVolume m).compContinuousLinearMap (tailCLM m) | |
| lemma collarVolumeForm_smooth {θ : ℝ → ℝ} {ρ : CoordinateSpace m → ℝ} | |
| (hθ : ContDiff ℝ ∞ θ) (hρ : ContDiff ℝ ∞ ρ) : ContDiff ℝ ∞ (collarVolumeForm θ ρ) := | |
| ((hθ.comp (contDiff_pi.mp contDiff_id 0)).mul (hρ.comp tail_smooth)).smul contDiff_const | |
| lemma collarVolumeForm_flux_zero (θ : ℝ → ℝ) (ρ : CoordinateSpace m → ℝ) | |
| (v : CoordinateSpace (m+1)) : | |
| formFlux (collarVolumeForm θ ρ) 0 v=θ (v 0)*ρ (Fin.tail v) := by | |
| change (-1:ℝ)^0 • ((θ (v 0)*ρ (Fin.tail v)) • | |
| (coordinateVolume m) (fun i => tailCLM m (coordinateVector ((0:Fin (m+1)).succAbove i))))=_ | |
| simp only [Fin.zero_succAbove,tail_coordinate_succ,coordinateVolume_basis,pow_zero,smul_eq_mul,mul_one,one_mul] | |
| lemma collarVolumeForm_flux_other (θ : ℝ → ℝ) (ρ : CoordinateSpace m → ℝ) | |
| (i : Fin (m+1)) (hi : i≠0) (v : CoordinateSpace (m+1)) : | |
| formFlux (collarVolumeForm θ ρ) i v=0 := by | |
| obtain ⟨j,hj⟩ := Fin.exists_succAbove_eq hi.symm | |
| have hz : (coordinateVolume m) (fun k => tailCLM m (coordinateVector (i.succAbove k)))=0 := by | |
| apply (coordinateVolume m).toAlternatingMap.map_coord_zero j | |
| rw [hj,tail_coordinate_zero] | |
| change (-1:ℝ)^i.val • ((θ (v 0)*ρ (Fin.tail v)) • | |
| (coordinateVolume m) (fun k => tailCLM m (coordinateVector (i.succAbove k))))=0 | |
| rw [hz,smul_zero,smul_zero] | |
| lemma collarVolumeForm_exterior_basis {θ : ℝ → ℝ} {ρ : CoordinateSpace m → ℝ} | |
| (hθ : ContDiff ℝ ∞ θ) (hρ : ContDiff ℝ ∞ ρ) (v : CoordinateSpace (m+1)) : | |
| extDeriv (collarVolumeForm θ ρ) v coordinateVector=deriv θ (v 0)*ρ (Fin.tail v) := by | |
| rw [←formFlux_divergence ((collarVolumeForm_smooth hθ hρ).differentiable (by simp))] | |
| rw [Finset.sum_eq_single (0:Fin (m+1))] | |
| · have he : formFlux (collarVolumeForm θ ρ) 0=(fun y => θ (y 0)*ρ (Fin.tail y)) := | |
| funext (collarVolumeForm_flux_zero θ ρ) | |
| rw [he] | |
| have ht := ((hθ.differentiable (by simp) (v 0)).hasDerivAt.hasFDerivAt).comp v | |
| ((ContinuousLinearMap.proj (R := ℝ) (φ := fun _ : Fin (m+1) => ℝ) 0).hasFDerivAt (x := v)) | |
| have hr := ((hρ.differentiable (by simp) (Fin.tail v)).hasFDerivAt).comp v (tailCLM m).hasFDerivAt | |
| have hh := (ht.mul hr).fderiv | |
| simp only [Function.comp_def,Pi.mul_def,ContinuousLinearMap.proj_apply] at hh | |
| rw [hh] | |
| have hz : tailCLM m (Pi.single 0 1)=0 := tail_coordinate_zero | |
| simp [coordinateVector,hz,mul_comm] | |
| · intro i hi hi0 | |
| have he : formFlux (collarVolumeForm θ ρ) i=(fun _ => 0) := | |
| funext (collarVolumeForm_flux_other θ ρ i hi0) | |
| rw [he] | |
| simp | |
| · simp | |
| lemma collarVolumeForm_zero_of_time {θ : ℝ → ℝ} {ρ : CoordinateSpace m → ℝ} | |
| {v : CoordinateSpace (m+1)} (h : θ (v 0)=0) : collarVolumeForm θ ρ v=0 := by | |
| simp [collarVolumeForm,h] | |
| lemma collarVolumeForm_zero_of_space {θ : ℝ → ℝ} {ρ : CoordinateSpace m → ℝ} | |
| {v : CoordinateSpace (m+1)} (h : ρ (Fin.tail v)=0) : collarVolumeForm θ ρ v=0 := by | |
| simp [collarVolumeForm,h] | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| def collarRise (a b t : ℝ) : ℝ := Real.smoothTransition ((t-a)/(b-a)) | |
| lemma collarRise_smooth (a b : ℝ) : ContDiff ℝ ∞ (collarRise a b) := | |
| (show ContDiff ℝ ∞ Real.smoothTransition from contDiff_infty.mpr (fun _ => Real.smoothTransition.contDiff)).comp | |
| ((contDiff_id.sub contDiff_const).div_const _) | |
| lemma collarRise_initial {a b t : ℝ} (hab : a<b) (ht : t≤a) : collarRise a b t=0 := | |
| Real.smoothTransition.zero_of_nonpos (div_nonpos_of_nonpos_of_nonneg (sub_nonpos.mpr ht) (sub_pos.mpr hab).le) | |
| lemma collarRise_final {a b t : ℝ} (hab : a<b) (ht : b≤t) : collarRise a b t=1 := | |
| Real.smoothTransition.one_of_one_le ((le_div_iff₀ (sub_pos.mpr hab)).mpr (by linarith)) | |
| lemma collarRise_monotone {a b : ℝ} (hab : a<b) : Monotone (collarRise a b) := by | |
| intro x y hxy | |
| exact Real.smoothTransition.monotone (div_le_div_of_nonneg_right (sub_le_sub_right hxy _) (sub_pos.mpr hab).le) | |
| lemma collarRise_deriv_nonneg {a b : ℝ} (hab : a<b) (t : ℝ) : 0≤deriv (collarRise a b) t := | |
| (collarRise_monotone hab).deriv_nonneg | |
| lemma collarRise_deriv_zero {a b t : ℝ} (hab : a<b) (ht : t∉Icc a b) : deriv (collarRise a b) t=0 := by | |
| simp only [mem_Icc,not_and_or,not_le] at ht | |
| rcases ht with ht|ht | |
| · have he : collarRise a b =ᶠ[𝓝 t] fun _ => 0 := by | |
| filter_upwards [gt_mem_nhds ht] with s hs | |
| exact collarRise_initial hab hs.le | |
| rw [he.deriv_eq] | |
| simp | |
| · have he : collarRise a b =ᶠ[𝓝 t] fun _ => 1 := by | |
| filter_upwards [lt_mem_nhds ht] with s hs | |
| exact collarRise_final hab hs.le | |
| rw [he.deriv_eq] | |
| simp | |
| lemma collarRise_deriv_support {a b : ℝ} (hab : a<b) : tsupport (deriv (collarRise a b))⊆Icc a b := by | |
| apply closure_minimal _ isClosed_Icc | |
| intro t ht | |
| by_contra hn | |
| exact ht (collarRise_deriv_zero hab hn) | |
| lemma collarRise_deriv_positive {a b : ℝ} (hab : a<b) : ∃ t∈Ioo a b,0<deriv (collarRise a b) t := by | |
| obtain ⟨t,ht,he⟩ := exists_deriv_eq_slope (collarRise a b) hab | |
| (collarRise_smooth a b).continuous.continuousOn ((collarRise_smooth a b).differentiable (by simp)).differentiableOn | |
| refine ⟨t,ht,?_⟩ | |
| rw [he,collarRise_initial hab le_rfl,collarRise_final hab le_rfl,sub_zero] | |
| exact div_pos zero_lt_one (sub_pos.mpr hab) | |
| def collarCutoff (a b c d t : ℝ) : ℝ := collarRise a b t-collarRise c d t | |
| lemma collarCutoff_smooth (a b c d : ℝ) : ContDiff ℝ ∞ (collarCutoff a b c d) := | |
| (collarRise_smooth a b).sub (collarRise_smooth c d) | |
| lemma collarCutoff_deriv (a b c d t : ℝ) : | |
| deriv (collarCutoff a b c d) t=deriv (collarRise a b) t-deriv (collarRise c d) t := by | |
| exact deriv_sub ((collarRise_smooth a b).differentiable (by simp) t) | |
| ((collarRise_smooth c d).differentiable (by simp) t) | |
| lemma collarCutoff_zero {a b c d t : ℝ} (hab : a<b) (hbc : b<c) (hcd : c<d) | |
| (ht : t∉Icc a d) : collarCutoff a b c d t=0 := by | |
| simp only [mem_Icc,not_and_or,not_le] at ht | |
| rcases ht with ht|ht | |
| · rw [collarCutoff,collarRise_initial hab ht.le,collarRise_initial hcd (ht.le.trans (hab.trans hbc).le),sub_self] | |
| · rw [collarCutoff,collarRise_final hab ((hbc.trans hcd).le.trans ht.le),collarRise_final hcd ht.le,sub_self] | |
| lemma collarCutoff_deriv_initial {a b c d t : ℝ} (hcd : c<d) (ht : t<c) : | |
| deriv (collarCutoff a b c d) t=deriv (collarRise a b) t := by | |
| rw [collarCutoff_deriv,collarRise_deriv_zero hcd (fun h => (not_le.mpr ht) h.1),sub_zero] | |
| lemma collarCutoff_deriv_support {a b c d : ℝ} (hab : a<b) (hcd : c<d) : | |
| tsupport (deriv (collarCutoff a b c d))⊆Icc a b ∪ Icc c d := by | |
| apply closure_minimal _ (isClosed_Icc.union isClosed_Icc) | |
| intro t ht | |
| by_contra hn | |
| have ha : t∉Icc a b := fun h => hn (Or.inl h) | |
| have hb : t∉Icc c d := fun h => hn (Or.inr h) | |
| apply ht | |
| rw [collarCutoff_deriv,collarRise_deriv_zero hab ha,collarRise_deriv_zero hcd hb,sub_self] | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter MeasureTheory | |
| variable {m : ℕ} | |
| lemma topForm_eq_zero_of_basis (w : CoordinateSpace m [⋀^Fin m]→L[ℝ] ℝ) | |
| (hw : w coordinateVector=0) : w=0 := by | |
| have he := w.toAlternatingMap.eq_smul_basis_det (Pi.basisFun ℝ (Fin m)) | |
| have hb : (coordinateVector : Fin m → CoordinateSpace m)=Pi.basisFun ℝ (Fin m) := by | |
| funext i | |
| exact (Pi.basisFun_apply ℝ (Fin m) i).symm | |
| rw [←hb] at he | |
| change w.toAlternatingMap coordinateVector=0 at hw | |
| rw [hw,zero_smul] at he | |
| ext v | |
| exact congrArg (fun A : AlternatingMap ℝ (CoordinateSpace m) ℝ (Fin m) => A v) he | |
| lemma collarVolumeForm_exterior_zero {θ : ℝ → ℝ} {ρ : CoordinateSpace m → ℝ} | |
| (hθ : ContDiff ℝ ∞ θ) (hρ : ContDiff ℝ ∞ ρ) {v : CoordinateSpace (m+1)} | |
| (hz : deriv θ (v 0)=0 ∨ ρ (Fin.tail v)=0) : extDeriv (collarVolumeForm θ ρ) v=0 := by | |
| apply topForm_eq_zero_of_basis | |
| rw [collarVolumeForm_exterior_basis hθ hρ] | |
| exact mul_eq_zero.mpr hz | |
| variable {M I : Type*} [TopologicalSpace M] {a : SignedSmoothAtlas M I (m+1)} | |
| (f : AtlasSmoothMap a (CoordinateSpace (m+1))) | |
| {θ : ℝ → ℝ} {ρ : CoordinateSpace m → ℝ} | |
| (hθ : ContDiff ℝ ∞ θ) (hρ : ContDiff ℝ ∞ ρ) | |
| lemma collar_pullback_density (i : I) {q : CoordinateSpace (m+1)} (hq : q∈(a.chart i).target) : | |
| (f.pullback (collarVolumeForm θ ρ) (collarVolumeForm_smooth hθ hρ)).exterior.form i q coordinateVector= | |
| (fderiv ℝ (f.map ∘ (a.chart i).symm) q).det * | |
| (deriv θ (f.map ((a.chart i).symm q) 0)*ρ (Fin.tail (f.map ((a.chart i).symm q)))) := by | |
| rw [f.pullback_exterior _ _ i hq] | |
| change (extDeriv (collarVolumeForm θ ρ) (f.map ((a.chart i).symm q))) | |
| (fun j => fderiv ℝ (f.map ∘ (a.chart i).symm) q (coordinateVector j))=_ | |
| rw [topForm_evaluation,collarVolumeForm_exterior_basis hθ hρ] | |
| lemma collar_pullback_exterior_supported {K : Set M} | |
| (hK : ∀ x : M,x∉K →deriv θ (f.map x 0)=0 ∨ ρ (Fin.tail (f.map x))=0) : | |
| (f.pullback (collarVolumeForm θ ρ) (collarVolumeForm_smooth hθ hρ)).exterior.SupportedIn K := by | |
| intro i q hq hn | |
| rw [f.pullback_exterior _ _ i hq,collarVolumeForm_exterior_zero hθ hρ (hK _ hn)] | |
| ext v | |
| rfl | |
| lemma collar_pullback_identity_density (i : I) | |
| (he : EqOn (f.map ∘ (a.chart i).symm) id (a.chart i).target) | |
| {q : CoordinateSpace (m+1)} (hq : q∈(a.chart i).target) : | |
| (f.pullback (collarVolumeForm θ ρ) (collarVolumeForm_smooth hθ hρ)).exterior.form i q coordinateVector= | |
| deriv θ (q 0)*ρ (Fin.tail q) := by | |
| have heg : (f.map ∘ (a.chart i).symm)=ᶠ[𝓝 q] id := | |
| Filter.eventually_of_mem ((a.chart i).open_target.mem_nhds hq) he | |
| rw [collar_pullback_density f hθ hρ i hq,heg.fderiv_eq] | |
| have hp : f.map ((a.chart i).symm q)=q := he hq | |
| rw [hp,fderiv_id] | |
| simp [ContinuousLinearMap.det,LinearMap.det_id] | |
| end | |
| section | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter MeasureTheory Manifold | |
| variable {M I : Type*} [TopologicalSpace M] [T2Space M] [Fintype I] {d : ℕ} | |
| (a : SignedSmoothAtlas M I d) | |
| @[instance_reducible] def SignedSmoothAtlas.chartedSpace : ChartedSpace (CoordinateSpace d) M where | |
| atlas := range a.chart | |
| chartAt x := a.chart (a.cover x).choose | |
| mem_chart_source x := (a.cover x).choose_spec | |
| chart_mem_atlas _ := mem_range_self _ | |
| omit [T2Space M] [Fintype I] in | |
| lemma SignedSmoothAtlas.isManifold [T2Space M] [Fintype I] : | |
| @IsManifold ℝ _ (CoordinateSpace d) _ _ (CoordinateSpace d) _ | |
| (𝓘(ℝ,CoordinateSpace d)) ∞ M _ a.chartedSpace := by | |
| let := a.chartedSpace | |
| apply isManifold_of_contDiffOn | |
| rintro e e' ⟨i,rfl⟩ ⟨j,rfl⟩ | |
| simpa only [modelWithCornersSelf_coe,modelWithCornersSelf_coe_symm,Function.id_comp, | |
| Function.comp_id,Set.preimage_id,Set.range_id,Set.inter_univ,OpenPartialHomeomorph.coe_trans] using a.transition_smooth i j | |
| include a in | |
| omit [T2Space M] in | |
| lemma SignedSmoothAtlas.secondCountable [T2Space M] : SecondCountableTopology M := by | |
| let (i : I) : SecondCountableTopology (a.chart i).source := (a.chart i).secondCountableTopology_source | |
| apply TopologicalSpace.secondCountableTopology_of_countable_cover (fun i => (a.chart i).open_source) | |
| exact eq_univ_iff_forall.mpr (fun x => mem_iUnion.mpr (a.cover x)) | |
| theorem SignedSmoothAtlas.partition_exists {K : Set M} (hK : IsCompact K) : | |
| Nonempty (AtlasPartition a K) := by | |
| let := a.chartedSpace | |
| let := a.isManifold | |
| let := a.secondCountable | |
| let : LocallyCompactSpace M := ChartedSpace.locallyCompactSpace (CoordinateSpace d) M | |
| obtain ⟨p,hp⟩ := SmoothPartitionOfUnity.exists_isSubordinate (𝓘(ℝ,CoordinateSpace d)) hK.isClosed | |
| (fun i => (a.chart i).source) (fun i => (a.chart i).open_source) | |
| (fun x hx => mem_iUnion.mpr (a.cover x)) | |
| refine ⟨{weight := fun i => p i,smooth := ?_,sum_one := ?_,subordinate := hp}⟩ | |
| · intro i j | |
| have hj : a.chart j∈IsManifold.maximalAtlas (𝓘(ℝ,CoordinateSpace d)) ∞ M := | |
| IsManifold.subset_maximalAtlas (mem_range_self j) | |
| exact ((p i).contMDiff.comp_contMDiffOn (contMDiffOn_symm_of_mem_maximalAtlas hj)).contDiffOn | |
| · intro x hx | |
| simpa only [finsum_eq_sum_of_fintype] using p.sum_eq_one hx | |
| end | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter | |
| variable {M I : Type*} [TopologicalSpace M] {d : ℕ} | |
| def SignedSmoothAtlas.restrict (a : SignedSmoothAtlas M I d) | |
| (J : Set I) (W : TopologicalSpace.Opens M) (hW : Nonempty W) | |
| (hcover : ∀ x : W,∃ i∈J,x.val∈(a.chart i).source) : SignedSmoothAtlas W J d where | |
| chart i := (a.chart i.val).subtypeRestr hW | |
| cover x := by | |
| obtain ⟨i,hi,hx⟩ := hcover x | |
| refine ⟨⟨i,hi⟩,?_⟩ | |
| simpa only [OpenPartialHomeomorph.subtypeRestr_source,Set.mem_preimage] using hx | |
| sign i := a.sign i.val | |
| sign_sq i := a.sign_sq i.val | |
| transition_smooth i j := by | |
| let c := (a.chart i.val).subtypeRestr hW | |
| let b := (a.chart j.val).subtypeRestr hW | |
| have hsub : (c.symm ≫ₕ b).source ⊆ ((a.chart i.val).symm ≫ₕ a.chart j.val).source := by | |
| intro q hq | |
| refine ⟨(a.chart i.val).subtypeRestr_target_subset hW hq.1,?_⟩ | |
| have he := (a.chart i.val).subtypeRestr_symm_apply hW hq.1 | |
| change ((c.symm q).val)=(a.chart i.val).symm q at he | |
| change (a.chart i.val).symm q∈(a.chart j.val).source | |
| rw [←he] | |
| simpa only [OpenPartialHomeomorph.symm_symm,OpenPartialHomeomorph.subtypeRestr_source,Set.mem_preimage,c,b] using hq.2 | |
| apply ((a.transition_smooth i.val j.val).mono hsub).congr | |
| intro q hq | |
| change a.chart j.val (((a.chart i.val).subtypeRestr hW).symm q).val=_ | |
| exact congrArg (a.chart j.val) ((a.chart i.val).subtypeRestr_symm_apply hW hq.1) | |
| orientation i j q hq := by | |
| let c := (a.chart i.val).subtypeRestr hW | |
| let b := (a.chart j.val).subtypeRestr hW | |
| have he : (b ∘ c.symm) =ᶠ[𝓝 q] (a.chart j.val ∘ (a.chart i.val).symm) := by | |
| filter_upwards [(c.symm ≫ₕ b).open_source.mem_nhds hq] with r hr | |
| change a.chart j.val (((a.chart i.val).subtypeRestr hW).symm r).val=_ | |
| exact congrArg (a.chart j.val) ((a.chart i.val).subtypeRestr_symm_apply hW hr.1) | |
| change a.sign i.val*(fderiv ℝ (b ∘ c.symm) q).det = | |
| a.sign j.val*|(fderiv ℝ (b ∘ c.symm) q).det| | |
| rw [he.fderiv_eq] | |
| apply a.orientation i.val j.val q | |
| refine ⟨(a.chart i.val).subtypeRestr_target_subset hW hq.1,?_⟩ | |
| have he := (a.chart i.val).subtypeRestr_symm_apply hW hq.1 | |
| change ((c.symm q).val)=(a.chart i.val).symm q at he | |
| change (a.chart i.val).symm q∈(a.chart j.val).source | |
| rw [←he] | |
| simpa only [OpenPartialHomeomorph.symm_symm,OpenPartialHomeomorph.subtypeRestr_source,Set.mem_preimage,c,b] using hq.2 | |
| theorem SignedSmoothAtlas.finite_neighborhood (a : SignedSmoothAtlas M I d) | |
| {K : Set M} (hK : IsCompact K) (hne : K.Nonempty) : | |
| ∃ W : TopologicalSpace.Opens M,K⊆W ∧ | |
| ∃ J : Finset I,Nonempty (SignedSmoothAtlas W J d) := by | |
| classical | |
| obtain ⟨J,hJ⟩ := hK.elim_finite_subcover (fun i => (a.chart i).source) | |
| (fun i => (a.chart i).open_source) (fun x hx => mem_iUnion.mpr (a.cover x)) | |
| let W : TopologicalSpace.Opens M := | |
| ⟨⋃ i∈J,(a.chart i).source,isOpen_biUnion (fun i hi => (a.chart i).open_source)⟩ | |
| have hW : Nonempty W := by | |
| obtain ⟨x,hx⟩ := hne | |
| exact ⟨⟨x,hJ hx⟩⟩ | |
| refine ⟨W,hJ,J,⟨a.restrict (J : Set I) W hW ?_⟩⟩ | |
| intro x | |
| obtain ⟨i,hi,hx⟩ := mem_iUnion₂.mp x.property | |
| exact ⟨i,hi,hx⟩ | |
| end HigherDimensionalBallPacking.Rigidity.Degree | |
| end | |
| end OAI | |