File size: 9,358 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
import OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Relative.HomogeneousPicardEvaluation
import OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Relative.DualGroupLaw

/-! # Poincare Class Additivity -/

namespace OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Relative.PoincareClassAdditivity.RelativePoincareClasses

noncomputable section

section

/-! Actual normalized Poincare classes are additive in the specified
dual group law over locally noetherian bases, on arbitrary quasi-compact
quasi-separated parameter schemes. Rigidity and effective descent prove it. -/

open _root_.CategoryTheory _root_.AlgebraicGeometry Opposite
open _root_.CategoryTheory.MonoidalCategory _root_.CategoryTheory.CartesianMonoidalCategory
open scoped _root_.CategoryTheory.MonObj

open OAI.AlgebraicGeometry.Isogenies.NeighborCounting.PoincareNormalization OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Relative.HomogeneousPicardEvaluation.RelativeNormalizedPicard

variable {S : Scheme.{0}} [IsLocallyNoetherian S] {g : ℕ}
  {A : HilbertConstruction.Abelian.Schemes.AbelianScheme g S} (D : HilbertConstruction.Dual.Data.DualAbelianData A)
  {T : Over S}

theorem representable_mul (a b : T ⟶ D.abelian.scheme) :
    D.representable.homEquiv (a * b) =
      D.representable.homEquiv a * D.representable.homEquiv b := by
  have h : letI := Picard.Homomorphisms.CanonicalDualGroup.Construction.dualPicardGroup D
      D.representable.homEquiv (a * b) =
        D.representable.homEquiv a * D.representable.homEquiv b := by
    let := Picard.Homomorphisms.CanonicalDualGroup.Construction.dualPicardGroup D
    exact (Picard.Homomorphisms.CanonicalDualGroup.Construction.dualPicardGroupHomEquiv D T).map_mul a b
  rw [DualGroupLaw.dualPicardGroup_eq_given_relative D] at h
  exact h

theorem poincareClass_mul (a b : T ⟶ D.abelian.scheme) :
    Picard.Homomorphisms.PoincareDetection.Construction.poincareClass D (a * b) = Picard.Homomorphisms.PoincareDetection.Construction.poincareClass D a * Picard.Homomorphisms.PoincareDetection.Construction.poincareClass D b := by
  have h := (congrArg (Picard.Homomorphisms.HomogeneousGroup.Construction.homogeneousPicardSheafInclusionHom A T) (representable_mul D a b)).trans
    ((Picard.Homomorphisms.HomogeneousGroup.Construction.homogeneousPicardSheafInclusionHom A T).map_mul _ _)
  simpa only [Picard.Homomorphisms.HomogeneousGroup.Construction.homogeneousPicardSheafInclusionHom_apply, ← Picard.Homomorphisms.PoincareDetection.Construction.poincareClass_eq_representation] using h

def familyClass (t : T ⟶ D.abelian.scheme) : HilbertConstruction.Line.Bundles.LineBundle.IsoClass (T ⊗ A.scheme).left :=
  Picard.Homomorphisms.SchemePullback.Construction.schemePicardPullback (t ▷ A.scheme).left (HilbertConstruction.Line.Bundles.LineBundle.classOf D.poincare)

omit [IsLocallyNoetherian S] in
theorem familyClass_zero (t : T ⟶ D.abelian.scheme) :
    Picard.Homomorphisms.SchemePullback.Construction.schemePicardPullback (Isogenies.NeighborCounting.PoincareNormalization.familyZero A T).left (familyClass D t) = 1 := by
  rw [familyClass, PELModuli.IntegralModel.Picard.Inv.NormalizedPicard.zero_class_naturality]
  have h : Picard.Homomorphisms.SchemePullback.Construction.schemePicardPullback (Isogenies.NeighborCounting.PoincareNormalization.familyZero A D.abelian.scheme).left
      (HilbertConstruction.Line.Bundles.LineBundle.classOf D.poincare) = 1 := Quotient.sound D.normalizedAtAbelianZero
  rw [h, map_one]

variable [CompactSpace T.left] [QuasiSeparatedSpace T.left]

theorem familyClass_mul (a b : T ⟶ D.abelian.scheme) :
    familyClass D (a * b) = familyClass D a * familyClass D b := by
  have hs : (HilbertConstruction.Picard.PicardSheaf.toRelativePicard A.scheme).app (op T) (familyClass D (a * b)) =
      (HilbertConstruction.Picard.PicardSheaf.toRelativePicard A.scheme).app (op T) (familyClass D a * familyClass D b) := by
    exact (poincareClass_mul D a b).trans
      (Picard.Homomorphisms.RelativeGroup.Construction.toRelativePicard_mul A.scheme T (familyClass D a) (familyClass D b)).symm
  have h := HomogeneousPicardEvaluation.RelativeNormalizedPicard.normalizedClass_eq_of_picard_eq A _ _ hs
  have hab : Picard.Homomorphisms.SchemePullback.Construction.schemePicardPullback (Isogenies.NeighborCounting.PoincareNormalization.familyZero A T).left (familyClass D a * familyClass D b) = 1 := by
    rw [map_mul, familyClass_zero, familyClass_zero, one_mul]
  rw [PELModuli.IntegralModel.Picard.Inv.NormalizedPicard.normalizedClass_eq_self A T _ (familyClass_zero D (a * b)),
    PELModuli.IntegralModel.Picard.Inv.NormalizedPicard.normalizedClass_eq_self A T _ hab] at h
  exact h

theorem familyClass_one : familyClass D (1 : T ⟶ D.abelian.scheme) = 1 := by
  have h := familyClass_mul D (1 : T ⟶ D.abelian.scheme) 1
  rw [one_mul] at h
  exact (mul_left_cancel ((mul_one _).trans h)).symm

def familyClassHom : (T ⟶ D.abelian.scheme) →* HilbertConstruction.Line.Bundles.LineBundle.IsoClass (T ⊗ A.scheme).left where
  toFun := familyClass D
  map_one' := familyClass_one D
  map_mul' := familyClass_mul D

end

/-! The actual Poincare bundle on a varying family defines a bilinear
pairing of points with values in line-bundle classes on arbitrary quasi-compact
quasi-separated parameter schemes over a locally noetherian base. -/

open _root_.CategoryTheory _root_.AlgebraicGeometry
open _root_.CategoryTheory.MonoidalCategory _root_.CategoryTheory.CartesianMonoidalCategory
open scoped _root_.CategoryTheory.MonObj

open OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Relative.HomogeneousPicardEvaluation.RelativeNormalizedPicard

variable {S : Scheme.{0}} [IsLocallyNoetherian S] {g : ℕ}
  {A : HilbertConstruction.Abelian.Schemes.AbelianScheme g S} (D : HilbertConstruction.Dual.Data.DualAbelianData A)
  {T : Over S}

def pairClass (t : T ⟶ D.abelian.scheme) (a : T ⟶ A.scheme) : HilbertConstruction.Line.Bundles.LineBundle.IsoClass T.left :=
  Picard.Homomorphisms.SchemePullback.Construction.schemePicardPullback (lift t a).left (HilbertConstruction.Line.Bundles.LineBundle.classOf D.poincare)

omit [IsLocallyNoetherian S] in
theorem pairClass_eq_evaluate (t : T ⟶ D.abelian.scheme) (a : T ⟶ A.scheme) :
    pairClass D t a = HomogeneousPicardEvaluation.RelativeNormalizedPicard.evaluateClass A (familyClass D t) a := by
  have h : HomogeneousPicardEvaluation.RelativeNormalizedPicard.evaluationSection A a ≫ (t ▷ A.scheme) = lift t a := by
    apply hom_ext <;> simp [HomogeneousPicardEvaluation.RelativeNormalizedPicard.evaluationSection]
  exact (congrArg (fun f => HilbertConstruction.Line.Bundles.LineBundle.pullbackClass f (HilbertConstruction.Line.Bundles.LineBundle.classOf D.poincare))
    (congrArg Over.Hom.left h).symm).trans
    (HilbertConstruction.Line.Bundles.LineBundle.pullbackClass_comp (HomogeneousPicardEvaluation.RelativeNormalizedPicard.evaluationSection A a).left (t ▷ A.scheme).left
      (HilbertConstruction.Line.Bundles.LineBundle.classOf D.poincare))

variable [CompactSpace T.left] [QuasiSeparatedSpace T.left]

theorem pairClass_mul_left (s t : T ⟶ D.abelian.scheme) (a : T ⟶ A.scheme) :
    pairClass D (s * t) a = pairClass D s a * pairClass D t a := by
  simp only [pairClass_eq_evaluate, HomogeneousPicardEvaluation.RelativeNormalizedPicard.evaluateClass, familyClass_mul, map_mul]

theorem pairClass_one_left (a : T ⟶ A.scheme) : pairClass D 1 a = 1 := by
  rw [pairClass_eq_evaluate, HomogeneousPicardEvaluation.RelativeNormalizedPicard.evaluateClass, familyClass_one, map_one]

theorem pairClass_mul_right (t : T ⟶ D.abelian.scheme) (a b : T ⟶ A.scheme) :
    pairClass D t (a * b) = pairClass D t a * pairClass D t b := by
  simp only [pairClass_eq_evaluate]
  exact HomogeneousPicardEvaluation.RelativeNormalizedPicard.evaluateClass_mul A (familyClass D t)
    (D.poincareHomogeneous.pullback A t) (familyClass_zero D t) a b

omit [IsLocallyNoetherian S] [CompactSpace T.left] [QuasiSeparatedSpace T.left] in
theorem pairClass_one_right (t : T ⟶ D.abelian.scheme) : pairClass D t 1 = 1 := by
  rw [pairClass_eq_evaluate]
  exact HomogeneousPicardEvaluation.RelativeNormalizedPicard.evaluateClass_one A (familyClass D t) (familyClass_zero D t)

def pairLeftHom (a : T ⟶ A.scheme) : (T ⟶ D.abelian.scheme) →* HilbertConstruction.Line.Bundles.LineBundle.IsoClass T.left where
  toFun := fun t => pairClass D t a
  map_one' := pairClass_one_left D a
  map_mul' := fun s t => pairClass_mul_left D s t a

def pairRightHom (t : T ⟶ D.abelian.scheme) : (T ⟶ A.scheme) →* HilbertConstruction.Line.Bundles.LineBundle.IsoClass T.left where
  toFun := pairClass D t
  map_one' := pairClass_one_right D t
  map_mul' := pairClass_mul_right D t

theorem pairClass_pow_left (t : T ⟶ D.abelian.scheme) (a : T ⟶ A.scheme) (n : ℕ) :
    pairClass D (t ^ n) a = pairClass D t a ^ n := (pairLeftHom D a).map_pow t n

theorem pairClass_pow_right (t : T ⟶ D.abelian.scheme) (a : T ⟶ A.scheme) (n : ℕ) :
    pairClass D t (a ^ n) = pairClass D t a ^ n := (pairRightHom D t).map_pow a n

theorem pairClass_inv_right (t : T ⟶ D.abelian.scheme) (a : T ⟶ A.scheme) :
    pairClass D t a⁻¹ = (pairClass D t a)⁻¹ := (pairRightHom D t).map_inv a

end

end OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Relative.PoincareClassAdditivity.RelativePoincareClasses