File size: 11,061 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
199
200
201
202
203
204
205
206
207
208
209
210
211
import OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition
import OAI.AlgebraicGeometry.ComplexMultiplication.EmbeddingHodgeType
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.LinearAlgebra.Finsupp.VectorSpace
import Mathlib.Algebra.Module.Rat

/-! # Decomposition Embedding Basis -/

namespace OAI

noncomputable section

namespace AlgebraicGeometry.ComplexMultiplication.DecompositionEmbeddingBasis.CM.CMDecomposition

/-!
# Embedding basis for a CM decomposition with different fields

Complexification commutes with the actual internal direct sum. Applying the
embedding basis construction on each summand therefore gives a basis of the
whole weight-one space. Its vectors are the images under the actual subspace
inclusions, and their signs retain their geometric Hodge types.
-/

open scoped DirectSum TensorProduct Classical

variable {U : Type*} [AddCommGroup U] [Module β„š U]
variable {H : WeightOne.CM.WeightOneHodgeStructure U} (D : Decomposition.CM.CMDecomposition H)

local instance (i : Fin D.numberOfComponents) : NumberField (D.component i).field :=
  (D.component i).cm.numberField

/-- The sum of complexified summands is the complexification of the original
space, using the same internal sum map as the rational decomposition. -/
def _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.complexDirectSumEquiv :
    (⨁ i, WeightOne.CM.Complexification (D.component i).subspace) ≃ₗ[β„‚] WeightOne.CM.Complexification U :=
  (TensorProduct.directSumRight β„š β„‚ β„‚ (fun i => (D.component i).subspace)).symm.trans
    (D.linearEquiv.baseChange β„š β„‚ _ _)

@[simp]
theorem _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.complexDirectSumEquiv_lof_tmul (i : Fin D.numberOfComponents) (z : β„‚)
    (u : (D.component i).subspace) :
    D.complexDirectSumEquiv
      (DirectSum.lof β„‚ _ (fun i => WeightOne.CM.Complexification (D.component i).subspace) i (z βŠ—β‚œ[β„š] u)) =
      z βŠ—β‚œ[β„š] (u : U) := by
  simp [Decomposition.CM.CMDecomposition.complexDirectSumEquiv]

/-- On an entire complexified component, the map is its actual scalar-extended inclusion. -/
theorem _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.complexDirectSumEquiv_lof (i : Fin D.numberOfComponents)
    (x : WeightOne.CM.Complexification (D.component i).subspace) :
    D.complexDirectSumEquiv
      (DirectSum.lof β„‚ _ (fun i => WeightOne.CM.Complexification (D.component i).subspace) i x) =
      (D.component i).subspace.subtype.baseChange β„‚ x := by
  induction x using TensorProduct.inductionOn with
  | add x y hx hy => simp only [map_add, hx, hy]
  | tmul z u => simp

/-- The basis of one summand indexed by embeddings of that summand's own field. -/
def _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.componentEmbeddingBasis (i : Fin D.numberOfComponents) :
    Module.Basis ((D.component i).field →ₐ[β„š] β„‚) β„‚
      (WeightOne.CM.Complexification (D.component i).subspace) :=
  (D.component i).cm.embeddingBasis

/-- Basis indices retain both the component and the embedding of its field. -/
abbrev _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.EmbeddingIndex := Ξ£ i : Fin D.numberOfComponents, (D.component i).field →ₐ[β„š] β„‚

instance _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.embeddingIndexFintype : Fintype D.EmbeddingIndex :=
  inferInstanceAs (Fintype (Ξ£ i : Fin D.numberOfComponents, (D.component i).field →ₐ[β„š] β„‚))

/-- All embedding lines together form a basis of the actual complexified space. -/
def _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.embeddingBasis : Module.Basis D.EmbeddingIndex β„‚ (WeightOne.CM.Complexification U) :=
  (DFinsupp.basis D.componentEmbeddingBasis).map D.complexDirectSumEquiv

/-- Each global basis vector is included from its actual rational Hodge summand. -/
theorem _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.embeddingBasis_apply (i : Fin D.numberOfComponents) (Οƒ : (D.component i).field →ₐ[β„š] β„‚) :
    D.embeddingBasis ⟨i, ΟƒβŸ© =
      (D.component i).subspace.subtype.baseChange β„‚ (D.componentEmbeddingBasis i Οƒ) := by
  have hb : (DFinsupp.basis D.componentEmbeddingBasis) ⟨i, ΟƒβŸ© =
      DirectSum.lof β„‚ _ (fun i => WeightOne.CM.Complexification (D.component i).subspace) i
        (D.componentEmbeddingBasis i Οƒ) := by
    simp [DFinsupp.basis, DFinsupp.mapRange.linearEquiv]
    change DFinsupp.mapRange (fun k => (D.componentEmbeddingBasis k).repr.symm)
      (fun k => map_zero _) (DFinsupp.single i (Finsupp.single Οƒ 1)) = _
    rw [DFinsupp.mapRange_single, Module.Basis.repr_symm_single, one_smul]
    rfl
  change D.complexDirectSumEquiv ((DFinsupp.basis D.componentEmbeddingBasis) ⟨i, ΟƒβŸ©) = _
  rw [hb]
  exact D.complexDirectSumEquiv_lof i _

/-- Each sign is attached to its own field's actual embedding line. -/
def _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.embeddingSign (j : D.EmbeddingIndex) : Bool :=
  (D.component j.1).cm.embeddingSign j.2

/-- Conjugation acts within each component's embedding set. -/
def _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.conjugateIndex (j : D.EmbeddingIndex) : D.EmbeddingIndex :=
  ⟨j.1, EmbeddingHodgeType.CM.conjugateEmbedding j.2⟩

@[simp]
theorem _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.conjugateIndex_involutive (j : D.EmbeddingIndex) :
    D.conjugateIndex (D.conjugateIndex j) = j := by
  rcases j with ⟨i, ΟƒβŸ©
  exact congrArg (fun Ο„ => (⟨i, Ο„βŸ© : D.EmbeddingIndex)) (EmbeddingHodgeType.CM.conjugateEmbedding_involutive Οƒ)

/-- Positive signs identify holomorphic basis vectors in the whole space. -/
theorem _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.embeddingBasis_holomorphic (j : D.EmbeddingIndex) (hj : D.embeddingSign j = true) :
    D.embeddingBasis j ∈ H.holomorphic := by
  rcases j with ⟨i, ΟƒβŸ©
  rw [D.embeddingBasis_apply]
  apply (D.component i).inclusion_hodge
  exact ((D.component i).cm.embeddingBasis_mem_holomorphic_iff Οƒ).mpr hj

/-- Negative signs identify antiholomorphic basis vectors in the whole space. -/
theorem _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.embeddingBasis_antiholomorphic (j : D.EmbeddingIndex) (hj : D.embeddingSign j = false) :
    D.embeddingBasis j ∈ H.antiholomorphic := by
  rcases j with ⟨i, ΟƒβŸ©
  rw [D.embeddingBasis_apply]
  apply (D.component i).inclusion_hodge.map_antiholomorphic
  exact ((D.component i).cm.embeddingBasis_mem_antiholomorphic_iff Οƒ).mpr hj

/-- The sign functions remain odd when the decomposition uses different CM fields. -/
theorem _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.embeddingSign_conjugate (j : D.EmbeddingIndex) :
    D.embeddingSign (D.conjugateIndex j) = !D.embeddingSign j :=
  (D.component j.1).cm.embeddingSign_conjugate j.2

/-- Every vector has a finite, unique expansion in these actual embedding lines. -/
theorem _root_.OAI.AlgebraicGeometry.ComplexMultiplication.Decomposition.CM.CMDecomposition.sum_embeddingBasis (x : WeightOne.CM.Complexification U) :
    βˆ‘ j, D.embeddingBasis.repr x j β€’ D.embeddingBasis j = x :=
  D.embeddingBasis.sum_repr x

end AlgebraicGeometry.ComplexMultiplication.DecompositionEmbeddingBasis.CM.CMDecomposition

namespace AlgebraicGeometry.ComplexMultiplication

/-!
# The full weight-one Hodge subspaces in the CM basis

The positive and negative embedding vectors span precisely the given
holomorphic and antiholomorphic subspaces. In particular, the nonzero
coordinates of a pure vector have its assigned Hodge sign.
-/

open scoped Classical

variable {U : Type*} [AddCommGroup U] [Module β„š U]

section

/-- Select one of the two given weight-one Hodge subspaces by its sign. -/
def WeightOne.CM.WeightOneHodgeStructure.signSubspace (H : WeightOne.CM.WeightOneHodgeStructure U) (b : Bool) :
    Submodule β„‚ (WeightOne.CM.Complexification U) := if b then H.holomorphic else H.antiholomorphic

theorem WeightOne.CM.WeightOneHodgeStructure.signSubspace_isCompl (H : WeightOne.CM.WeightOneHodgeStructure U) (b : Bool) :
    IsCompl (H.signSubspace b) (H.signSubspace (!b)) := by
  cases b
  Β· exact H.complementary.symm
  Β· exact H.complementary

end

variable {H : WeightOne.CM.WeightOneHodgeStructure U} (D : Decomposition.CM.CMDecomposition H)

theorem Decomposition.CM.CMDecomposition.embeddingBasis_mem_signSubspace (j : D.EmbeddingIndex) :
    D.embeddingBasis j ∈ H.signSubspace (D.embeddingSign j) := by
  cases he : D.embeddingSign j
  Β· exact D.embeddingBasis_antiholomorphic j he
  Β· exact D.embeddingBasis_holomorphic j he

/-- Each prescribed Hodge subspace is the span of exactly its embedding basis vectors. -/
theorem Decomposition.CM.CMDecomposition.signSubspace_eq_span_embeddingBasis (b : Bool) :
    H.signSubspace b = Submodule.span β„‚ (D.embeddingBasis '' {j | D.embeddingSign j = b}) := by
  apply le_antisymm
  Β· intro x hx
    let P := (H.signSubspace b).projection (H.signSubspace (!b)) (H.signSubspace_isCompl b)
    have hp : P x = x := Submodule.projection_apply_of_mem_left (H.signSubspace_isCompl b) hx
    have he := congrArg P (D.embeddingBasis.sum_repr x)
    rw [hp] at he
    rw [← he]
    simp only [map_sum, map_smul]
    apply Submodule.sum_mem
    intro j _
    by_cases hj : D.embeddingSign j = b
    · have hm : D.embeddingBasis j ∈ H.signSubspace b :=
        hj β–Έ D.embeddingBasis_mem_signSubspace j
      have hb : P (D.embeddingBasis j) = D.embeddingBasis j :=
        Submodule.projection_apply_of_mem_left (H.signSubspace_isCompl b) hm
      rw [hb]
      exact Submodule.smul_mem _ _ (Submodule.subset_span ⟨j, hj, rfl⟩)
    Β· have hj' : D.embeddingSign j = !b := by
        cases b <;> cases heq : D.embeddingSign j <;> simp_all
      have hm : D.embeddingBasis j ∈ H.signSubspace (!b) :=
        hj' β–Έ D.embeddingBasis_mem_signSubspace j
      have hb : P (D.embeddingBasis j) = 0 :=
        Submodule.projection_apply_of_mem_right (H.signSubspace_isCompl b) hm
      rw [hb, smul_zero]
      exact Submodule.zero_mem _
  Β· apply Submodule.span_le.mpr
    rintro x ⟨j, hj, rfl⟩
    exact hj β–Έ D.embeddingBasis_mem_signSubspace j

/-- A nonzero coordinate of a pure weight-one vector has the same Hodge sign. -/
theorem Decomposition.CM.CMDecomposition.embeddingBasis_repr_sign {b : Bool} {x : WeightOne.CM.Complexification U}
    (hx : x ∈ H.signSubspace b) (j : D.EmbeddingIndex)
    (hj : D.embeddingBasis.repr x j β‰  0) : D.embeddingSign j = b := by
  rw [D.signSubspace_eq_span_embeddingBasis b] at hx
  exact D.embeddingBasis.mem_span_image.mp hx (Finset.mem_coe.mpr (Finsupp.mem_support_iff.mpr hj))

end AlgebraicGeometry.ComplexMultiplication

end

end OAI