File size: 8,817 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
import OAI.AlgebraicGeometry.HodgeConjecture.GeometricOperations
import OAI.Algebra.FieldTheory.ScalarDescentTrace
import OAI.AlgebraicGeometry.HodgeConjecture.FourProduct

/-! # Geometric Normalization -/

namespace OAI.AlgebraicGeometry.HodgeConjecture.GeometricNormalization.Lefschetz.Geometry

noncomputable section

/-!
# LefschetzNormalization on actual geometric cycle-class images

The historical abstract theorem is instantiated with the constructed
twofold/fourfold products, canonical embedding tensors and geometric cycle
images. All four interface laws have proofs. Scalar descent is discharged
by the unconditional ScalarDescent proof. This intermediate theorem still names the
full DegreeTwo conclusions and the native ExteriorCohomology/LineBundleCycles/ThomClass result inputs; the separate
composition module discharges the available native inputs.
-/

open _root_.CategoryTheory _root_.CategoryTheory.Limits
open scoped TensorProduct Classical

def Conclusions : Prop := LefschetzNormalization.WeightOneInput ∧ LefschetzNormalization.AlbaneseInput ∧ LefschetzNormalization.DegreeTwoInput

theorem scalarTraceInput_proved : LefschetzNormalization.ScalarTraceInput :=
  Algebra.FieldTheory.ScalarDescentTrace.Core.scalar_trace_descent

theorem weightOne_fullness (h : LefschetzNormalization.WeightOneInput) : ComplexMultiplication.KnownAlgebraicity.CM.KnownResults.RationalH1MapsAreAlgebraic := by
  intro A B f hhol hanti
  obtain ⟨n, hn, g, hg, he⟩ := h A B f hhol hanti
  refine ⟨(n : β„š)⁻¹, g, hg, ?_⟩
  have hnQ : (n : β„š) β‰  0 := Nat.cast_ne_zero.mpr (Nat.ne_of_gt hn)
  rw [he, smul_smul, inv_mul_cancelβ‚€ hnQ, one_smul]

variable (E : IntermediateField β„š β„‚)
  [NumberField E] [IsGalois β„š E] [NumberField.IsCMField E]

/-- The concrete tensor comparison never kills an embedding tensor in an
actual fourfold product. This uses the proved geometric KΓΌnneth map. -/
theorem fourClass_ne_zero {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)
    (hprod : IsLimit (Fan.mk X.toOver Ο€)) (a : Fin 4 β†’ LefschetzNormalization.G E) :
    GeometricFour.LefschetzNormalization.Geometry.fourClass E R X Ο€ a β‰  0 := by
  apply FourProduct.CM.SurfaceConstruction.fourProduct_cup_ne_zero (fun i => (R i).abelianVariety.variety) X Ο€ hprod
    (fun i => (R i).complexComparison (LefschetzNormalization.embeddingGenerator E (a i)))
  intro i hzero
  exact ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector_ne_zero E _
    ((R i).complexComparison.injective (hzero.trans (map_zero _).symm))

/-- The comparison carries exactly the prescribed tensor line to the
span of the actual nonzero fourfold cohomology class. -/
theorem fourTensorLine_image {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) :
    (Submodule.span β„‚ ({GeometricFour.LefschetzNormalization.Geometry.embeddingTensor E a} : Set (GeometricFour.LefschetzNormalization.Geometry.FourTensor E))).map
        (GeometricFour.LefschetzNormalization.Geometry.fourTensorComparison E R X Ο€) =
      Submodule.span β„‚ ({GeometricFour.LefschetzNormalization.Geometry.fourClass E R X Ο€ a} : Set (X.complexCohomology 4)) := by
  rw [Submodule.map_span, Set.image_singleton, GeometricFour.LefschetzNormalization.Geometry.fourTensorComparison_embedding]

theorem Aβ‚„_iff_tensorLine_algebraic (R : GeometricFour.LefschetzNormalization.Geometry.RealizationFamily E)
    (v : LefschetzNormalization.FourTypes E) (a : Fin 4 β†’ LefschetzNormalization.G E) :
    GeometricFour.LefschetzNormalization.Geometry.Aβ‚„ E R v a ↔
      (Submodule.span β„‚ ({GeometricFour.LefschetzNormalization.Geometry.embeddingTensor E a} : Set (GeometricFour.LefschetzNormalization.Geometry.FourTensor E))).map
        (GeometricFour.LefschetzNormalization.Geometry.fourTensorComparison E (fun i => R (v i))
          (CMVariety.Products.CM.Abelian.fourProduct (fun i => (R (v i)).abelianVariety)).variety
          (CMVariety.Products.CM.Abelian.fourProjection _)) ≀
        (CMVariety.Products.CM.Abelian.fourProduct (fun i => (R (v i)).abelianVariety)).variety.complexGeometricAlgebraicClasses 2 := by
  rw [fourTensorLine_image, Submodule.span_singleton_le_iff_mem]
  rfl

/-- Every original normalization clause, with Aβ‚„ now the actual geometric
cycle-class image on the specified product and marking. -/
def Normalization (R : GeometricFour.LefschetzNormalization.Geometry.RealizationFamily E) (s : β„•) (v : LefschetzNormalization.FourTypes E) : Prop :=
  ((Β¬ βˆƒ g : LefschetzNormalization.G E, (v 0).val g = true ∧ (v 1).val g = true) ∧
    (βˆ€ Ο„ : LefschetzNormalization.G E, (v 1).val Ο„ = !((v 0).val Ο„) ∧
      (v 3).val Ο„ = !((v 2).val Ο„)) ∧ GeometricFour.LefschetzNormalization.Geometry.Aβ‚„ E R v (LefschetzNormalization.switchLabels E))
  ∨
  (βˆƒ (g : LefschetzNormalization.G E) (w : LefschetzNormalization.FourTypes E) (d : Fin 4 β†’ LefschetzNormalization.G E β†’ Bool) (reps : Finset (LefschetzNormalization.G E)),
    (βˆ€ i Οƒ, (w i).val Οƒ = (v i).val (Οƒ * g)) ∧
    (βˆ€ i, (w i).val 1 = true) ∧
    (βˆ€ Ο„ : LefschetzNormalization.G E,
      ComplexMultiplication.SignSwitch.CM.signValue ((w 0).val Ο„) + ComplexMultiplication.SignSwitch.CM.signValue ((w 1).val Ο„) =
        ComplexMultiplication.SignSwitch.CM.signValue ((w 2).val Ο„) + ComplexMultiplication.SignSwitch.CM.signValue ((w 3).val Ο„)) ∧
    (βˆ€ i, ComplexMultiplication.WeightOne.CM.IsHodgeMap (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E (w i)) (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E (v i)) (g⁻¹).toLinearMap) ∧
    (βˆ€ Ο„ : LefschetzNormalization.G E, (g⁻¹).toLinearMap.baseChange β„‚ (LefschetzNormalization.embeddingGenerator E Ο„) =
      LefschetzNormalization.embeddingGenerator E (Ο„ * g)) ∧
    (βˆ€ i Ο„, d i Ο„ = (w i).val τ⁻¹) ∧
    (βˆ€ i Ο„, d i (ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E * Ο„) = !(d i Ο„)) ∧
    (1 : LefschetzNormalization.G E) ∈ reps ∧
    (βˆ€ Ο„ : LefschetzNormalization.G E, Ο„ ∈ reps ↔ ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E * Ο„ βˆ‰ reps) ∧
    reps.card = s ∧
    (GeometricFour.LefschetzNormalization.Geometry.Aβ‚„ E R w (LefschetzNormalization.switchLabels E) ↔ GeometricFour.LefschetzNormalization.Geometry.Aβ‚„ E R v (LefschetzNormalization.switchLabels E)) ∧
    ((s = 1 ∧ GeometricFour.LefschetzNormalization.Geometry.Aβ‚„ E R v (LefschetzNormalization.switchLabels E)) ∨ 2 ≀ s))

theorem normalization_on_realized_products
    (hDegreeTwo : Conclusions)
    (hExteriorCohomology : ComplexMultiplication.KnownExteriorCohomology.CM.KnownResults.AbelianExteriorCohomology)
    (hLineBundleCycles : CMReduction.CycleOperations.CM.Construction.LineBundleCyclesInput) (hThomClass : CMReduction.CycleOperations.CM.Construction.ExteriorInput)
    (R : GeometricFour.LefschetzNormalization.Geometry.RealizationFamily E) (s : β„•)
    (hdegree : Fintype.card (LefschetzNormalization.G E) = 2 * s)
    (v : LefschetzNormalization.FourTypes E)
    (hbalance : βˆ€ Ο„ : LefschetzNormalization.G E,
      ComplexMultiplication.SignSwitch.CM.signValue ((v 0).val Ο„) + ComplexMultiplication.SignSwitch.CM.signValue ((v 1).val Ο„) =
        ComplexMultiplication.SignSwitch.CM.signValue ((v 2).val Ο„) + ComplexMultiplication.SignSwitch.CM.signValue ((v 3).val Ο„)) :
    Normalization E R s v := by
  exact LefschetzNormalization.normalization_of_active_embedding E
    scalarTraceInput_proved hDegreeTwo.1 hDegreeTwo.2.1 hDegreeTwo.2.2 s hdegree (GeometricFour.LefschetzNormalization.Geometry.Aβ‚‚ E R) (GeometricFour.LefschetzNormalization.Geometry.Aβ‚„ E R)
    (GeometricFour.LefschetzNormalization.Geometry.Aβ‚‚_of_balance E R (scalarTraceInput_proved E) hDegreeTwo.2.2)
    (GeometricOperations.LefschetzNormalization.Geometry.Aβ‚„_of_pairs E R hLineBundleCycles hThomClass hExteriorCohomology)
    (GeometricFour.LefschetzNormalization.Geometry.Aβ‚„_scalar_iff E R)
    (GeometricOperations.LefschetzNormalization.Geometry.Aβ‚„_hodge_transfer E R hLineBundleCycles (weightOne_fullness hDegreeTwo.1)) v hbalance

end

end OAI.AlgebraicGeometry.HodgeConjecture.GeometricNormalization.Lefschetz.Geometry