Download data/lean/OAI/Geometry/ComplexBundle/Replacement.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Replacement.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/Replacement.lean
-
curl -L -o Replacement.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Replacement.lean
19.9 kB
| import OAI.Analysis.MatrixScaling.Expansion | |
| import OAI.Geometry.ComplexBundle.BundleIncidence | |
| import OAI.Geometry.ComplexBundle.DirectSum | |
| import Mathlib.Basic.Real.Basic | |
| import Mathlib.Order.Interval.Finset.Nat | |
| namespace OAI | |
| noncomputable section | |
| /-! Quantitative bundle rank margins and repeated-line replacement maps. -/ | |
| namespace Kaplansky | |
| theorem small_incidence (m s D : β) (hm : 0 < m) (hs : 0 < s) | |
| (hsm : s β€ m) (hD : 64*m β€ D) : | |
| 0 < (16*s-2*s)*(D/4-2*s)-s*(D-s) β§ | |
| 133*m*s β€ (16*s-2*s)*(D/4-2*s)-s*(D-s) := by | |
| have h1 := mul_le_mul_of_nonneg_right hD hs.le | |
| have h2 := mul_le_mul_of_nonneg_right hsm hs.le | |
| have h3 : 0 < m*s := mul_pos hm hs | |
| constructor <;> nlinarith | |
| theorem small_rank_endpoint (m s D : β) (hm : 0 < m) | |
| (hsm : s β€ m) (hD : 64*m β€ D) : | |
| 2*s < D/4 β§ D/8 β€ D/4-2*s := by constructor <;> linarith | |
| theorem large_incidence (m s d Ξ· : β) (hm : 0 β€ m) (hd : 0 < d) | |
| (hms : m < s) (hsd : s β€ d) (hΞ· : Ξ· < (20/3)*m*d) : | |
| 2*s < (15/4)*d β§ Ξ· < (8*s-2*s)*(15*d/4-2*s)-s*(d-s) := by | |
| have hs : 0 < s := lt_of_le_of_lt hm hms | |
| have h1 := mul_le_mul_of_nonneg_right hsd hs.le | |
| have h2 := mul_lt_mul_of_pos_right hms hd | |
| have h3 := mul_nonneg hm hd.le | |
| constructor <;> nlinarith | |
| theorem replacement_rank (d : β) : d/4 + (15/4)*d = 4*d := by ring | |
| theorem prefix_dimension_margin (m dβ q : β) (hm : 0 < m) (hd : 0 < dβ) : | |
| (5/3)*m*dβ*(4*q-1) < (20/3)*m*(dβ*q) := by | |
| nlinarith [mul_pos hm hd] | |
| theorem retained_trivial_rank_bound (m dβ e : β) (hm : 0 < m) (hd : 0 < dβ) | |
| (he : 0 β€ e) : (4/3)*m*dβ*(1-e) < 2*m*dβ := by | |
| have h := mul_pos hm hd | |
| have h' := mul_nonneg h.le he | |
| nlinarith | |
| end Kaplansky | |
| namespace Kaplansky.Incidence | |
| theorem fresh_incidence_dimension (m d r N s : β) (hd : 0<d) | |
| (hr : 4*r=15*d) (hN : 3*N<40*m*d) (hms : m<s) (hsd : sβ€d) : | |
| 2*sβ€r β§ N+2*s*(d-s)+2*(2*s)*(r-2*s)<2*8*s*(r-2*s) := by | |
| have hrr : (r : β)=15*(d : β)/4 := by | |
| have hh : (4 : β)*r=15*d := by exact_mod_cast hr | |
| linarith | |
| have hn : (N : β)/2 < (20/3)*(m : β)*d := by | |
| have hh : (3 : β)*N<40*(m : β)*d := by exact_mod_cast hN | |
| linarith | |
| obtain β¨hep,hgapβ© := Kaplansky.large_incidence (m : β) (s : β) (d : β) ((N : β)/2) | |
| (by positivity) (by exact_mod_cast hd) (by exact_mod_cast hms) (by exact_mod_cast hsd) hn | |
| have htr : 2*sβ€r := by | |
| have hh : (2 : β)*s<(r : β) := by rw [hrr]; linarith | |
| exact le_of_lt (by exact_mod_cast hh) | |
| refine β¨htr,?_β© | |
| apply (Nat.cast_lt (Ξ± := β)).mp | |
| push_cast [Nat.cast_sub hsd,Nat.cast_sub htr] | |
| rw [hrr] | |
| nlinarith | |
| theorem source_incidence_dimension_iff {q d r s t h : β} (hsd : sβ€d) (htr : tβ€r) : | |
| ((q : β€)*s-t)*(r-t)-(s : β€)*(d-s)>(h : β€) β | |
| 2*h+2*s*(d-s)+2*t*(r-t)<2*q*s*(r-t) := by | |
| rw [β Int.ofNat_sub hsd,β Int.ofNat_sub htr] | |
| constructor | |
| Β· intro hh | |
| have hg : ((2*h+2*s*(d-s)+2*t*(r-t) : β) : β€) < | |
| ((2*q*s*(r-t) : β) : β€) := by | |
| push_cast | |
| nlinarith | |
| exact_mod_cast hg | |
| Β· intro hh | |
| have hg : ((2*h+2*s*(d-s)+2*t*(r-t) : β) : β€) < | |
| ((2*q*s*(r-t) : β) : β€) := by exact_mod_cast hh | |
| push_cast at hg | |
| nlinarith | |
| end Kaplansky.Incidence | |
| section | |
| open Module | |
| namespace Kaplansky.Incidence | |
| theorem exists_sixteen_replacement_maps (m r : β) (hm : 0<m) (hr : 16*mβ€r) : | |
| β T : MatrixTuple 16 (4*r) r, β S : Submodule β (Fin (4*r) β β), | |
| finrank β Sβ€m β 2*finrank β Sβ€ | |
| finrank β (β¨ i, S.map (T i).toLinearMap : Submodule β (Fin r β β)) := by | |
| let pairs : Finset (β Γ β) := (Finset.Icc 1 m).image (fun s => (s,2*s)) | |
| have hpairs : β p β pairs, p.1β€4*r β§ p.2β€r β§ | |
| p.1*(4*r-p.1)+p.2*(r-p.2)<16*p.1*(r-p.2) := by | |
| intro p hp | |
| obtain β¨s,hs,rflβ© := Finset.mem_image.mp hp | |
| have hs1 : 1β€s := (Finset.mem_Icc.mp hs).1 | |
| have hsm : sβ€m := (Finset.mem_Icc.mp hs).2 | |
| have hsd : sβ€4*r := by omega | |
| have htr : 2*sβ€r := by omega | |
| refine β¨hsd,htr,?_β© | |
| apply (point_dimension_inequality_iff (q := 16) hsd htr).mp | |
| have hi := (Kaplansky.small_incidence (m : β) (s : β) (4*(r : β)) | |
| (by exact_mod_cast hm) (by exact_mod_cast (show 0<s by omega)) (by exact_mod_cast hsm) | |
| (by exact_mod_cast (show 64*mβ€4*r by omega))).1 | |
| have hi' : 0<((16 : β)*s-2*s)*(r-2*s)-(s : β)*(4*r-s) := by | |
| convert hi using 1; ring | |
| exact_mod_cast hi' | |
| obtain β¨T,hTβ© := exists_point_incidence_tuple pairs hpairs | |
| refine β¨T,fun S hS => ?_β© | |
| by_cases hz : finrank β S=0 | |
| Β· simp [hz] | |
| Β· have hs1 : 1β€finrank β S := by omega | |
| have hp : (finrank β S,2*finrank β S) β pairs := | |
| Finset.mem_image.mpr β¨finrank β S,Finset.mem_Icc.mpr β¨hs1,hSβ©,rflβ© | |
| exact (hT _ hp S rfl).le | |
| end Kaplansky.Incidence | |
| end | |
| section | |
| open Bundle Module Set | |
| open scoped Topology Manifold ContDiff | |
| namespace Kaplansky.Incidence | |
| variable {X B : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [FiniteDimensional β X] [TopologicalSpace B] [ChartedSpace X B] | |
| [IsManifold π(β,X) β B] [T2Space B] [CompactSpace B] | |
| {d r : β} (E F : B β Type*) | |
| [β x, NormedAddCommGroup (E x)] [β x, NormedSpace β (E x)] | |
| [β x, NormedAddCommGroup (F x)] [β x, NormedSpace β (F x)] | |
| [TopologicalSpace (TotalSpace (Fin d β β) E)] [TopologicalSpace (TotalSpace (Fin r β β) F)] | |
| [FiberBundle (Fin d β β) E] [FiberBundle (Fin r β β) F] | |
| [VectorBundle β (Fin d β β) E] [VectorBundle β (Fin d β β) E] | |
| [VectorBundle β (Fin r β β) F] [VectorBundle β (Fin r β β) F] | |
| [ContMDiffVectorBundle β (Fin d β β) E π(β,X)] | |
| [ContMDiffVectorBundle β (Fin r β β) F π(β,X)] | |
| theorem exists_eight_fresh_bundle_maps (m : β) (hd : 0<d) | |
| (hr : 4*r=15*d) (hbase : 3*finrank β X<40*m*d) : | |
| β T : Fin 8 β β y, E y βL[β] F y, | |
| (β i, ContMDiff π(β,X) (π(β,X).prod π(β,(Fin d β β) βL[β] (Fin r β β))) β | |
| (fun y => TotalSpace.mk' ((Fin d β β) βL[β] (Fin r β β)) y ((T i y).restrictScalars β))) β§ | |
| β y (S : Submodule β (E y)), m<finrank β S β | |
| 2*finrank β Sβ€finrank β (β¨ i, S.map (T i y).toLinearMap : Submodule β (F y)) := by | |
| classical | |
| let pairs : Finset (β Γ β) := (Finset.Icc (m+1) d).image (fun s => (s,2*s)) | |
| have hpairs : β p β pairs, p.1β€d β§ p.2β€r β§ | |
| finrank β X+2*p.1*(d-p.1)+2*p.2*(r-p.2)<2*8*p.1*(r-p.2) := by | |
| intro p hp | |
| obtain β¨s,hs,rflβ© := Finset.mem_image.mp hp | |
| obtain β¨hms,hsdβ© := Finset.mem_Icc.mp hs | |
| obtain β¨htr,hgapβ© := fresh_incidence_dimension m d r (finrank β X) s hd hr hbase (by omega) hsd | |
| exact β¨hsd,htr,hgapβ© | |
| obtain β¨T,hT,hExpβ© := exists_smooth_bundle_incidence_maps E F pairs hpairs | |
| refine β¨T,hT,fun y S hS => ?_β© | |
| let e := trivializationAt (Fin d β β) E y | |
| let a := e.toPretrivialization.linearEquivAt β y (mem_baseSet_trivializationAt (Fin d β β) E y) | |
| have hsd : finrank β Sβ€d := by | |
| have hh := (S.map a.toLinearMap).finrank_le | |
| simpa [a.finrank_map_eq,Module.finrank_pi_fintype] using hh | |
| have hp : (finrank β S,2*finrank β S) β pairs := | |
| Finset.mem_image.mpr β¨finrank β S,Finset.mem_Icc.mpr β¨by omega,hsdβ©,rflβ© | |
| exact (hExp y _ hp S rfl).le | |
| end Kaplansky.Incidence | |
| end | |
| section | |
| open scoped BigOperators | |
| namespace Kaplansky | |
| variable {d r n : β} {L : Type*} [AddCommGroup L] [Module β L] | |
| /-- A scalar matrix tensored with the identity of a line fiber. This formula | |
| uses only scalar multiplication, not a choice of a vector in that line. -/ | |
| def scalarTensor (T : (Fin d β β) ββ[β] (Fin r β β)) : | |
| (Fin d β L) ββ[β] (Fin r β L) where | |
| toFun v a := β j, (T (Pi.single j 1) a) β’ v j | |
| map_add' v w := by funext a; simp [smul_add,Finset.sum_add_distrib] | |
| map_smul' c v := by | |
| funext a | |
| simp [Finset.smul_sum,smul_smul,mul_comm] | |
| def lineCoordinates (e : L ββ[β] β) (d : β) : (Fin d β L) ββ[β] (Fin d β β) where | |
| toFun v j := e (v j) | |
| invFun v j := e.symm (v j) | |
| left_inv v := by funext j; exact e.symm_apply_apply _ | |
| right_inv v := by funext j; exact e.apply_symm_apply _ | |
| map_add' v w := by funext j; exact map_add e _ _ | |
| map_smul' c v := by funext j; exact map_smul e _ _ | |
| theorem scalarTensor_coordinates (T : (Fin d β β) ββ[β] (Fin r β β)) | |
| (e : L ββ[β] β) (v : Fin d β L) : | |
| lineCoordinates e r (scalarTensor T v)=T (lineCoordinates e d v) := by | |
| classical | |
| have hv : lineCoordinates e d v = β j, e (v j) β’ Pi.single j 1 := by | |
| funext j | |
| simp [lineCoordinates,Pi.single_apply] | |
| rw [hv,map_sum] | |
| funext a | |
| simp [scalarTensor,lineCoordinates,map_sum,map_smul,Finset.sum_apply,mul_comm] | |
| theorem scalarTensor_eq_conjugate (T : (Fin d β β) ββ[β] (Fin r β β)) | |
| (e : L ββ[β] β) : | |
| scalarTensor T=(lineCoordinates e r).symm.toLinearMap.comp | |
| (T.comp (lineCoordinates e d).toLinearMap) := by | |
| apply LinearMap.ext | |
| intro v | |
| apply (lineCoordinates e r).injective | |
| simpa using scalarTensor_coordinates T e v | |
| /-- Tensoring an expanding scalar family with a line preserves expansion for | |
| all subspaces, and the tensor maps themselves are independent of the frame. -/ | |
| theorem scalarTensor_expanding (m : β) (T : Fin n β (Fin d β β) ββ[β] (Fin r β β)) | |
| (e : L ββ[β] β) (hT : ExpandingThrough m T) : | |
| ExpandingThrough m (fun i => scalarTensor (L := L) (T i)) := by | |
| have h := expandingThrough_equiv m T (lineCoordinates e d).symm (lineCoordinates e r).symm hT | |
| simpa only [LinearEquiv.symm_symm,β scalarTensor_eq_conjugate] using h | |
| theorem exists_sixteen_line_replacement_maps (m r : β) (hm : 0<m) (hr : 16*mβ€r) : | |
| β T : Incidence.MatrixTuple 16 (4*r) r, | |
| β (L : Type*) [AddCommGroup L] [Module β L] (_ : L ββ[β] β), | |
| ExpandingThrough m (fun i => scalarTensor (L := L) (T i).toLinearMap) := by | |
| obtain β¨T,hTβ© := Incidence.exists_sixteen_replacement_maps m r hm hr | |
| exact β¨T,fun L _ _ e => scalarTensor_expanding m (fun i => (T i).toLinearMap) e hTβ© | |
| /-- Rank one is enough; the line coordinate equivalence is constructed. -/ | |
| theorem scalarTensor_expanding_rank_one [FiniteDimensional β L] | |
| (hL : Module.finrank β L=1) (m : β) | |
| (T : Fin n β (Fin d β β) ββ[β] (Fin r β β)) (hT : ExpandingThrough m T) : | |
| ExpandingThrough m (fun i => scalarTensor (L := L) (T i)) := by | |
| obtain β¨eβ© := (FiniteDimensional.nonempty_linearEquiv_iff_finrank_eq | |
| (R := β) (M := L) (M' := β)).mpr (by simpa using hL) | |
| exact scalarTensor_expanding m T e hT | |
| /-- Tensoring commutes with every linear change of line coordinates. -/ | |
| theorem scalarTensor_natural {M : Type*} [AddCommGroup M] [Module β M] | |
| (T : (Fin d β β) ββ[β] (Fin r β β)) (f : L ββ[β] M) (v : Fin d β L) : | |
| (fun a => f (scalarTensor T v a))=scalarTensor T (fun j => f (v j)) := by | |
| funext a | |
| simp [scalarTensor,map_sum,map_smul] | |
| /-- The actual replacement maps on a finite sum of line-multiplicity blocks | |
| expand correlated subspaces. Each scalar family is constructed, not assumed. -/ | |
| theorem exists_line_block_replacements (k m : β) (hm : 0<m) (r : Fin k β β) | |
| (hr : β j, 16*mβ€r j) (L : Fin k β Type*) | |
| [β j, AddCommGroup (L j)] [β j, Module β (L j)] [β j, FiniteDimensional β (L j)] | |
| (hL : β j, Module.finrank β (L j)=1) : | |
| β T : β j, Incidence.MatrixTuple 16 (4*r j) (r j), | |
| ExpandingThrough m (blockDiagonal (fun j i => scalarTensor (L := L j) (T j i).toLinearMap)) := by | |
| choose T hT using fun j => Incidence.exists_sixteen_replacement_maps m (r j) hm (hr j) | |
| exact β¨T,expandingThrough_blocks k m (fun j => Fin (4*r j) β L j) | |
| (fun j => Fin (r j) β L j) _ | |
| (fun j => scalarTensor_expanding_rank_one (hL j) m (fun i => (T j i).toLinearMap) (hT j))β© | |
| end Kaplansky | |
| end | |
| section | |
| open Bundle Module | |
| open scoped Topology Manifold ContDiff | |
| namespace Kaplansky | |
| /-- The same scalar choices work simultaneously over every base point, | |
| including for nontrivial line bundles; fiber coordinates are not input. -/ | |
| theorem exists_uniform_line_block_replacements {B : Type*} | |
| (k m : β) (hm : 0<m) (r : Fin k β β) (hr : β j, 16*mβ€r j) | |
| (L : Fin k β B β Type*) | |
| [β j x, AddCommGroup (L j x)] [β j x, Module β (L j x)] | |
| [β j x, FiniteDimensional β (L j x)] | |
| (hL : β j x, finrank β (L j x)=1) : | |
| β T : β j, Incidence.MatrixTuple 16 (4*r j) (r j), | |
| β x, ExpandingThrough m | |
| (blockDiagonal (fun j i => scalarTensor (L := L j x) (T j i).toLinearMap)) := by | |
| choose T hT using fun j => Incidence.exists_sixteen_replacement_maps m (r j) hm (hr j) | |
| exact β¨T,fun x => expandingThrough_blocks k m (fun j => Fin (4*r j) β L j x) | |
| (fun j => Fin (r j) β L j x) _ | |
| (fun j => scalarTensor_expanding_rank_one (hL j x) m (fun i => (T j i).toLinearMap) (hT j))β© | |
| variable {X H B F : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [FiniteDimensional β X] [TopologicalSpace H] (I : ModelWithCorners β X H) | |
| [TopologicalSpace B] [ChartedSpace H B] [IsManifold I β B] | |
| [T2Space B] [CompactSpace B] | |
| [NormedAddCommGroup F] [NormedSpace β F] [FiniteDimensional β F] | |
| (E : B β Type*) [β x, AddCommGroup (E x)] [β x, Module β (E x)] | |
| [β x, Module β (E x)] [β x, IsScalarTower β β (E x)] | |
| [β x, TopologicalSpace (E x)] [TopologicalSpace (TotalSpace F E)] | |
| [FiberBundle F E] [VectorBundle β F E] [VectorBundle β F E] | |
| [ContMDiffVectorBundle β F E I] | |
| omit [FiniteDimensional β X] [IsManifold I β B] [T2Space B] [CompactSpace B] | |
| [FiniteDimensional β F] [β x, IsScalarTower β β (E x)] in | |
| /-- The frame-independent tensor formula preserves smooth sections in every | |
| output component. Thus the scalar tensor maps have the required local | |
| smoothness; no smooth global frame for the line is assumed. -/ | |
| theorem scalarTensor_smooth_section_components {d r : β} | |
| (T : (Fin d β β) ββ[β] (Fin r β β)) (s : Fin d β β x, E x) | |
| (hs : β j, ContMDiff I (I.prod π(β,F)) β | |
| (fun x => TotalSpace.mk' F x (s j x))) (a : Fin r) : | |
| ContMDiff I (I.prod π(β,F)) β | |
| (fun x => TotalSpace.mk' F x (scalarTensor T (fun j => s j x) a)) := | |
| sectionEvaluation_smooth I E s hs (fun j => T (Pi.single j 1) a) | |
| end Kaplansky | |
| end | |
| section | |
| open Bundle Topology | |
| open scoped BigOperators | |
| namespace Kaplansky | |
| variable {B : Type*} [TopologicalSpace B] {k : β} | |
| {J : Fin k β Type*} (C : β s, VectorBundleCore β B β (J s)) | |
| abbrev RepeatedLineModel (D : Fin k β β) := EuclideanSpace β (Ξ£ s, Fin (D s)) | |
| def repeatedLineCore (D : Fin k β β) := finiteLineSumCore (fun a : Ξ£ s, Fin (D s) => C a.1) | |
| def repeatedLineFiberEquiv (D : Fin k β β) (x : B) : | |
| (repeatedLineCore C D).Fiber x ββ[β] (β s, Fin (D s) β (C s).Fiber x) where | |
| toFun v s a := (show RepeatedLineModel D from v) β¨s,aβ© | |
| invFun v := WithLp.toLp 2 (fun a => v a.1 a.2) | |
| left_inv _ := rfl | |
| right_inv _ := rfl | |
| map_add' _ _ := rfl | |
| map_smul' _ _ := rfl | |
| /-- The actual bundle map obtained by tensoring each scalar block with its | |
| line identity, expressed in the finite-sum core fibers. -/ | |
| def repeatedLineMap (D E : Fin k β β) | |
| (T : β s, (Fin (D s) β β) ββ[β] (Fin (E s) β β)) (x : B) : | |
| (repeatedLineCore C D).Fiber x ββ[β] (repeatedLineCore C E).Fiber x := | |
| (repeatedLineFiberEquiv C E x).symm.toLinearMap.comp | |
| ((blockDiagonal (n := 1) (fun s _ => scalarTensor (L := (C s).Fiber x) (T s)) 0).comp | |
| (repeatedLineFiberEquiv C D x).toLinearMap) | |
| @[simp] theorem repeatedLineMap_apply (D E : Fin k β β) | |
| (T : β s, (Fin (D s) β β) ββ[β] (Fin (E s) β β)) (x : B) | |
| (v : (repeatedLineCore C D).Fiber x) (s : Fin k) (b : Fin (E s)) : | |
| (show RepeatedLineModel E from repeatedLineMap C D E T x v) β¨s,bβ© = β a, T s (Pi.single a 1) b * (show RepeatedLineModel D from v) β¨s,aβ© := rfl | |
| /-- The local chart formula is exactly the same scalar tensor expression. | |
| In particular it contains no arbitrary choice of line frame. -/ | |
| theorem repeatedLineMap_chart (D E : Fin k β β) | |
| (T : β s, (Fin (D s) β β) ββ[β] (Fin (E s) β β)) (x y : B) | |
| (v : (repeatedLineCore C D).Fiber y) (s : Fin k) (b : Fin (E s)) : | |
| ((trivializationAt (RepeatedLineModel E) (repeatedLineCore C E).Fiber x) | |
| β¨y,repeatedLineMap C D E T y vβ©).2 β¨s,bβ© = | |
| β a, T s (Pi.single a 1) b * | |
| ((trivializationAt (RepeatedLineModel D) (repeatedLineCore C D).Fiber x) β¨y,vβ©).2 β¨s,aβ© := by | |
| change (C s).coordChange ((C s).indexAt y) ((C s).indexAt x) y | |
| (β a, T s (Pi.single a 1) b β’ (show RepeatedLineModel D from v) β¨s,aβ©) = _ | |
| rw [map_sum] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| exact map_smul _ _ _ | |
| /-- Componentwise smooth-section formulas alone do not establish this | |
| claim: the map on the actual finite-sum total spaces is continuous. -/ | |
| theorem continuous_repeatedLineMap (D E : Fin k β β) | |
| (T : β s, (Fin (D s) β β) ββ[β] (Fin (E s) β β)) : | |
| Continuous (fun z : TotalSpace (RepeatedLineModel D) (repeatedLineCore C D).Fiber => | |
| TotalSpace.mk' (RepeatedLineModel E) z.proj (repeatedLineMap C D E T z.proj z.2)) := by | |
| apply continuous_iff_continuousAt.mpr | |
| intro z | |
| rw [FiberBundle.continuousAt_totalSpace] | |
| refine β¨(FiberBundle.continuous_proj _ _).continuousAt, ?_β© | |
| have hc := ((trivializationAt (RepeatedLineModel D) (repeatedLineCore C D).Fiber z.proj).continuousAt | |
| FiberBundle.mem_trivializationAt_proj_source).snd | |
| have hpi := (EuclideanSpace.equiv (Ξ£ s, Fin (D s)) β).continuous.continuousAt.comp hc | |
| apply (EuclideanSpace.equiv (Ξ£ s, Fin (E s)) β).symm.continuous.continuousAt.comp | |
| apply continuousAt_pi.mpr | |
| rintro β¨s,bβ© | |
| have h : ContinuousAt (fun w : TotalSpace (RepeatedLineModel D) (repeatedLineCore C D).Fiber => | |
| β a, T s (Pi.single a 1) b * | |
| ((trivializationAt (RepeatedLineModel D) (repeatedLineCore C D).Fiber z.proj) w).2 β¨s,aβ©) z := | |
| tendsto_finsetSum Finset.univ (fun a _ => | |
| continuousAt_const.mul ((continuous_apply (β¨s,aβ© : Ξ£ s, Fin (D s))).continuousAt.comp hpi)) | |
| exact h.congr (Filter.Eventually.of_forall (fun w => | |
| (repeatedLineMap_chart C D E T z.proj w.proj w.2 s b).symm)) | |
| end Kaplansky | |
| end | |
| open Bundle Topology | |
| namespace Kaplansky | |
| variable {B : Type*} [TopologicalSpace B] {k : β} | |
| {J : Fin k β Type*} (C : β s, VectorBundleCore β B β (J s)) | |
| local instance (s : Fin k) (x : B) : FiniteDimensional β ((C s).Fiber x) := | |
| inferInstanceAs (FiniteDimensional β β) | |
| /-- The constructed uniform scalar choices give continuous total-space | |
| maps on the actual bundles and expand every small fiber subspace. -/ | |
| theorem exists_continuous_repeatedLine_replacements | |
| (m : β) (hm : 0<m) (r : Fin k β β) (hr : β s, 16*mβ€r s) : | |
| β A : β x, Fin 16 β | |
| (repeatedLineCore C (fun s => 4*r s)).Fiber x ββ[β] (repeatedLineCore C r).Fiber x, | |
| (β i, Continuous (fun z : TotalSpace (RepeatedLineModel (fun s => 4*r s)) | |
| (repeatedLineCore C (fun s => 4*r s)).Fiber => | |
| TotalSpace.mk' (RepeatedLineModel r) z.proj (A z.proj i z.2))) β§ | |
| β x, ExpandingThrough m (A x) := by | |
| obtain β¨T,hTβ© := exists_uniform_line_block_replacements k m hm r hr | |
| (fun s x => (C s).Fiber x) (fun _ _ => Module.finrank_self β) | |
| let A := fun x i => repeatedLineMap C (fun s => 4*r s) r | |
| (fun s => (T s i).toLinearMap) x | |
| refine β¨A,fun i => continuous_repeatedLineMap C _ _ _,?_β© | |
| intro x | |
| have h := expandingThrough_equiv m _ | |
| (repeatedLineFiberEquiv C (fun s => 4*r s) x).symm | |
| (repeatedLineFiberEquiv C r x).symm (hT x) | |
| exact h | |
| end Kaplansky | |
| end | |
| end OAI | |