Download data/lean/OAI/Geometry/BallPacking/Degree/ChartFormZeroExtension.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Degree/ChartFormZeroExtension.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Degree/ChartFormZeroExtension.lean
-
curl -L -o ChartFormZeroExtension.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Degree/ChartFormZeroExtension.lean
25 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Degree.HomotopyFlux | |
| namespace OAI | |
| noncomputable section | |
| namespace HigherDimensionalBallPacking.Rigidity.Degree | |
| section | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter MeasureTheory | |
| variable {d k : β} | |
| lemma supported_indicator_smooth {Z : Type*} [NormedAddCommGroup Z] [NormedSpace β Z] | |
| {S K : Set (CoordinateSpace d)} (hS : IsOpen S) (hK : IsClosed K) (hKS : KβS) | |
| {f : CoordinateSpace d β Z} (hf : ContDiffOn β β f S) | |
| (hz : β xβS,xβK βf x=0) : ContDiff β β (S.indicator f) := by | |
| classical | |
| apply contDiff_iff_contDiffAt.mpr | |
| intro x | |
| by_cases hx : xβS | |
| Β· apply (hf.contDiffAt (hS.mem_nhds hx)).congr_of_eventuallyEq | |
| filter_upwards [hS.mem_nhds hx] with y hy | |
| exact indicator_of_mem hy _ | |
| Β· apply (contDiffAt_const (c := (0:Z))).congr_of_eventuallyEq | |
| filter_upwards [hK.isOpen_compl.mem_nhds (fun h => hx (hKS h))] with y hy | |
| by_cases hys : yβS | |
| Β· rw [indicator_of_mem hys,hz y hys hy] | |
| Β· exact indicator_of_notMem hys _ | |
| lemma extDeriv_supported_indicator | |
| {S K : Set (CoordinateSpace d)} (hS : IsOpen S) (hK : IsClosed K) (hKS : KβS) | |
| {w : CoordinateSpace d β CoordinateSpace d [β^Fin k]βL[β] β} | |
| (hz : β xβS,xβK βw x=0) : extDeriv (S.indicator w)=S.indicator (extDeriv w) := by | |
| classical | |
| funext x | |
| by_cases hx : xβS | |
| Β· have he : S.indicator w =αΆ [π x] w := by | |
| filter_upwards [hS.mem_nhds hx] with y hy | |
| exact indicator_of_mem hy _ | |
| rw [he.extDeriv_eq,indicator_of_mem hx] | |
| Β· have he : S.indicator w =αΆ [π x] fun _ => 0 := by | |
| filter_upwards [hK.isOpen_compl.mem_nhds (fun h => hx (hKS h))] with y hy | |
| by_cases hys : yβS | |
| Β· rw [indicator_of_mem hys,hz y hys hy] | |
| Β· exact indicator_of_notMem hys _ | |
| rw [he.extDeriv_eq,indicator_of_notMem hx] | |
| ext v | |
| rw [extDeriv_apply (differentiableAt_const _)] | |
| simp | |
| variable {M I : Type*} [TopologicalSpace M] [T2Space M] | |
| {a : SignedSmoothAtlas M I d} (Ξ± : AtlasForm a k) | |
| omit [T2Space M] in | |
| lemma AtlasForm.supporting_chart_compact [T2Space M] {K : Set M} (hK : IsCompact K) | |
| (i : I) (hi : Kβ(a.chart i).source) : IsCompact (a.chart i '' K) := | |
| hK.image_of_continuousOn ((a.chart i).continuousOn.mono hi) | |
| omit [T2Space M] in | |
| lemma AtlasForm.supporting_chart_zero [T2Space M] {K : Set M} (hΞ± : Ξ±.SupportedIn K) | |
| (i : I) {q : CoordinateSpace d} (hq : qβ(a.chart i).target) (hqn : qβa.chart i '' K) : | |
| Ξ±.form i q=0 := | |
| hΞ± i q hq (fun hk => hqn β¨_,hk,(a.chart i).right_inv hqβ©) | |
| def AtlasForm.chartExtension (i : I) : | |
| CoordinateSpace d β CoordinateSpace d [β^Fin k]βL[β] β := | |
| (a.chart i).target.indicator (Ξ±.form i) | |
| lemma AtlasForm.chartExtension_zero {K : Set M} (hΞ± : Ξ±.SupportedIn K) | |
| (i : I) {q : CoordinateSpace d} (hqn : qβa.chart i '' K) : Ξ±.chartExtension i q=0 := by | |
| classical | |
| by_cases hq : qβ(a.chart i).target | |
| Β· rw [chartExtension,indicator_of_mem hq] | |
| exact Ξ±.supporting_chart_zero hΞ± i hq hqn | |
| Β· exact indicator_of_notMem hq _ | |
| lemma AtlasForm.chartExtension_smooth {K : Set M} (hK : IsCompact K) | |
| (hΞ± : Ξ±.SupportedIn K) (i : I) (hi : Kβ(a.chart i).source) : | |
| ContDiff β β (Ξ±.chartExtension i) := by | |
| apply supported_indicator_smooth (a.chart i).open_target (AtlasForm.supporting_chart_compact (a := a) hK i hi).isClosed | |
| Β· rintro _ β¨x,hx,rflβ© | |
| exact (a.chart i).map_source (hi hx) | |
| Β· exact Ξ±.smooth i | |
| Β· exact fun q hq hn => Ξ±.supporting_chart_zero hΞ± i hq hn | |
| lemma AtlasForm.chartExtension_support {K : Set M} (hK : IsCompact K) | |
| (hΞ± : Ξ±.SupportedIn K) (i : I) (hi : Kβ(a.chart i).source) : | |
| HasCompactSupport (Ξ±.chartExtension i) := | |
| HasCompactSupport.intro (AtlasForm.supporting_chart_compact (a := a) hK i hi) (fun _ h => Ξ±.chartExtension_zero hΞ± i h) | |
| lemma AtlasForm.exterior_chartExtension {K : Set M} (hK : IsCompact K) | |
| (hΞ± : Ξ±.SupportedIn K) (i : I) (hi : Kβ(a.chart i).source) : | |
| Ξ±.exterior.chartExtension i=extDeriv (Ξ±.chartExtension i) := by | |
| symm | |
| apply extDeriv_supported_indicator (a.chart i).open_target (AtlasForm.supporting_chart_compact (a := a) hK i hi).isClosed | |
| Β· rintro _ β¨x,hx,rflβ© | |
| exact (a.chart i).map_source (hi hx) | |
| Β· exact fun q hq hn => Ξ±.supporting_chart_zero hΞ± i hq hn | |
| def AtlasForm.chartMass {a : SignedSmoothAtlas M I d} (Ξ± : AtlasForm a d) (i : I) : β := | |
| β« q,a.sign i*Ξ±.chartExtension i q coordinateVector | |
| lemma AtlasForm.chart_coefficient_integrable {a : SignedSmoothAtlas M I d} | |
| (Ξ± : AtlasForm a d) {K : Set M} (hK : IsCompact K) | |
| (hΞ± : Ξ±.SupportedIn K) (i : I) (hi : Kβ(a.chart i).source) : | |
| Integrable (fun q => a.sign i*Ξ±.chartExtension i q coordinateVector) := by | |
| have hc : Continuous (fun q => a.sign i*Ξ±.chartExtension i q coordinateVector) := | |
| continuous_const.mul ((ContinuousAlternatingMap.apply β _ β coordinateVector).continuous.comp | |
| (Ξ±.chartExtension_smooth hK hΞ± i hi).continuous) | |
| apply hc.integrable_of_hasCompactSupport | |
| apply HasCompactSupport.intro (AtlasForm.supporting_chart_compact (a := a) hK i hi) | |
| intro q hq | |
| rw [Ξ±.chartExtension_zero hΞ± i hq] | |
| exact mul_zero _ | |
| lemma AtlasForm.chartMass_exterior_zero {a : SignedSmoothAtlas M I (k+1)} | |
| (Ξ± : AtlasForm a k) {K : Set M} (hK : IsCompact K) | |
| (hΞ± : Ξ±.SupportedIn K) (i : I) (hi : Kβ(a.chart i).source) : | |
| Ξ±.exterior.chartMass i=0 := by | |
| unfold chartMass | |
| rw [Ξ±.exterior_chartExtension hK hΞ± i hi,integral_const_mul, | |
| compact_euclidean_stokes ((Ξ±.chartExtension_smooth hK hΞ± i hi).of_le (by | |
| exact WithTop.coe_le_coe.mpr le_top)) (Ξ±.chartExtension_support hK hΞ± i hi),mul_zero] | |
| end | |
| section | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter MeasureTheory | |
| variable {M I : Type*} [TopologicalSpace M] [T2Space M] {d k : β} | |
| {a : SignedSmoothAtlas M I d} | |
| lemma AtlasForm.chartMass_eq_compact_integral (Ξ± : AtlasForm a d) | |
| {K : Set M} (hK : IsCompact K) (hΞ± : Ξ±.SupportedIn K) (i : I) (hi : Kβ(a.chart i).source) : | |
| Ξ±.chartMass i=β«q in a.chart i '' K,a.sign i*Ξ±.form i q coordinateVector := by | |
| unfold chartMass | |
| rw [βsetIntegral_eq_integral_of_forall_compl_eq_zero (s := a.chart i '' K)] | |
| Β· apply setIntegral_congr_fun | |
| Β· exact (hK.image_of_continuousOn ((a.chart i).continuousOn.mono hi)).measurableSet | |
| Β· intro q hq | |
| obtain β¨x,hx,rflβ© := hq | |
| dsimp only | |
| rw [chartExtension,indicator_of_mem ((a.chart i).map_source (hi hx))] | |
| Β· intro q hq | |
| rw [Ξ±.chartExtension_zero hΞ± i hq] | |
| exact mul_zero _ | |
| lemma AtlasForm.chartMass_change (Ξ± : AtlasForm a d) | |
| {K : Set M} (hK : IsCompact K) (hΞ± : Ξ±.SupportedIn K) | |
| (i j : I) (hi : Kβ(a.chart i).source) (hj : Kβ(a.chart j).source) : | |
| Ξ±.chartMass i=Ξ±.chartMass j := by | |
| rw [Ξ±.chartMass_eq_compact_integral hK hΞ± i hi,Ξ±.chartMass_eq_compact_integral hK hΞ± j hj] | |
| apply topForm_chartMass_change (a.chart j) (a.chart i) hK hi hj (a.transition_smooth i j) | |
| Β· rintro q β¨x,hx,rflβ© | |
| apply Ξ±.compatible i j | |
| exact β¨(a.chart i).map_source (hi hx),by | |
| change (a.chart i).symm ((a.chart i) x)β(a.chart j).source | |
| rw [(a.chart i).left_inv (hi hx)]; exact hj hxβ© | |
| Β· rintro q β¨x,hx,rflβ© | |
| apply a.orientation i j | |
| exact β¨(a.chart i).map_source (hi hx),by | |
| change (a.chart i).symm ((a.chart i) x)β(a.chart j).source | |
| rw [(a.chart i).left_inv (hi hx)]; exact hj hxβ© | |
| omit [T2Space M] in | |
| lemma AtlasForm.chartMass_sum [T2Space M] {J : Type*} [Fintype J] | |
| (Ξ© : AtlasForm a d) (Ξ² : J β AtlasForm a d) (i : I) | |
| (he : β qβ(a.chart i).target,Ξ©.form i q=βj,(Ξ² j).form i q) | |
| (hi : β j,Integrable (fun q => a.sign i*(Ξ² j).chartExtension i q coordinateVector)) : | |
| Ξ©.chartMass i=βj,(Ξ² j).chartMass i := by | |
| classical | |
| change (β«q,a.sign i*Ξ©.chartExtension i q coordinateVector)=βj,β«q,a.sign i*(Ξ² j).chartExtension i q coordinateVector | |
| rw [βintegral_finsetSum _ (fun j _ => hi j)] | |
| apply integral_congr_ae | |
| apply Filter.Eventually.of_forall | |
| intro q | |
| by_cases hq : qβ(a.chart i).target | |
| Β· simp only [AtlasForm.chartExtension,indicator_of_mem hq,he q hq] | |
| rw [ContinuousAlternatingMap.sum_apply,Finset.mul_sum] | |
| Β· simp only [AtlasForm.chartExtension,indicator_of_notMem hq] | |
| change a.sign i*0=βj,a.sign i*0 | |
| simp | |
| variable [Fintype I] | |
| structure AtlasPartition (a : SignedSmoothAtlas M I d) (K : Set M) where | |
| weight : I β M β β | |
| smooth : β i j,ContDiffOn β β (weight i β (a.chart j).symm) (a.chart j).target | |
| sum_one : β xβK,βi,weight i x=1 | |
| subordinate : β i,tsupport (weight i)β(a.chart i).source | |
| namespace AtlasPartition | |
| variable {K : Set M} (p : AtlasPartition a K) | |
| def mass (Ξ© : AtlasForm a d) : β := | |
| βi,(Ξ©.smul (p.weight i) (p.smooth i)).chartMass i | |
| omit [T2Space M] in | |
| lemma smul_sum [T2Space M] (Ξ© : AtlasForm a k) (hΞ© : Ξ©.SupportedIn K) (i : I) {q : CoordinateSpace d} | |
| (hq : qβ(a.chart i).target) : | |
| βj,(Ξ©.smul (p.weight j) (p.smooth j)).form i q=Ξ©.form i q := by | |
| change (βj,p.weight j ((a.chart i).symm q) β’ Ξ©.form i q)=Ξ©.form i q | |
| rw [βFinset.sum_smul] | |
| by_cases hx : (a.chart i).symm qβK | |
| Β· rw [p.sum_one _ hx,one_smul] | |
| Β· rw [hΞ© i q hq hx,smul_zero] | |
| lemma mass_eq_chartMass {L : Set M} (hL : IsCompact L) (hLK : LβK) | |
| (Ξ© : AtlasForm a d) (hΞ© : Ξ©.SupportedIn L) | |
| (j : I) (hj : Lβ(a.chart j).source) : p.mass Ξ©=Ξ©.chartMass j := by | |
| classical | |
| let D : I β AtlasForm a d := fun i => Ξ©.smul (p.weight i) (p.smooth i) | |
| let C : I β Set M := fun i => Lβ©tsupport (p.weight i) | |
| have hC (i : I) : IsCompact (C i) := hL.inter_right (isClosed_tsupport _) | |
| have hD (i : I) : (D i).SupportedIn (C i) := Ξ©.smul_supported _ _ hΞ© | |
| have hci (i : I) : C iβ(a.chart i).source := fun _ h => p.subordinate i h.2 | |
| have hcj (i : I) : C iβ(a.chart j).source := fun _ h => hj h.1 | |
| have hm (i : I) : (D i).chartMass i=(D i).chartMass j := | |
| (D i).chartMass_change (hC i) (hD i) i j (hci i) (hcj i) | |
| change (βi,(D i).chartMass i)=_ | |
| simp_rw [hm] | |
| symm | |
| apply Ξ©.chartMass_sum D j | |
| Β· intro q hq | |
| have hΞ©K : Ξ©.SupportedIn K := fun i q hq hn => hΞ© i q hq (fun hx => hn (hLK hx)) | |
| exact (p.smul_sum Ξ© hΞ©K j hq).symm | |
| Β· exact fun i => (D i).chart_coefficient_integrable (hC i) (hD i) j (hcj i) | |
| end AtlasPartition | |
| end | |
| section | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter MeasureTheory | |
| variable {M I : Type*} [TopologicalSpace M] [T2Space M] [Fintype I] {d k : β} | |
| {a : SignedSmoothAtlas M I d} {K : Set M} | |
| lemma AtlasPartition.mass_sum (p : AtlasPartition a K) (hK : IsCompact K) | |
| {J : Type*} [Fintype J] (Ξ© : AtlasForm a d) (Ξ² : J β AtlasForm a d) | |
| (hΞ² : β j,(Ξ² j).SupportedIn K) | |
| (he : β i q,qβ(a.chart i).target β Ξ©.form i q=βj,(Ξ² j).form i q) : | |
| p.mass Ξ©=βj,p.mass (Ξ² j) := by | |
| classical | |
| unfold mass | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| apply AtlasForm.chartMass_sum _ (fun j => (Ξ² j).smul (p.weight i) (p.smooth i)) i | |
| Β· intro q hq | |
| change p.weight i ((a.chart i).symm q) β’ Ξ©.form i q= | |
| βj,p.weight i ((a.chart i).symm q) β’ (Ξ² j).form i q | |
| rw [he i q hq,Finset.smul_sum] | |
| Β· intro j | |
| exact ((Ξ² j).smul (p.weight i) (p.smooth i)).chart_coefficient_integrable | |
| (hK.inter_right (isClosed_tsupport _)) ((Ξ² j).smul_supported _ _ (hΞ² j)) i | |
| (fun _ h => p.subordinate i h.2) | |
| lemma extDeriv_fintype_sum {J : Type*} [Fintype J] | |
| (Ξ² : J β CoordinateSpace d β CoordinateSpace d [β^Fin k]βL[β] β) | |
| (q : CoordinateSpace d) (hΞ² : β j,DifferentiableAt β (Ξ² j) q) : | |
| extDeriv (fun y => βj,Ξ² j y) q=βj,extDeriv (Ξ² j) q := by | |
| classical | |
| simp only [extDeriv,fderiv_fun_sum (fun j _ => hΞ² j)] | |
| exact map_sum (ContinuousAlternatingMap.alternatizeUncurryFinCLM β _ β) _ _ | |
| theorem AtlasPartition.compact_stokes {a : SignedSmoothAtlas M I (k+1)} | |
| (p : AtlasPartition a K) (hK : IsCompact K) | |
| (Ξ± : AtlasForm a k) (hΞ± : Ξ±.SupportedIn K) : p.mass Ξ±.exterior=0 := by | |
| classical | |
| let Ξ² : I β AtlasForm a k := fun i => Ξ±.smul (p.weight i) (p.smooth i) | |
| let L : I β Set M := fun i => Kβ©tsupport (p.weight i) | |
| have hL (i : I) : IsCompact (L i) := hK.inter_right (isClosed_tsupport _) | |
| have hΞ² (i : I) : (Ξ² i).SupportedIn (L i) := Ξ±.smul_supported _ _ hΞ± | |
| have hLi (i : I) : L iβ(a.chart i).source := fun _ h => p.subordinate i h.2 | |
| have hdΞ² (i : I) : (Ξ² i).exterior.SupportedIn K := by | |
| have hs := (Ξ² i).exterior_supported (hL i).isClosed (hΞ² i) | |
| exact fun j q hq hn => hs j q hq (fun h => hn h.1) | |
| have hsum (i : I) (q : CoordinateSpace (k+1)) (hq : qβ(a.chart i).target) : | |
| Ξ±.exterior.form i q=βj,(Ξ² j).exterior.form i q := by | |
| have he : Ξ±.form i =αΆ [π q] fun y => βj,(Ξ² j).form i y := by | |
| filter_upwards [(a.chart i).open_target.mem_nhds hq] with y hy | |
| exact (p.smul_sum Ξ± hΞ± i hy).symm | |
| change extDeriv (Ξ±.form i) q=βj,extDeriv ((Ξ² j).form i) q | |
| rw [he.extDeriv_eq] | |
| apply extDeriv_fintype_sum | |
| intro j | |
| exact (((Ξ² j).smooth i).contDiffAt ((a.chart i).open_target.mem_nhds hq)).differentiableAt (by simp) | |
| rw [p.mass_sum hK Ξ±.exterior (fun j => (Ξ² j).exterior) hdΞ² hsum] | |
| apply Finset.sum_eq_zero | |
| intro i hi | |
| rw [p.mass_eq_chartMass (hL i) inter_subset_left (Ξ² i).exterior | |
| ((Ξ² i).exterior_supported (hL i).isClosed (hΞ² i)) i (hLi i)] | |
| exact (Ξ² i).chartMass_exterior_zero (hL i) (hΞ² i) i (hLi i) | |
| end | |
| section | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| variable {A B Z : Type*} [NormedAddCommGroup A] [NormedSpace β A] | |
| [NormedAddCommGroup B] [NormedSpace β B] | |
| [NormedAddCommGroup Z] [NormedSpace β Z] {k : β} | |
| def alternationCLM : (ContinuousMultilinearMap β (fun _ : Fin k => A) β) βL[β] | |
| (A [β^Fin k]βL[β] β) where | |
| toFun := ContinuousMultilinearMap.alternatization | |
| map_add' := map_add _ | |
| map_smul' r f := by | |
| ext v | |
| simp only [RingHom.id_apply,ContinuousMultilinearMap.alternatization_apply_apply, | |
| smul_apply,ContinuousAlternatingMap.smul_apply] | |
| rw [Finset.smul_sum] | |
| apply Finset.sum_congr rfl | |
| intro Ο hΟ | |
| exact smul_comm _ _ _ | |
| cont := by | |
| rw [ContinuousAlternatingMap.isEmbedding_toContinuousMultilinearMap.continuous_iff] | |
| change Continuous (fun f : ContinuousMultilinearMap β (fun _ : Fin k => A) β => | |
| βΟ : Equiv.Perm (Fin k),Equiv.Perm.sign Ο β’ f.domDomCongr Ο) | |
| apply continuous_finsetSum | |
| intro Ο hΟ | |
| exact (ContinuousMultilinearMap.domDomCongrβα΅’ β A β Ο).continuous.const_smul _ | |
| lemma alternationCLM_alternating (w : A [β^Fin k]βL[β] β) : | |
| alternationCLM w.toContinuousMultilinearMap=(k.factorial:β) β’ w := by | |
| apply ContinuousAlternatingMap.toAlternatingMap_injective | |
| change (ContinuousMultilinearMap.alternatization w.toContinuousMultilinearMap).toAlternatingMap=_ | |
| rw [ContinuousMultilinearMap.alternatization_apply_toAlternatingMap] | |
| change MultilinearMap.alternatization w.toAlternatingMap.toMultilinearMap= | |
| (k.factorial:β) β’ w.toAlternatingMap | |
| simpa only [Fintype.card_fin,Nat.cast_smul_eq_nsmul] using w.toAlternatingMap.coe_alternatization | |
| lemma contDiffOn_alternating_of_multilinear {f : Z β A [β^Fin k]βL[β] β} {S : Set Z} | |
| (hf : ContDiffOn β β (fun z => (f z).toContinuousMultilinearMap) S) : ContDiffOn β β f S := by | |
| have h := (alternationCLM (A := A) (k := k)).contDiff.comp_contDiffOn hf | |
| have hn : (k.factorial:β)β 0 := Nat.cast_ne_zero.mpr (Nat.factorial_ne_zero _) | |
| convert h.const_smul (k.factorial:β)β»ΒΉ using 1 | |
| funext z | |
| simp only [Function.comp_apply] | |
| rw [alternationCLM_alternating,smul_smul,inv_mul_cancelβ hn,one_smul] | |
| lemma contDiffOn_alternating_comp {f : Z β B [β^Fin k]βL[β] β} | |
| {g : Z β A βL[β] B} {S : Set Z} | |
| (hf : ContDiffOn β β f S) (hg : ContDiffOn β β g S) : | |
| ContDiffOn β β (fun z => (f z).compContinuousLinearMap (g z)) S := by | |
| apply contDiffOn_alternating_of_multilinear | |
| have hp : ContDiffOn β β (fun z => ((fun _ : Fin k => g z),(f z).toContinuousMultilinearMap)) S := | |
| (contDiffOn_pi.mpr (fun _ => hg)).prodMk | |
| ((ContinuousAlternatingMap.toContinuousMultilinearMapCLM β : (B [β^Fin k]βL[β] β) βL[β] ContinuousMultilinearMap β (fun _ : Fin k => B) β).contDiff.comp_contDiffOn hf) | |
| have ha : ContDiff β β (fun p : (Fin k β A βL[β] B) Γ | |
| ContinuousMultilinearMap β (fun _ : Fin k => B) β => p.2.compContinuousLinearMap p.1) := | |
| (show AnalyticOnNhd β _ univ from ContinuousMultilinearMap.analyticOnNhd_uncurry_compContinuousLinearMap).contDiff | |
| exact ha.comp_contDiffOn hp | |
| end | |
| section | |
| open scoped ContDiff Topology Manifold | |
| open Set Function Filter | |
| variable {M I P : Type*} [TopologicalSpace M] | |
| [NormedAddCommGroup P] [NormedSpace β P] | |
| {d k : β} {a : SignedSmoothAtlas M I d} | |
| structure AtlasSmoothMap (a : SignedSmoothAtlas M I d) (P : Type*) | |
| [NormedAddCommGroup P] [NormedSpace β P] where | |
| map : M β P | |
| smooth : β i,ContDiffOn β β (map β (a.chart i).symm) (a.chart i).target | |
| namespace AtlasSmoothMap | |
| variable (f : AtlasSmoothMap a P) | |
| lemma derivative_transition (i j : I) {q : CoordinateSpace d} | |
| (hq : qβ((a.chart i).symm β«β a.chart j).source) : | |
| fderiv β (f.map β (a.chart i).symm) q= | |
| (fderiv β (f.map β (a.chart j).symm) (a.chart j ((a.chart i).symm q))).comp | |
| (fderiv β (a.chart j β (a.chart i).symm) q) := by | |
| let g := a.chart j β (a.chart i).symm | |
| have he : (f.map β (a.chart i).symm) =αΆ [π q] ((f.map β (a.chart j).symm) β g) := by | |
| filter_upwards [((a.chart i).symm β«β a.chart j).open_source.mem_nhds hq] with r hr | |
| simp only [Function.comp_apply,g] | |
| exact congrArg f.map ((a.chart j).left_inv hr.2).symm | |
| rw [he.fderiv_eq] | |
| apply fderiv_comp | |
| Β· exact ((f.smooth j).contDiffAt ((a.chart j).open_target.mem_nhds ((a.chart j).map_source hq.2))).differentiableAt (by simp) | |
| Β· exact ((a.transition_smooth i j).contDiffAt (((a.chart i).symm β«β a.chart j).open_source.mem_nhds hq)).differentiableAt (by simp) | |
| def pullback (w : P β P [β^Fin k]βL[β] β) (hw : ContDiff β β w) : AtlasForm a k where | |
| form i q := (w (f.map ((a.chart i).symm q))).compContinuousLinearMap | |
| (fderiv β (f.map β (a.chart i).symm) q) | |
| smooth i := contDiffOn_alternating_comp (hw.comp_contDiffOn (f.smooth i)) | |
| ((contDiffOn_infty_iff_fderiv_of_isOpen (a.chart i).open_target).mp (f.smooth i)).2 | |
| compatible i j q hq := by | |
| change (w (f.map ((a.chart i).symm q))).compContinuousLinearMap _= | |
| ((w (f.map ((a.chart j).symm (a.chart j ((a.chart i).symm q))))).compContinuousLinearMap _).compContinuousLinearMap _ | |
| have he := (a.chart j).left_inv hq.2 | |
| simp only [OpenPartialHomeomorph.symm_symm] at he | |
| rw [he,f.derivative_transition i j hq] | |
| rfl | |
| lemma pullback_exterior (w : P β P [β^Fin k]βL[β] β) (hw : ContDiff β β w) | |
| (i : I) {q : CoordinateSpace d} (hq : qβ(a.chart i).target) : | |
| (f.pullback w hw).exterior.form i q= | |
| (extDeriv w (f.map ((a.chart i).symm q))).compContinuousLinearMap | |
| (fderiv β (f.map β (a.chart i).symm) q) := by | |
| exact extDeriv_pullback (hw.differentiable (by simp) _) | |
| ((f.smooth i).contDiffAt ((a.chart i).open_target.mem_nhds hq)) (by | |
| rw [minSmoothness_of_isRCLikeNormedField] | |
| exact WithTop.coe_le_coe.mpr le_top) | |
| lemma pullback_supported (w : P β P [β^Fin k]βL[β] β) (hw : ContDiff β β w) | |
| {K : Set M} (hK : β x : M,xβK βw (f.map x)=0) : (f.pullback w hw).SupportedIn K := by | |
| intro i q hq hn | |
| change (w (f.map ((a.chart i).symm q))).compContinuousLinearMap _=0 | |
| rw [hK _ hn] | |
| ext v | |
| rfl | |
| end AtlasSmoothMap | |
| end | |
| open scoped ContDiff Topology | |
| open Set Filter MeasureTheory | |
| variable {m : β} | |
| def spatialBox (R : β) : Set (CoordinateSpace m) := Icc (fun _ => -R) (fun _ => R) | |
| def lowerCorner (R : β) : CoordinateSpace (m+1) := Fin.cons 0 (fun _ => -R) | |
| def upperCorner (R : β) : CoordinateSpace (m+1) := Fin.cons 1 (fun _ => R) | |
| def exitFaces (R : β) : Set (CoordinateSpace (m+1)) := | |
| Icc (lowerCorner R) (upperCorner R) β© | |
| ({v | v 0=1} βͺ β i : Fin m,{v | v i.succ = -R} βͺ {v | v i.succ=R}) | |
| lemma corners_le {R : β} (hR : 0β€R) : lowerCorner (m := m) Rβ€upperCorner R := by | |
| intro i | |
| refine Fin.cases ?_ (fun j => ?_) i | |
| Β· norm_num [lowerCorner,upperCorner] | |
| Β· simpa [lowerCorner,upperCorner] using neg_le_self hR | |
| lemma exitFaces_compact (R : β) : IsCompact (exitFaces (m := m) R) := by | |
| apply isCompact_Icc.inter_right | |
| apply IsClosed.union | |
| Β· exact isClosed_eq (continuous_apply _) continuous_const | |
| Β· exact isClosed_iUnion_of_finite (fun i : Fin m => (isClosed_eq (continuous_apply _) continuous_const).union | |
| (isClosed_eq (continuous_apply _) continuous_const)) | |
| lemma tail_mem_spatialBox {R : β} {v : CoordinateSpace (m+1)} | |
| (hv : vβIcc (lowerCorner R) (upperCorner R)) : Fin.tail vβspatialBox R := by | |
| exact β¨fun i => hv.1 i.succ,fun i => hv.2 i.succβ© | |
| lemma time_mem_interval {R : β} {v : CoordinateSpace (m+1)} | |
| (hv : vβIcc (lowerCorner R) (upperCorner R)) : v 0βIcc (0:β) 1 := | |
| β¨hv.1 0,hv.2 0β© | |
| lemma timeFace_mem_box {R : β} {t : β} {x : CoordinateSpace m} | |
| (ht : tβIcc (0:β) 1) (hx : xβspatialBox R) : | |
| timeFace t xβIcc (lowerCorner R) (upperCorner R) := by | |
| constructor | |
| Β· intro i | |
| exact Fin.cases ht.1 hx.1 i | |
| Β· intro i | |
| exact Fin.cases ht.2 hx.2 i | |
| lemma initialFace_box (R : β) : | |
| Icc (lowerCorner (m := m) R β (0:Fin (m+1)).succAbove) | |
| (upperCorner R β (0:Fin (m+1)).succAbove)=spatialBox R := by | |
| simp only [Fin.succAbove_zero,lowerCorner,upperCorner,Function.comp_def,Fin.cons_succ,spatialBox] | |
| lemma insertNth_mem_box {a b : CoordinateSpace (m+1)} (_hab : aβ€b) (i : Fin (m+1)) | |
| {c : β} (hc : cβIcc (a i) (b i)) {y : CoordinateSpace m} | |
| (hy : yβIcc (a β i.succAbove) (b β i.succAbove)) : i.insertNth c yβIcc a b := by | |
| constructor | |
| Β· change β j,a j β€ i.insertNth (Ξ± := fun _ => β) c y j | |
| rw [Fin.forall_iff_succAbove i] | |
| exact β¨by simpa using hc.1,fun j => by simpa using hy.1 jβ© | |
| Β· change β j,i.insertNth (Ξ± := fun _ => β) c y j β€ b j | |
| rw [Fin.forall_iff_succAbove i] | |
| exact β¨by simpa using hc.2,fun j => by simpa using hy.2 jβ© | |
| lemma sideFace_mem_exit (R : β) (hR : 0β€R) (i : Fin (m+1)) (hi : iβ 0) | |
| {y : CoordinateSpace m} | |
| (hy : yβIcc (lowerCorner R β i.succAbove) (upperCorner R β i.succAbove)) : | |
| i.insertNth (upperCorner R i) yβexitFaces R β§ | |
| i.insertNth (lowerCorner R i) yβexitFaces R := by | |
| have hab := corners_le (m := m) hR | |
| have hi' : β j : Fin m,i=j.succ := by | |
| rcases Fin.eq_zero_or_eq_succ i with h|β¨j,hβ© | |
| Β· exact (hi h).elim | |
| Β· exact β¨j,hβ© | |
| obtain β¨j,rflβ© := hi' | |
| constructor | |
| Β· refine β¨insertNth_mem_box hab j.succ β¨hab j.succ,le_rflβ© hy,Or.inr ?_β© | |
| exact mem_iUnion.mpr β¨j,Or.inr (by simp [upperCorner])β© | |
| Β· refine β¨insertNth_mem_box hab j.succ β¨le_rfl,hab j.succβ© hy,Or.inr ?_β© | |
| exact mem_iUnion.mpr β¨j,Or.inl (by simp [lowerCorner])β© | |
| lemma norm_ball_subset_spatialBox {R r : β} (hr : rβ€R) : | |
| Metric.ball (0:CoordinateSpace m) rβspatialBox R := by | |
| intro x hx | |
| have hnorm : βxβ<r := by simpa only [Metric.mem_ball,dist_zero_right] using hx | |
| have hb (i : Fin m) : |x i|β€R := by | |
| have hi : βx iββ€βxβ := norm_le_pi_norm x i | |
| exact (Real.norm_eq_abs (x i) βΈ hi).trans ((le_of_lt hnorm).trans hr) | |
| exact β¨fun i => (abs_le.mp (hb i)).1,fun i => (abs_le.mp (hb i)).2β© | |
| lemma separating_bump {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,b x=0 := 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 | |
| apply b.zero_of_le_dist | |
| by_contra hn | |
| have hxball : xβMetric.ball (0:CoordinateSpace m) Ξ΅ := | |
| (lt_of_not_ge hn).trans hrΞ΅ | |
| exact hball hxball hx | |
| lemma bump_initial_integral_pos (b : ContDiffBump (0:CoordinateSpace m)) {R : β} | |
| (hb : b.rOutβ€R) : 0<β« y in spatialBox R,b y := by | |
| rw [setIntegral_eq_integral_of_forall_compl_eq_zero] | |
| Β· exact b.integral_pos | |
| Β· intro x hx | |
| by_contra hbx | |
| have hxs : xβFunction.support b := hbx | |
| rw [b.support_eq] at hxs | |
| exact hx (norm_ball_subset_spatialBox hb hxs) | |
| end HigherDimensionalBallPacking.Rigidity.Degree | |
| end | |
| end OAI | |