| 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 |
|
|
