File size: 9,707 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
import OAI.AlgebraicGeometry.HodgeConjecture.CanonicalCoefficients

/-! # Neg Realization -/

namespace OAI.AlgebraicGeometry.HodgeConjecture.NegRealization.CM.SurfaceConstruction

noncomputable section

/-! Negating a CM type changes its rational marking by the field's
complex conjugation, retaining the supplied abelian variety. -/

open _root_.CategoryTheory
open scoped TensorProduct

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

def fieldConjugationMap : E ≃ₗ[β„š] E := (ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E).toLinearEquiv

omit [IsGalois β„š E] in
theorem fieldConjugation_coordinates (x : ComplexMultiplication.WeightOne.CM.Complexification E) (Ο„ : E →ₐ[β„š] β„‚) :
    ComplexMultiplication.EmbeddingDecomposition.CM.fieldComplexificationEquiv E ((fieldConjugationMap E).toLinearMap.baseChange β„‚ x) Ο„ =
      ComplexMultiplication.EmbeddingDecomposition.CM.fieldComplexificationEquiv E x (ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Ο„) := by
  induction x using TensorProduct.inductionOn with
  | add x y hx hy => simp [hx, hy]
  | tmul a x =>
    rw [LinearMap.baseChange_tmul, ComplexMultiplication.EmbeddingDecomposition.CM.fieldComplexificationEquiv_tmul,
      ComplexMultiplication.EmbeddingDecomposition.CM.fieldComplexificationEquiv_tmul]
    change a * Ο„ (ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E x) = a * (ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Ο„) x
    exact congrArg (fun z => a * z)
      (ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.embedding_conjugation E Ο„.toRingHom x)

omit [IsGalois β„š E] in
theorem fieldConjugation_embeddingVector (Ο„ : E →ₐ[β„š] β„‚) :
    (fieldConjugationMap E).toLinearMap.baseChange β„‚ (ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E Ο„) =
      ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E (ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Ο„) := by
  classical
  apply (ComplexMultiplication.EmbeddingDecomposition.CM.fieldComplexificationEquiv E).injective
  funext Οƒ
  rw [fieldConjugation_coordinates, ComplexMultiplication.EmbeddingDecomposition.CM.fieldComplexificationEquiv_embeddingVector,
    ComplexMultiplication.EmbeddingDecomposition.CM.fieldComplexificationEquiv_embeddingVector]
  by_cases h : ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Οƒ = Ο„
  Β· have h' : ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Ο„ = Οƒ := by rw [← h, ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding_involutive]
    simp [h, h']
  Β· have h' : ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Ο„ β‰  Οƒ := by
      intro he
      apply h
      rw [← he, ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding_involutive]
    simp [h, h']

theorem fieldConjugation_subspace
    (v : ComplexMultiplication.OddSignSwitch.CM.OddSignPattern (fun g : Gal(E/β„š) => ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E * g))
    (b : Bool) (x : ComplexMultiplication.WeightOne.CM.Complexification E) :
    (fieldConjugationMap E).toLinearMap.baseChange β„‚ x ∈
        (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.embeddingType E v).subspace b ↔
      x ∈ (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.embeddingType E v.neg).subspace b := by
  rw [ComplexMultiplication.CM.TypeHodgeStructure.CMEmbeddingType.mem_subspace_iff, ComplexMultiplication.CM.TypeHodgeStructure.CMEmbeddingType.mem_subspace_iff]
  constructor
  · intro hx σ hσ
    have hc := hx (ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Οƒ)
    rw [fieldConjugation_coordinates, ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding_involutive] at hc
    have hh := hc hσ
    rw [(ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.embeddingType E v).property] at hh
    exact hh
  · intro hx σ hσ
    rw [fieldConjugation_coordinates] at hσ
    have hh := hx (ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding σ) hσ
    change Bool.not ((ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.embeddingType E v).val (ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Οƒ)) = b at hh
    rw [(ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.embeddingType E v).property, Bool.not_not] at hh
    exact hh

def negRealization
    (v : ComplexMultiplication.OddSignSwitch.CM.OddSignPattern (fun g : Gal(E/β„š) => ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E * g))
    (R : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v)) :
    ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v.neg) where
  abelianVariety := R.abelianVariety
  comparison := (fieldConjugationMap E).trans R.comparison
  holomorphic x := by
    change (R.comparison.toLinearMap.comp (fieldConjugationMap E).toLinearMap).baseChange β„‚ x ∈ _ ↔ _
    rw [LinearMap.baseChange_comp, LinearMap.comp_apply, R.holomorphic]
    exact fieldConjugation_subspace E v true x
  antiholomorphic x := by
    change (R.comparison.toLinearMap.comp (fieldConjugationMap E).toLinearMap).baseChange β„‚ x ∈ _ ↔ _
    rw [LinearMap.baseChange_comp, LinearMap.comp_apply, R.antiholomorphic]
    exact fieldConjugation_subspace E v false x

theorem negRealization_complexComparison
    (v : ComplexMultiplication.OddSignSwitch.CM.OddSignPattern (fun g : Gal(E/β„š) => ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E * g))
    (R : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v))
    (x : ComplexMultiplication.WeightOne.CM.Complexification E) :
    (negRealization E v R).complexComparison x =
      R.complexComparison ((fieldConjugationMap E).toLinearMap.baseChange β„‚ x) := by
  change ComplexMultiplication.CohomologyBaseChange.CM.singularCohomologyComplexification (Betti.Scheme.schemePointSpace R.abelianVariety.toOver) 1
    ((R.comparison.toLinearMap.comp (fieldConjugationMap E).toLinearMap).baseChange β„‚ x) = _
  rw [LinearMap.baseChange_comp, LinearMap.comp_apply]
  rfl

theorem negRealization_embeddingVector
    (v : ComplexMultiplication.OddSignSwitch.CM.OddSignPattern (fun g : Gal(E/β„š) => ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E * g))
    (R : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v))
    (Ο„ : E →ₐ[β„š] β„‚) :
    (negRealization E v R).complexComparison (ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E Ο„) =
      R.complexComparison (ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E (ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding Ο„)) := by
  rw [negRealization_complexComparison, fieldConjugation_embeddingVector]

theorem negRealization_at_one
    (v : ComplexMultiplication.OddSignSwitch.CM.OddSignPattern (fun g : Gal(E/β„š) => ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E * g))
    (R : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v)) :
    (negRealization E v R).complexComparison
        (ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.galoisEmbeddingEquiv E 1)) =
      R.complexComparison (ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E
        (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.galoisEmbeddingEquiv E (ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E))) := by
  rw [negRealization_embeddingVector]
  exact congrArg (fun Ο„ => R.complexComparison (ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E Ο„))
    (by simpa only [mul_one] using (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.galoisEmbeddingEquiv_conjugation E 1).symm)

theorem negRealization_at_conjugation
    (v : ComplexMultiplication.OddSignSwitch.CM.OddSignPattern (fun g : Gal(E/β„š) => ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E * g))
    (R : ComplexMultiplication.CMKnownResults.CM.HodgeRealization (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.hodgeStructure E v)) :
    (negRealization E v R).complexComparison (ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E
        (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.galoisEmbeddingEquiv E (ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E))) =
      R.complexComparison (ComplexMultiplication.EmbeddingDecomposition.CM.embeddingVector E (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.galoisEmbeddingEquiv E 1)) := by
  rw [negRealization_embeddingVector]
  have hc : ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.galoisEmbeddingEquiv E (ComplexMultiplication.GaloisSigns.CM.CMCoefficientField.conjugation E) =
      ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding (ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.galoisEmbeddingEquiv E 1) := by
    simpa only [mul_one] using ComplexMultiplication.GaloisCMType.CM.CMCoefficientField.galoisEmbeddingEquiv_conjugation E 1
  rw [hc, ComplexMultiplication.EmbeddingHodgeType.CM.conjugateEmbedding_involutive]

end

end OAI.AlgebraicGeometry.HodgeConjecture.NegRealization.CM.SurfaceConstruction