math / data /lean /OAI /Geometry /ComplexBundle /Incidence.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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