File size: 10,788 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
import OAI.AlgebraicGeometry.IntersectionTheory.ProjectionFormula.ProperCycleLinearity
import OAI.AlgebraicGeometry.CycleClass.Geometric.ProjectivePresentation
import OAI.AlgebraicTopology.Products.CupCohomology
import OAI.AlgebraicGeometry.ComplexMultiplication.HomBaseChange

/-! # Intersections -/

namespace OAI.AlgebraicGeometry.HodgeConjecture.Intersections.CM.SurfaceConstruction

noncomputable section

/-!
Actual intersection representatives and their cup classes. The full ProjectionFormula Chow
proposition supplies existence of representatives, rather than an unproved
moving-lemma axiom. Full ThomClass intersection compatibility identifies their
native geometric classes. This module uses smooth projective presentations,
exactly as those two committed input specifications do.
-/

open _root_.CategoryTheory _root_.AlgebraicGeometry
open OAI.AlgebraicTopology.Products.CupCohomology
open scoped TensorProduct

/-- The complete strengthened Chow statement of ProjectionFormula. -/
def ChowProjectionFormula : Prop :=
  βˆ€ {X Y : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation} (f : X.toOver ⟢ Y.toOver)
    (_hf : IsProper f.left) (P : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ProductPresentation X Y)
    (m n : β„•) [SmoothOfRelativeDimension m X.structureMap]
    [SmoothOfRelativeDimension n Y.structureMap]
    (p q s : β„•) (_hdeg : q + n = s + m)
    (_hdegCup : (p + q) + n = (p + s) + m),
    βˆƒ (intersectionX : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ X p β†’β‚—[β„š]
          IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ X q β†’β‚—[β„š] IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ X (p + q))
      (intersectionY : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ Y p β†’β‚—[β„š]
          IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ Y s β†’β‚—[β„š] IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ Y (p + s))
      (pull : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ Y p β†’β‚—[β„š] IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ X p)
      (pushQ : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ X q β†’β‚—[β„š] IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ Y s)
      (pushPQ : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ X (p + q) β†’β‚—[β„š]
          IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ Y (p + s)),
      (βˆ€ a b, IntersectionTheory.ProjectionFormula.ProperCycleLinearity.chowIntersection X p q a b = {intersectionX a b}) ∧
      (βˆ€ a b, IntersectionTheory.ProjectionFormula.ProperCycleLinearity.chowIntersection Y p s a b = {intersectionY a b}) ∧
      (βˆ€ a, IntersectionTheory.ProjectionFormula.ProperCycleLinearity.chowPullback P f n p a = {pull a}) ∧
      (βˆ€ b, IntersectionTheory.ProjectionFormula.ProperCycleLinearity.chowPushforward f q s b = {pushQ b}) ∧
      (βˆ€ c, IntersectionTheory.ProjectionFormula.ProperCycleLinearity.chowPushforward f (p + q) (p + s) c = {pushPQ c}) ∧
      βˆ€ (Ξ± : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ Y p) (Ξ² : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ChowQ X q),
        pushPQ (intersectionX (pull Ξ±) Ξ²) = intersectionY Ξ± (pushQ Ξ²)

/-- ProjectionFormula totality yields a genuine intersection representative for every
pair of finite cycles, without assuming they already meet properly. -/
theorem exists_intersectionCycle (hProjectionFormula : ChowProjectionFormula)
    (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) (P : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ProductPresentation X X)
    (d : β„•) [SmoothOfRelativeDimension d X.structureMap]
    (p q : β„•) (a : X.RationalDimensionCycle p) (b : X.RationalDimensionCycle q) :
    βˆƒ c : X.RationalDimensionCycle (p + q), CycleClass.Thom.IntersectionGeometry.RepresentsIntersection X p q a b c := by
  obtain ⟨I, J, pull, pushQ, pushPQ, hI, _⟩ :=
    hProjectionFormula (πŸ™ X.toOver) (IntersectionTheory.ProjectionFormula.ProperCycleLinearity.morphism_isProper _) P d d p q q rfl rfl
  obtain ⟨c, hc⟩ := IntersectionTheory.ProjectionFormula.ProperCycleLinearity.cycleToChowQ_surjective X (p + q)
    (I (IntersectionTheory.ProjectionFormula.ProperCycleLinearity.cycleToChowQ X p a) (IntersectionTheory.ProjectionFormula.ProperCycleLinearity.cycleToChowQ X q b))
  refine ⟨c, (IntersectionTheory.ProjectionFormula.ProperCycleLinearity.chowIntersection_mk_iff X p q a b c).mp ?_⟩
  rw [hI, hc]
  exact Set.mem_singleton _

/-- Choose an actual finite-cycle representative of the geometric intersection. -/
def intersectionCycle (hProjectionFormula : ChowProjectionFormula)
    (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) (P : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ProductPresentation X X)
    (d : β„•) [SmoothOfRelativeDimension d X.structureMap]
    (p q : β„•) (a : X.RationalDimensionCycle p) (b : X.RationalDimensionCycle q) :
    X.RationalDimensionCycle (p + q) :=
  (exists_intersectionCycle hProjectionFormula X P d p q a b).choose

theorem intersectionCycle_spec (hProjectionFormula : ChowProjectionFormula)
    (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) (P : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ProductPresentation X X)
    (d : β„•) [SmoothOfRelativeDimension d X.structureMap]
    (p q : β„•) (a : X.RationalDimensionCycle p) (b : X.RationalDimensionCycle q) :
    CycleClass.Thom.IntersectionGeometry.RepresentsIntersection X p q a b (intersectionCycle hProjectionFormula X P d p q a b) :=
  (exists_intersectionCycle hProjectionFormula X P d p q a b).choose_spec

def presentationDegreeCast (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) {m n : β„•} (h : m = n) :
    X.rationalCohomology m β†’β‚—[β„š] X.rationalCohomology n := by
  subst n
  exact LinearMap.id

/-- Cup product with exactly the even-degree transport used by ThomClass. -/
def evenCup (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) (p q : β„•) :
    X.rationalCohomology (p + p) β†’β‚—[β„š]
      X.rationalCohomology (q + q) β†’β‚—[β„š] X.rationalCohomology ((p + q) + (p + q)) :=
  (AlgebraicTopology.Products.CupCohomology.singularCohomologyCup (R := β„š) (Betti.Scheme.schemePointSpace X.toOver) (p + p) (q + q)).comprβ‚‚
    (presentationDegreeCast X (add_add_add_comm p p q q))

/-- Full ThomClass intersection compatibility; the separate exterior statement
is not needed for the intersection helpers here. -/
def IntersectionCycleClassCompatibility : Prop :=
  βˆ€ (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) (p q : β„•)
    (a : X.RationalDimensionCycle p) (b : X.RationalDimensionCycle q)
    (c : X.RationalDimensionCycle (p + q)),
    CycleClass.Thom.IntersectionGeometry.RepresentsIntersection X p q a b c β†’
    X.geometricCycleClassMap (p + q) c =
      evenCup X p q (X.geometricCycleClassMap p a) (X.geometricCycleClassMap q b)

theorem intersectionCycle_class (hThomClass : IntersectionCycleClassCompatibility)
    (hProjectionFormula : ChowProjectionFormula)
    (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) (P : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ProductPresentation X X)
    (d : β„•) [SmoothOfRelativeDimension d X.structureMap]
    (p q : β„•) (a : X.RationalDimensionCycle p) (b : X.RationalDimensionCycle q) :
    X.geometricCycleClassMap (p + q) (intersectionCycle hProjectionFormula X P d p q a b) =
      evenCup X p q (X.geometricCycleClassMap p a) (X.geometricCycleClassMap q b) :=
  hThomClass X p q a b _ (intersectionCycle_spec hProjectionFormula X P d p q a b)

/-- Base change for a bilinear map with possibly different argument spaces. -/
def extendBilinear (E U V W : Type*) [Field E] [Algebra β„š E]
    [AddCommGroup U] [Module β„š U] [AddCommGroup V] [Module β„š V]
    [AddCommGroup W] [Module β„š W] (B : U β†’β‚—[β„š] V β†’β‚—[β„š] W) :
    (E βŠ—[β„š] U) β†’β‚—[E] (E βŠ—[β„š] V) β†’β‚—[E] (E βŠ—[β„š] W) :=
  (ComplexMultiplication.HomBaseChange.CM.homBaseChange E V W).comp (B.baseChange E)

@[simp]
theorem extendBilinear_tmul (E U V W : Type*) [Field E] [Algebra β„š E]
    [AddCommGroup U] [Module β„š U] [AddCommGroup V] [Module β„š V]
    [AddCommGroup W] [Module β„š W] (B : U β†’β‚—[β„š] V β†’β‚—[β„š] W)
    (a b : E) (u : U) (v : V) :
    extendBilinear E U V W B (a βŠ—β‚œ[β„š] u) (b βŠ—β‚œ[β„š] v) =
      (a * b) βŠ—β‚œ[β„š] B u v := by
  simp [extendBilinear, ComplexMultiplication.HomBaseChange.CM.homBaseChange_tmul, TensorProduct.smul_tmul', smul_eq_mul]

def presentationCoefficientAlgebraicClasses (E : Type*) [Field E] [Algebra β„š E]
    (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) (p : β„•) :
    Submodule E (E βŠ—[β„š] X.rationalCohomology (p + p)) :=
  LinearMap.range ((X.geometricCycleClassMap p).baseChange E)

/-- Finite coefficient cycles are closed under the actual even-degree cup
product. The proof constructs representatives term by term through ProjectionFormula. -/
theorem coefficient_evenCup_algebraic (E : Type*) [Field E] [Algebra β„š E]
    (hThomClass : IntersectionCycleClassCompatibility) (hProjectionFormula : ChowProjectionFormula)
    (X : Foundations.Scheme.SmoothProjective.SmoothProjectivePresentation) (P : IntersectionTheory.ProjectionFormula.ProperCycleLinearity.ProductPresentation X X)
    (d : β„•) [SmoothOfRelativeDimension d X.structureMap] (p q : β„•)
    (u : E βŠ—[β„š] X.rationalCohomology (p + p))
    (v : E βŠ—[β„š] X.rationalCohomology (q + q))
    (hu : u ∈ presentationCoefficientAlgebraicClasses E X p)
    (hv : v ∈ presentationCoefficientAlgebraicClasses E X q) :
    extendBilinear E _ _ _ (evenCup X p q) u v ∈
      presentationCoefficientAlgebraicClasses E X (p + q) := by
  obtain ⟨a, rfl⟩ := hu
  obtain ⟨b, rfl⟩ := hv
  induction a using TensorProduct.inductionOn with
  | add a c ha hc =>
    simpa only [map_add, LinearMap.add_apply] using
      (presentationCoefficientAlgebraicClasses E X (p + q)).add_mem ha hc
  | tmul r a =>
    induction b using TensorProduct.inductionOn with
    | add b c hb hc =>
      simpa only [map_add] using
        (presentationCoefficientAlgebraicClasses E X (p + q)).add_mem hb hc
    | tmul s b =>
      refine ⟨(r * s) βŠ—β‚œ[β„š] intersectionCycle hProjectionFormula X P d p q a b, ?_⟩
      rw [LinearMap.baseChange_tmul, LinearMap.baseChange_tmul,
        LinearMap.baseChange_tmul, extendBilinear_tmul,
        intersectionCycle_class hThomClass hProjectionFormula]

end

end OAI.AlgebraicGeometry.HodgeConjecture.Intersections.CM.SurfaceConstruction