Download data/lean/OAI/Geometry/ComplexBundle/OpenIncidence.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/OpenIncidence.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/OpenIncidence.lean
-
curl -L -o OpenIncidence.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/OpenIncidence.lean
12.4 kB
| import OAI.Geometry.ComplexBundle.PointExpansion | |
| namespace OAI | |
| noncomputable section | |
| /-! Openness of kernel, graph, frame, and rank incidence conditions. -/ | |
| section | |
| open scoped ContDiff Topology MeasureTheory | |
| open Set MeasureTheory MeasureTheory.Measure Module | |
| namespace Kaplansky.SmoothKernel | |
| variable {X V W : Type*} | |
| [NormedAddCommGroup X] [NormedSpace β X] [FiniteDimensional β X] | |
| [NormedAddCommGroup V] [NormedSpace β V] [FiniteDimensional β V] | |
| [NormedAddCommGroup W] [NormedSpace β W] [FiniteDimensional β W] | |
| local instance : CompleteSpace W := FiniteDimensional.complete β W | |
| /-- Nullity for a surjective family defined smoothly only on an open domain. | |
| Values outside that domain need not be smooth, continuous or surjective. -/ | |
| theorem open_kernel_incidence_image_null [MeasurableSpace V] [BorelSpace V] | |
| (a : X β V βL[β] W) (U : Set X) (hU : IsOpen U) | |
| (ha : ContDiffOn β β a U) (hs : β x β U, Function.Surjective (a x)) | |
| (hd : finrank β (X Γ KernelModel V W)<finrank β V) : | |
| ΞΌH[finrank β V] {v : V | β x β U, a x v=0}=0 := by | |
| let A : SurjectiveFamily U V W := β¨fun x => a x,ha.continuousOn.domRestrict,fun x => hs x x.propertyβ© | |
| let D (i : U) : Set X := U β© a β»ΒΉ' splitDomain (A.rightInverse i) | |
| have hD : β i, IsOpen (D i) := fun i => | |
| ha.continuousOn.isOpen_inter_preimage hU (splitDomain_open (A.rightInverse i)) | |
| have hcov : U β β i, D i := by | |
| intro x hx | |
| exact mem_iUnion.mpr β¨β¨x,hxβ©,hx,A.center_mem β¨x,hxβ©β© | |
| obtain β¨c,hc,hcovβ© := (HereditarilyLindelofSpace.isLindelof U).elim_countable_subcover D hD hcov | |
| let := hc.toEncodable | |
| let f (i : U) (p : X Γ KernelModel V W) : V := | |
| kernelProjection (A.rightInverse i) (a p.1) | |
| (((LinearMap.ker (A.map i).toLinearMap).subtypeL).comp | |
| (A.modelEquiv i).toContinuousLinearMap p.2) | |
| have hf (i : U) : ContDiffOn β β (f i) (D i ΓΛ’ univ) := by | |
| intro p hp | |
| have hk := ((kernelProjection_smooth (A.rightInverse i) (a p.1) hp.1.2).restrict_scalars β).comp p.1 | |
| ((ha p.1 hp.1.1).contDiffAt (hU.mem_nhds hp.1.1)) | |
| have hc := ((ContinuousLinearMap.restrictScalarsL β V V β β).contDiff.contDiffAt.comp p.1 hk).comp p contDiffAt_fst | |
| have hz : ContDiffAt β β (fun p : X Γ KernelModel V W => | |
| (((LinearMap.ker (A.map i).toLinearMap).subtypeL).comp | |
| (A.modelEquiv i).toContinuousLinearMap) p.2) p := | |
| ((((LinearMap.ker (A.map i).toLinearMap).subtypeL).comp | |
| (A.modelEquiv i).toContinuousLinearMap).restrictScalars β).contDiff.contDiffAt.comp p contDiffAt_snd | |
| exact (hc.clm_apply hz).contDiffWithinAt | |
| have hn (i : c) : ΞΌH[finrank β V] (f i.val '' (D i.val ΓΛ’ univ))=0 := | |
| Kaplansky.Incidence.smoothOn_open_image_null ((hD i.val).prod isOpen_univ) | |
| ((hf i.val).of_le (by simp)) hd | |
| apply measure_mono_null (t := β i : c, f i.val '' (D i.val ΓΛ’ univ)) ?_ | |
| (measure_iUnion_null hn) | |
| rintro v β¨x,hx,hvβ© | |
| obtain β¨i,hi,hxiβ© : β i β c, x β D i := by | |
| simpa only [mem_iUnion,exists_prop] using hcov hx | |
| refine mem_iUnion.mpr β¨β¨i,hiβ©,(x,A.toModel i v),β¨hxi,mem_univ _β©,?_β© | |
| exact A.fromModel_toModel i β¨x,hxβ© hxi.2 v hv | |
| end Kaplansky.SmoothKernel | |
| end | |
| section | |
| open scoped ContDiff MeasureTheory | |
| open Module Set MeasureTheory MeasureTheory.Measure | |
| namespace Kaplansky.Incidence | |
| open ComplexGrassmann SmoothKernel | |
| variable {s k t l q : β} | |
| 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) (U : Set Y) | |
| omit [FiniteDimensional β Y] [FiniteDimensional β V] in | |
| theorem graphEvaluation_smoothOn (hU : IsOpen U) (he : ContDiffOn β β ev U) : | |
| ContDiffOn β β (graphEvaluation ev) (U ΓΛ’ univ) := by | |
| intro p hp | |
| have hc : ContDiff β β (fun z : | |
| (TupleAmbient q s k t l βL[β] TupleTarget q s l) Γ (V βL[β] TupleAmbient q s k t l) => | |
| z.1.comp z.2) := contDiff_fst.clm_comp contDiff_snd | |
| have h1 := ((tupleGraphRestriction_smooth (q := q) (s := s) (k := k) (t := t) (l := l)).restrict_scalars β).contDiffAt.comp p contDiffAt_snd | |
| have h2 := ((he p.1 hp.1).contDiffAt (hU.mem_nhds hp.1)).comp p contDiffAt_fst | |
| exact ((hc.restrict_scalars β).contDiffAt.comp p (h1.prodMk h2)).contDiffWithinAt | |
| /-- Actual graph incidence over an open base chart is null under the real | |
| dimension gap; no extension of its evaluation map off the chart is assumed. -/ | |
| theorem open_graph_incidence_image_null [MeasurableSpace V] [BorelSpace V] | |
| (hU : IsOpen U) (he : ContDiffOn β β ev U) | |
| (hs : β y β U, Function.Surjective (ev y)) | |
| (hgap : finrank β Y+2*s*k+2*t*l<2*q*s*l) : | |
| ΞΌH[finrank β V] {v : V | β y β U, β (a : GraphSlope s k) (b : GraphSlope t l), | |
| β i, β x β a.toLinearMap.graph, ev y v i x β b.toLinearMap.graph}=0 := by | |
| by_cases hu : U.Nonempty | |
| Β· obtain β¨y,hyβ© := hu | |
| have hsur : β p β U ΓΛ’ (univ : Set (GraphSlope s k Γ GraphSlope t l)), | |
| Function.Surjective (graphEvaluation ev p) := fun p hp => | |
| (tupleGraphRestriction_surjective p.2.1 p.2.2).comp (hs p.1 hp.1) | |
| have hr := (graphEvaluation ev (y,(0,0))).toLinearMap.finrank_range_add_finrank_ker | |
| rw [LinearMap.range_eq_top.mpr (hsur _ β¨hy,mem_univ _β©),finrank_top,tupleTarget_finrank] at hr | |
| have hd : finrank β ((Y Γ (GraphSlope s k Γ GraphSlope t l)) Γ KernelModel V (TupleTarget q s l)) < finrank β V := by | |
| rw [incidence_model_finrank,finrank_real_of_complex] | |
| simp only [Nat.mul_assoc] at * | |
| omega | |
| have hn := open_kernel_incidence_image_null (graphEvaluation ev) (U ΓΛ’ univ) | |
| (hU.prod isOpen_univ) (graphEvaluation_smoothOn ev U hU he) hsur hd | |
| have heq : {v : V | β p β U ΓΛ’ (univ : Set (GraphSlope s k Γ GraphSlope t l)), graphEvaluation ev p v=0} = | |
| {v : V | β y β U, β (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 [mem_ofPred_eq,Prod.exists,mem_prod,mem_univ,and_true,graphEvaluation_zero_iff] | |
| constructor | |
| Β· rintro β¨y,a,b,hy,hβ©; exact β¨y,hy,a,b,hβ© | |
| Β· rintro β¨y,hy,a,b,hβ©; exact β¨y,a,b,hy,hβ© | |
| rw [heq] at hn | |
| exact hn | |
| Β· have hempty : U=β := Set.not_nonempty_iff_eq_empty.mp hu | |
| simp [hempty] | |
| end Kaplansky.Incidence | |
| end | |
| section | |
| open scoped ContDiff MeasureTheory | |
| open Set Module MeasureTheory MeasureTheory.Measure | |
| namespace Kaplansky.Incidence | |
| open ComplexGrassmann | |
| variable {q s k t l : β} | |
| variable {Y V : Type*} [NormedAddCommGroup Y] [NormedSpace β Y] [FiniteDimensional β Y] | |
| [NormedAddCommGroup V] [NormedSpace β V] [FiniteDimensional β V] | |
| variable (ev : Y β V βL[β] TupleOperators q s k t l) (U : Set Y) | |
| def OpenFrameBad : Set V := | |
| {v | β y β U, β (P : Grassmann s k) (Q : Grassmann t l), | |
| β i, β x β P.val, ev y v i x β Q.val} | |
| theorem openFrameBad_null [MeasurableSpace V] [BorelSpace V] | |
| (hU : IsOpen U) (he : ContDiffOn β β ev U) | |
| (hs : β y β U, Function.Surjective (ev y)) | |
| (hgap : finrank β Y+2*s*k+2*t*l<2*q*s*l) : | |
| ΞΌH[finrank β V] (OpenFrameBad ev U)=0 := by | |
| obtain β¨c,hc,hcoverβ© := exists_countable_graph_cover (s := s) (k := k) | |
| obtain β¨d,hd,hcover'β© := exists_countable_graph_cover (s := t) (k := l) | |
| let := hc.toEncodable | |
| let := hd.toEncodable | |
| let bad (i : c Γ d) : Set V := {v | β y β U, β (a : GraphSlope s k) (b : GraphSlope t l), | |
| β j, β x β a.toLinearMap.graph, | |
| frameEvaluation i.1.val i.2.val (ev y v) j x β b.toLinearMap.graph} | |
| have hn (i : c Γ d) : ΞΌH[finrank β V] (bad i)=0 := by | |
| let ef : Y β V βL[β] TupleAmbient q s k t l := fun y => | |
| (frameEvaluation i.1.val i.2.val).comp (ev y) | |
| have hf : ContDiffOn β β ef U := by | |
| have hh : ContDiff β β (fun L : V βL[β] TupleOperators q s k t l => | |
| (frameEvaluation i.1.val i.2.val).comp L) := contDiff_const.clm_comp contDiff_id | |
| exact (hh.restrict_scalars β).comp_contDiffOn he | |
| exact open_graph_incidence_image_null ef U hU hf | |
| (fun y hy => (frameEvaluation_surjective i.1.val i.2.val).comp (hs y hy)) hgap | |
| apply measure_mono_null (t := β i : c Γ d, bad i) ?_ (measure_iUnion_null hn) | |
| rintro v β¨y,hy,P,Q,hPQβ© | |
| obtain β¨F,hFc,hFβ© := hcover P | |
| obtain β¨G,hGd,hGβ© := hcover' Q | |
| refine mem_iUnion.mpr β¨(β¨F,hFcβ©,β¨G,hGdβ©),y,hy,slopeCoordinate F P,slopeCoordinate G Q,?_β© | |
| apply (frame_incidence_iff F G (ev y v) _ _).mp | |
| have hp : graphPlane F (slopeCoordinate F P).toLinearMap=P.val := | |
| congrArg Subtype.val (slopePoint_coordinate F P hF) | |
| have hq : graphPlane G (slopeCoordinate G Q).toLinearMap=Q.val := | |
| congrArg Subtype.val (slopePoint_coordinate G Q hG) | |
| rw [hp,hq] | |
| exact hPQ | |
| end Kaplansky.Incidence | |
| end | |
| open scoped ContDiff MeasureTheory | |
| open Set Module MeasureTheory MeasureTheory.Measure | |
| namespace Kaplansky.Incidence | |
| variable {q d r : β} | |
| variable {Y V : Type*} [NormedAddCommGroup Y] [NormedSpace β Y] [FiniteDimensional β Y] | |
| [NormedAddCommGroup V] [NormedSpace β V] [FiniteDimensional β V] | |
| def OpenRankBad (ev : Y β V βL[β] MatrixTuple q d r) (U : Set Y) (s t : β) : Set V := | |
| {v | β y β U, ev y v β RankBad s t} | |
| theorem openRankBad_null [MeasurableSpace V] [BorelSpace V] | |
| (ev : Y β V βL[β] MatrixTuple q d r) (U : Set Y) | |
| (hU : IsOpen U) (he : ContDiffOn β β ev U) | |
| (hs : β y β U, Function.Surjective (ev y)) {s t : β} | |
| (hsd : sβ€d) (htr : tβ€r) | |
| (hgap : finrank β Y+2*s*(d-s)+2*t*(r-t)<2*q*s*(r-t)) : | |
| ΞΌH[finrank β V] (OpenRankBad ev U s t)=0 := by | |
| obtain β¨k,rflβ© := Nat.exists_eq_add_of_le hsd | |
| obtain β¨l,rflβ© := Nat.exists_eq_add_of_le htr | |
| have heq : OpenRankBad ev U s t=OpenFrameBad ev U := by | |
| ext v | |
| constructor | |
| Β· rintro β¨y,hy,S,hS,T,hT,hβ© | |
| exact β¨y,hy,β¨S,hSβ©,β¨T,hTβ©,hβ© | |
| Β· rintro β¨y,hy,β¨S,hSβ©,β¨T,hTβ©,hβ© | |
| exact β¨y,hy,S,hS,T,hT,hβ© | |
| rw [heq] | |
| exact openFrameBad_null ev U hU he hs (by simpa using hgap) | |
| /-- A single parameter avoids every forbidden rank pair on every chart of a | |
| countable family. The maps, kernels, graph coverage and nullity are actual; | |
| only the smooth surjective coordinate evaluation data enter as hypotheses. -/ | |
| theorem exists_countable_chart_incidence_parameter {ΞΉ : Type*} [Countable ΞΉ] | |
| (ev : ΞΉ β Y β V βL[β] MatrixTuple q d r) (U : ΞΉ β Set Y) | |
| (hU : β j, IsOpen (U j)) (he : β j, ContDiffOn β β (ev j) (U j)) | |
| (hs : β j y, y β U j β Function.Surjective (ev j y)) | |
| (pairs : Finset (β Γ β)) | |
| (hpairs : β p β pairs, p.1β€d β§ p.2β€r β§ | |
| finrank β Y+2*p.1*(d-p.1)+2*p.2*(r-p.2)<2*q*p.1*(r-p.2)) : | |
| β v : V, β j y, y β U j β β p β pairs, β S : Submodule β (Fin d β β), | |
| finrank β S=p.1 β p.2<finrank β | |
| (β¨ i, S.map (ev j y v i).toLinearMap : Submodule β (Fin r β β)) := by | |
| borelize V | |
| have hn : ΞΌH[finrank β V] (β j, β p β pairs, OpenRankBad (ev j) (U j) p.1 p.2)=0 := | |
| measure_iUnion_null (fun j => measure_iUnion_null (fun p => measure_iUnion_null (fun hp => | |
| openRankBad_null (ev j) (U j) (hU j) (he j) (hs j) | |
| (hpairs p hp).1 (hpairs p hp).2.1 (hpairs p hp).2.2))) | |
| have hev : β v : V, v β β j, β p β pairs, OpenRankBad (ev j) (U j) p.1 p.2 := by | |
| by_contra h | |
| push Not at h | |
| have hu : (β j, β p β pairs, OpenRankBad (ev j) (U j) p.1 p.2)=univ := Set.eq_univ_of_forall h | |
| rw [hu] at hn | |
| exact (ne_of_gt (isOpen_univ.measure_pos (ΞΌH[finrank β V]) Set.univ_nonempty)) hn | |
| obtain β¨v,hvβ© := hev | |
| refine β¨v,fun j y hy p hp S hS => ?_β© | |
| by_contra h | |
| have hd : finrank β (β¨ i, S.map (ev j y v i).toLinearMap : Submodule β (Fin r β β))β€p.2 := by omega | |
| obtain β¨T,hWT,hTβ© := exists_super_finrank | |
| (β¨ i, S.map (ev j y v i).toLinearMap : Submodule β (Fin r β β)) hd | |
| (by simpa using (hpairs p hp).2.1) | |
| apply hv | |
| refine mem_iUnion.mpr β¨j,mem_iUnion.mpr β¨p,mem_iUnion.mpr β¨hp,y,hy,S,hS,T,hT,?_β©β©β© | |
| intro i x hx | |
| exact hWT ((le_iSup (fun i => S.map (ev j y v i).toLinearMap) i) | |
| (Submodule.mem_map.mpr β¨x,hx,rflβ©)) | |
| end Kaplansky.Incidence | |
| end | |
| end OAI | |