Download data/lean/OAI/Geometry/ComplexBundle/Incidence.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/Incidence.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBundle/Incidence.lean
-
curl -L -o Incidence.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBundle/Incidence.lean
12.4 kB
| import OAI.Geometry.ComplexBundle.GrassmannManifold | |
| import OAI.Geometry.ComplexBundle.Kernel | |
| namespace OAI | |
| noncomputable section | |
| /-! Linear incidence equations and their graph-coordinate kernel bundles. -/ | |
| section | |
| open Module | |
| namespace Kaplansky.Incidence | |
| variable {E F V : Type*} [AddCommGroup E] [Module β E] | |
| [AddCommGroup F] [Module β F] [AddCommGroup V] [Module β V] | |
| def restrictQuotient (S : Submodule β E) (U : Submodule β F) : | |
| (E ββ[β] F) ββ[β] (S ββ[β] F β§Έ U) where | |
| toFun T := U.mkQ.comp (T.comp S.subtype) | |
| map_add' _ _ := by ext; rfl | |
| map_smul' _ _ := by ext; rfl | |
| theorem restrictQuotient_surjective (S : Submodule β E) (U : Submodule β F) : | |
| Function.Surjective (restrictQuotient S U) := by | |
| obtain β¨C,hCβ© := S.exists_isCompl | |
| obtain β¨lift,hliftβ© := U.mkQ.exists_rightInverse_of_surjective | |
| (LinearMap.range_eq_top.mpr U.mkQ_surjective) | |
| intro T | |
| refine β¨lift.comp (T.comp (S.projectionOnto C hC)),?_β© | |
| ext x | |
| change U.mkQ (lift (T (S.projectionOnto C hC x.val)))=T x | |
| rw [Submodule.projectionOnto_apply_left] | |
| exact congrArg (fun L : (F β§Έ U) ββ[β] (F β§Έ U) => L (T x)) hlift | |
| /-- The q-fold evaluation/restriction/quotient map used by the incidence locus. -/ | |
| def tupleRestriction {q : β} (S : Submodule β E) (U : Submodule β F) | |
| (ev : V ββ[β] (Fin q β E ββ[β] F)) : | |
| V ββ[β] (Fin q β S ββ[β] F β§Έ U) where | |
| toFun v i := restrictQuotient S U (ev v i) | |
| map_add' _ _ := by ext; simp | |
| map_smul' _ _ := by ext; simp | |
| theorem tupleRestriction_surjective {q : β} (S : Submodule β E) (U : Submodule β F) | |
| (ev : V ββ[β] (Fin q β E ββ[β] F)) (hev : Function.Surjective ev) : | |
| Function.Surjective (tupleRestriction S U ev) := by | |
| intro T | |
| choose L hL using (fun i => restrictQuotient_surjective S U (T i)) | |
| obtain β¨v,hvβ© := hev L | |
| refine β¨v,?_β© | |
| funext i | |
| change restrictQuotient S U (ev v i)=T i | |
| rw [hv,hL] | |
| theorem mem_tupleRestriction_ker {q : β} (S : Submodule β E) (U : Submodule β F) | |
| (ev : V ββ[β] (Fin q β E ββ[β] F)) (v : V) : | |
| v β LinearMap.ker (tupleRestriction S U ev) β | |
| β i, β x β S, ev v i x β U := by | |
| change (fun i => U.mkQ.comp ((ev v i).comp S.subtype))=0 β _ | |
| constructor | |
| Β· intro h i x hx | |
| have he := congrArg (fun T : Fin q β S ββ[β] F β§Έ U => T i β¨x,hxβ©) h | |
| exact (Submodule.Quotient.mk_eq_zero U).mp he | |
| Β· intro h | |
| funext i | |
| apply LinearMap.ext | |
| intro x | |
| exact (Submodule.Quotient.mk_eq_zero U).mpr (h i x.val x.property) | |
| variable [FiniteDimensional β E] [FiniteDimensional β F] | |
| theorem incidence_target_finrank (q : β) (S : Submodule β E) (U : Submodule β F) : | |
| finrank β (Fin q β S ββ[β] F β§Έ U)= | |
| q * finrank β S * (finrank β F-finrank β U) := by | |
| have hU := U.finrank_quotient_add_finrank | |
| have hQ : finrank β (F β§Έ U)=finrank β F-finrank β U := by omega | |
| simp [Module.finrank_pi_fintype,Module.finrank_linearMap,hQ, Nat.mul_assoc] | |
| /-- Exact rank-nullity for the actual incidence fiber in the parameter space V. -/ | |
| theorem incidence_kernel_finrank [FiniteDimensional β V] {q : β} | |
| (S : Submodule β E) (U : Submodule β F) | |
| (ev : V ββ[β] (Fin q β E ββ[β] F)) (hev : Function.Surjective ev) : | |
| finrank β (LinearMap.ker (tupleRestriction S U ev))= | |
| finrank β V-q * finrank β S * (finrank β F-finrank β U) := by | |
| have h := (tupleRestriction S U ev).finrank_range_add_finrank_ker | |
| rw [LinearMap.range_eq_top.mpr (tupleRestriction_surjective S U ev hev), | |
| finrank_top, incidence_target_finrank] at h | |
| omega | |
| theorem incidence_kernel_real_finrank [FiniteDimensional β V] {q : β} | |
| (S : Submodule β E) (U : Submodule β F) | |
| (ev : V ββ[β] (Fin q β E ββ[β] F)) (hev : Function.Surjective ev) : | |
| finrank β (LinearMap.ker (tupleRestriction S U ev))= | |
| 2*(finrank β V-q * finrank β S * (finrank β F-finrank β U)) := by | |
| rw [finrank_real_of_complex,incidence_kernel_finrank S U ev hev] | |
| end Kaplansky.Incidence | |
| end | |
| section | |
| open scoped ContDiff | |
| namespace Kaplansky.Incidence | |
| variable {s k t l : β} | |
| open ComplexGrassmann | |
| /-- The quotient coordinate of a graph t-plane, (u,v) β¦ v-bu. -/ | |
| def graphQuotient (b : GraphSlope t l) : GraphAmbient t l βL[β] GraphVertical l := | |
| ContinuousLinearMap.snd β _ _ - b.comp (ContinuousLinearMap.fst β _ _) | |
| @[simp] theorem graphQuotient_apply (b : GraphSlope t l) (v : GraphAmbient t l) : | |
| graphQuotient b v=v.2-b v.1 := rfl | |
| theorem graphQuotient_zero_iff (b : GraphSlope t l) (v : GraphAmbient t l) : | |
| graphQuotient b v=0 β v β b.toLinearMap.graph := sub_eq_zero | |
| theorem graphQuotient_surjective (b : GraphSlope t l) : Function.Surjective (graphQuotient b) := by | |
| intro w | |
| exact β¨(0,w),by simpβ© | |
| def graphRestriction (a : GraphSlope s k) (b : GraphSlope t l) : | |
| (GraphAmbient s k βL[β] GraphAmbient t l) βL[β] | |
| (GraphHorizontal s βL[β] GraphVertical l) := | |
| ((ContinuousLinearMap.compL β (GraphHorizontal s) (GraphAmbient t l) (GraphVertical l)) | |
| (graphQuotient b)).comp | |
| ((ContinuousLinearMap.compL β (GraphHorizontal s) (GraphAmbient s k) (GraphAmbient t l)).flip | |
| (graphInclusion a)) | |
| @[simp] theorem graphRestriction_apply (a : GraphSlope s k) (b : GraphSlope t l) | |
| (T : GraphAmbient s k βL[β] GraphAmbient t l) (v : GraphHorizontal s) : | |
| graphRestriction a b T v=graphQuotient b (T (v,a v)) := by | |
| simp [graphRestriction] | |
| /-- The zero equation for these smooth coordinates is exactly preservation of | |
| S into U, with S and U the actual graph subspaces. -/ | |
| theorem graphRestriction_zero_iff (a : GraphSlope s k) (b : GraphSlope t l) | |
| (T : GraphAmbient s k βL[β] GraphAmbient t l) : | |
| graphRestriction a b T=0 β β v β a.toLinearMap.graph, T v β b.toLinearMap.graph := by | |
| constructor | |
| Β· intro h v hv | |
| have he := congrArg (fun Q : GraphHorizontal s βL[β] GraphVertical l => Q v.1) h | |
| have hv' : v.2=a v.1 := hv | |
| have hvv : (v.1,a v.1)=v := Prod.ext rfl hv'.symm | |
| rw [graphRestriction_apply,hvv] at he | |
| exact (graphQuotient_zero_iff b (T v)).mp he | |
| Β· intro h | |
| apply ContinuousLinearMap.ext | |
| intro v | |
| simpa only [graphRestriction_apply,zero_apply] using | |
| (graphQuotient_zero_iff b (T (v,a v))).mpr (h _ rfl) | |
| /-- A concrete right inverse: place the requested quotient map in the lower | |
| left block and set all other blocks to zero. -/ | |
| theorem graphRestriction_surjective (a : GraphSlope s k) (b : GraphSlope t l) : | |
| Function.Surjective (graphRestriction a b) := by | |
| intro C | |
| refine β¨(ContinuousLinearMap.inr β _ _).comp | |
| (C.comp (ContinuousLinearMap.fst β _ _)),?_β© | |
| ext v | |
| simp [graphRestriction_apply] | |
| theorem graphQuotient_smooth : ContDiff β β (graphQuotient (t := t) (l := l)) := | |
| contDiff_const.sub (contDiff_id.clm_comp contDiff_const) | |
| theorem graphInclusion_smooth : ContDiff β β (graphInclusion (s := s) (k := k)) := | |
| contDiff_const.add (contDiff_const.clm_comp contDiff_id) | |
| theorem graphRestriction_smooth : ContDiff β β | |
| (fun p : GraphSlope s k Γ GraphSlope t l => graphRestriction p.1 p.2) := by | |
| have hq : ContDiff β β (fun p : GraphSlope s k Γ GraphSlope t l => graphQuotient p.2) := | |
| graphQuotient_smooth.comp contDiff_snd | |
| have hi : ContDiff β β (fun p : GraphSlope s k Γ GraphSlope t l => graphInclusion p.1) := | |
| graphInclusion_smooth.comp contDiff_fst | |
| exact (((ContinuousLinearMap.compL β (GraphHorizontal s) (GraphAmbient t l) | |
| (GraphVertical l)).contDiff.comp hq)).clm_comp | |
| (((ContinuousLinearMap.compL β (GraphHorizontal s) (GraphAmbient s k) | |
| (GraphAmbient t l)).flip.contDiff).comp hi) | |
| theorem graphRestriction_smooth_real : ContDiff β β | |
| (fun p : GraphSlope s k Γ GraphSlope t l => graphRestriction p.1 p.2) := | |
| (graphRestriction_smooth (s := s) (k := k) (t := t) (l := l)).restrict_scalars β | |
| end Kaplansky.Incidence | |
| end | |
| open scoped ContDiff Manifold | |
| namespace Kaplansky.Incidence | |
| open ComplexGrassmann SmoothKernel | |
| variable {s k t l q : β} | |
| abbrev TupleAmbient (q s k t l : β) := | |
| Fin q β GraphAmbient s k βL[β] GraphAmbient t l | |
| abbrev TupleTarget (q s l : β) := Fin q β GraphHorizontal s βL[β] GraphVertical l | |
| def tupleGraphRestriction (a : GraphSlope s k) (b : GraphSlope t l) : | |
| TupleAmbient q s k t l βL[β] TupleTarget q s l := | |
| ContinuousLinearMap.pi (fun i => (graphRestriction a b).comp (ContinuousLinearMap.proj i)) | |
| theorem tupleGraphRestriction_surjective (a : GraphSlope s k) (b : GraphSlope t l) : | |
| Function.Surjective (tupleGraphRestriction (q := q) a b) := by | |
| intro C | |
| choose T hT using fun i => graphRestriction_surjective a b (C i) | |
| exact β¨T,funext hTβ© | |
| theorem tupleGraphRestriction_smooth : ContDiff β β | |
| (fun p : GraphSlope s k Γ GraphSlope t l => tupleGraphRestriction (q := q) p.1 p.2) := by | |
| apply contDiff_clm_apply_iff.mpr | |
| intro T | |
| apply contDiff_pi.mpr | |
| intro i | |
| exact graphRestriction_smooth.clm_apply contDiff_const | |
| theorem tupleTarget_finrank : Module.finrank β (TupleTarget q s l)=q*s*l := by | |
| have h : Module.finrank β (GraphHorizontal s βL[β] GraphVertical l)=s*l := | |
| graph_slope_complex_finrank | |
| simp [TupleTarget,Module.finrank_pi_fintype,h,Nat.mul_assoc] | |
| variable {Y V : Type*} [NormedAddCommGroup Y] [NormedSpace β Y] | |
| [NormedAddCommGroup V] [NormedSpace β V] | |
| variable (ev : Y β V βL[β] TupleAmbient q s k t l) | |
| /-- The actual linear family whose zero set is the local incidence locus. -/ | |
| def graphEvaluation (p : Y Γ (GraphSlope s k Γ GraphSlope t l)) : V βL[β] TupleTarget q s l := | |
| (tupleGraphRestriction p.2.1 p.2.2).comp (ev p.1) | |
| theorem graphEvaluation_smooth (he : ContDiff β β ev) : ContDiff β β (graphEvaluation ev) := by | |
| have hc : ContDiff β β (fun p : | |
| (TupleAmbient q s k t l βL[β] TupleTarget q s l) Γ (V βL[β] TupleAmbient q s k t l) => | |
| p.1.comp p.2) := contDiff_fst.clm_comp contDiff_snd | |
| exact (hc.restrict_scalars β).comp | |
| (((tupleGraphRestriction_smooth (q := q) (s := s) (k := k) (t := t) (l := l)).restrict_scalars β).comp | |
| contDiff_snd |>.prodMk (he.comp contDiff_fst)) | |
| def graphFamily (he : ContDiff β β ev) (hs : β y, Function.Surjective (ev y)) : | |
| SurjectiveFamily (Y Γ (GraphSlope s k Γ GraphSlope t l)) V (TupleTarget q s l) where | |
| map := graphEvaluation ev | |
| continuous := (graphEvaluation_smooth ev he).continuous | |
| surjective p := (tupleGraphRestriction_surjective p.2.1 p.2.2).comp (hs p.1) | |
| omit [NormedAddCommGroup Y] [NormedSpace β Y] in | |
| theorem graphEvaluation_zero_iff (p : Y Γ (GraphSlope s k Γ GraphSlope t l)) (v : V) : | |
| graphEvaluation ev p v=0 β β i, β x β p.2.1.toLinearMap.graph, | |
| ev p.1 v i x β p.2.2.toLinearMap.graph := by | |
| constructor | |
| Β· intro h i | |
| have hi := congrArg (fun T : TupleTarget q s l => T i) h | |
| exact (graphRestriction_zero_iff p.2.1 p.2.2 (ev p.1 v i)).mp hi | |
| Β· intro h | |
| funext i | |
| exact (graphRestriction_zero_iff p.2.1 p.2.2 (ev p.1 v i)).mpr (h i) | |
| variable [FiniteDimensional β V] | |
| theorem graph_kernel_finrank (he : ContDiff β β ev) (hs : β y, Function.Surjective (ev y)) | |
| (p : Y Γ (GraphSlope s k Γ GraphSlope t l)) : | |
| Module.finrank β (LinearMap.ker (graphEvaluation ev p).toLinearMap)= | |
| Module.finrank β V-q*s*l := by | |
| have h := (graphFamily ev he hs).kernel_finrank p | |
| change Module.finrank β (LinearMap.ker (graphEvaluation ev p).toLinearMap) = | |
| Module.finrank β V - Module.finrank β (TupleTarget q s l) at h | |
| rw [tupleTarget_finrank] at h | |
| exact h | |
| theorem graph_kernel_bundle_smooth (he : ContDiff β β ev) (hs : β y, Function.Surjective (ev y)) : | |
| (graphFamily ev he hs).realCore.IsContMDiff | |
| π(β,Y Γ (GraphSlope s k Γ GraphSlope t l)) β := | |
| (graphFamily ev he hs).realCore_isContMDiff (graphEvaluation_smooth ev he) | |
| omit [FiniteDimensional β V] in | |
| theorem incidence_model_finrank [FiniteDimensional β Y] : Module.finrank β | |
| ((Y Γ (GraphSlope s k Γ GraphSlope t l)) Γ KernelModel V (TupleTarget q s l))= | |
| Module.finrank β Y+2*s*k+2*t*l+2*(Module.finrank β V-q*s*l) := by | |
| simp only [Module.finrank_prod,graph_slope_real_finrank, | |
| SurjectiveFamily.kernel_model_real_finrank,tupleTarget_finrank] | |
| omega | |
| end Kaplansky.Incidence | |
| end | |
| end OAI | |