Download data/lean/OAI/Geometry/BallPacking/Fredholm/ProjectionTimeGrid.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Fredholm/ProjectionTimeGrid.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/BallPacking/Fredholm/ProjectionTimeGrid.lean
-
curl -L -o ProjectionTimeGrid.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/BallPacking/Fredholm/ProjectionTimeGrid.lean
17.6 kB
| import Mathlib | |
| import OAI.Geometry.BallPacking.Fredholm.SurjectiveParametricReduction | |
| namespace OAI | |
| noncomputable section | |
| namespace HigherDimensionalBallPacking.Rigidity | |
| section | |
| open scoped Topology | |
| open Set Function Filter | |
| variable {X Z : Type*} [NormedAddCommGroup X] [NormedSpace β X] [CompleteSpace X] | |
| [MetricSpace Z] | |
| def cappedTime (N j : β) (t : β) : β := min t ((j:β)/N) | |
| lemma cappedTime_continuous (N j : β) : Continuous (cappedTime N j) := | |
| continuous_id.min continuous_const | |
| lemma cappedTime_mem (N j : β) {t : β} (ht : tβIcc (0:β) 1) : | |
| cappedTime N j tβIcc (0:β) 1 := | |
| β¨le_min ht.1 (div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _)),(min_le_left _ _).trans ht.2β© | |
| lemma cappedTime_zero (N : β) {t : β} (ht : 0β€t) : cappedTime N 0 t=0 := by | |
| simp only [cappedTime,Nat.cast_zero,zero_div,min_eq_right ht] | |
| lemma cappedTime_last {N : β} (hN : 0<N) {t : β} (ht : tβ€1) : cappedTime N N t=t := by | |
| have hNr : (N:β)β 0 := by exact_mod_cast hN.ne' | |
| simp only [cappedTime,div_self hNr,min_eq_left ht] | |
| lemma cappedTime_step (N j : β) (t : β) : | |
| dist (cappedTime N j t) (cappedTime N (j+1) t)β€1/(N:β) := by | |
| have hN : (0:β)β€N := Nat.cast_nonneg N | |
| have hi : (j:β)/(N:β)β€(j+1:β)/(N:β) := div_le_div_of_nonneg_right (by norm_num) hN | |
| have hmono : cappedTime N j tβ€cappedTime N (j+1) t := min_le_min_left t hi | |
| rw [Real.dist_eq,abs_of_nonpos (sub_nonpos.mpr hmono)] | |
| change -(min t ((j:β)/N)-min t ((j+1:β)/N))β€_ | |
| have hg : (j+1:β)/(N:β)=(j:β)/(N:β)+1/(N:β) := by rw [Nat.cast_add,Nat.cast_one,add_div] | |
| rw [hg] | |
| have hnon : 0β€1/(N:β) := div_nonneg zero_le_one hN | |
| by_cases hj : tβ€(j:β)/(N:β) | |
| Β· rw [min_eq_left hj,min_eq_left (hj.trans (le_add_of_nonneg_right hnon))] | |
| linarith | |
| Β· have hj' := le_of_not_ge hj | |
| rw [min_eq_right hj'] | |
| have hh := min_le_right t ((j:β)/N+1/(N:β)) | |
| linarith | |
| def projectionTimeChain (P : β Γ Z β X βL[β] X) (N : β) : β β (β Γ Z) β X βL[β] X | |
| | 0,_ => 1 | |
| | j+1,v => projectionTransport (P (cappedTime N j v.1,v.2)) | |
| (P (cappedTime N (j+1) v.1,v.2))*projectionTimeChain P N j v | |
| lemma projectionTimeChain_continuousOn {P : β Γ Z β X βL[β] X} {K : Set Z} | |
| (hP : ContinuousOn P (Icc (0:β) 1 ΓΛ’ K)) (N j : β) : | |
| ContinuousOn (projectionTimeChain P N j) (Icc (0:β) 1 ΓΛ’ K) := by | |
| induction j with | |
| | zero => exact continuousOn_const | |
| | succ j ih => | |
| apply ContinuousOn.mul _ ih | |
| apply projectionTransport_continuousOn | |
| Β· exact hP.comp (((cappedTime_continuous N j).comp continuous_fst).prodMk continuous_snd).continuousOn | |
| (fun v hv => β¨cappedTime_mem N j hv.1,hv.2β©) | |
| Β· exact hP.comp (((cappedTime_continuous N (j+1)).comp continuous_fst).prodMk continuous_snd).continuousOn | |
| (fun v hv => β¨cappedTime_mem N (j+1) hv.1,hv.2β©) | |
| omit [MetricSpace Z] in | |
| lemma projectionTimeChain_intertwines [MetricSpace Z] {P : β Γ Z β X βL[β] X} {K : Set Z} | |
| (hp : β vβIcc (0:β) 1 ΓΛ’ K,P v*P v=P v) (N j : β) | |
| {v : β Γ Z} (hv : vβIcc (0:β) 1 ΓΛ’ K) : | |
| projectionTimeChain P N j v*P (0,v.2)=P (cappedTime N j v.1,v.2)*projectionTimeChain P N j v := by | |
| induction j with | |
| | zero => simp only [projectionTimeChain,one_mul,mul_one,cappedTime_zero N hv.1.1] | |
| | succ j ih => | |
| rw [projectionTimeChain,mul_assoc,ih,βmul_assoc, | |
| projectionTransport_intertwines (hp (cappedTime N j v.1,v.2) β¨cappedTime_mem N j hv.1,hv.2β©) | |
| (hp (cappedTime N (j+1) v.1,v.2) β¨cappedTime_mem N (j+1) hv.1,hv.2β©),mul_assoc] | |
| omit [CompleteSpace X] in | |
| lemma projectionTimeChain_invertible [CompleteSpace X] {P : β Γ Z β X βL[β] X} {K : Set Z} {Ξ΄ : β} | |
| (hs : β zβIcc (0:β) 1 ΓΛ’ K,β wβIcc (0:β) 1 ΓΛ’ K,dist z w<Ξ΄ β | |
| (projectionTransport (P z) (P w)).IsInvertible) | |
| {N : β} (hN : 1/(N:β)<Ξ΄) (j : β) {v : β Γ Z} (hv : vβIcc (0:β) 1 ΓΛ’ K) : | |
| (projectionTimeChain P N j v).IsInvertible := by | |
| induction j with | |
| | zero => exact β¨ContinuousLinearEquiv.refl β X,rflβ© | |
| | succ j ih => | |
| change (projectionTransport _ _ * _).IsInvertible | |
| apply ContinuousLinearMap.IsInvertible.comp _ ih | |
| apply hs (cappedTime N j v.1,v.2) β¨cappedTime_mem N j hv.1,hv.2β© | |
| (cappedTime N (j+1) v.1,v.2) β¨cappedTime_mem N (j+1) hv.1,hv.2β© | |
| simpa only [Prod.dist_eq,dist_self,max_eq_left (dist_nonneg)] using (cappedTime_step N j v.1).trans_lt hN | |
| lemma compact_projection_time_transport {P : β Γ Z β X βL[β] X} {K : Set Z} | |
| (hK : IsCompact K) (hP : ContinuousOn P (Icc (0:β) 1 ΓΛ’ K)) | |
| (hp : β vβIcc (0:β) 1 ΓΛ’ K,P v*P v=P v) : | |
| β T : (β Γ Z) β X βL[β] X,ContinuousOn T (Icc (0:β) 1 ΓΛ’ K) β§ | |
| β vβIcc (0:β) 1 ΓΛ’ K,(T v).IsInvertible β§ T v*P (0,v.2)=P v*T v := by | |
| obtain β¨Ξ΄,hΞ΄,hstepβ© := compact_projection_transport (isCompact_Icc.prod hK) hP hp | |
| obtain β¨N,hNβ© := exists_nat_one_div_lt hΞ΄ | |
| let M := N+1 | |
| have hM : 0<M := Nat.succ_pos N | |
| have hNM : 1/(M:β)<Ξ΄ := by simpa only [M,Nat.cast_add,Nat.cast_one] using hN | |
| refine β¨projectionTimeChain P M M,projectionTimeChain_continuousOn hP M M,?_β© | |
| intro v hv | |
| refine β¨projectionTimeChain_invertible hstep hNM M hv,?_β© | |
| simpa only [cappedTime_last hM hv.1.2,Prod.mk.eta] using projectionTimeChain_intertwines hp M M hv | |
| def cappedTimeMap (N j : β) (v : β Γ Z) : β Γ Z := (cappedTime N j v.1,v.2) | |
| lemma cappedTimeMap_continuous (N j : β) : Continuous (cappedTimeMap (Z := Z) N j) := | |
| ((cappedTime_continuous N j).comp continuous_fst).prodMk continuous_snd | |
| def gridDomain (V : Set (β Γ Z)) (N : β) : Set (β Γ Z) := | |
| V β© (fun v : β Γ Z => (0,v.2)) β»ΒΉ' V β© β j : Fin (N+1),cappedTimeMap N j.val β»ΒΉ' V | |
| lemma gridDomain_open {V : Set (β Γ Z)} (hV : IsOpen V) (N : β) : IsOpen (gridDomain V N) := | |
| (hV.inter (hV.preimage (continuous_const.prodMk continuous_snd))).inter | |
| (isOpen_iInter_of_finite (fun j => hV.preimage (cappedTimeMap_continuous N j.val))) | |
| omit [MetricSpace Z] in | |
| lemma gridDomain_time_mem [MetricSpace Z] {V : Set (β Γ Z)} {N j : β} (hj : jβ€N) | |
| {v : β Γ Z} (hv : vβgridDomain V N) : cappedTimeMap N j vβV := | |
| mem_iInter.mp hv.2 β¨j,Nat.lt_succ_of_le hjβ© | |
| omit [MetricSpace Z] in | |
| lemma gridDomain_contains [MetricSpace Z] {V : Set (β Γ Z)} {K : Set Z} | |
| (hVK : Icc (0:β) 1 ΓΛ’ KβV) (N : β) : | |
| Icc (0:β) 1 ΓΛ’ KβgridDomain V N := by | |
| intro v hv | |
| refine β¨β¨hVK hv,hVK β¨by constructor <;> norm_num,hv.2β©β©,mem_iInter.mpr ?_β© | |
| intro j | |
| exact hVK β¨cappedTime_mem N j.val hv.1,hv.2β© | |
| lemma projectionTimeChain_continuousOn_grid {V : Set (β Γ Z)} {P : β Γ Z β X βL[β] X} | |
| (hP : ContinuousOn P V) (N j : β) (hj : jβ€N) : | |
| ContinuousOn (projectionTimeChain P N j) (gridDomain V N) := by | |
| induction j with | |
| | zero => exact continuousOn_const | |
| | succ j ih => | |
| apply ContinuousOn.mul _ (ih (Nat.le_trans (Nat.le_succ j) hj)) | |
| apply projectionTransport_continuousOn | |
| Β· exact hP.comp (cappedTimeMap_continuous N j).continuousOn | |
| (fun v hv => gridDomain_time_mem (Nat.le_trans (Nat.le_succ j) hj) hv) | |
| Β· exact hP.comp (cappedTimeMap_continuous N (j+1)).continuousOn | |
| (fun v hv => gridDomain_time_mem hj hv) | |
| lemma projectionTimeChain_intertwines_grid {V : Set (β Γ Z)} {P : β Γ Z β X βL[β] X} | |
| (hp : β vβV,P v*P v=P v) (N j : β) (hj : jβ€N) | |
| {v : β Γ Z} (hv : vβgridDomain V N) : | |
| projectionTimeChain P N j v*P (cappedTimeMap N 0 v)= | |
| P (cappedTimeMap N j v)*projectionTimeChain P N j v := by | |
| induction j with | |
| | zero => simp only [projectionTimeChain,one_mul,mul_one] | |
| | succ j ih => | |
| have hj' : jβ€N := Nat.le_trans (Nat.le_succ j) hj | |
| change (projectionTransport (P (cappedTimeMap N j v)) (P (cappedTimeMap N (j+1) v))* | |
| projectionTimeChain P N j v)*P (cappedTimeMap N 0 v)=_ | |
| rw [mul_assoc,ih hj',βmul_assoc, | |
| projectionTransport_intertwines (hp _ (gridDomain_time_mem hj' hv)) | |
| (hp _ (gridDomain_time_mem hj hv)),mul_assoc] | |
| rfl | |
| def extendedTimeTransport (P : β Γ Z β X βL[β] X) (N : β) (v : β Γ Z) : X βL[β] X := | |
| projectionTransport (P (cappedTimeMap N N v)) (P v)*projectionTimeChain P N N v* | |
| projectionTransport (P (0,v.2)) (P (cappedTimeMap N 0 v)) | |
| lemma extendedTimeTransport_continuousOn {V : Set (β Γ Z)} {P : β Γ Z β X βL[β] X} | |
| (hP : ContinuousOn P V) (N : β) : ContinuousOn (extendedTimeTransport P N) (gridDomain V N) := by | |
| apply ContinuousOn.mul | |
| Β· apply ContinuousOn.mul | |
| Β· exact projectionTransport_continuousOn | |
| (hP.comp (cappedTimeMap_continuous N N).continuousOn (fun v hv => gridDomain_time_mem le_rfl hv)) | |
| (hP.mono (fun v hv => hv.1.1)) | |
| Β· exact projectionTimeChain_continuousOn_grid hP N N le_rfl | |
| Β· exact projectionTransport_continuousOn | |
| (hP.comp (continuous_const.prodMk continuous_snd).continuousOn (fun v hv => hv.1.2)) | |
| (hP.comp (cappedTimeMap_continuous N 0).continuousOn (fun v hv => gridDomain_time_mem (Nat.zero_le N) hv)) | |
| lemma extendedTimeTransport_intertwines {V : Set (β Γ Z)} {P : β Γ Z β X βL[β] X} | |
| (hp : β vβV,P v*P v=P v) (N : β) {v : β Γ Z} (hv : vβgridDomain V N) : | |
| extendedTimeTransport P N v*P (0,v.2)=P v*extendedTimeTransport P N v := by | |
| have h0 : P (0,v.2)*P (0,v.2)=P (0,v.2) := hp _ hv.1.2 | |
| have hvp := hp v hv.1.1 | |
| have hs := hp _ (gridDomain_time_mem (Nat.zero_le N) hv) | |
| have hf := hp _ (gridDomain_time_mem (N := N) le_rfl hv) | |
| unfold extendedTimeTransport | |
| rw [mul_assoc,projectionTransport_intertwines h0 hs,βmul_assoc, mul_assoc | |
| (projectionTransport _ _) (projectionTimeChain P N N v), | |
| projectionTimeChain_intertwines_grid hp N N le_rfl hv,βmul_assoc | |
| (projectionTransport _ _),projectionTransport_intertwines hf hvp] | |
| simp only [mul_assoc] | |
| omit [MetricSpace Z] in | |
| lemma extendedTimeTransport_eq_chain [MetricSpace Z] {V : Set (β Γ Z)} {P : β Γ Z β X βL[β] X} | |
| (hp : β vβV,P v*P v=P v) {N : β} (hN : 0<N) {v : β Γ Z} | |
| (ht : v.1βIcc (0:β) 1) (hv : vβgridDomain V N) : | |
| extendedTimeTransport P N v=projectionTimeChain P N N v := by | |
| have h0 : P (0,v.2)*P (0,v.2)=P (0,v.2) := hp _ hv.1.2 | |
| have hvp := hp v hv.1.1 | |
| simp only [extendedTimeTransport,cappedTimeMap,cappedTime_last hN ht.2, | |
| cappedTime_zero N ht.1,Prod.mk.eta,projectionTransport_self hvp,projectionTransport_self h0,one_mul,mul_one] | |
| lemma compact_kernel_transport_neighborhood {V : Set (β Γ Z)} {K : Set Z} | |
| {P : β Γ Z β X βL[β] X} (hK : IsCompact K) (hV : IsOpen V) | |
| (hVK : Icc (0:β) 1 ΓΛ’ KβV) (hP : ContinuousOn P V) (hp : β vβV,P v*P v=P v) : | |
| β W : Set (β Γ Z),IsOpen W β§ Icc (0:β) 1 ΓΛ’ KβW β§ WβV β§ | |
| (β vβW,(0,v.2)βV) β§ β T : β Γ Z β X βL[β] X,ContinuousOn T W β§ | |
| β vβW,(T v).IsInvertible β§ T v*P (0,v.2)=P v*T v := by | |
| obtain β¨Ξ΄,hΞ΄,hstepβ© := compact_projection_transport (isCompact_Icc.prod hK) (hP.mono hVK) | |
| (fun v hv => hp v (hVK hv)) | |
| obtain β¨N,hNβ© := exists_nat_one_div_lt hΞ΄ | |
| let M := N+1 | |
| have hM : 0<M := Nat.succ_pos N | |
| have hNM : 1/(M:β)<Ξ΄ := by simpa only [M,Nat.cast_add,Nat.cast_one] using hN | |
| let T := extendedTimeTransport P M | |
| let G := gridDomain V M | |
| have hGs : IsOpen G := gridDomain_open hV M | |
| have hGc : Icc (0:β) 1 ΓΛ’ KβG := gridDomain_contains hVK M | |
| have hT : ContinuousOn T G := extendedTimeTransport_continuousOn hP M | |
| let W := G β© T β»ΒΉ' {L : X βL[β] X | L.IsInvertible} | |
| have hW : IsOpen W := hT.isOpen_inter_preimage hGs ContinuousLinearEquiv.isOpen | |
| refine β¨W,hW,?_,(fun v hv => hv.1.1.1),(fun v hv => hv.1.1.2),T,hT.mono inter_subset_left,?_β© | |
| Β· intro v hv | |
| refine β¨hGc hv,?_β© | |
| change (extendedTimeTransport P M v).IsInvertible | |
| rw [extendedTimeTransport_eq_chain hp hM hv.1 (hGc hv)] | |
| exact projectionTimeChain_invertible hstep hNM M hv | |
| Β· intro v hv | |
| exact β¨hv.2,extendedTimeTransport_intertwines hp M hv.1β© | |
| end | |
| open scoped ContDiff Topology | |
| open Set Function Filter | |
| open HolderCompletion | |
| variable {X Y : Type*} [NormedAddCommGroup X] [NormedSpace β X] [CompleteSpace X] | |
| [NormedAddCommGroup Y] [NormedSpace β Y] [CompleteSpace Y] | |
| lemma pathSpatialDerivative_initial {F : β Γ X β Y} (hF : ContDiff β β F) | |
| {L : X βL[β] Y} (hL : β x,F (0,x)=L x) (x : X) : | |
| pathSpatialDerivative F (0,x)=L.toContinuousLinearMap := by | |
| rw [pathSpatialDerivative_eq hF] | |
| have he : (fun y => F (0,y))=L := funext hL | |
| rw [he] | |
| exact L.hasFDerivAt.fderiv | |
| def initialKernelGraph (L : X βL[β] Y) (E : Submodule β Y) : E βL[β] (X Γ E) := | |
| (-(L.symm.toContinuousLinearMap.comp E.subtypeL)).prod (ContinuousLinearMap.id β E) | |
| omit [CompleteSpace X] [CompleteSpace Y] in | |
| lemma initialKernelGraph_apply [CompleteSpace X] [CompleteSpace Y] | |
| (L : X βL[β] Y) (E : Submodule β Y) (e : E) : | |
| initialKernelGraph L E e=(-L.symm (e:Y),e) := rfl | |
| lemma initialKernelGraph_kernel {L : X βL[β] Y} {E : Submodule β Y} (v : X Γ E) : | |
| L v.1+(v.2:Y)=0 β initialKernelGraph L E v.2=v := by | |
| constructor | |
| Β· intro hv | |
| rw [initialKernelGraph_apply] | |
| refine Prod.ext ?_ (rfl : (v.2:E)=v.2) | |
| change -L.symm (v.2:Y)=v.1 | |
| apply L.injective | |
| rw [map_neg,L.apply_symm_apply] | |
| exact (eq_neg_of_add_eq_zero_left hv).symm | |
| Β· intro hv | |
| rw [βhv] | |
| simp only [initialKernelGraph_apply,map_neg,L.apply_symm_apply,neg_add_cancel] | |
| omit [CompleteSpace X] in | |
| lemma projection_fixed_iff_range [CompleteSpace X] {Q : X βL[β] X} (hQ : Q.comp Q=Q) (x : X) : | |
| Q x=x β xβQ.range := by | |
| constructor | |
| Β· intro hx; exact β¨x,hxβ© | |
| Β· rintro β¨y,rflβ© | |
| exact congrArg (fun A : X βL[β] X => A y) hQ | |
| structure StabilizedKernelFrame (F : β Γ X β Y) (E : Submodule β Y) | |
| (V : Set (β Γ X)) where | |
| frame : (β Γ X) β E βL[β] (X Γ E) | |
| coordinate : (β Γ X) β (X Γ E) βL[β] E | |
| frame_continuous : ContinuousOn frame V | |
| coordinate_continuous : ContinuousOn coordinate V | |
| kernel : β vβV,β e : E,((pathSpatialDerivative F v).coprod E.subtypeL) (frame v e)=0 | |
| left_inv : β vβV,β e : E,coordinate v (frame v e)=e | |
| right_inv : β vβV,β w : X Γ E,((pathSpatialDerivative F v).coprod E.subtypeL) w=0 β | |
| frame v (coordinate v w)=w | |
| lemma ProperIndexZeroPath.stabilized_kernel_frame {F : β Γ X β Y} {U : Set X} | |
| (h : ProperIndexZeroPath F U) : | |
| β K : Set X,IsCompact K β§ KβU β§ (0:X)βK β§ | |
| (β tβIcc (0:β) 1,β xβU,F (t,x)=0 βxβK) β§ | |
| β E : Submodule β Y,β _ : FiniteDimensional β E, | |
| β V : Set (β Γ X),IsOpen V β§ Icc (0:β) 1 ΓΛ’ KβV β§ | |
| (β vβV,Surjective ((pathSpatialDerivative F v).coprod E.subtypeL)) β§ | |
| Nonempty (StabilizedKernelFrame F E V) := by | |
| obtain β¨K,hK,hKU,h0K,hZ,E,hE,V,hVo,hKV,P,hP,hprojβ© := h.cylinder_kernel_projection | |
| let := hE | |
| have hp : β vβV,P v*P v=P v := fun v hv => (hproj v hv).2.1 | |
| obtain β¨W,hWo,hKW,hWV,hW0,T,hT,hTiβ© := compact_kernel_transport_neighborhood hK hVo hKV hP hp | |
| obtain β¨L,hLβ© := h.initial | |
| let B := initialKernelGraph L E | |
| have hB (e : E) : L (B e).1+((B e).2:Y)=0 := by | |
| simp only [B,initialKernelGraph_apply,map_neg,L.apply_symm_apply,neg_add_cancel] | |
| have hPf {v : β Γ X} (hv : vβV) (w : X Γ E) : | |
| P v w=w β ((pathSpatialDerivative F v).coprod E.subtypeL) w=0 := by | |
| rw [projection_fixed_iff_range (hproj v hv).2.1,(hproj v hv).2.2] | |
| rfl | |
| have hP0 {v : β Γ X} (hv : vβW) (e : E) : P (0,v.2) (B e)=B e := by | |
| apply (hPf (hW0 v hv) (B e)).mpr | |
| rw [pathSpatialDerivative_initial h.smooth hL] | |
| exact hB e | |
| let Q : (β Γ X) β E βL[β] (X Γ E) := fun v => (T v).comp B | |
| let C : (β Γ X) β (X Γ E) βL[β] E := fun v => | |
| (ContinuousLinearMap.snd β X E).comp (T v).inverse | |
| have hcT : ContinuousOn (fun v => (T v).inverse) W := by | |
| intro v hv | |
| exact ((hTi v hv).1.contDiffAt_map_inverse (n := β)).continuousAt.comp_continuousWithinAt (hT v hv) | |
| refine β¨K,hK,hKU,h0K,hZ,E,hE,W,hWo,hKW,(fun v hv => (hproj v (hWV hv)).1),β¨{ | |
| frame := Q | |
| coordinate := C | |
| frame_continuous := hT.clm_comp continuousOn_const | |
| coordinate_continuous := continuousOn_const.clm_comp hcT | |
| kernel := ?_ | |
| left_inv := ?_ | |
| right_inv := ?_ }β©β© | |
| Β· intro v hv e | |
| apply (hPf (hWV hv) (Q v e)).mp | |
| have hh := congrArg (fun A : (X Γ E) βL[β] (X Γ E) => A (B e)) (hTi v hv).2 | |
| change T v (P (0,v.2) (B e))=P v (T v (B e)) at hh | |
| rw [hP0 hv e] at hh | |
| exact hh.symm | |
| Β· intro v hv e | |
| change ((T v).inverse (T v (B e))).2=e | |
| rw [(hTi v hv).1.inverse_apply_self] | |
| rfl | |
| Β· intro v hv w hw | |
| have hPw := (hPf (hWV hv) w).mpr hw | |
| have hTiw := (hTi v hv).1.self_apply_inverse w | |
| have hh := congrArg (fun A : (X Γ E) βL[β] (X Γ E) => A ((T v).inverse w)) (hTi v hv).2 | |
| change T v (P (0,v.2) ((T v).inverse w))=P v (T v ((T v).inverse w)) at hh | |
| rw [hTiw,hPw] at hh | |
| have hp0 : P (0,v.2) ((T v).inverse w)=(T v).inverse w := | |
| (hTi v hv).1.injective (hh.trans hTiw.symm) | |
| have hk0 := (hPf (hW0 v hv) ((T v).inverse w)).mp hp0 | |
| rw [pathSpatialDerivative_initial h.smooth hL] at hk0 | |
| have hb0 := (initialKernelGraph_kernel ((T v).inverse w)).mp hk0 | |
| change T v (B (((T v).inverse w).2))=w | |
| rw [show B (((T v).inverse w).2)=(T v).inverse w from hb0] | |
| exact hTiw | |
| end HigherDimensionalBallPacking.Rigidity | |
| end | |
| end OAI | |