math / data /lean /OAI /Geometry /ComplexBall /ArithmeticQuotientEquationsData.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
26.5 kB
import Mathlib
/-! # Arithmetic Quotient Equations Data -/
namespace OAI.Geometry.ComplexBall.ArithmeticQuotientEquationsData
noncomputable section
section
/-! Concrete data for ArithmeticQuotient, shared with its statement without importing a proof stub.
The definitions retain the committed statement's meanings and names. -/
open scoped BigOperators _root_.Manifold Classical
variable {E : Type*} [Field E] [NumberField E]
[NumberField.IsCMField E]
abbrev Vec (K : Type*) := Fin 3 → K
abbrev Mat (K : Type*) := Matrix (Fin 3) (Fin 3) K
-- Hermitian form linear in its first argument.
def hermitian (b : E) (x y : Vec E) : E :=
∑ i, (if i = 2 then b else 1) * x i *
NumberField.IsCMField.complexConj E (y i)
def complexHermitian (b : E) (μ : E →+* ℂ)
(x y : Vec ℂ) : ℂ :=
∑ i, (if i = 2 then μ b else 1) * x i * star (y i)
-- Principal level N for the lattice O_E^3 in SU(hermitian b)(F).
def principalLevel (b : E) (N : ℕ) (g : Mat E) : Prop :=
g.det = 1 ∧
(∀ x y : Vec E,
hermitian b (g.mulVec x) (g.mulVec y) =
hermitian b x y) ∧
∃ B : Mat (NumberField.RingOfIntegers E),
∀ i j,
g i j - (1 : Mat E) i j =
(N : E) * (B i j : E)
def NegativeVectors (b : E) (μ : E →+* ℂ) :=
{z : Vec ℂ // (complexHermitian b μ z z).re < 0}
/-- The negative cone has the topology induced from complex three-space. -/
instance negativeVectorsTopologicalSpace (b : E) (μ : E →+* ℂ) :
TopologicalSpace (NegativeVectors b μ) :=
inferInstanceAs (TopologicalSpace
{z : Vec ℂ // (complexHermitian b μ z z).re < 0})
-- Quotienting also by nonzero scalars passes from vectors to lines.
def orbitRelation (b : E) (μ : E →+* ℂ) (N : ℕ)
(z w : NegativeVectors b μ) : Prop :=
∃ g : Mat E, principalLevel b N g ∧
∃ t : ℂ, t ≠ 0 ∧
∀ i, w.val i = t * ∑ j, μ (g i j) * z.val j
-- An ambient extension of the projection, used only at negative vectors.
def projection (b : E) (μ : E →+* ℂ)
(R : Setoid (NegativeVectors b μ))
(z₀ : NegativeVectors b μ) (z : Vec ℂ) : Quotient R :=
if hz : (complexHermitian b μ z z).re < 0 then
Quotient.mk R ⟨z, hz⟩
else
Quotient.mk R z₀
end
section
/-! The actual special unitary matrix groups and their equations. The group
over E uses CM conjugation; its complex realizations use ordinary conjugation.
Form preservation is equivalent to nine explicit degree-two equations. -/
open scoped BigOperators Classical
abbrev SL (K : Type*) [CommRing K] := Matrix.SpecialLinearGroup (Fin 3) K
section Ring
variable {K : Type*} [CommRing K]
def diagonalCoefficient (b : K) (i : Fin 3) : K := if i = 2 then b else 1
def form (c : K →+* K) (b : K) (x y : Vec K) : K :=
∑ i, diagonalCoefficient b i * x i * c (y i)
lemma form_axis (c : K →+* K) (b : K) (i j : Fin 3) :
form c b (Pi.single i 1) (Pi.single j 1) =
if i = j then diagonalCoefficient b i else 0 := by
by_cases h : i = j
· subst j
simp [form, Pi.single_apply, apply_ite]
· simp [form, Pi.single_apply, apply_ite, h, Ne.symm h]
/-- The determinant-one isometries of the displayed sesquilinear form. -/
def unitarySubgroup (c : K →+* K) (b : K) : Subgroup (SL K) where
carrier := {g | ∀ x y : Vec K,
form c b (Matrix.SpecialLinearGroup.toLin' g x)
(Matrix.SpecialLinearGroup.toLin' g y) = form c b x y}
one_mem' := by simp
mul_mem' := by
intro g h hg hh x y
rw [map_mul, LinearEquiv.mul_apply, LinearEquiv.mul_apply, hg, hh]
inv_mem' := by
intro g hg x y
have h := hg (Matrix.SpecialLinearGroup.toLin' g⁻¹ x)
(Matrix.SpecialLinearGroup.toLin' g⁻¹ y)
have hc (z : Vec K) :
Matrix.SpecialLinearGroup.toLin' g (Matrix.SpecialLinearGroup.toLin' g⁻¹ z) = z := by
rw [← LinearEquiv.mul_apply, ← map_mul, mul_inv_cancel, map_one]
rfl
simpa only [hc] using h.symm
abbrev SU (c : K →+* K) (b : K) := ↥(unitarySubgroup c b)
def matrixOf (c : K →+* K) (b : K) : SU c b →* Mat K :=
{ toFun := fun g => (g.val : Mat K)
map_one' := rfl
map_mul' := fun _ _ => rfl }
lemma form_mulVec (c : K →+* K) (b : K) (g : Mat K) (x y : Vec K) :
form c b (g.mulVec x) (g.mulVec y) =
∑ i, ∑ j, (∑ k, diagonalCoefficient b k * g k i * c (g k j)) * x i * c (y j) := by
simp only [form, Matrix.mulVec, dotProduct, map_sum, map_mul,
Finset.mul_sum, Finset.sum_mul]
conv_rhs => rw [Finset.sum_comm]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro i _
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro j _
apply Finset.sum_congr rfl
intro k _
ring
/-- The finite system of equations defining form preservation. -/
lemma unitary_iff_columns (c : K →+* K) (b : K) (g : SL K) :
g ∈ unitarySubgroup c b ↔
∀ i j : Fin 3,
(∑ k, diagonalCoefficient b k * g k i * c (g k j)) =
if i = j then diagonalCoefficient b i else 0 := by
constructor
· intro hg i j
have h := hg (Pi.single i 1) (Pi.single j 1)
rw [form_axis] at h
simpa [Matrix.SpecialLinearGroup.toLin'_apply, Matrix.toLin'_apply,
Matrix.mulVec_single, form] using h
· intro hg x y
change form c b ((g : Mat K).mulVec x) ((g : Mat K).mulVec y) = _
rw [form_mulVec]
simp [hg, form]
end Ring
section Map
variable {K L : Type*} [CommRing K] [CommRing L]
/-- Scalar extension along an embedding commuting with the two involutions. -/
def unitaryMap (c : K →+* K) (d : L →+* L) (b : K) (f : K →+* L)
(hc : ∀ x : K, f (c x) = d (f x)) : SU c b →* SU d (f b) where
toFun g := ⟨Matrix.SpecialLinearGroup.map f g.val, by
apply (unitary_iff_columns d (f b) _).mpr
intro i j
have h := congrArg f ((unitary_iff_columns c b g.val).mp g.property i j)
simpa [diagonalCoefficient, map_sum, map_mul, hc, apply_ite] using h⟩
map_one' := by apply Subtype.ext; exact map_one _
map_mul' g h := by apply Subtype.ext; exact map_mul _ g.val h.val
end Map
variable {E : Type*} [Field E] [NumberField E] [NumberField.IsCMField E]
/-- F-rational points of SU(diag(1,1,b)), for a conjugation-fixed b. -/
abbrev RationalSU (b : E) :=
SU (NumberField.IsCMField.complexConj E).toRingHom b
/-- The special unitary real Lie group at the embedding μ. -/
abbrev ArchimedeanSU (b : E) (μ : E →+* ℂ) := SU (starRingEnd ℂ) (μ b)
def infinitePlaceMap (b : E) (μ : E →+* ℂ) : RationalSU b →* ArchimedeanSU b μ :=
unitaryMap _ _ b μ (NumberField.IsCMField.complexEmbedding_complexConj E μ)
lemma rationalSU_preserves (b : E) (g : RationalSU b) (x y : Vec E) :
hermitian b ((matrixOf _ b g).mulVec x) ((matrixOf _ b g).mulVec y) =
hermitian b x y := g.property x y
lemma infinitePlaceMap_injective (b : E) (μ : E →+* ℂ) :
Function.Injective (infinitePlaceMap b μ) := by
intro g h he
apply Subtype.ext
apply Matrix.SpecialLinearGroup.ext
intro i j
apply μ.injective
exact congrArg (fun z : ArchimedeanSU b μ => z.val i j) he
end
section
/-! An explicit quadratic presentation of E over E⁺. This provides the two
real coordinates needed to write the unitary group as polynomial equations
over the actual totally real field. -/
open scoped Classical
open _root_.NumberField
abbrev RealField (E : Type*) [Field E] := maximalRealSubfield E
variable {E : Type*} [Field E] [NumberField E] [IsCMField E]
theorem exists_imaginary_generator :
∃ δ : E, δ ≠ 0 ∧ IsCMField.complexConj E δ = -δ := by
obtain ⟨x, hx⟩ := DFunLike.ne_iff.mp (IsCMField.complexConj_ne_one E)
refine ⟨x - IsCMField.complexConj E x, ?_, ?_⟩
· intro h
exact hx (sub_eq_zero.mp h).symm
· simp only [map_sub, IsCMField.complexConj_apply_apply, neg_sub]
def imaginarySquare (δ : E) (hδ : IsCMField.complexConj E δ = -δ) : RealField E :=
⟨δ ^ 2, (IsCMField.complexConj_eq_self_iff E _).mp (by simp [map_pow, hδ])⟩
def realCoordinate (x : E) : RealField E :=
⟨(x + IsCMField.complexConj E x) / 2,
(IsCMField.complexConj_eq_self_iff E _).mp (by
simp [map_div₀, map_add, map_ofNat, IsCMField.complexConj_apply_apply, add_comm])⟩
def imaginaryCoordinate (δ : E) (hδ : IsCMField.complexConj E δ = -δ) (x : E) : RealField E :=
⟨(x - IsCMField.complexConj E x) / (2 * δ),
(IsCMField.complexConj_eq_self_iff E _).mp (by
simp only [map_div₀, map_sub, map_mul, map_ofNat,
IsCMField.complexConj_apply_apply, hδ, mul_neg]
rw [← neg_sub, neg_div_neg_eq])⟩
lemma coordinate_decomposition (δ : E) (hδ : IsCMField.complexConj E δ = -δ)
(hδ0 : δ ≠ 0) (x : E) :
(realCoordinate x : E) + (imaginaryCoordinate δ hδ x : E) * δ = x := by
change (x + IsCMField.complexConj E x) / 2 +
((x - IsCMField.complexConj E x) / (2 * δ)) * δ = x
field_simp
ring
def quadraticLift (δ : E) (hδ : IsCMField.complexConj E δ = -δ) :
QuadraticAlgebra (RealField E) (imaginarySquare δ hδ) 0 →ₐ[RealField E] E :=
QuadraticAlgebra.lift ⟨δ, by
simp only [Algebra.smul_def, map_zero, zero_mul, add_zero, mul_one]
change δ * δ = δ ^ 2
exact (pow_two δ).symm⟩
lemma quadraticLift_apply (δ : E) (hδ : IsCMField.complexConj E δ = -δ)
(z : QuadraticAlgebra (RealField E) (imaginarySquare δ hδ) 0) :
quadraticLift δ hδ z = (z.re : E) + (z.im : E) * δ := by
simp [quadraticLift, QuadraticAlgebra.lift, Algebra.smul_def]
rfl
lemma quadraticLift_conjugate (δ : E) (hδ : IsCMField.complexConj E δ = -δ)
(z : QuadraticAlgebra (RealField E) (imaginarySquare δ hδ) 0) :
IsCMField.complexConj E (quadraticLift δ hδ z) = (z.re : E) - (z.im : E) * δ := by
simp [quadraticLift_apply, map_add, map_mul,
IsCMField.complexConj_apply_eq_self, hδ, sub_eq_add_neg]
lemma realCoordinate_quadraticLift (δ : E) (hδ : IsCMField.complexConj E δ = -δ)
(z : QuadraticAlgebra (RealField E) (imaginarySquare δ hδ) 0) :
realCoordinate (quadraticLift δ hδ z) = z.re := by
apply Subtype.ext
change (quadraticLift δ hδ z + IsCMField.complexConj E (quadraticLift δ hδ z)) / 2 = _
rw [quadraticLift_conjugate, quadraticLift_apply]
field_simp
ring
lemma imaginaryCoordinate_quadraticLift (δ : E) (hδ : IsCMField.complexConj E δ = -δ)
(hδ0 : δ ≠ 0) (z : QuadraticAlgebra (RealField E) (imaginarySquare δ hδ) 0) :
imaginaryCoordinate δ hδ (quadraticLift δ hδ z) = z.im := by
apply Subtype.ext
change (quadraticLift δ hδ z - IsCMField.complexConj E (quadraticLift δ hδ z)) / (2 * δ) = _
rw [quadraticLift_conjugate, quadraticLift_apply]
field_simp
ring
/-- The quadratic algebra is the actual CM field, not an assumed model. -/
def quadraticEquiv (δ : E) (hδ : IsCMField.complexConj E δ = -δ) (hδ0 : δ ≠ 0) :
QuadraticAlgebra (RealField E) (imaginarySquare δ hδ) 0 ≃ₐ[RealField E] E :=
AlgEquiv.ofBijective (quadraticLift δ hδ) ⟨by
intro z w h
apply QuadraticAlgebra.ext
· have hh := congrArg realCoordinate h
simpa only [realCoordinate_quadraticLift] using hh
· have hh := congrArg (imaginaryCoordinate δ hδ) h
simpa only [imaginaryCoordinate_quadraticLift δ hδ hδ0] using hh,
by
intro x
refine ⟨⟨realCoordinate x, imaginaryCoordinate δ hδ x⟩, ?_⟩
exact (quadraticLift_apply _ _ _).trans (coordinate_decomposition δ hδ hδ0 x)⟩
lemma imaginary_generator_embedding_re (δ : E) (hδ : IsCMField.complexConj E δ = -δ)
(μ : E →+* ℂ) : (μ δ).re = 0 := by
have h := congrArg (fun x : E => (μ x).re) hδ
rw [IsCMField.complexEmbedding_complexConj, map_neg] at h
change (μ δ).re = -(μ δ).re at h
linarith
lemma imaginary_square_negative (δ : E) (hδ : IsCMField.complexConj E δ = -δ)
(hδ0 : δ ≠ 0) (μ : E →+* ℂ) : (μ (imaginarySquare δ hδ : E)).re < 0 := by
have hμ0 : μ δ ≠ 0 := (map_ne_zero μ).mpr hδ0
have hre := imaginary_generator_embedding_re δ hδ μ
have him : (μ δ).im ≠ 0 := by
intro h
apply hμ0
exact Complex.ext hre h
change (μ (δ ^ 2)).re < 0
rw [map_pow]
simp only [pow_two, Complex.mul_re, hre, zero_mul, zero_sub]
exact neg_neg_of_pos (mul_self_pos.mpr him)
end
section
/-! Explicit six-dimensional restriction of scalars for a rank-three module
over K[δ]/(δ²-d). Entries are polynomial in d and in the two coordinates of
each original matrix entry. -/
open scoped BigOperators Classical QuadraticAlgebra
section Ring
variable {K : Type*} [CommRing K]
def quadraticRegular (d : K) : QuadraticAlgebra K d 0 →+* Matrix (Fin 2) (Fin 2) K where
toFun z := !![z.re, d * z.im; z.im, z.re]
map_one' := by
ext i j
fin_cases i <;> fin_cases j <;> simp
map_zero' := by
ext i j
fin_cases i <;> fin_cases j <;> simp
map_add' z w := by
ext i j
fin_cases i <;> fin_cases j <;> simp
ring
map_mul' z w := by
ext i j
fin_cases i <;> fin_cases j <;>
simp [Matrix.mul_apply, Fin.sum_univ_two] <;> ring
abbrev pairIndex : Fin 3 × Fin 2 ≃ Fin 6 := finProdFinEquiv
/-- The faithful regular matrix representation over K. -/
def regularMatrix (d : K) :
Mat (QuadraticAlgebra K d 0) →+* Matrix (Fin 6) (Fin 6) K :=
(Matrix.reindexRingEquiv K pairIndex).toRingHom.comp
((Matrix.compRingEquiv (Fin 3) (Fin 2) K).toRingHom.comp
(quadraticRegular d).mapMatrix)
lemma regularMatrix_entry (d : K) (A : Mat (QuadraticAlgebra K d 0))
(i j : Fin 3) (a b : Fin 2) :
regularMatrix d A (pairIndex (i, a)) (pairIndex (j, b)) =
quadraticRegular d (A i j) a b := by
simp [regularMatrix, Matrix.reindex_apply, Matrix.comp_apply]
/-- The first column of each 2 by 2 block recovers its quadratic entry. -/
def decodeMatrix (d : K) (M : Matrix (Fin 6) (Fin 6) K) : Mat (QuadraticAlgebra K d 0) :=
fun i j => ⟨M (pairIndex (i, 0)) (pairIndex (j, 0)),
M (pairIndex (i, 1)) (pairIndex (j, 0))⟩
@[simp] lemma decode_regularMatrix (d : K) (A : Mat (QuadraticAlgebra K d 0)) :
decodeMatrix d (regularMatrix d A) = A := by
apply Matrix.ext
intro i j
apply QuadraticAlgebra.ext
· simp [decodeMatrix, regularMatrix_entry, quadraticRegular]
· simp [decodeMatrix, regularMatrix_entry, quadraticRegular]
theorem regularMatrix_injective (d : K) : Function.Injective (regularMatrix d) :=
Function.LeftInverse.injective (decode_regularMatrix d)
end Ring
variable {K L : Type*} [CommRing K] [CommRing L]
def quadraticMap (d : K) (f : K →+* L) :
QuadraticAlgebra K d 0 →+* QuadraticAlgebra L (f d) 0 where
toFun z := ⟨f z.re, f z.im⟩
map_one' := by ext <;> simp
map_zero' := by ext <;> simp
map_add' z w := by ext <;> simp
map_mul' z w := by ext <;> simp [map_add, map_mul]
lemma quadraticRegular_map (d : K) (f : K →+* L) (z : QuadraticAlgebra K d 0) :
quadraticRegular (f d) (quadraticMap d f z) = (quadraticRegular d z).map f := by
ext i j
fin_cases i <;> fin_cases j <;> simp [quadraticRegular, quadraticMap, map_mul]
theorem regularMatrix_map (d : K) (f : K →+* L) (A : Mat (QuadraticAlgebra K d 0)) :
regularMatrix (f d) (A.map (quadraticMap d f)) = (regularMatrix d A).map f := by
apply Matrix.ext
intro i j
obtain ⟨⟨i, a⟩, rfl⟩ := pairIndex.surjective i
obtain ⟨⟨j, b⟩, rfl⟩ := pairIndex.surjective j
simp only [regularMatrix_entry, Matrix.map_apply]
exact congrArg (fun M : Matrix (Fin 2) (Fin 2) L => M a b) (quadraticRegular_map d f (A i j))
end
section
/-! The explicit regular matrices are the matrices of restriction of scalars
in a specified basis. In particular their determinant is the quadratic norm
of the original determinant, so determinant-one matrices map into SL(6). -/
open scoped BigOperators Classical QuadraticAlgebra
variable {K : Type*} [CommRing K]
def quadraticCoordinates (d : K) :
Vec (QuadraticAlgebra K d 0) ≃ₗ[K] (Fin 6 → K) where
toFun x i := if (pairIndex.symm i).2 = 0 then (x (pairIndex.symm i).1).re
else (x (pairIndex.symm i).1).im
invFun y i := ⟨y (pairIndex (i, 0)), y (pairIndex (i, 1))⟩
left_inv x := by ext i <;> simp
right_inv y := by
ext i
obtain ⟨⟨i, a⟩, rfl⟩ := pairIndex.surjective i
fin_cases a <;> simp
map_add' x y := by
ext i
split_ifs <;> simp_all
map_smul' a x := by
ext i
split_ifs <;> simp_all
lemma quadraticCoordinates_pair (d : K) (x : Vec (QuadraticAlgebra K d 0))
(i : Fin 3) (a : Fin 2) :
quadraticCoordinates d x (pairIndex (i, a)) =
if a = 0 then (x i).re else (x i).im := by
simp [quadraticCoordinates]
def restrictionBasis (d : K) : Module.Basis (Fin 6) K (Vec (QuadraticAlgebra K d 0)) :=
Module.Basis.ofEquivFun (quadraticCoordinates d)
theorem quadraticCoordinates_mulVec (d : K) (A : Mat (QuadraticAlgebra K d 0))
(x : Vec (QuadraticAlgebra K d 0)) :
quadraticCoordinates d (A.mulVec x) =
(regularMatrix d A).mulVec (quadraticCoordinates d x) := by
ext r
obtain ⟨⟨i, a⟩, rfl⟩ := pairIndex.surjective r
change _ = ∑ j : Fin 6, regularMatrix d A (pairIndex (i, a)) j * quadraticCoordinates d x j
rw [← Equiv.sum_comp pairIndex]
rw [Fintype.sum_prod_type]
simp only [regularMatrix_entry, quadraticCoordinates_pair]
fin_cases a
· simp [quadraticRegular, Matrix.mulVec, dotProduct, Fin.sum_univ_succ]
· simp [quadraticRegular, Matrix.mulVec, dotProduct, Fin.sum_univ_succ]
ring
theorem regularMatrix_eq_restriction (d : K) (A : Mat (QuadraticAlgebra K d 0)) :
regularMatrix d A = LinearMap.toMatrix (restrictionBasis d) (restrictionBasis d)
((Matrix.toLin' A).restrictScalars K) := by
apply Matrix.ext
intro i j
rw [LinearMap.toMatrix_apply]
simp only [restrictionBasis, Module.Basis.ofEquivFun_repr_apply, Module.Basis.coe_ofEquivFun]
change regularMatrix d A i j =
quadraticCoordinates d (A.mulVec ((quadraticCoordinates d).symm (Pi.single j 1))) i
rw [quadraticCoordinates_mulVec, LinearEquiv.apply_symm_apply]
simp [Matrix.mulVec_single]
theorem regularMatrix_det (d : K) (A : Mat (QuadraticAlgebra K d 0)) :
(regularMatrix d A).det = Algebra.norm K A.det := by
rw [regularMatrix_eq_restriction, LinearMap.det_toMatrix, LinearMap.det_restrictScalars,
LinearMap.det_toLin']
def regularSpecialLinear (d : K) :
SL (QuadraticAlgebra K d 0) →* Matrix.SpecialLinearGroup (Fin 6) K where
toFun g := ⟨regularMatrix d (g : Mat (QuadraticAlgebra K d 0)), by
rw [regularMatrix_det, g.property, map_one]⟩
map_one' := Subtype.ext (map_one (regularMatrix d))
map_mul' g h := Subtype.ext (map_mul (regularMatrix d) _ _)
theorem regularSpecialLinear_injective (d : K) :
Function.Injective (regularSpecialLinear d) := by
intro g h he
apply Subtype.ext
exact regularMatrix_injective d (congrArg Subtype.val he)
end
section
/-! The actual special unitary group as a subgroup of SL(6), with explicit
finite equations characterizing its image. These equations consist of block
shape, the quadratic-valued determinant, and Hermitian column pairings. -/
open scoped BigOperators Classical QuadraticAlgebra
section Ring
variable {K : Type*} [CommRing K]
def columnError (d b : K) (A : Mat (QuadraticAlgebra K d 0)) :
Mat (QuadraticAlgebra K d 0) := fun i j =>
(∑ k, diagonalCoefficient (algebraMap K _ b) k * A k i * star (A k j)) -
if i = j then diagonalCoefficient (algebraMap K _ b) i else 0
lemma columnError_eq_zero_iff (d b : K) (A : SL (QuadraticAlgebra K d 0)) :
columnError d b (A : Mat (QuadraticAlgebra K d 0)) = 0 ↔
A ∈ unitarySubgroup (starRingEnd _) (algebraMap K _ b) := by
rw [unitary_iff_columns]
constructor
· intro h i j
have hij := congrArg (fun M : Mat (QuadraticAlgebra K d 0) => M i j) h
exact sub_eq_zero.mp hij
· intro h
apply Matrix.ext
intro i j
exact sub_eq_zero.mpr (h i j)
/-- The faithful six-dimensional special unitary group over K. -/
def sixDimensionalUnitary (d b : K) : Subgroup (Matrix.SpecialLinearGroup (Fin 6) K) :=
(unitarySubgroup (starRingEnd (QuadraticAlgebra K d 0)) (algebraMap K _ b)).map
(regularSpecialLinear d)
/-- Explicit equations characterize membership, with no realization assumed. -/
theorem mem_sixDimensionalUnitary_iff (d b : K) (M : Matrix.SpecialLinearGroup (Fin 6) K) :
M ∈ sixDimensionalUnitary d b ↔
regularMatrix d (decodeMatrix d M.val) = M.val ∧
(decodeMatrix d M.val).det = 1 ∧
columnError d b (decodeMatrix d M.val) = 0 := by
constructor
· rintro ⟨A, hA, rfl⟩
change regularMatrix d (decodeMatrix d (regularMatrix d A.val)) = regularMatrix d A.val ∧
(decodeMatrix d (regularMatrix d A.val)).det = 1 ∧
columnError d b (decodeMatrix d (regularMatrix d A.val)) = 0
rw [decode_regularMatrix]
exact ⟨rfl, A.property, (columnError_eq_zero_iff d b A).mpr hA⟩
· rintro ⟨hshape, hdet, hform⟩
let A : SL (QuadraticAlgebra K d 0) := ⟨decodeMatrix d M.val, hdet⟩
exact ⟨A, (columnError_eq_zero_iff d b A).mp hform, Subtype.ext hshape⟩
end Ring
variable {K L : Type*} [CommRing K] [CommRing L]
lemma quadraticMap_star (d : K) (f : K →+* L) (z : QuadraticAlgebra K d 0) :
quadraticMap d f (star z) = star (quadraticMap d f z) := by
apply QuadraticAlgebra.ext <;> simp [quadraticMap, QuadraticAlgebra.re_star,
QuadraticAlgebra.im_star]
lemma quadraticMap_algebraMap (d b : K) (f : K →+* L) :
quadraticMap d f (algebraMap K (QuadraticAlgebra K d 0) b) =
algebraMap L (QuadraticAlgebra L (f d) 0) (f b) := by
apply QuadraticAlgebra.ext <;> simp [quadraticMap]
lemma columnError_map (d b : K) (f : K →+* L) (A : Mat (QuadraticAlgebra K d 0)) :
(columnError d b A).map (quadraticMap d f) =
columnError (f d) (f b) (A.map (quadraticMap d f)) := by
apply Matrix.ext
intro i j
simp only [Matrix.map_apply, columnError, map_sub, map_sum, map_mul,
diagonalCoefficient, apply_ite, map_one, map_zero,
quadraticMap_algebraMap, quadraticMap_star]
split_ifs <;> simp_all
lemma decodeMatrix_map (d : K) (f : K →+* L) (M : Matrix (Fin 6) (Fin 6) K) :
(decodeMatrix d M).map (quadraticMap d f) = decodeMatrix (f d) (M.map f) := rfl
end
/-! Actual ground-field polynomials cutting out the six-dimensional unitary
group. Evaluation of this fixed family recovers its matrix equations over
every scalar extension. -/
open scoped BigOperators Classical QuadraticAlgebra
abbrev EquationIndex := (Fin 6 × Fin 6) ⊕ (Fin 2 ⊕ ((Fin 3 × Fin 3) × Fin 2))
def quadraticComponent {K : Type*} [Zero K] {d : K}
(a : Fin 2) (z : QuadraticAlgebra K d (0 : K)) : K := if a = 0 then z.re else z.im
section Ring
variable {K : Type*} [CommRing K]
def unitaryEquation (d b : K) (M : Matrix (Fin 6) (Fin 6) K) : EquationIndex → K
| .inl (i, j) => M i j - regularMatrix d (decodeMatrix d M) i j
| .inr (.inl a) => quadraticComponent a ((decodeMatrix d M).det - 1)
| .inr (.inr ((i, j), a)) => quadraticComponent a (columnError d b (decodeMatrix d M) i j)
theorem unitaryEquation_zero_iff (d b : K) (M : Matrix.SpecialLinearGroup (Fin 6) K) :
(∀ e : EquationIndex, unitaryEquation d b M.val e = 0) ↔
M ∈ sixDimensionalUnitary d b := by
rw [mem_sixDimensionalUnitary_iff]
constructor
· intro h
refine ⟨?_, ?_, ?_⟩
· apply Matrix.ext
intro i j
exact (sub_eq_zero.mp (h (.inl (i, j)))).symm
· apply sub_eq_zero.mp
apply QuadraticAlgebra.ext
· exact h (.inr (.inl 0))
· exact h (.inr (.inl 1))
· apply Matrix.ext
intro i j
apply QuadraticAlgebra.ext
· exact h (.inr (.inr ((i, j), 0)))
· exact h (.inr (.inr ((i, j), 1)))
· rintro ⟨hshape, hdet, hcol⟩ e
rcases e with ⟨i, j⟩ | (a | ⟨⟨i, j⟩, a⟩) <;>
simp [unitaryEquation, hshape, hdet, hcol, quadraticComponent]
end Ring
section ScalarExtension
variable {K L : Type*} [CommRing K] [CommRing L]
lemma quadraticComponent_map (d : K) (f : K →+* L) (a : Fin 2)
(z : QuadraticAlgebra K d 0) :
f (quadraticComponent a z) = quadraticComponent a (quadraticMap d f z) := by
fin_cases a <;> simp [quadraticComponent, quadraticMap]
lemma decode_determinant_map (d : K) (f : K →+* L) (M : Matrix (Fin 6) (Fin 6) K) :
quadraticMap d f ((decodeMatrix d M).det - 1) =
(decodeMatrix (f d) (M.map f)).det - 1 := by
rw [map_sub, map_one, RingHom.map_det, RingHom.mapMatrix_apply, decodeMatrix_map]
lemma unitaryEquation_map (d b : K) (f : K →+* L) (M : Matrix (Fin 6) (Fin 6) K)
(e : EquationIndex) :
f (unitaryEquation d b M e) = unitaryEquation (f d) (f b) (M.map f) e := by
rcases e with ⟨i, j⟩ | (a | ⟨⟨i, j⟩, a⟩)
· have h := regularMatrix_map d f (decodeMatrix d M)
rw [decodeMatrix_map] at h
change f (M i j - regularMatrix d (decodeMatrix d M) i j) =
f (M i j) - regularMatrix (f d) (decodeMatrix (f d) (M.map f)) i j
rw [map_sub, h]
rfl
· change f (quadraticComponent a ((decodeMatrix d M).det - 1)) = _
rw [quadraticComponent_map, decode_determinant_map]
rfl
· have h := columnError_map d b f (decodeMatrix d M)
rw [decodeMatrix_map] at h
change f (quadraticComponent a (columnError d b (decodeMatrix d M) i j)) = _
rw [quadraticComponent_map]
exact congrArg (fun A : Mat (QuadraticAlgebra L (f d) 0) => quadraticComponent a (A i j)) h
end ScalarExtension
abbrev GroundPolynomial (K : Type*) [CommRing K] := MvPolynomial (Fin 6 × Fin 6) K
def variableMatrix (K : Type*) [CommRing K] : Matrix (Fin 6) (Fin 6) (GroundPolynomial K) :=
fun i j => MvPolynomial.X (i, j)
def unitaryPolynomial {K : Type*} [CommRing K] (d b : K) (e : EquationIndex) : GroundPolynomial K :=
unitaryEquation (MvPolynomial.C d) (MvPolynomial.C b) (variableMatrix K) e
theorem unitaryPolynomial_eval {K L : Type*} [CommRing K] [CommRing L]
(d b : K) (f : K →+* L) (M : Matrix (Fin 6) (Fin 6) L) (e : EquationIndex) :
MvPolynomial.eval₂Hom f (fun ij => M ij.1 ij.2) (unitaryPolynomial d b e) =
unitaryEquation (f d) (f b) M e := by
let φ : GroundPolynomial K →+* L := MvPolynomial.eval₂Hom f (fun ij => M ij.1 ij.2)
have hM : (variableMatrix K).map φ = M := by
ext i j
simp [variableMatrix, φ]
change φ (unitaryEquation (MvPolynomial.C d) (MvPolynomial.C b) (variableMatrix K) e) = _
rw [unitaryEquation_map, hM]
simp only [φ, MvPolynomial.eval₂Hom_C]
end
end OAI.Geometry.ComplexBall.ArithmeticQuotientEquationsData