Download data/lean/OAI/Geometry/ComplexBundle/Avoidance.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 15.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Avoidance.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/Avoidance.lean
-
curl -L -o Avoidance.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Avoidance.lean
15.9 kB
| import OAI.Geometry.ComplexBundle.Incidence | |
| import Mathlib.Geometry.Manifold.ContMDiff.Atlas | |
| import Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | |
| import Mathlib.Topology.MetricSpace.HausdorffDimension | |
| namespace OAI | |
| noncomputable section | |
| /-! Avoidance of lower-dimensional incidence images in local manifold charts. -/ | |
| section | |
| open scoped MeasureTheory ENNReal NNReal Topology | |
| open Set MeasureTheory MeasureTheory.Measure Module | |
| namespace Kaplansky.Incidence | |
| /-- Local smoothness on an open coordinate domain suffices; convexity and | |
| compactness of the whole coordinate domain are not assumptions. -/ | |
| theorem smoothOn_open_dimH_image_le {E F : Type*} | |
| [NormedAddCommGroup E] [NormedSpace β E] [FiniteDimensional β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| {f : E β F} {s : Set E} (hs : IsOpen s) (hf : ContDiffOn β 1 f s) : | |
| dimH (f '' s) β€ finrank β E := by | |
| apply le_trans (dimH_image_le_of_locally_lipschitzOn ?_) | |
| ((dimH_mono (subset_univ s)).trans_eq (Real.dimH_univ_eq_finrank E)) | |
| intro x hx | |
| obtain β¨C,t,ht,hLβ© := ((hf x hx).contDiffAt (hs.mem_nhds hx)).exists_lipschitzOnWith | |
| exact β¨C,t,nhdsWithin_le_nhds ht,hLβ© | |
| /-- The lower-dimensional smooth image is null for top-dimensional Hausdorff | |
| measure, which is an additive Haar measure on the target. -/ | |
| theorem smoothOn_open_image_null {E F : Type*} | |
| [NormedAddCommGroup E] [NormedSpace β E] [FiniteDimensional β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] [FiniteDimensional β F] | |
| [MeasurableSpace F] [BorelSpace F] | |
| {f : E β F} {s : Set E} (hs : IsOpen s) (hf : ContDiffOn β 1 f s) | |
| (hd : finrank β E < finrank β F) : ΞΌH[finrank β F] (f '' s)=0 := by | |
| have h : dimH (f '' s) < (finrank β F : ββ₯0β) := | |
| (smoothOn_open_dimH_image_le hs hf).trans_lt (Nat.cast_lt.mpr hd) | |
| simpa only [NNReal.coe_natCast] using | |
| (hausdorffMeasure_of_dimH_lt (d := (finrank β F : ββ₯0)) h) | |
| /-- A countable family of smaller-dimensional smooth coordinate images | |
| cannot exhaust the parameter space. The null-image claims are proved here. -/ | |
| theorem exists_outside_countable_smooth_images {ΞΉ F : Type*} [Countable ΞΉ] | |
| [NormedAddCommGroup F] [NormedSpace β F] [FiniteDimensional β F] | |
| (E : ΞΉ β Type*) [β i, NormedAddCommGroup (E i)] [β i, NormedSpace β (E i)] | |
| [β i, FiniteDimensional β (E i)] (s : β i, Set (E i)) (f : β i, E i β F) | |
| (hs : β i, IsOpen (s i)) (hf : β i, ContDiffOn β 1 (f i) (s i)) | |
| (hd : β i, finrank β (E i)<finrank β F) : | |
| β v : F, β i, v β f i '' s i := by | |
| borelize F | |
| have hn : ΞΌH[finrank β F] (β i, f i '' s i)=0 := | |
| measure_iUnion_null (fun i => smoothOn_open_image_null (hs i) (hf i) (hd i)) | |
| have hne : (β i, f i '' s i) β univ := by | |
| intro h | |
| rw [h] at hn | |
| have hp : 0<ΞΌH[finrank β F] (univ : Set F) := | |
| isOpen_univ.measure_pos _ Set.univ_nonempty | |
| exact (ne_of_gt hp) hn | |
| by_contra h | |
| push Not at h | |
| apply hne | |
| apply Set.eq_univ_of_forall | |
| intro v | |
| obtain β¨i,hiβ© := h v | |
| exact Set.mem_iUnion.mpr β¨i,hiβ© | |
| end Kaplansky.Incidence | |
| end | |
| section | |
| open Set | |
| open scoped Topology Manifold ContDiff | |
| namespace Kaplansky | |
| variable {X B Z : Type*} [NormedAddCommGroup X] [NormedSpace β X] | |
| [TopologicalSpace B] [ChartedSpace X B] [IsManifold π(β,X) β B] | |
| [NormedAddCommGroup Z] [NormedSpace β Z] | |
| /-- The actual chart domain restricted to a bundle trivializing open set. -/ | |
| def localChartDomain (U : B β Set B) (x : B) : Set X := | |
| (chartAt X x).target β© (chartAt X x).symm β»ΒΉ' U x | |
| omit [NormedSpace β X] [IsManifold π(β, X) β B] in | |
| theorem localChartDomain_open (U : B β Set B) (hU : β x, IsOpen (U x)) (x : B) : | |
| IsOpen (localChartDomain (X := X) U x) := | |
| (chartAt X x).continuousOn_symm.isOpen_inter_preimage (chartAt X x).open_target (hU x) | |
| theorem localChartDomain_smooth (U : B β Set B) (f : B β Z) (x : B) | |
| (hf : ContMDiffOn π(β,X) π(β,Z) β f (U x)) : | |
| ContDiffOn β β (fun z => f ((chartAt X x).symm z)) (localChartDomain U x) := by | |
| apply ContMDiffOn.contDiffOn | |
| exact hf.comp ((contMDiffOn_chart_symm (I := π(β,X)) (x := x)).mono inter_subset_left) | |
| (fun _ hz => hz.2) | |
| omit [NormedSpace β X] [IsManifold π(β, X) β B] in | |
| /-- A countable choice of actual base charts covers the manifold while also | |
| respecting the prescribed open neighborhoods. -/ | |
| theorem exists_countable_local_chart_cover [LindelofSpace B] | |
| (U : B β Set B) (hU : β x, IsOpen (U x)) (hxU : β x, x β U x) : | |
| β c : Set B, c.Countable β§ β y, β x β c, | |
| y β U x β§ y β (chartAt X x).source β§ | |
| (chartAt X x) y β localChartDomain U x β§ | |
| (chartAt X x).symm ((chartAt X x) y)=y := by | |
| let O x := U x β© (chartAt X x).source | |
| have ho : β x, IsOpen (O x) := fun x => (hU x).inter (chartAt X x).open_source | |
| have hcov : (univ : Set B) β β x, O x := by | |
| intro y _ | |
| exact mem_iUnion.mpr β¨y,hxU y,mem_chart_source X yβ© | |
| obtain β¨c,hc,hcovβ© := isLindelof_univ.elim_countable_subcover O ho hcov | |
| refine β¨c,hc,fun y => ?_β© | |
| obtain β¨x,hxc,hxyβ© : β x β c, y β O x := by | |
| simpa only [mem_iUnion,exists_prop] using hcov (mem_univ y) | |
| have he := (chartAt X x).left_inv hxy.2 | |
| refine β¨x,hxc,hxy.1,hxy.2,β¨(chartAt X x).mapsTo hxy.2,?_β©,heβ© | |
| simpa only [mem_preimage,he] using hxy.1 | |
| end Kaplansky | |
| end | |
| section | |
| open scoped ContDiff Topology MeasureTheory | |
| open Set MeasureTheory MeasureTheory.Measure Module | |
| namespace Kaplansky.SmoothKernel.SurjectiveFamily | |
| variable {X V W : Type*} | |
| [NormedAddCommGroup X] [NormedSpace β X] | |
| [NormedAddCommGroup V] [NormedSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] [FiniteDimensional β W] | |
| local instance : CompleteSpace W := FiniteDimensional.complete β W | |
| variable (A : SurjectiveFamily X V W) | |
| theorem fromModel_contDiffAt (hA : ContDiff β β A.map) (i x : X) (hx : x β A.baseSet i) : | |
| ContDiffAt β β (A.fromModel i) x := by | |
| have hc : ContDiff β β (fun P : V βL[β] V => | |
| P.comp (((LinearMap.ker (A.map i).toLinearMap).subtypeL).comp | |
| (A.modelEquiv i).toContinuousLinearMap)) := contDiff_id.clm_comp contDiff_const | |
| exact (hc.restrict_scalars β).contDiffAt.comp x | |
| (((kernelProjection_smooth (A.rightInverse i) (A.map x) hx).restrict_scalars β).comp x hA.contDiffAt) | |
| def kernelParameterization (i : X) (p : X Γ KernelModel V W) : V := A.fromModel i p.1 p.2 | |
| theorem kernelParameterization_smooth (hA : ContDiff β β A.map) (i : X) : | |
| ContDiffOn β β (A.kernelParameterization i) (A.baseSet i ΓΛ’ univ) := by | |
| intro p hp | |
| have hc := (ContinuousLinearMap.restrictScalarsL β (KernelModel V W) V β β).contDiff.contDiffAt.comp p.1 | |
| (A.fromModel_contDiffAt hA i p.1 hp.1) | |
| exact ((hc.comp p contDiffAt_fst).clm_apply contDiffAt_snd).contDiffWithinAt | |
| variable [FiniteDimensional β X] | |
| omit [FiniteDimensional β V] in | |
| theorem exists_countable_baseSet_cover : | |
| β c : Set X, c.Countable β§ β x : X, β i β c, x β A.baseSet i := by | |
| have hc : (univ : Set X) β β i, A.baseSet i := by | |
| intro x _ | |
| exact mem_iUnion.mpr β¨x,A.center_mem xβ© | |
| obtain β¨c,hc,hcovβ© := isLindelof_univ.elim_countable_subcover A.baseSet A.baseSet_open hc | |
| exact β¨c,hc,fun x => by simpa only [Set.mem_iUnion,exists_prop] using hcov (mem_univ x)β© | |
| /-- The image of the ACTUAL kernel incidence subset is null. The proof uses a | |
| countable cover of the constructed kernel charts, not a null-image premise. -/ | |
| theorem kernel_incidence_image_null [MeasurableSpace V] [BorelSpace V] | |
| (hA : ContDiff β β A.map) | |
| (hd : finrank β (X Γ KernelModel V W)<finrank β V) : | |
| ΞΌH[finrank β V] {v : V | β x, A.map x v=0}=0 := by | |
| obtain β¨c,hc,hcovβ© := A.exists_countable_baseSet_cover | |
| let := hc.toEncodable | |
| have hi (i : c) : ΞΌH[finrank β V] | |
| (A.kernelParameterization i.val '' (A.baseSet i.val ΓΛ’ univ))=0 := | |
| Kaplansky.Incidence.smoothOn_open_image_null ((A.baseSet_open i.val).prod isOpen_univ) | |
| ((A.kernelParameterization_smooth hA i.val).of_le (by simp)) hd | |
| apply measure_mono_null (t := β i : c, A.kernelParameterization i.val '' (A.baseSet i.val ΓΛ’ univ)) | |
| ?_ (measure_iUnion_null hi) | |
| rintro v β¨x,hxβ© | |
| obtain β¨i,hi,hxiβ© := hcov x | |
| apply mem_iUnion.mpr | |
| refine β¨β¨i,hiβ©,(x,A.toModel i v),β¨hxi,mem_univ _β©,?_β© | |
| exact A.fromModel_toModel i x hxi v hx | |
| /-- A parameter outside every actual kernel exists under the dimension gap. -/ | |
| theorem exists_avoiding_kernels (hA : ContDiff β β A.map) | |
| (hd : finrank β (X Γ KernelModel V W)<finrank β V) : | |
| β v : V, β x, A.map x v β 0 := by | |
| borelize V | |
| have hn := A.kernel_incidence_image_null hA hd | |
| by_contra h | |
| push Not at h | |
| have he : {v : V | β x, A.map x v=0}=univ := Set.eq_univ_of_forall h | |
| rw [he] at hn | |
| have hp : 0<ΞΌH[finrank β V] (univ : Set V) := isOpen_univ.measure_pos _ Set.univ_nonempty | |
| exact (ne_of_gt hp) hn | |
| end Kaplansky.SmoothKernel.SurjectiveFamily | |
| end | |
| section | |
| open scoped ContDiff MeasureTheory | |
| open Module MeasureTheory MeasureTheory.Measure | |
| namespace Kaplansky.Incidence | |
| open ComplexGrassmann SmoothKernel | |
| variable {s k t l q h : β} | |
| variable {Y V : Type*} [NormedAddCommGroup Y] [NormedSpace β Y] [FiniteDimensional β Y] | |
| [NormedAddCommGroup V] [NormedSpace β V] [FiniteDimensional β V] | |
| variable (ev : Y β V βL[β] TupleAmbient q s k t l) | |
| omit [NormedSpace β Y] [FiniteDimensional β Y] in | |
| theorem evaluation_target_rank_le (hs : β y, Function.Surjective (ev y)) : | |
| q*s*l β€ finrank β V := by | |
| let A := graphEvaluation ev (0,(0,0)) | |
| have ha : Function.Surjective A := | |
| (tupleGraphRestriction_surjective 0 0).comp (hs 0) | |
| have hr := A.toLinearMap.finrank_range_add_finrank_ker | |
| rw [LinearMap.range_eq_top.mpr ha,finrank_top,tupleTarget_finrank] at hr | |
| omega | |
| theorem graph_incidence_dimension_gap (hs : β y, Function.Surjective (ev y)) | |
| (hY : finrank β Y=2*h) (hgap : h+s*k+t*l<q*s*l) : | |
| finrank β ((Y Γ (GraphSlope s k Γ GraphSlope t l)) Γ KernelModel V (TupleTarget q s l))< | |
| finrank β V := by | |
| rw [incidence_model_finrank,hY,finrank_real_of_complex] | |
| have hm := evaluation_target_rank_le ev hs | |
| simp only [Nat.mul_assoc] at * | |
| omega | |
| /-- On one pair of Grassmann graph charts, the actual bad-parameter locus is | |
| null under exactly the incidence dimension gap. -/ | |
| theorem graph_incidence_image_null [MeasurableSpace V] [BorelSpace V] | |
| (he : ContDiff β β ev) (hs : β y, Function.Surjective (ev y)) | |
| (hY : finrank β Y=2*h) (hgap : h+s*k+t*l<q*s*l) : | |
| ΞΌH[finrank β V] {v : V | β (y : Y) (a : GraphSlope s k) (b : GraphSlope t l), β i, β x β a.toLinearMap.graph, | |
| ev y v i x β b.toLinearMap.graph}=0 := by | |
| have hn := (graphFamily ev he hs).kernel_incidence_image_null | |
| (graphEvaluation_smooth ev he) (graph_incidence_dimension_gap ev hs hY hgap) | |
| have heq : {v : V | β p, (graphFamily ev he hs).map p v=0}= | |
| {v : V | β (y : Y) (a : GraphSlope s k) (b : GraphSlope t l), β i, β x β a.toLinearMap.graph, ev y v i x β b.toLinearMap.graph} := by | |
| ext v | |
| simp only [Set.mem_ofPred_eq,graphFamily,graphEvaluation_zero_iff,Prod.exists] | |
| rw [heq] at hn | |
| exact hn | |
| /-- A tuple is constructed outside all incidence kernels in these charts; | |
| it is not supplied as a premise. Full Grassmann coverage is a separate step. -/ | |
| theorem exists_avoiding_graph_incidence (he : ContDiff β β ev) | |
| (hs : β y, Function.Surjective (ev y)) (hY : finrank β Y=2*h) | |
| (hgap : h+s*k+t*l<q*s*l) : | |
| β v : V, β y (a : GraphSlope s k) (b : GraphSlope t l), | |
| Β¬ β i, β x β a.toLinearMap.graph, ev y v i x β b.toLinearMap.graph := by | |
| obtain β¨v,hvβ© := (graphFamily ev he hs).exists_avoiding_kernels | |
| (graphEvaluation_smooth ev he) (graph_incidence_dimension_gap ev hs hY hgap) | |
| refine β¨v,fun y a b hh => ?_β© | |
| exact hv (y,(a,b)) ((graphEvaluation_zero_iff ev (y,(a,b)) v).mpr hh) | |
| end Kaplansky.Incidence | |
| end | |
| open scoped ContDiff MeasureTheory | |
| open Module MeasureTheory MeasureTheory.Measure | |
| namespace Kaplansky.Incidence | |
| open ComplexGrassmann | |
| variable {s k t l q : β} | |
| abbrev TupleOperators (q s k t l : β) := Fin q β Components s k βL[β] Components t l | |
| def frameEvaluationLinear (F : GraphFrame s k) (G : GraphFrame t l) : | |
| TupleOperators q s k t l ββ[β] TupleAmbient q s k t l where | |
| toFun T i := G.toContinuousLinearEquiv.toContinuousLinearMap.comp | |
| ((T i).comp F.symm.toContinuousLinearEquiv.toContinuousLinearMap) | |
| map_add' T U := by | |
| funext i | |
| apply ContinuousLinearMap.ext | |
| intro x | |
| change G (T i (F.symm x)+U i (F.symm x))=G (T i (F.symm x))+G (U i (F.symm x)) | |
| exact G.map_add _ _ | |
| map_smul' c T := by | |
| funext i | |
| apply ContinuousLinearMap.ext | |
| intro x | |
| change G (c β’ T i (F.symm x))=c β’ G (T i (F.symm x)) | |
| exact G.map_smul c _ | |
| def frameEvaluation (F : GraphFrame s k) (G : GraphFrame t l) : | |
| TupleOperators q s k t l βL[β] TupleAmbient q s k t l := | |
| (frameEvaluationLinear F G).toContinuousLinearMap | |
| @[simp] theorem frameEvaluation_apply (F : GraphFrame s k) (G : GraphFrame t l) | |
| (T : TupleOperators q s k t l) (i : Fin q) (x : GraphAmbient s k) : | |
| frameEvaluation F G T i x=G (T i (F.symm x)) := rfl | |
| theorem frameEvaluation_surjective (F : GraphFrame s k) (G : GraphFrame t l) : | |
| Function.Surjective (frameEvaluation (q := q) F G) := by | |
| intro C | |
| refine β¨fun i => G.symm.toContinuousLinearEquiv.toContinuousLinearMap.comp | |
| ((C i).comp F.toContinuousLinearEquiv.toContinuousLinearMap),?_β© | |
| funext i | |
| apply ContinuousLinearMap.ext | |
| intro x | |
| change G (G.symm (C i (F (F.symm x))))=C i x | |
| simp | |
| theorem frame_incidence_iff (F : GraphFrame s k) (G : GraphFrame t l) | |
| (T : TupleOperators q s k t l) (a : GraphSlope s k) (b : GraphSlope t l) : | |
| (β i, β x β graphPlane F a.toLinearMap, T i x β graphPlane G b.toLinearMap) β | |
| β i, β x β a.toLinearMap.graph, frameEvaluation F G T i x β b.toLinearMap.graph := by | |
| constructor | |
| Β· intro h i x hx | |
| have hi : F.symm x β graphPlane F a.toLinearMap := by simpa using hx | |
| exact h i (F.symm x) hi | |
| Β· intro h i x hx | |
| have hi : F x β a.toLinearMap.graph := hx | |
| have hh := h i (F x) hi | |
| change G (T i x) β b.toLinearMap.graph | |
| simpa only [frameEvaluation_apply,LinearEquiv.symm_apply_apply] using hh | |
| def ChartBad (F : GraphFrame s k) (G : GraphFrame t l) : Set (TupleOperators q s k t l) := | |
| {T | β (a : GraphSlope s k) (b : GraphSlope t l), | |
| β i, β x β graphPlane F a.toLinearMap, T i x β graphPlane G b.toLinearMap} | |
| /-- The actual bad tuples in any pair of graph charts form a null set over a | |
| point; no restriction is placed on the positions of the two charts. -/ | |
| theorem chartBad_null (F : GraphFrame s k) (G : GraphFrame t l) | |
| [MeasurableSpace (TupleOperators q s k t l)] [BorelSpace (TupleOperators q s k t l)] | |
| (hgap : s*k+t*l<q*s*l) : ΞΌH[finrank β (TupleOperators q s k t l)] (ChartBad (q := q) F G)=0 := by | |
| let ev : (Fin 0 β β) β TupleOperators q s k t l βL[β] TupleAmbient q s k t l := | |
| fun _ => frameEvaluation F G | |
| have hn := graph_incidence_image_null (h := 0) ev contDiff_const | |
| (fun _ => frameEvaluation_surjective F G) (by simp) (by simpa using hgap) | |
| have he : {T : TupleOperators q s k t l | β (y : Fin 0 β β) | |
| (a : GraphSlope s k) (b : GraphSlope t l), β i, β x β a.toLinearMap.graph, | |
| ev y T i x β b.toLinearMap.graph}=ChartBad F G := by | |
| ext T | |
| constructor | |
| Β· rintro β¨_,a,b,habβ© | |
| exact β¨a,b,(frame_incidence_iff F G T a b).mpr habβ© | |
| Β· rintro β¨a,b,habβ© | |
| exact β¨0,a,b,(frame_incidence_iff F G T a b).mp habβ© | |
| rw [he] at hn | |
| exact hn | |
| end Kaplansky.Incidence | |
| end | |
| end OAI | |