| import OAI.AlgebraicGeometry.SurfaceCones.KummerTripleDiagonalCoordinates |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Algebra MvPolynomial |
| open nonZeroDivisors |
| namespace KummerShifted |
| open KummerLines |
| variable (p : ℕ) [Fact p.Prime] |
|
|
| /-- The actual blowup chart open containing s=t=0 (the intersection of |
| its exceptional divisor with the strict transform of y=0). -/ |
| def cX (i : Fin 2) : C := X i |
| def chartDenominator : C := (cX 0 * cX 1 + 1) * (cX 0 + 1) * (cX 1 - 1) |
| lemma chartDenominator_ne_zero : chartDenominator ≠ 0 := by |
| let f : C →+* ℂ := MvPolynomial.eval ![(0 : ℂ), 2] |
| have hf (i : Fin 2) : f (cX i) = ![(0 : ℂ), 2] i := by |
| exact MvPolynomial.eval_X i |
| intro hz |
| have he := congrArg f hz |
| simp only [chartDenominator, map_mul, map_sub, map_add, map_one, map_zero, hf] at he |
| norm_num at he |
| lemma planeMap_injective : Function.Injective (planeMap p) := by |
| intro a b h |
| apply chartMap_injective p |
| exact congrArg (fun g : C →ₐ[ℂ] L p => g a) (planeMap_comp p).symm |>.trans |
| ((congrArg (fun z : B p => (z : L p)) h).trans |
| (congrArg (fun g : C →ₐ[ℂ] L p => g b) (planeMap_comp p))) |
|
|
| def bDenominator : B p := planeMap p chartDenominator |
| lemma bDenominator_ne_zero : bDenominator p ≠ 0 := |
| (map_ne_zero_iff _ (planeMap_injective p)).mpr chartDenominator_ne_zero |
| lemma bPowers_le : Submonoid.powers (bDenominator p) ≤ (B p)⁰ := by |
| rintro _ ⟨n, rfl⟩ |
| exact mem_nonZeroDivisors_of_ne_zero (pow_ne_zero n (bDenominator_ne_zero p)) |
|
|
| def S := Localization.Away (bDenominator p) |
| instance : CommRing (S p) := inferInstanceAs (CommRing (Localization.Away (bDenominator p))) |
| instance : Algebra (B p) (S p) := |
| OreLocalization.instAlgebra (R := B p) (R₀ := B p) |
| (S := Submonoid.powers (bDenominator p)) |
| instance : IsLocalization.Away (bDenominator p) (S p) := Localization.isLocalization |
| instance : IsDomain (S p) := |
| IsLocalization.isDomain_of_le_nonZeroDivisors _ (bPowers_le p) |
| instance : IsIntegrallyClosed (S p) := |
| isIntegrallyClosed_of_isLocalization (S p) (Submonoid.powers (bDenominator p)) (bPowers_le p) |
| instance : Algebra.Etale (B p) (S p) := |
| Algebra.Etale.of_isLocalizationAway (bDenominator p) |
| instance : IsRegularRing (S p) := EtaleRegular.regular (B p) (S p) |
|
|
| lemma bDenominator_unit_in_L : IsUnit (algebraMap (B p) (L p) (bDenominator p)) := by |
| apply isUnit_iff_ne_zero.mpr |
| exact (map_ne_zero_iff _ (Subtype.val_injective)).mpr (bDenominator_ne_zero p) |
| |
| instance : Algebra (S p) (L p) := |
| (IsLocalization.Away.lift (bDenominator p) (bDenominator_unit_in_L p) : S p →+* L p).toAlgebra |
| instance : IsScalarTower (B p) (S p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := B p) (S := S p) (A := L p) |
| (IsLocalization.Away.lift_comp (S := S p) (bDenominator p) (bDenominator_unit_in_L p)).symm |
| instance : Module.IsTorsionFree (S p) (L p) := by |
| apply Module.isTorsionFree_iff_algebraMap_injective.mpr |
| change Function.Injective (IsLocalization.Away.lift (bDenominator p) (bDenominator_unit_in_L p)) |
| apply (IsLocalization.lift_injective_iff _).mpr |
| intro a b |
| rw [(IsLocalization.injective (S p) (bPowers_le p)).eq_iff] |
| change a = b ↔ (a : L p) = (b : L p) |
| exact Subtype.val_injective.eq_iff.symm |
| instance : Algebra C (S p) := (algebraMap (B p) (S p)).comp (algebraMap C (B p)) |>.toAlgebra |
| instance : IsScalarTower C (B p) (S p) := |
| IsScalarTower.of_algebraMap_eq' (R := C) (S := B p) (A := S p) rfl |
| instance : IsScalarTower C (S p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := C) (S := S p) (A := L p) (by |
| rw [IsScalarTower.algebraMap_eq C (B p) (L p), IsScalarTower.algebraMap_eq (B p) (S p) (L p)] |
| rfl) |
|
|
| def remainingRoot : Fin 3 → L p := ![root p 0, root p 1, root p 4 / root p 3] |
| def remainingForm : Fin 3 → C := ![cX 0 * cX 1 + 1, cX 0 + 1, cX 1 - 1] |
| lemma remaining_dvd (i : Fin 3) : remainingForm i ∣ chartDenominator := by |
| fin_cases i <;> simp only [remainingForm, chartDenominator] |
| · exact dvd_mul_of_dvd_left (dvd_mul_right _ _) _ |
| · exact dvd_mul_of_dvd_left (dvd_mul_left _ _) _ |
| · exact dvd_mul_left _ _ |
| lemma remaining_unit (i : Fin 3) : IsUnit (algebraMap C (S p) (remainingForm i)) := |
| IsLocalization.Away.isUnit_of_dvd (S := S p) (bDenominator p) |
| (map_dvd (planeMap p) (remaining_dvd i)) |
| lemma chartMap_X (i : Fin 2) : chartMap p (cX i) = |
| ![algebraMap R (L p) (X 1 - 1), |
| algebraMap R (L p) (X 0 - 1) / algebraMap R (L p) (X 1 - 1)] i := by |
| change MvPolynomial.aeval _ (X i) = _ |
| exact MvPolynomial.aeval_X _ _ |
| lemma remainingRoot_pow (i : Fin 3) : remainingRoot p i ^ p = |
| algebraMap C (L p) (remainingForm i) := by |
| have hd : algebraMap R (L p) (X 1 - 1) ≠ 0 := by |
| rw [← coordinateRoot_zero_pow p] |
| exact pow_ne_zero _ (root_ne_zero p 3) |
| fin_cases i |
| · change root p 0 ^ p = chartMap p (cX 0 * cX 1 + 1) |
| rw [root_pow, map_add, map_one, map_mul, chartMap_X, chartMap_X] |
| change algebraMap R (L p) (X 0) = algebraMap R (L p) (X 1 - 1) * |
| (algebraMap R (L p) (X 0 - 1) / algebraMap R (L p) (X 1 - 1)) + 1 |
| rw [mul_div_cancel₀ _ hd, map_sub, map_one, sub_add_cancel] |
| · change root p 1 ^ p = chartMap p (cX 0 + 1) |
| rw [root_pow, map_add, map_one, chartMap_X] |
| change algebraMap R (L p) (X 1) = algebraMap R (L p) (X 1 - 1) + 1 |
| rw [map_sub, map_one, sub_add_cancel] |
| · change (root p 4 / root p 3) ^ p = chartMap p (cX 1 - 1) |
| rw [div_pow, root_pow, root_pow, map_sub, map_one, chartMap_X] |
| change algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1) = |
| algebraMap R (L p) (X 0 - 1) / algebraMap R (L p) (X 1 - 1) - 1 |
| apply (div_eq_iff hd).mpr |
| rw [sub_mul, div_mul_cancel₀ _ hd, one_mul, map_sub, map_sub, map_sub, map_one] |
| ring |
| lemma exponent_unit : IsUnit (p : S p) := by |
| have hC : IsUnit (p : ℂ) := isUnit_iff_ne_zero.mpr (by exact_mod_cast (NeZero.ne p)) |
| have hB : IsUnit (p : B p) := by simpa using hC.map (algebraMap ℂ (B p)) |
| simpa using hB.map (algebraMap (B p) (S p)) |
|
|
| def remainingRoots : Finset (L p) := by |
| classical |
| exact Finset.univ.image (fun i : Fin 3 => remainingRoot p i) |
| abbrev chartRootAlgebra := Algebra.adjoin (S p) (remainingRoots p : Set (L p)) |
|
|
| theorem chartRootAlgebra_finiteFreeEtale : |
| Algebra.Etale (S p) (chartRootAlgebra p) ∧ |
| Module.Finite (S p) (chartRootAlgebra p) ∧ |
| Module.Free (S p) (chartRootAlgebra p) ∧ |
| IsIntegrallyClosed (chartRootAlgebra p) := by |
| apply KummerEtale.finite_unit_roots (R := S p) (L := L p) p |
| (NeZero.pos p) (exponent_unit p) (remainingRoots p) |
| intro x hx |
| classical |
| obtain ⟨i, -, rfl⟩ := Finset.mem_image.mp (show x ∈ Finset.univ.image _ from hx) |
| refine ⟨(remaining_unit p i).unit, ?_⟩ |
| rw [IsUnit.unit_spec, ← IsScalarTower.algebraMap_apply C (S p) (L p)] |
| exact remainingRoot_pow p i |
|
|
| theorem chartRootAlgebra_regular : IsRegularRing (chartRootAlgebra p) := by |
| have := (chartRootAlgebra_finiteFreeEtale p).1 |
| exact EtaleRegular.regular (S p) (chartRootAlgebra p) |
| end KummerShifted |
|
|
| end |
|
|
|
|
| noncomputable section |
| open Algebra MvPolynomial |
| open nonZeroDivisors |
| namespace KummerShifted |
| open KummerLines |
| variable (p : ℕ) [Fact p.Prime] |
| instance : IsDomain C := inferInstanceAs (IsDomain (MvPolynomial (Fin 2) ℂ)) |
| instance : Module.IsTorsionFree C (L p) := |
| Module.isTorsionFree_iff_algebraMap_injective.mpr (chartMap_injective p) |
|
|
| /-- The actual open D((st+1)(s+1)(t−1)) of the blowup chart. -/ |
| def T := Localization.Away chartDenominator |
| instance : CommRing T := inferInstanceAs (CommRing (Localization.Away chartDenominator)) |
| instance : Algebra C T := OreLocalization.instAlgebra (R := C) (R₀ := C) |
| (S := Submonoid.powers chartDenominator) |
| instance : IsLocalization.Away chartDenominator T := Localization.isLocalization |
| instance coordinateMappedLocalization : |
| IsLocalization (Algebra.algebraMapSubmonoid (B p) (Submonoid.powers chartDenominator)) (S p) := by |
| change IsLocalization ((Submonoid.powers chartDenominator).map (algebraMap C (B p))) (S p) |
| rw [Submonoid.map_powers] |
| exact inferInstanceAs (IsLocalization.Away (bDenominator p) (S p)) |
| instance : Algebra T (S p) := localizationAlgebra (Submonoid.powers chartDenominator) (B p) |
| instance : IsScalarTower C T (S p) := |
| isScalarTower_localizationAlgebra (Submonoid.powers chartDenominator) (B p) |
| instance : Algebra T (L p) := ((algebraMap (S p) (L p)).comp (algebraMap T (S p))).toAlgebra |
| instance : IsScalarTower T (S p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := T) (S := S p) (A := L p) rfl |
| instance : IsScalarTower C T (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := C) (S := T) (A := L p) (by |
| rw [IsScalarTower.algebraMap_eq C (S p) (L p), IsScalarTower.algebraMap_eq C T (S p)] |
| rfl) |
| instance : Algebra.IsIntegral T (S p) := ⟨isIntegral_localization⟩ |
| instance : Module.Finite T (S p) := |
| Module.Finite.of_isLocalizedModule (Submonoid.powers chartDenominator) |
| (IsScalarTower.toAlgHom C (B p) (S p)).toLinearMap |
| |
| instance : Algebra T (chartRootAlgebra p) := |
| ((algebraMap (S p) (chartRootAlgebra p)).comp (algebraMap T (S p))).toAlgebra |
| instance : IsScalarTower T (S p) (chartRootAlgebra p) := |
| IsScalarTower.of_algebraMap_eq' (R := T) (S := S p) (A := chartRootAlgebra p) rfl |
| instance : IsScalarTower T (chartRootAlgebra p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := T) (S := chartRootAlgebra p) (A := L p) (by |
| rw [IsScalarTower.algebraMap_eq T (S p) (L p), |
| IsScalarTower.algebraMap_eq (S p) (chartRootAlgebra p) (L p)] |
| rfl) |
| instance : Algebra C (chartRootAlgebra p) := |
| ((algebraMap (S p) (chartRootAlgebra p)).comp (algebraMap C (S p))).toAlgebra |
| instance : IsScalarTower C (S p) (chartRootAlgebra p) := |
| IsScalarTower.of_algebraMap_eq' (R := C) (S := S p) (A := chartRootAlgebra p) rfl |
| instance : IsScalarTower C (chartRootAlgebra p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := C) (S := chartRootAlgebra p) (A := L p) (by |
| rw [IsScalarTower.algebraMap_eq C (S p) (L p), |
| IsScalarTower.algebraMap_eq (S p) (chartRootAlgebra p) (L p)] |
| rfl) |
| instance : Module.Finite (S p) (chartRootAlgebra p) := (chartRootAlgebra_finiteFreeEtale p).2.1 |
| instance : Module.Finite T (chartRootAlgebra p) := Module.Finite.trans (S p) (chartRootAlgebra p) |
| instance : IsIntegrallyClosed (chartRootAlgebra p) := (chartRootAlgebra_finiteFreeEtale p).2.2.2 |
|
|
| lemma coordinateRoot_mem_chartRootAlgebra (i : Fin 2) : |
| coordinateRoot p i ∈ chartRootAlgebra p := by |
| have h := (chartRootAlgebra p).algebraMap_mem (algebraMap (B p) (S p) (bRoot p i)) |
| rw [← IsScalarTower.algebraMap_apply (B p) (S p) (L p)] at h |
| exact h |
| lemma remainingRoot_mem_chartRootAlgebra (i : Fin 3) : |
| remainingRoot p i ∈ chartRootAlgebra p := by |
| apply Algebra.subset_adjoin |
| classical |
| exact Finset.mem_image.mpr ⟨i, Finset.mem_univ i, rfl⟩ |
| lemma allRoots_mem_chartRootAlgebra (i : Fin 5) : |
| root p i ∈ chartRootAlgebra p := by |
| fin_cases i |
| · exact remainingRoot_mem_chartRootAlgebra p 0 |
| · exact remainingRoot_mem_chartRootAlgebra p 1 |
| · change root p 2 ∈ chartRootAlgebra p |
| rw [original_root_two p] |
| exact Subalgebra.mul_mem _ (coordinateRoot_mem_chartRootAlgebra p 0) |
| (coordinateRoot_mem_chartRootAlgebra p 1) |
| · exact coordinateRoot_mem_chartRootAlgebra p 0 |
| · change root p 4 ∈ chartRootAlgebra p |
| have he : root p 4 = coordinateRoot p 0 * remainingRoot p 2 := by |
| change root p 4 = root p 3 * (root p 4 / root p 3) |
| exact (mul_div_cancel₀ _ (root_ne_zero p 3)).symm |
| rw [he] |
| exact Subalgebra.mul_mem _ (coordinateRoot_mem_chartRootAlgebra p 0) |
| (remainingRoot_mem_chartRootAlgebra p 2) |
|
|
| /- The fraction field is the SAME original Kummer field, not a proper |
| subcover of it. The blowdown supplies the original plane action. -/ |
| instance : Algebra R (S p) := |
| ((algebraMap C (S p)).comp (algebraMap R C)).toAlgebra |
| instance : IsScalarTower R C (S p) := |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := C) (A := S p) rfl |
| instance : IsScalarTower R (S p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := S p) (A := L p) (by |
| rw [IsScalarTower.algebraMap_eq R C (L p), IsScalarTower.algebraMap_eq C (S p) (L p)] |
| rfl) |
| instance : Algebra R (chartRootAlgebra p) := |
| ((algebraMap (S p) (chartRootAlgebra p)).comp (algebraMap R (S p))).toAlgebra |
| instance : IsScalarTower R (S p) (chartRootAlgebra p) := |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := S p) (A := chartRootAlgebra p) rfl |
| instance : IsScalarTower R (chartRootAlgebra p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := chartRootAlgebra p) (A := L p) (by |
| rw [IsScalarTower.algebraMap_eq R (S p) (L p), |
| IsScalarTower.algebraMap_eq (S p) (chartRootAlgebra p) (L p)] |
| rfl) |
| instance : IsFractionRing (chartRootAlgebra p) (L p) := by |
| apply KummerEtale.fractionRing_of_generators ((chartRootAlgebra p).restrictScalars R) |
| (Set.range (KummerCover.fieldRoot (p := p) radicand)) |
| (KummerCover.fieldRoot_generates radicand) |
| rintro x ⟨i, rfl⟩ |
| exact allRoots_mem_chartRootAlgebra p i |
|
|
| /-- The entire normalization over this actual triple-point blowup open is the |
| regular algebra of the two ramified coordinates and three unit roots. -/ |
| theorem chart_normalization : integralClosure T (L p) = |
| (chartRootAlgebra p).restrictScalars T := by |
| apply le_antisymm |
| · intro x hx |
| have hx' : IsIntegral (chartRootAlgebra p) x := |
| ((mem_integralClosure_iff T (L p)).mp hx).tower_top |
| obtain ⟨a, ha⟩ := (isIntegrallyClosed_iff (L p)).mp |
| (inferInstance : IsIntegrallyClosed (chartRootAlgebra p)) hx' |
| change (a : L p) = x at ha |
| exact ha ▸ a.property |
| · intro x hx |
| exact (mem_integralClosure_iff T (L p)).mpr |
| ((Algebra.IsIntegral.isIntegral (R := T) (⟨x, hx⟩ : chartRootAlgebra p)).map |
| (IsScalarTower.toAlgHom T (chartRootAlgebra p) (L p))) |
|
|
| /-- Regularity is asserted for the actual integral closure, not just a |
| subextension or the conditional diagonal coordinate algebra. -/ |
| theorem chart_normalization_regular : IsRegularRing (integralClosure T (L p)) := by |
| let : IsRegularRing ((chartRootAlgebra p).restrictScalars T) := chartRootAlgebra_regular p |
| exact IsRegularRing.of_ringEquiv |
| (Subalgebra.equivOfEq _ _ (chart_normalization p).symm).toRingEquiv |
| open scoped TensorProduct |
| /-- This normalization is the actual restriction of the normalization of |
| the blowup chart in the original five-root field. -/ |
| def chartRestrictionEquiv : |
| T ⊗[C] integralClosure C (L p) ≃ₐ[T] integralClosure T (L p) := by |
| have : Algebra.Etale C T := Algebra.Etale.of_isLocalizationAway chartDenominator |
| exact (AlgEquiv.ofBijective (TensorProduct.toIntegralClosure C T (L p)) |
| TensorProduct.toIntegralClosure_bijective_of_smooth).trans |
| (IsLocalization.algebraLid (Submonoid.powers chartDenominator) T (L p)).mapIntegralClosure |
|
|
| theorem normalization_chart_regular : IsRegularRing (T ⊗[C] integralClosure C (L p)) := by |
| have : IsRegularRing (integralClosure T (L p)) := chart_normalization_regular p |
| exact IsRegularRing.of_ringEquiv |
| (R := integralClosure T (L p)) (chartRestrictionEquiv p).symm.toRingEquiv |
| end KummerShifted |
|
|
|
|
| end |
|
|
|
|
| noncomputable section |
| open Algebra MvPolynomial |
| namespace KummerShifted |
| open KummerLines |
| variable (p : ℕ) [Fact p.Prime] |
|
|
| lemma remainingRoot_inv_mem (i : Fin 3) : (remainingRoot p i)⁻¹ ∈ chartRootAlgebra p := by |
| let z : chartRootAlgebra p := ⟨remainingRoot p i, remainingRoot_mem_chartRootAlgebra p i⟩ |
| have hz : z ^ p = algebraMap (S p) (chartRootAlgebra p) |
| (algebraMap C (S p) (remainingForm i)) := by |
| apply Subtype.ext |
| exact (remainingRoot_pow p i).trans |
| (IsScalarTower.algebraMap_apply C (S p) (L p) _) |
| have hu : IsUnit (z ^ p) := by |
| rw [hz] |
| exact (remaining_unit p i).map (algebraMap (S p) (chartRootAlgebra p)) |
| exact Submonoid.inv_mem_of_isUnit ((isUnit_pow_iff (NeZero.ne p)).mp hu) |
| end KummerShifted |
|
|
| namespace ExplicitCone |
|
|
| def shiftedSectionDenominator : sectionChart := |
| ⟨y 0 * y 1 * ratioR, sectionChart.mul_mem |
| (sectionChart.mul_mem (y_mem_sectionChart 0) (y_mem_sectionChart 1)) ratioR_mem_sectionChart⟩ |
| lemma shiftedSectionDenominator_ne_zero : shiftedSectionDenominator ≠ 0 := by |
| intro h |
| exact mul_ne_zero (mul_ne_zero (y_ne_zero 0) (y_ne_zero 1)) ratioR_ne_zero |
| (congrArg Subtype.val h) |
| def shiftedSectionOpen : Subalgebra ℂ L := |
| FieldPrincipalOpen.away sectionChart shiftedSectionDenominator shiftedSectionDenominator_ne_zero |
|
|
| def shiftedRegularAlgebra : Subalgebra ℂ L where |
| toSubsemiring := (KummerShifted.chartRootAlgebra 7).toSubsemiring |
| algebraMap_mem' c := by |
| have h := (KummerShifted.chartRootAlgebra 7).algebraMap_mem |
| (algebraMap (KummerShifted.B 7) (KummerShifted.S 7) |
| (algebraMap ℂ (KummerShifted.B 7) c)) |
| rw [← IsScalarTower.algebraMap_apply (KummerShifted.B 7) (KummerShifted.S 7) L] at h |
| exact h |
|
|
| lemma y_mem_shiftedRegular (i : Fin 5) : y i ∈ shiftedRegularAlgebra := |
| KummerShifted.allRoots_mem_chartRootAlgebra 7 i |
| lemma unitRoot_inv_mem_shiftedRegular (i : Fin 3) : |
| (KummerShifted.remainingRoot 7 i)⁻¹ ∈ shiftedRegularAlgebra := |
| KummerShifted.remainingRoot_inv_mem 7 i |
|
|
| lemma ratioQ_mem_shiftedRegular : ratioQ ∈ shiftedRegularAlgebra := by |
| have h0 : y 2 / y 3 ∈ shiftedRegularAlgebra := |
| KummerShifted.coordinateRoot_mem_chartRootAlgebra 7 1 |
| have h1 : (y 0)⁻¹ ∈ shiftedRegularAlgebra := unitRoot_inv_mem_shiftedRegular 0 |
| have he : ratioQ = (y 2 / y 3) * y 1 * (y 0)⁻¹ := by |
| unfold ratioQ |
| field_simp [y_ne_zero] |
| rw [he] |
| exact shiftedRegularAlgebra.mul_mem |
| (shiftedRegularAlgebra.mul_mem h0 (y_mem_shiftedRegular 1)) h1 |
| lemma ratioR_mem_shiftedRegular : ratioR ∈ shiftedRegularAlgebra := by |
| have h0 : y 4 / y 3 ∈ shiftedRegularAlgebra := |
| KummerShifted.remainingRoot_mem_chartRootAlgebra 7 2 |
| have h1 : (y 0)⁻¹ ∈ shiftedRegularAlgebra := unitRoot_inv_mem_shiftedRegular 0 |
| have he : ratioR = (y 4 / y 3) * (y 0)⁻¹ := by |
| unfold ratioR |
| field_simp [y_ne_zero] |
| rw [he] |
| exact shiftedRegularAlgebra.mul_mem h0 h1 |
| lemma sectionChart_le_shiftedRegular : sectionChart ≤ shiftedRegularAlgebra := by |
| rw [sectionChart_eq] |
| apply Algebra.adjoin_le |
| rintro t (⟨i,rfl⟩ | ht) |
| · exact y_mem_shiftedRegular i |
| · rcases (show t = ratioQ ∨ t = ratioR from by simpa using ht) with rfl | rfl |
| · exact ratioQ_mem_shiftedRegular |
| · exact ratioR_mem_shiftedRegular |
| lemma ratioR_inv_mem_shiftedRegular : ratioR⁻¹ ∈ shiftedRegularAlgebra := by |
| have h0 : (y 4 / y 3)⁻¹ ∈ shiftedRegularAlgebra := unitRoot_inv_mem_shiftedRegular 2 |
| have he : ratioR⁻¹ = (y 4 / y 3)⁻¹ * y 0 := by |
| unfold ratioR |
| field_simp [y_ne_zero] |
| rw [he] |
| exact shiftedRegularAlgebra.mul_mem h0 (y_mem_shiftedRegular 0) |
| lemma shiftedSectionOpen_le : shiftedSectionOpen ≤ shiftedRegularAlgebra := by |
| apply (FieldPrincipalOpen.away_le_iff sectionChart shiftedSectionDenominator |
| shiftedSectionDenominator_ne_zero shiftedRegularAlgebra).mpr |
| refine ⟨sectionChart_le_shiftedRegular, ?_⟩ |
| change (y 0 * y 1 * ratioR)⁻¹ ∈ shiftedRegularAlgebra |
| rw [mul_inv_rev, mul_inv_rev] |
| exact shiftedRegularAlgebra.mul_mem ratioR_inv_mem_shiftedRegular |
| (shiftedRegularAlgebra.mul_mem (unitRoot_inv_mem_shiftedRegular 1) |
| (unitRoot_inv_mem_shiftedRegular 0)) |
|
|
| lemma sectionChart_le_shiftedOpen : sectionChart ≤ shiftedSectionOpen := |
| FieldPrincipalOpen.le_away sectionChart shiftedSectionDenominator shiftedSectionDenominator_ne_zero |
| lemma y_mem_shiftedOpen (i : Fin 5) : y i ∈ shiftedSectionOpen := |
| sectionChart_le_shiftedOpen (y_mem_sectionChart i) |
| lemma ratioQ_mem_shiftedOpen : ratioQ ∈ shiftedSectionOpen := |
| sectionChart_le_shiftedOpen ratioQ_mem_sectionChart |
| lemma ratioR_mem_shiftedOpen : ratioR ∈ shiftedSectionOpen := |
| sectionChart_le_shiftedOpen ratioR_mem_sectionChart |
| lemma shiftedProduct_inv_mem : (y 0 * y 1 * ratioR)⁻¹ ∈ shiftedSectionOpen := |
| FieldPrincipalOpen.inv_mem_away sectionChart shiftedSectionDenominator shiftedSectionDenominator_ne_zero |
| lemma y0_inv_mem_shiftedOpen : (y 0)⁻¹ ∈ shiftedSectionOpen := by |
| apply FieldPrincipalOpen.inv_left_mem shiftedSectionOpen |
| (mul_ne_zero (y_ne_zero 1) ratioR_ne_zero) |
| (shiftedSectionOpen.mul_mem (y_mem_shiftedOpen 1) ratioR_mem_shiftedOpen) |
| simpa only [mul_assoc] using shiftedProduct_inv_mem |
| lemma y1_inv_mem_shiftedOpen : (y 1)⁻¹ ∈ shiftedSectionOpen := by |
| apply FieldPrincipalOpen.inv_left_mem shiftedSectionOpen |
| (mul_ne_zero (y_ne_zero 0) ratioR_ne_zero) |
| (shiftedSectionOpen.mul_mem (y_mem_shiftedOpen 0) ratioR_mem_shiftedOpen) |
| simpa only [mul_assoc, mul_comm, mul_left_comm] using shiftedProduct_inv_mem |
| lemma ratioR_inv_mem_shiftedOpen : ratioR⁻¹ ∈ shiftedSectionOpen := by |
| apply FieldPrincipalOpen.inv_left_mem shiftedSectionOpen |
| (mul_ne_zero (y_ne_zero 0) (y_ne_zero 1)) |
| (shiftedSectionOpen.mul_mem (y_mem_shiftedOpen 0) (y_mem_shiftedOpen 1)) |
| simpa only [mul_assoc, mul_comm, mul_left_comm] using shiftedProduct_inv_mem |
|
|
| lemma coordinateRoot_mem_shiftedOpen (i : Fin 2) : |
| KummerShifted.coordinateRoot 7 i ∈ shiftedSectionOpen := by |
| fin_cases i |
| · exact y_mem_shiftedOpen 3 |
| · change y 2 / y 3 ∈ shiftedSectionOpen |
| have he : y 2 / y 3 = ratioQ * y 0 * (y 1)⁻¹ := by |
| unfold ratioQ |
| field_simp [y_ne_zero] |
| rw [he] |
| exact shiftedSectionOpen.mul_mem |
| (shiftedSectionOpen.mul_mem ratioQ_mem_shiftedOpen (y_mem_shiftedOpen 0)) |
| y1_inv_mem_shiftedOpen |
| lemma B_mem_shiftedOpen (b : KummerShifted.B 7) : (b : L) ∈ shiftedSectionOpen := by |
| have h := b.property |
| change (b : L) ∈ Algebra.adjoin ℂ (Set.range (KummerShifted.coordinateRoot 7)) at h |
| exact (Algebra.adjoin_le (by rintro _ ⟨i,rfl⟩; exact coordinateRoot_mem_shiftedOpen i)) h |
| lemma remainingRoot_mem_shiftedOpen (i : Fin 3) : |
| KummerShifted.remainingRoot 7 i ∈ shiftedSectionOpen := by |
| fin_cases i |
| · exact y_mem_shiftedOpen 0 |
| · exact y_mem_shiftedOpen 1 |
| · change y 4 / y 3 ∈ shiftedSectionOpen |
| have he : y 4 / y 3 = ratioR * y 0 := by |
| unfold ratioR |
| field_simp [y_ne_zero] |
| rw [he] |
| exact shiftedSectionOpen.mul_mem ratioR_mem_shiftedOpen (y_mem_shiftedOpen 0) |
| lemma remainingRoot_inv_mem_shiftedOpen (i : Fin 3) : |
| (KummerShifted.remainingRoot 7 i)⁻¹ ∈ shiftedSectionOpen := by |
| fin_cases i |
| · exact y0_inv_mem_shiftedOpen |
| · exact y1_inv_mem_shiftedOpen |
| · change (y 4 / y 3)⁻¹ ∈ shiftedSectionOpen |
| have he : (y 4 / y 3)⁻¹ = ratioR⁻¹ * (y 0)⁻¹ := by |
| unfold ratioR |
| field_simp [y_ne_zero] |
| rw [he] |
| exact shiftedSectionOpen.mul_mem ratioR_inv_mem_shiftedOpen y0_inv_mem_shiftedOpen |
|
|
| lemma shifted_bDenominator_image : |
| algebraMap (KummerShifted.B 7) L (KummerShifted.bDenominator 7) = |
| KummerShifted.remainingRoot 7 0 ^ 7 * KummerShifted.remainingRoot 7 1 ^ 7 * |
| KummerShifted.remainingRoot 7 2 ^ 7 := by |
| change algebraMap (KummerShifted.B 7) L |
| (algebraMap KummerShifted.C (KummerShifted.B 7) KummerShifted.chartDenominator) = _ |
| rw [← IsScalarTower.algebraMap_apply KummerShifted.C (KummerShifted.B 7) L] |
| change algebraMap KummerShifted.C L |
| (KummerShifted.remainingForm 0 * KummerShifted.remainingForm 1 * KummerShifted.remainingForm 2) = _ |
| simp only [map_mul, KummerShifted.remainingRoot_pow] |
| lemma bDenominator_inv_mem_shiftedOpen : |
| (algebraMap (KummerShifted.B 7) L (KummerShifted.bDenominator 7))⁻¹ ∈ shiftedSectionOpen := by |
| rw [shifted_bDenominator_image, mul_inv_rev, mul_inv_rev, ← inv_pow, ← inv_pow, ← inv_pow] |
| exact shiftedSectionOpen.mul_mem (shiftedSectionOpen.pow_mem (remainingRoot_inv_mem_shiftedOpen 2) 7) |
| (shiftedSectionOpen.mul_mem (shiftedSectionOpen.pow_mem (remainingRoot_inv_mem_shiftedOpen 1) 7) |
| (shiftedSectionOpen.pow_mem (remainingRoot_inv_mem_shiftedOpen 0) 7)) |
| lemma S_mem_shiftedOpen (s : KummerShifted.S 7) : |
| algebraMap (KummerShifted.S 7) L s ∈ shiftedSectionOpen := by |
| apply FieldPrincipalOpen.localizationImage_mem shiftedSectionOpen (KummerShifted.bDenominator 7) |
| ((isUnit_iff_ne_zero).mp (KummerShifted.bDenominator_unit_in_L 7)) |
| (fun b => B_mem_shiftedOpen b) bDenominator_inv_mem_shiftedOpen |
| lemma shiftedRegular_le_sectionOpen : shiftedRegularAlgebra ≤ shiftedSectionOpen := by |
| intro t ht |
| change t ∈ Algebra.adjoin (KummerShifted.S 7) (KummerShifted.remainingRoots 7 : Set L) at ht |
| induction ht using Algebra.adjoin_induction with |
| | mem x hx => |
| classical |
| obtain ⟨i,-,rfl⟩ := Finset.mem_image.mp (show x ∈ Finset.univ.image _ from hx) |
| exact remainingRoot_mem_shiftedOpen i |
| | algebraMap s => exact S_mem_shiftedOpen s |
| | add x y hx hy h₁ h₂ => exact shiftedSectionOpen.add_mem h₁ h₂ |
| | mul x y hx hy h₁ h₂ => exact shiftedSectionOpen.mul_mem h₁ h₂ |
|
|
| /-- The literal polarization chart, localized at a*b*r, is exactly the |
| regular normalization of the literal shifted-point blowup open, within the |
| same original function field. -/ |
| theorem shiftedSectionOpen_eq : shiftedSectionOpen = shiftedRegularAlgebra := |
| le_antisymm shiftedSectionOpen_le shiftedRegular_le_sectionOpen |
|
|
| theorem sectionChart_shiftedOpen_regular : |
| IsRegularRing (Localization.Away shiftedSectionDenominator) := by |
| have : IsRegularRing shiftedRegularAlgebra := KummerShifted.chartRootAlgebra_regular 7 |
| exact FieldPrincipalOpen.regular_away_of_eq sectionChart shiftedSectionDenominator |
| shiftedSectionDenominator_ne_zero shiftedRegularAlgebra shiftedSectionOpen_eq |
|
|
| end ExplicitCone |
|
|
| end |
|
|
|
|
| noncomputable section |
| open Algebra MvPolynomial |
| namespace KummerShiftedDiagonal |
| open KummerLines |
| variable (p : ℕ) [Fact p.Prime] |
| local instance : IsScalarTower ℂ R (L p) := IsScalarTower.of_algebraMap_eq' rfl |
| abbrev root := KummerTriple.root |
| lemma root_pow (i : Fin 5) : root p i ^ p = algebraMap R (L p) (lineForm i) := |
| KummerTriple.root_pow p i |
| lemma root_ne_zero (i : Fin 5) : root p i ≠ 0 := KummerTriple.root_ne_zero p i |
|
|
| /-- Literal y-chart over the other affine triple point (1,1). -/ |
| def coordinateRoot : Fin 2 → L p := ![root p 3, root p 4 / root p 3] |
| lemma coordinateRoot_zero_pow : coordinateRoot p 0 ^ p = algebraMap R (L p) (X 1 - 1) := |
| root_pow p 3 |
| lemma coordinateRoot_one_pow : coordinateRoot p 1 ^ p = |
| algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1) := by |
| change (root p 4 / root p 3) ^ p = _ |
| rw [div_pow, root_pow, root_pow] |
| rfl |
| lemma original_root_four : root p 4 = coordinateRoot p 0 * coordinateRoot p 1 := by |
| change root p 4 = root p 3 * (root p 4 / root p 3) |
| field_simp [root_ne_zero p 3] |
| lemma original_x : algebraMap R (L p) (X 0) = |
| (coordinateRoot p 0 * coordinateRoot p 1) ^ p + coordinateRoot p 0 ^ p + 1 := by |
| rw [← original_root_four p, root_pow, coordinateRoot_zero_pow] |
| change algebraMap R (L p) (X 0) = |
| algebraMap R (L p) (X 0 - X 1) + algebraMap R (L p) (X 1 - 1) + 1 |
| rw [map_sub, map_sub, map_one] |
| ring |
| lemma original_y : algebraMap R (L p) (X 1) = coordinateRoot p 0 ^ p + 1 := by |
| rw [coordinateRoot_zero_pow, map_sub, map_one, sub_add_cancel] |
| lemma coordinateRoot_independent : AlgebraicIndependent ℂ (coordinateRoot p) := by |
| have hi : Function.Injective (algebraMap R (L p)) := by |
| rw [IsScalarTower.algebraMap_eq R K (L p)] |
| exact (algebraMap K (L p)).injective.comp (IsFractionRing.injective R K) |
| have h := (algebraicIndependent_X (Fin 2) ℂ).map |
| (f := IsScalarTower.toAlgHom ℂ R (L p)) hi.injOn |
| apply _root_.OAI.AlgebraicIndependent.of_polynomial_expressions h |
| intro i |
| have hu : coordinateRoot p 0 ∈ Algebra.adjoin ℂ (Set.range (coordinateRoot p)) := |
| Algebra.subset_adjoin (Set.mem_range_self 0) |
| have hv : coordinateRoot p 1 ∈ Algebra.adjoin ℂ (Set.range (coordinateRoot p)) := |
| Algebra.subset_adjoin (Set.mem_range_self 1) |
| fin_cases i |
| · change algebraMap R (L p) (X 0) ∈ _ |
| rw [original_x p] |
| exact Subalgebra.add_mem _ |
| (Subalgebra.add_mem _ (Subalgebra.pow_mem _ (Subalgebra.mul_mem _ hu hv) _) |
| (Subalgebra.pow_mem _ hu _)) (one_mem _) |
| · change algebraMap R (L p) (X 1) ∈ _ |
| rw [original_y p] |
| exact Subalgebra.add_mem _ (Subalgebra.pow_mem _ hu _) (one_mem _) |
|
|
| def C := MvPolynomial (Fin 2) ℂ |
| instance : CommRing C := inferInstanceAs (CommRing (MvPolynomial (Fin 2) ℂ)) |
| instance : Algebra ℂ C := inferInstanceAs (Algebra ℂ (MvPolynomial (Fin 2) ℂ)) |
| instance : IsRegularRing C := inferInstanceAs (IsRegularRing (MvPolynomial (Fin 2) ℂ)) |
| instance : Algebra.FiniteType ℂ C := inferInstanceAs (Algebra.FiniteType ℂ (MvPolynomial (Fin 2) ℂ)) |
| def blowdown : R →ₐ[ℂ] C := MvPolynomial.aeval ![X 0 * X 1 + X 0 + 1, X 0 + 1] |
| instance : Algebra R C := blowdown.toRingHom.toAlgebra |
| instance : IsScalarTower ℂ R C := |
| IsScalarTower.of_algebraMap_eq' (AlgHom.comp_algebraMap blowdown).symm |
|
|
| def chartMap : C →ₐ[ℂ] L p := MvPolynomial.aeval ![ |
| algebraMap R (L p) (X 1 - 1), |
| algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)] |
| instance : Algebra C (L p) := (chartMap p).toRingHom.toAlgebra |
| instance : IsScalarTower ℂ C (L p) := |
| IsScalarTower.of_algebraMap_eq' (AlgHom.comp_algebraMap (chartMap p)).symm |
| lemma chartMap_blowdown : (chartMap p).comp blowdown = IsScalarTower.toAlgHom ℂ R (L p) := by |
| have hd : algebraMap R (L p) (X 1 - 1) ≠ 0 := by |
| rw [← coordinateRoot_zero_pow p] |
| exact pow_ne_zero _ (root_ne_zero p 3) |
| apply MvPolynomial.algHom_ext |
| intro i |
| have hb : blowdown (X i) = ![(X 0 : C) * (X 1 : C) + (X 0 : C) + 1, |
| (X 0 : C) + 1] i := by |
| simp only [blowdown] |
| exact MvPolynomial.aeval_X (R := ℂ) (S₁ := C) _ i |
| have hc (j : Fin 2) : (chartMap p) (X j) = |
| ![algebraMap R (L p) (X 1 - 1), |
| algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)] j := |
| MvPolynomial.aeval_X (R := ℂ) (S₁ := L p) _ j |
| refine (congrArg (chartMap p) hb).trans ?_ |
| fin_cases i |
| · refine (map_add (chartMap p) ((X 0 : C) * (X 1 : C) + (X 0 : C)) (1 : C)).trans ?_ |
| refine (congrArg₂ (fun x y : L p => x + y) |
| ((map_add (chartMap p) ((X 0 : C) * (X 1 : C)) (X 0 : C)).trans |
| (congrArg₂ (fun x y : L p => x + y) |
| ((map_mul (chartMap p) (X 0 : C) (X 1 : C)).trans |
| (congrArg₂ (fun x y : L p => x * y) (hc 0) (hc 1))) (hc 0))) |
| (map_one (chartMap p))).trans ?_ |
| change algebraMap R (L p) (X 1 - 1) * |
| (algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)) + |
| algebraMap R (L p) (X 1 - 1) + 1 = algebraMap R (L p) (X 0) |
| rw [mul_div_cancel₀ _ hd, map_sub, map_sub, map_one] |
| ring |
| · refine (map_add (chartMap p) (X 0 : C) (1 : C)).trans ?_ |
| refine (congrArg₂ (fun x y : L p => x + y) (hc 0) (map_one (chartMap p))).trans ?_ |
| change algebraMap R (L p) (X 1 - 1) + 1 = _ |
| rw [map_sub, map_one, sub_add_cancel] |
| rfl |
| |
| instance : IsScalarTower R C (L p) := |
| IsScalarTower.of_algebraMap_eq' (congrArg AlgHom.toRingHom (chartMap_blowdown p).symm) |
|
|
| lemma chartMap_injective : Function.Injective (chartMap p) := by |
| have hi : Function.Injective (algebraMap R (L p)) := by |
| rw [IsScalarTower.algebraMap_eq R K (L p)] |
| exact (algebraMap K (L p)).injective.comp (IsFractionRing.injective R K) |
| have h := (algebraicIndependent_X (Fin 2) ℂ).map |
| (f := IsScalarTower.toAlgHom ℂ R (L p)) hi.injOn |
| have hc : AlgebraicIndependent ℂ ![algebraMap R (L p) (X 1 - 1), |
| algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)] := by |
| apply _root_.OAI.AlgebraicIndependent.of_polynomial_expressions h |
| intro i |
| have hs : algebraMap R (L p) (X 1 - 1) ∈ Algebra.adjoin ℂ |
| (Set.range ![algebraMap R (L p) (X 1 - 1), |
| algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)]) := |
| Algebra.subset_adjoin ⟨0, rfl⟩ |
| have ht : algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1) ∈ |
| Algebra.adjoin ℂ (Set.range ![algebraMap R (L p) (X 1 - 1), |
| algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)]) := |
| Algebra.subset_adjoin ⟨1, rfl⟩ |
| have hd : algebraMap R (L p) (X 1 - 1) ≠ 0 := by |
| rw [← coordinateRoot_zero_pow p] |
| exact pow_ne_zero _ (root_ne_zero p 3) |
| fin_cases i |
| · change algebraMap R (L p) (X 0) ∈ _ |
| have hx : algebraMap R (L p) (X 0) = |
| algebraMap R (L p) (X 1 - 1) * |
| (algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)) + |
| algebraMap R (L p) (X 1 - 1) + 1 := by |
| rw [mul_div_cancel₀ _ hd, map_sub, map_sub, map_one] |
| ring |
| rw [hx] |
| exact Subalgebra.add_mem _ (Subalgebra.add_mem _ (Subalgebra.mul_mem _ hs ht) hs) (one_mem _) |
| · change algebraMap R (L p) (X 1) ∈ _ |
| have hy : algebraMap R (L p) (X 1) = algebraMap R (L p) (X 1 - 1) + 1 := by |
| rw [map_sub, map_one, sub_add_cancel] |
| rw [hy] |
| exact Subalgebra.add_mem _ hs (one_mem _) |
| exact hc |
|
|
| /-- The two ramified coordinates form an actual polynomial plane in the |
| original field. No independent auxiliary Kummer field is substituted. -/ |
| def coordinateAlgebra : Subalgebra ℂ (L p) := |
| Algebra.adjoin ℂ (Set.range (coordinateRoot p)) |
| abbrev B := coordinateAlgebra p |
| def planeEquiv : C ≃ₐ[ℂ] B p := (coordinateRoot_independent p).aevalEquiv |
| instance : IsRegularRing (B p) := |
| IsRegularRing.of_ringEquiv (planeEquiv p).toRingEquiv |
| instance : IsIntegrallyClosed (B p) := by |
| have hC : IsIntegrallyClosed C := |
| UniqueFactorizationMonoid.instIsIntegrallyClosed (A := MvPolynomial (Fin 2) ℂ) |
| exact IsIntegrallyClosed.of_equiv (R := C) (S := B p) (planeEquiv p).toRingEquiv |
|
|
| def bRoot (i : Fin 2) : B p := |
| ⟨coordinateRoot p i, Algebra.subset_adjoin (Set.mem_range_self i)⟩ |
| def planeMap : C →ₐ[ℂ] B p := MvPolynomial.aeval ![bRoot p 0 ^ p, bRoot p 1 ^ p] |
| lemma planeMap_comp : (coordinateAlgebra p).val.comp (planeMap p) = chartMap p := by |
| apply MvPolynomial.algHom_ext |
| intro i |
| change (coordinateAlgebra p).val (MvPolynomial.aeval ![bRoot p 0 ^ p, bRoot p 1 ^ p] (X i)) = _ |
| simp only [chartMap, MvPolynomial.aeval_X] |
| fin_cases i |
| · exact coordinateRoot_zero_pow p |
| · exact coordinateRoot_one_pow p |
| instance : Algebra C (B p) := (planeMap p).toRingHom.toAlgebra |
| instance : IsScalarTower ℂ C (B p) := |
| IsScalarTower.of_algebraMap_eq' (AlgHom.comp_algebraMap (planeMap p)).symm |
| instance : IsScalarTower C (B p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (congrArg AlgHom.toRingHom (planeMap_comp p).symm) |
|
|
| lemma coordinateRoot_pow (i : Fin 2) : |
| coordinateRoot p i ^ p = algebraMap C (L p) (X i) := by |
| change coordinateRoot p i ^ p = MvPolynomial.aeval _ (X i) |
| rw [MvPolynomial.aeval_X] |
| fin_cases i |
| · exact coordinateRoot_zero_pow p |
| · exact coordinateRoot_one_pow p |
| lemma coordinateRoot_integral (i : Fin 2) : IsIntegral C (coordinateRoot p i) := by |
| refine ⟨(Polynomial.X : Polynomial C) ^ p - Polynomial.C (R := C) (X i), |
| Polynomial.monic_X_pow_sub_C _ (NeZero.ne p), ?_⟩ |
| change Polynomial.aeval (coordinateRoot p i) _ = 0 |
| erw [map_sub, map_pow, Polynomial.aeval_X, |
| Polynomial.aeval_C (R := C) (A := L p)] |
| exact sub_eq_zero.mpr (coordinateRoot_pow p i) |
| instance : Algebra.IsIntegral C (B p) := by |
| have hB : coordinateAlgebra p ≤ (integralClosure C (L p)).restrictScalars ℂ := by |
| apply Algebra.adjoin_le |
| rintro z ⟨i, rfl⟩ |
| exact coordinateRoot_integral p i |
| constructor |
| intro b |
| have hi : IsIntegral C (b : L p) := hB b.property |
| exact (isIntegral_algHom_iff (IsScalarTower.toAlgHom C (B p) (L p)) |
| Subtype.val_injective).mp hi |
| instance : Algebra.FiniteType ℂ (B p) := |
| Algebra.FiniteType.of_surjective (planeEquiv p).toAlgHom (planeEquiv p).surjective |
| instance : Algebra.FiniteType C (B p) := Algebra.FiniteType.of_restrictScalars_finiteType ℂ C (B p) |
| instance : Module.Finite C (B p) := Algebra.IsIntegral.finite |
| end KummerShiftedDiagonal |
|
|
| end |
|
|
|
|
| noncomputable section |
| open Algebra MvPolynomial |
| open nonZeroDivisors |
| namespace KummerShiftedDiagonal |
| open KummerLines |
| variable (p : ℕ) [Fact p.Prime] |
|
|
| /-- The actual blowup chart open containing s=t=0 (the intersection of |
| its exceptional divisor with the strict transform of y=0). -/ |
| def cX (i : Fin 2) : C := X i |
| def chartDenominator : C := (cX 0 * cX 1 + cX 0 + 1) * (cX 0 + 1) * (cX 1 + 1) |
| lemma chartDenominator_ne_zero : chartDenominator ≠ 0 := by |
| let f : C →+* ℂ := MvPolynomial.eval ![(0 : ℂ), 2] |
| have hf (i : Fin 2) : f (cX i) = ![(0 : ℂ), 2] i := by |
| exact MvPolynomial.eval_X i |
| intro hz |
| have he := congrArg f hz |
| simp only [chartDenominator, map_mul, map_add, map_one, map_zero, hf] at he |
| norm_num at he |
| lemma planeMap_injective : Function.Injective (planeMap p) := by |
| intro a b h |
| apply chartMap_injective p |
| exact congrArg (fun g : C →ₐ[ℂ] L p => g a) (planeMap_comp p).symm |>.trans |
| ((congrArg (fun z : B p => (z : L p)) h).trans |
| (congrArg (fun g : C →ₐ[ℂ] L p => g b) (planeMap_comp p))) |
|
|
| def bDenominator : B p := planeMap p chartDenominator |
| lemma bDenominator_ne_zero : bDenominator p ≠ 0 := |
| (map_ne_zero_iff _ (planeMap_injective p)).mpr chartDenominator_ne_zero |
| lemma bPowers_le : Submonoid.powers (bDenominator p) ≤ (B p)⁰ := by |
| rintro _ ⟨n, rfl⟩ |
| exact mem_nonZeroDivisors_of_ne_zero (pow_ne_zero n (bDenominator_ne_zero p)) |
|
|
| def S := Localization.Away (bDenominator p) |
| instance : CommRing (S p) := inferInstanceAs (CommRing (Localization.Away (bDenominator p))) |
| instance : Algebra (B p) (S p) := |
| OreLocalization.instAlgebra (R := B p) (R₀ := B p) |
| (S := Submonoid.powers (bDenominator p)) |
| instance : IsLocalization.Away (bDenominator p) (S p) := Localization.isLocalization |
| instance : IsDomain (S p) := |
| IsLocalization.isDomain_of_le_nonZeroDivisors _ (bPowers_le p) |
| instance : IsIntegrallyClosed (S p) := |
| isIntegrallyClosed_of_isLocalization (S p) (Submonoid.powers (bDenominator p)) (bPowers_le p) |
| instance : Algebra.Etale (B p) (S p) := |
| Algebra.Etale.of_isLocalizationAway (bDenominator p) |
| instance : IsRegularRing (S p) := EtaleRegular.regular (B p) (S p) |
|
|
| lemma bDenominator_unit_in_L : IsUnit (algebraMap (B p) (L p) (bDenominator p)) := by |
| apply isUnit_iff_ne_zero.mpr |
| exact (map_ne_zero_iff _ (Subtype.val_injective)).mpr (bDenominator_ne_zero p) |
| |
| instance : Algebra (S p) (L p) := |
| (IsLocalization.Away.lift (bDenominator p) (bDenominator_unit_in_L p) : S p →+* L p).toAlgebra |
| instance : IsScalarTower (B p) (S p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := B p) (S := S p) (A := L p) |
| (IsLocalization.Away.lift_comp (S := S p) (bDenominator p) (bDenominator_unit_in_L p)).symm |
| instance : Module.IsTorsionFree (S p) (L p) := by |
| apply Module.isTorsionFree_iff_algebraMap_injective.mpr |
| change Function.Injective (IsLocalization.Away.lift (bDenominator p) (bDenominator_unit_in_L p)) |
| apply (IsLocalization.lift_injective_iff _).mpr |
| intro a b |
| rw [(IsLocalization.injective (S p) (bPowers_le p)).eq_iff] |
| change a = b ↔ (a : L p) = (b : L p) |
| exact Subtype.val_injective.eq_iff.symm |
| instance : Algebra C (S p) := (algebraMap (B p) (S p)).comp (algebraMap C (B p)) |>.toAlgebra |
| instance : IsScalarTower C (B p) (S p) := |
| IsScalarTower.of_algebraMap_eq' (R := C) (S := B p) (A := S p) rfl |
| instance : IsScalarTower C (S p) (L p) := |
| IsScalarTower.of_algebraMap_eq' (R := C) (S := S p) (A := L p) (by |
| rw [IsScalarTower.algebraMap_eq C (B p) (L p), IsScalarTower.algebraMap_eq (B p) (S p) (L p)] |
| rfl) |
|
|
| def remainingRoot : Fin 3 → L p := ![root p 0, root p 1, root p 2 / root p 3] |
| def remainingForm : Fin 3 → C := ![cX 0 * cX 1 + cX 0 + 1, cX 0 + 1, cX 1 + 1] |
| lemma remaining_dvd (i : Fin 3) : remainingForm i ∣ chartDenominator := by |
| fin_cases i <;> simp only [remainingForm, chartDenominator] |
| · exact dvd_mul_of_dvd_left (dvd_mul_right _ _) _ |
| · exact dvd_mul_of_dvd_left (dvd_mul_left _ _) _ |
| · exact dvd_mul_left _ _ |
| lemma remaining_unit (i : Fin 3) : IsUnit (algebraMap C (S p) (remainingForm i)) := |
| IsLocalization.Away.isUnit_of_dvd (S := S p) (bDenominator p) |
| (map_dvd (planeMap p) (remaining_dvd i)) |
| lemma chartMap_X (i : Fin 2) : chartMap p (cX i) = |
| ![algebraMap R (L p) (X 1 - 1), |
| algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)] i := by |
| change MvPolynomial.aeval _ (X i) = _ |
| exact MvPolynomial.aeval_X _ _ |
| lemma remainingRoot_pow (i : Fin 3) : remainingRoot p i ^ p = |
| algebraMap C (L p) (remainingForm i) := by |
| have hd : algebraMap R (L p) (X 1 - 1) ≠ 0 := by |
| rw [← coordinateRoot_zero_pow p] |
| exact pow_ne_zero _ (root_ne_zero p 3) |
| fin_cases i |
| · change root p 0 ^ p = chartMap p (cX 0 * cX 1 + cX 0 + 1) |
| rw [root_pow, map_add, map_add, map_one, map_mul, chartMap_X, chartMap_X] |
| change algebraMap R (L p) (X 0) = algebraMap R (L p) (X 1 - 1) * |
| (algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1)) + |
| algebraMap R (L p) (X 1 - 1) + 1 |
| rw [mul_div_cancel₀ _ hd, map_sub, map_sub, map_one] |
| ring |
| · change root p 1 ^ p = chartMap p (cX 0 + 1) |
| rw [root_pow, map_add, map_one, chartMap_X] |
| change algebraMap R (L p) (X 1) = algebraMap R (L p) (X 1 - 1) + 1 |
| rw [map_sub, map_one, sub_add_cancel] |
| · change (root p 2 / root p 3) ^ p = chartMap p (cX 1 + 1) |
| rw [div_pow, root_pow, root_pow, map_add, map_one, chartMap_X] |
| change algebraMap R (L p) (X 0 - 1) / algebraMap R (L p) (X 1 - 1) = |
| algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 1 - 1) + 1 |
| apply (div_eq_iff hd).mpr |
| rw [add_mul, div_mul_cancel₀ _ hd, one_mul, map_sub, map_sub, map_sub, map_one] |
| ring |
| lemma exponent_unit : IsUnit (p : S p) := by |
| have hC : IsUnit (p : ℂ) := isUnit_iff_ne_zero.mpr (by exact_mod_cast (NeZero.ne p)) |
| have hB : IsUnit (p : B p) := by simpa using hC.map (algebraMap ℂ (B p)) |
| simpa using hB.map (algebraMap (B p) (S p)) |
|
|
| def remainingRoots : Finset (L p) := by |
| classical |
| exact Finset.univ.image (fun i : Fin 3 => remainingRoot p i) |
| abbrev chartRootAlgebra := Algebra.adjoin (S p) (remainingRoots p : Set (L p)) |
|
|
| theorem chartRootAlgebra_finiteFreeEtale : |
| Algebra.Etale (S p) (chartRootAlgebra p) ∧ |
| Module.Finite (S p) (chartRootAlgebra p) ∧ |
| Module.Free (S p) (chartRootAlgebra p) ∧ |
| IsIntegrallyClosed (chartRootAlgebra p) := by |
| apply KummerEtale.finite_unit_roots (R := S p) (L := L p) p |
| (NeZero.pos p) (exponent_unit p) (remainingRoots p) |
| intro x hx |
| classical |
| obtain ⟨i, -, rfl⟩ := Finset.mem_image.mp (show x ∈ Finset.univ.image _ from hx) |
| refine ⟨(remaining_unit p i).unit, ?_⟩ |
| rw [IsUnit.unit_spec, ← IsScalarTower.algebraMap_apply C (S p) (L p)] |
| exact remainingRoot_pow p i |
|
|
| theorem chartRootAlgebra_regular : IsRegularRing (chartRootAlgebra p) := by |
| have := (chartRootAlgebra_finiteFreeEtale p).1 |
| exact EtaleRegular.regular (S p) (chartRootAlgebra p) |
| end KummerShiftedDiagonal |
|
|
| end |
|
|
| end OAI |
|
|
