Download data/lean/OAI/Geometry/ComplexBall/ArithmeticQuotientEquationsData.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 26.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBall/ArithmeticQuotientEquationsData.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/ComplexBall/ArithmeticQuotientEquationsData.lean
-
curl -L -o ArithmeticQuotientEquationsData.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/ComplexBall/ArithmeticQuotientEquationsData.lean
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 | |