File size: 15,746 Bytes
4a56cd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 | import OAI.AlgebraicGeometry.HodgeConjecture.GeometricFour
import OAI.AlgebraicGeometry.HodgeConjecture.CMReduction.ComplexOperations
import OAI.AlgebraicGeometry.HodgeConjecture.CMReduction.CupAppend
import OAI.AlgebraicGeometry.HodgeConjecture.CMReduction.CupPermutation
import OAI.AlgebraicGeometry.HodgeConjecture.CMReduction.CanonicalExterior
import OAI.AlgebraicGeometry.ComplexMultiplication.RealizedHodgeMaps
import OAI.AlgebraicTopology.Kunneth.CupPullbackSingular
/-! # Geometric Operations -/
namespace OAI.AlgebraicGeometry.HodgeConjecture.GeometricOperations.LefschetzNormalization.Geometry
noncomputable section
/-! Construct the product and Hodge-map transfer laws for the concrete
cycle-image predicates of LefschetzNormalization. The explicit intermediate inputs are the
native cycle pullback/exterior-product theorems, exterior cohomology, and
weight-one algebraicity. None of these inputs asserts a switch is algebraic. -/
open _root_.CategoryTheory _root_.CategoryTheory.Limits
open scoped TensorProduct Classical
variable (E : IntermediateField β β)
[NumberField E] [IsGalois β E] [NumberField.IsCMField E]
theorem pulledClass_pullback {v : LefschetzNormalization.Sign E}
(R : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v))
{X Y : Foundations.Scheme.IntegralProjective.IntegralProjectiveVariety} (f : X.toOver βΆ Y.toOver)
(Ο : Y.toOver βΆ R.abelianVariety.toOver) (a : LefschetzNormalization.G E) :
Betti.Scheme.schemeBettiMap (ModuleCat.of β β) 1 f (GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E R Y Ο a) =
GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E R X (f β« Ο) a :=
CMReduction.CupPullback.CM.Construction.scheme_pullback_comp (R := β) f Ο 1 (R.complexComparison (LefschetzNormalization.embeddingGenerator E a))
theorem pairClass_pullback {u v : LefschetzNormalization.Sign E}
(R : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E u))
(T : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v))
{X Y : Foundations.Scheme.IntegralProjective.IntegralProjectiveVariety} (f : X.toOver βΆ Y.toOver)
(ΟR : Y.toOver βΆ R.abelianVariety.toOver)
(ΟT : Y.toOver βΆ T.abelianVariety.toOver) (a b : LefschetzNormalization.G E) :
Betti.Scheme.schemeBettiMap (ModuleCat.of β β) 2 f (GeometricCoefficients.LefschetzNormalization.Geometry.pairClass E R T Y ΟR ΟT a b) =
GeometricCoefficients.LefschetzNormalization.Geometry.pairClass E R T X (f β« ΟR) (f β« ΟT) a b := by
exact (AlgebraicTopology.Kunneth.CupPullbackSingular.Construction.CupPullback.singularCohomologyCup_pullback
(ComplexPoints.Analytic.SchemePointHomeomorphs.schemeComplexPointsFunctor.map f) 1 1
(GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E R Y ΟR a) (GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E T Y ΟT b)).trans
(congrArgβ (fun x y : X.complexCohomology 1 =>
AlgebraicTopology.Products.CupCohomology.singularCohomologyCup (R := β) (Betti.Scheme.schemePointSpace X.toOver) 1 1 x y)
(pulledClass_pullback E R f ΟR a) (pulledClass_pullback E T f ΟT b))
theorem Aβ_pullback (R : GeometricFour.LefschetzNormalization.Geometry.RealizationFamily E) (hLineBundleCycles : CMReduction.CycleOperations.CM.Construction.LineBundleCyclesInput)
(u v : LefschetzNormalization.Sign E) (a b : LefschetzNormalization.G E) (h : GeometricFour.LefschetzNormalization.Geometry.Aβ E R u v a b)
(X : Foundations.Scheme.IntegralProjective.IntegralProjectiveVariety)
(Οu : X.toOver βΆ (R u).abelianVariety.toOver)
(Οv : X.toOver βΆ (R v).abelianVariety.toOver) :
GeometricCoefficients.LefschetzNormalization.Geometry.pairClass E (R u) (R v) X Οu Οv a b β X.complexGeometricAlgebraicClasses 1 := by
let Y := Albanese.Construction.SegreClosed.abelianProduct (R u).abelianVariety (R v).abelianVariety
let f : X.toOver βΆ Y.toOver := CartesianMonoidalCategory.lift Οu Οv
have ht := CMReduction.ComplexOperations.CM.Construction.complex_pullback_algebraic hLineBundleCycles f 1 _ h
change Betti.Scheme.schemeBettiMap (ModuleCat.of β β) 2 f
(GeometricCoefficients.LefschetzNormalization.Geometry.pairClass E (R u) (R v) Y.variety (CartesianMonoidalCategory.fst _ _)
(CartesianMonoidalCategory.snd _ _) a b) β _ at ht
have he := pairClass_pullback E (R u) (R v) f
(CartesianMonoidalCategory.fst _ _) (CartesianMonoidalCategory.snd _ _) a b
have hfu : f β« CartesianMonoidalCategory.fst _ _ = Οu :=
CartesianMonoidalCategory.lift_fst Οu Οv
have hfv : f β« CartesianMonoidalCategory.snd _ _ = Οv :=
CartesianMonoidalCategory.lift_snd Οu Οv
rw [hfu, hfv] at he
exact he βΈ ht
theorem fourClass_eq_h1Cup {v : LefschetzNormalization.FourTypes E}
(R : β i, ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E (v i)))
(X : Foundations.Scheme.IntegralProjective.IntegralProjectiveVariety)
(Ο : β i, X.toOver βΆ (R i).abelianVariety.toOver) (a : Fin 4 β LefschetzNormalization.G E) :
GeometricFour.LefschetzNormalization.Geometry.fourClass E R X Ο a = CMReduction.IteratedCup.CM.Construction.h1Cup β (Betti.Scheme.schemePointSpace X.toOver) 4
(fun i => GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E (R i) X (Ο i) (a i)) := by
exact (CMReduction.CupAppend.CM.Construction.h1Cup_four (R := β) (Betti.Scheme.schemePointSpace X.toOver)
(fun i => GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E (R i) X (Ο i) (a i))).symm
theorem fourClass_pullback {v : LefschetzNormalization.FourTypes E}
(R : β i, ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E (v i)))
{X Y : Foundations.Scheme.IntegralProjective.IntegralProjectiveVariety} (f : X.toOver βΆ Y.toOver)
(Ο : β i, Y.toOver βΆ (R i).abelianVariety.toOver) (a : Fin 4 β LefschetzNormalization.G E) :
Betti.Scheme.schemeBettiMap (ModuleCat.of β β) 4 f (GeometricFour.LefschetzNormalization.Geometry.fourClass E R Y Ο a) =
GeometricFour.LefschetzNormalization.Geometry.fourClass E R X (fun i => f β« Ο i) a := by
exact (AlgebraicTopology.Kunneth.CupPullbackSingular.Construction.CupPullback.singularCohomologyCup_pullback
(ComplexPoints.Analytic.SchemePointHomeomorphs.schemeComplexPointsFunctor.map f) 2 2
(GeometricCoefficients.LefschetzNormalization.Geometry.pairClass E (R 0) (R 1) Y (Ο 0) (Ο 1) (a 0) (a 1))
(GeometricCoefficients.LefschetzNormalization.Geometry.pairClass E (R 2) (R 3) Y (Ο 2) (Ο 3) (a 2) (a 3))).trans
(congrArgβ (fun x y : X.complexCohomology 2 =>
AlgebraicTopology.Products.CupCohomology.singularCohomologyCup (R := β) (Betti.Scheme.schemePointSpace X.toOver) 2 2 x y)
(pairClass_pullback E (R 0) (R 1) f (Ο 0) (Ο 1) (a 0) (a 1))
(pairClass_pullback E (R 2) (R 3) f (Ο 2) (Ο 3) (a 2) (a 3)))
theorem Aβ_pullback (R : GeometricFour.LefschetzNormalization.Geometry.RealizationFamily E) (hLineBundleCycles : CMReduction.CycleOperations.CM.Construction.LineBundleCyclesInput)
(v : LefschetzNormalization.FourTypes E) (a : Fin 4 β LefschetzNormalization.G E) (h : GeometricFour.LefschetzNormalization.Geometry.Aβ E R v a)
(X : Foundations.Scheme.IntegralProjective.IntegralProjectiveVariety)
(Ο : β i, X.toOver βΆ (R (v i)).abelianVariety.toOver) :
GeometricFour.LefschetzNormalization.Geometry.fourClass E (fun i => R (v i)) X Ο a β X.complexGeometricAlgebraicClasses 2 := by
let B : Fin 4 β ComplexMultiplication.CMAbelianVariety.CM.AbelianVariety := fun i => (R (v i)).abelianVariety
let f : X.toOver βΆ (CMVariety.Products.CM.Abelian.fourProduct B).toOver :=
Fan.IsLimit.lift (CMVariety.Products.CM.Abelian.fourProductIsLimit B) Ο
have ht := CMReduction.ComplexOperations.CM.Construction.complex_pullback_algebraic hLineBundleCycles f 2 _ h
erw [fourClass_pullback E (fun i => R (v i)) f] at ht
have he (i : Fin 4) : f β« CMVariety.Products.CM.Abelian.fourProjection B i = Ο i :=
Fan.IsLimit.fac (CMVariety.Products.CM.Abelian.fourProductIsLimit B) Ο i
have hΟ : (fun i => f β« CMVariety.Products.CM.Abelian.fourProjection B i) = Ο := funext he
change GeometricFour.LefschetzNormalization.Geometry.fourClass E (fun i => R (v i)) X
(fun i => f β« CMVariety.Products.CM.Abelian.fourProjection B i) a β _ at ht
rw [hΟ] at ht
exact ht
/-- Products of two actual divisor classes, in any prescribed slot order,
give the original four-factor class. The permutation changes only its sign. -/
theorem Aβ_of_pairs (R : GeometricFour.LefschetzNormalization.Geometry.RealizationFamily E)
(hLineBundleCycles : CMReduction.CycleOperations.CM.Construction.LineBundleCyclesInput) (hThomClass : CMReduction.CycleOperations.CM.Construction.ExteriorInput)
(hExteriorCohomology : ComplexMultiplication.KnownExteriorCohomology.CM.KnownResults.AbelianExteriorCohomology)
(v : LefschetzNormalization.FourTypes E) (a : Fin 4 β LefschetzNormalization.G E) (p : Equiv.Perm (Fin 4))
(h01 : GeometricFour.LefschetzNormalization.Geometry.Aβ E R (v (p 0)) (v (p 1)) (a (p 0)) (a (p 1)))
(h23 : GeometricFour.LefschetzNormalization.Geometry.Aβ E R (v (p 2)) (v (p 3)) (a (p 2)) (a (p 3))) :
GeometricFour.LefschetzNormalization.Geometry.Aβ E R v a := by
let B : Fin 4 β ComplexMultiplication.CMAbelianVariety.CM.AbelianVariety := fun i => (R (v i)).abelianVariety
let X := CMVariety.Products.CM.Abelian.fourProduct B
let Ο := CMVariety.Products.CM.Abelian.fourProjection B
let x (i : Fin 4) := GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E (R (v i)) X.variety (Ο i) (a i)
have hleft := Aβ_pullback E R hLineBundleCycles _ _ _ _ h01 X.variety (Ο (p 0)) (Ο (p 1))
have hright := Aβ_pullback E R hLineBundleCycles _ _ _ _ h23 X.variety (Ο (p 2)) (Ο (p 3))
have hp : CMReduction.IteratedCup.CM.Construction.h1Cup β (Betti.Scheme.schemePointSpace X.toOver) 4 (fun i => x (p i)) β
X.variety.complexGeometricAlgebraicClasses 2 := by
rw [CMReduction.CupAppend.CM.Construction.h1Cup_four]
exact CMReduction.ComplexOperations.CM.Construction.complex_cup_algebraic hLineBundleCycles hThomClass X.variety 1 1 _ _ hleft hright
have ht := CMReduction.CupPermutation.CM.Construction.h1Cup_perm_mem (CMReduction.CanonicalExterior.CM.Construction.canonicalExterior hExteriorCohomology X) 2 (fun i => x (p i)) p.symm hp
have hs : (fun i : Fin 4 => x (p i)) β p.symm = x :=
funext (fun i => congrArg x (p.apply_symm_apply i))
rw [hs] at ht
change GeometricFour.LefschetzNormalization.Geometry.fourClass E (fun i => R (v i)) X.variety Ο a β _
rw [fourClass_eq_h1Cup]
exact ht
/-- Applying fullness to the marked rational Hodge map yields the exact
coefficient of an actual algebraic pullback on every complex vector. -/
theorem hodgeMap_complexComparison (hDegreeTwo : ComplexMultiplication.KnownAlgebraicity.CM.KnownResults.RationalH1MapsAreAlgebraic)
{u v : LefschetzNormalization.Sign E} (R : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E u))
(T : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v)) (f : E ββ[β] E)
(hf : ComplexMultiplication.WeightOne.CM.IsHodgeMap (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E u) (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v) f) :
β (r : β) (g : T.abelianVariety.toOver βΆ R.abelianVariety.toOver),
IsMonHom g β§ β x : ComplexMultiplication.WeightOne.CM.Complexification E,
T.complexComparison (f.baseChange β x) = (r : β) β’
Betti.Scheme.schemeBettiMap (ModuleCat.of β β) 1 g (R.complexComparison x) := by
obtain β¨r, g, hg, heβ© := R.realizedMap_eq_rational_pullback hDegreeTwo T f hf
refine β¨r, g, hg, ?_β©
intro x
have hm : T.comparison.toLinearMap.comp f =
(R.realizedMap T f).comp R.comparison.toLinearMap := by
ext y
simp only [ComplexMultiplication.CMKnownResults.CM.HodgeRealization.realizedMap, LinearMap.comp_apply,
LinearEquiv.coe_coe, LinearEquiv.symm_apply_apply]
have hc := congrArg (fun q : E ββ[β] T.abelianVariety.variety.rationalCohomology 1 =>
q.baseChange β x) hm
simp only [LinearMap.baseChange_comp, LinearMap.comp_apply] at hc
change T.abelianVariety.h1ScalarExtension
(T.comparison.toLinearMap.baseChange β (f.baseChange β x)) = _
rw [hc, he, LinearMap.baseChange_smul, LinearMap.smul_apply]
refine (map_ratCast_smul T.abelianVariety.h1ScalarExtension β β r _).trans ?_
have hp := Pairs.CM.SurfaceConstruction.complexification_pullback g 1
(R.comparison.toLinearMap.baseChange β x)
exact congrArg (fun z => (r : β) β’ z) hp
/-- The tensor product of four marked rational Hodge maps is a scalar
multiple of the pullback along the constructed product morphism. -/
theorem Aβ_hodge_transfer (R : GeometricFour.LefschetzNormalization.Geometry.RealizationFamily E)
(hLineBundleCycles : CMReduction.CycleOperations.CM.Construction.LineBundleCyclesInput) (hDegreeTwo : ComplexMultiplication.KnownAlgebraicity.CM.KnownResults.RationalH1MapsAreAlgebraic)
(u v : LefschetzNormalization.FourTypes E) (a b : Fin 4 β LefschetzNormalization.G E) (f : Fin 4 β (E ββ[β] E))
(hf : β i, ComplexMultiplication.WeightOne.CM.IsHodgeMap (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E (u i)) (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E (v i)) (f i))
(he : β i, (f i).baseChange β (LefschetzNormalization.embeddingGenerator E (a i)) = LefschetzNormalization.embeddingGenerator E (b i))
(h : GeometricFour.LefschetzNormalization.Geometry.Aβ E R u a) : GeometricFour.LefschetzNormalization.Geometry.Aβ E R v b := by
choose r g _hg hcomp using fun i =>
hodgeMap_complexComparison E hDegreeTwo (R (u i)) (R (v i)) (f i) (hf i)
let B : Fin 4 β ComplexMultiplication.CMAbelianVariety.CM.AbelianVariety := fun i => (R (v i)).abelianVariety
let X := CMVariety.Products.CM.Abelian.fourProduct B
let Ο := CMVariety.Products.CM.Abelian.fourProjection B
have ht := Aβ_pullback E R hLineBundleCycles u a h X.variety (fun i => Ο i β« g i)
rw [fourClass_eq_h1Cup] at ht
change GeometricFour.LefschetzNormalization.Geometry.fourClass E (fun i => R (v i)) X.variety Ο b β _
rw [fourClass_eq_h1Cup]
have hv (i : Fin 4) : GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E (R (v i)) X.variety (Ο i) (b i) =
(r i : β) β’ GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass E (R (u i)) X.variety (Ο i β« g i) (a i) := by
have hi := hcomp i (LefschetzNormalization.embeddingGenerator E (a i))
rw [he i] at hi
unfold GeometricCoefficients.LefschetzNormalization.Geometry.pulledClass
rw [hi, map_smul, CMReduction.CupPullback.CM.Construction.scheme_pullback_comp]
simp only [hv]
rw [MultilinearMap.map_smul_univ]
exact (X.variety.complexGeometricAlgebraicClasses 2).smul_mem _ ht
end
end OAI.AlgebraicGeometry.HodgeConjecture.GeometricOperations.LefschetzNormalization.Geometry
|