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