openAI-math-dataset / lean /OAI /AlgebraicGeometry /SurfaceCones /KummerShiftedDiagonalNormalization.lean
| import OAI.AlgebraicGeometry.SurfaceCones.KummerShiftedOpen | |
| namespace OAI | |
| noncomputable section | |
| open Algebra MvPolynomial | |
| open nonZeroDivisors | |
| namespace KummerShiftedDiagonal | |
| 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+s+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 | |
| have he : root p 2 = coordinateRoot p 0 * remainingRoot p 2 := by | |
| change root p 2 = root p 3 * (root p 2 / 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) | |
| · exact coordinateRoot_mem_chartRootAlgebra p 0 | |
| · change root p 4 ∈ chartRootAlgebra p | |
| rw [original_root_four p] | |
| exact Subalgebra.mul_mem _ (coordinateRoot_mem_chartRootAlgebra p 0) | |
| (coordinateRoot_mem_chartRootAlgebra p 1) | |
| /- 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 KummerShiftedDiagonal | |
| end | |
| noncomputable section | |
| open Algebra MvPolynomial | |
| namespace KummerShiftedDiagonal | |
| 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 KummerShiftedDiagonal | |
| namespace ExplicitCone | |
| def shiftedDiagonalSectionDenominator : sectionChart := | |
| ⟨y 0 * y 1 * ratioQ, sectionChart.mul_mem | |
| (sectionChart.mul_mem (y_mem_sectionChart 0) (y_mem_sectionChart 1)) ratioQ_mem_sectionChart⟩ | |
| lemma shiftedDiagonalSectionDenominator_ne_zero : shiftedDiagonalSectionDenominator ≠ 0 := by | |
| intro h | |
| exact mul_ne_zero (mul_ne_zero (y_ne_zero 0) (y_ne_zero 1)) ratioQ_ne_zero | |
| (congrArg Subtype.val h) | |
| def shiftedDiagonalSectionOpen : Subalgebra ℂ L := | |
| FieldPrincipalOpen.away sectionChart shiftedDiagonalSectionDenominator shiftedDiagonalSectionDenominator_ne_zero | |
| def shiftedDiagonalRegularAlgebra : Subalgebra ℂ L where | |
| toSubsemiring := (KummerShiftedDiagonal.chartRootAlgebra 7).toSubsemiring | |
| algebraMap_mem' c := by | |
| have h := (KummerShiftedDiagonal.chartRootAlgebra 7).algebraMap_mem | |
| (algebraMap (KummerShiftedDiagonal.B 7) (KummerShiftedDiagonal.S 7) | |
| (algebraMap ℂ (KummerShiftedDiagonal.B 7) c)) | |
| rw [← IsScalarTower.algebraMap_apply (KummerShiftedDiagonal.B 7) (KummerShiftedDiagonal.S 7) L] at h | |
| exact h | |
| lemma y_mem_shiftedDiagonalRegular (i : Fin 5) : y i ∈ shiftedDiagonalRegularAlgebra := | |
| KummerShiftedDiagonal.allRoots_mem_chartRootAlgebra 7 i | |
| lemma unitRoot_inv_mem_shiftedDiagonalRegular (i : Fin 3) : | |
| (KummerShiftedDiagonal.remainingRoot 7 i)⁻¹ ∈ shiftedDiagonalRegularAlgebra := | |
| KummerShiftedDiagonal.remainingRoot_inv_mem 7 i | |
| lemma ratioQ_mem_shiftedDiagonalRegular : ratioQ ∈ shiftedDiagonalRegularAlgebra := by | |
| have h0 : y 2 / y 3 ∈ shiftedDiagonalRegularAlgebra := | |
| KummerShiftedDiagonal.remainingRoot_mem_chartRootAlgebra 7 2 | |
| have h1 : (y 0)⁻¹ ∈ shiftedDiagonalRegularAlgebra := unitRoot_inv_mem_shiftedDiagonalRegular 0 | |
| have he : ratioQ = (y 2 / y 3) * y 1 * (y 0)⁻¹ := by | |
| unfold ratioQ | |
| field_simp [y_ne_zero] | |
| rw [he] | |
| exact shiftedDiagonalRegularAlgebra.mul_mem | |
| (shiftedDiagonalRegularAlgebra.mul_mem h0 (y_mem_shiftedDiagonalRegular 1)) h1 | |
| lemma ratioR_mem_shiftedDiagonalRegular : ratioR ∈ shiftedDiagonalRegularAlgebra := by | |
| have h0 : y 4 / y 3 ∈ shiftedDiagonalRegularAlgebra := | |
| KummerShiftedDiagonal.coordinateRoot_mem_chartRootAlgebra 7 1 | |
| have h1 : (y 0)⁻¹ ∈ shiftedDiagonalRegularAlgebra := unitRoot_inv_mem_shiftedDiagonalRegular 0 | |
| have he : ratioR = (y 4 / y 3) * (y 0)⁻¹ := by | |
| unfold ratioR | |
| field_simp [y_ne_zero] | |
| rw [he] | |
| exact shiftedDiagonalRegularAlgebra.mul_mem h0 h1 | |
| lemma sectionChart_le_shiftedDiagonalRegular : sectionChart ≤ shiftedDiagonalRegularAlgebra := by | |
| rw [sectionChart_eq] | |
| apply Algebra.adjoin_le | |
| rintro t (⟨i,rfl⟩ | ht) | |
| · exact y_mem_shiftedDiagonalRegular i | |
| · rcases (show t = ratioQ ∨ t = ratioR from by simpa using ht) with rfl | rfl | |
| · exact ratioQ_mem_shiftedDiagonalRegular | |
| · exact ratioR_mem_shiftedDiagonalRegular | |
| lemma ratioQ_inv_mem_shiftedDiagonalRegular : ratioQ⁻¹ ∈ shiftedDiagonalRegularAlgebra := by | |
| have h0 : (y 2 / y 3)⁻¹ ∈ shiftedDiagonalRegularAlgebra := unitRoot_inv_mem_shiftedDiagonalRegular 2 | |
| have h1 : (y 1)⁻¹ ∈ shiftedDiagonalRegularAlgebra := unitRoot_inv_mem_shiftedDiagonalRegular 1 | |
| have he : ratioQ⁻¹ = (y 2 / y 3)⁻¹ * y 0 * (y 1)⁻¹ := by | |
| unfold ratioQ | |
| field_simp [y_ne_zero] | |
| rw [he] | |
| exact shiftedDiagonalRegularAlgebra.mul_mem | |
| (shiftedDiagonalRegularAlgebra.mul_mem h0 (y_mem_shiftedDiagonalRegular 0)) h1 | |
| lemma shiftedDiagonalSectionOpen_le : shiftedDiagonalSectionOpen ≤ shiftedDiagonalRegularAlgebra := by | |
| apply (FieldPrincipalOpen.away_le_iff sectionChart shiftedDiagonalSectionDenominator | |
| shiftedDiagonalSectionDenominator_ne_zero shiftedDiagonalRegularAlgebra).mpr | |
| refine ⟨sectionChart_le_shiftedDiagonalRegular, ?_⟩ | |
| change (y 0 * y 1 * ratioQ)⁻¹ ∈ shiftedDiagonalRegularAlgebra | |
| rw [mul_inv_rev, mul_inv_rev] | |
| exact shiftedDiagonalRegularAlgebra.mul_mem ratioQ_inv_mem_shiftedDiagonalRegular | |
| (shiftedDiagonalRegularAlgebra.mul_mem (unitRoot_inv_mem_shiftedDiagonalRegular 1) | |
| (unitRoot_inv_mem_shiftedDiagonalRegular 0)) | |
| lemma sectionChart_le_shiftedDiagonalOpen : sectionChart ≤ shiftedDiagonalSectionOpen := | |
| FieldPrincipalOpen.le_away sectionChart shiftedDiagonalSectionDenominator shiftedDiagonalSectionDenominator_ne_zero | |
| lemma y_mem_shiftedDiagonalOpen (i : Fin 5) : y i ∈ shiftedDiagonalSectionOpen := | |
| sectionChart_le_shiftedDiagonalOpen (y_mem_sectionChart i) | |
| lemma ratioQ_mem_shiftedDiagonalOpen : ratioQ ∈ shiftedDiagonalSectionOpen := | |
| sectionChart_le_shiftedDiagonalOpen ratioQ_mem_sectionChart | |
| lemma ratioR_mem_shiftedDiagonalOpen : ratioR ∈ shiftedDiagonalSectionOpen := | |
| sectionChart_le_shiftedDiagonalOpen ratioR_mem_sectionChart | |
| lemma shiftedDiagonalProduct_inv_mem : (y 0 * y 1 * ratioQ)⁻¹ ∈ shiftedDiagonalSectionOpen := | |
| FieldPrincipalOpen.inv_mem_away sectionChart shiftedDiagonalSectionDenominator shiftedDiagonalSectionDenominator_ne_zero | |
| lemma y0_inv_mem_shiftedDiagonalOpen : (y 0)⁻¹ ∈ shiftedDiagonalSectionOpen := by | |
| apply FieldPrincipalOpen.inv_left_mem shiftedDiagonalSectionOpen | |
| (mul_ne_zero (y_ne_zero 1) ratioQ_ne_zero) | |
| (shiftedDiagonalSectionOpen.mul_mem (y_mem_shiftedDiagonalOpen 1) ratioQ_mem_shiftedDiagonalOpen) | |
| simpa only [mul_assoc] using shiftedDiagonalProduct_inv_mem | |
| lemma y1_inv_mem_shiftedDiagonalOpen : (y 1)⁻¹ ∈ shiftedDiagonalSectionOpen := by | |
| apply FieldPrincipalOpen.inv_left_mem shiftedDiagonalSectionOpen | |
| (mul_ne_zero (y_ne_zero 0) ratioQ_ne_zero) | |
| (shiftedDiagonalSectionOpen.mul_mem (y_mem_shiftedDiagonalOpen 0) ratioQ_mem_shiftedDiagonalOpen) | |
| simpa only [mul_assoc, mul_comm, mul_left_comm] using shiftedDiagonalProduct_inv_mem | |
| lemma ratioQ_inv_mem_shiftedDiagonalOpen : ratioQ⁻¹ ∈ shiftedDiagonalSectionOpen := by | |
| apply FieldPrincipalOpen.inv_left_mem shiftedDiagonalSectionOpen | |
| (mul_ne_zero (y_ne_zero 0) (y_ne_zero 1)) | |
| (shiftedDiagonalSectionOpen.mul_mem (y_mem_shiftedDiagonalOpen 0) (y_mem_shiftedDiagonalOpen 1)) | |
| simpa only [mul_assoc, mul_comm, mul_left_comm] using shiftedDiagonalProduct_inv_mem | |
| lemma coordinateRoot_mem_shiftedDiagonalOpen (i : Fin 2) : | |
| KummerShiftedDiagonal.coordinateRoot 7 i ∈ shiftedDiagonalSectionOpen := by | |
| fin_cases i | |
| · exact y_mem_shiftedDiagonalOpen 3 | |
| · change y 4 / y 3 ∈ shiftedDiagonalSectionOpen | |
| have he : y 4 / y 3 = ratioR * y 0 := by | |
| unfold ratioR | |
| field_simp [y_ne_zero] | |
| rw [he] | |
| exact shiftedDiagonalSectionOpen.mul_mem ratioR_mem_shiftedDiagonalOpen (y_mem_shiftedDiagonalOpen 0) | |
| lemma B_mem_shiftedDiagonalOpen (b : KummerShiftedDiagonal.B 7) : (b : L) ∈ shiftedDiagonalSectionOpen := by | |
| have h := b.property | |
| change (b : L) ∈ Algebra.adjoin ℂ (Set.range (KummerShiftedDiagonal.coordinateRoot 7)) at h | |
| exact (Algebra.adjoin_le (by rintro _ ⟨i,rfl⟩; exact coordinateRoot_mem_shiftedDiagonalOpen i)) h | |
| lemma remainingRoot_mem_shiftedDiagonalOpen (i : Fin 3) : | |
| KummerShiftedDiagonal.remainingRoot 7 i ∈ shiftedDiagonalSectionOpen := by | |
| fin_cases i | |
| · exact y_mem_shiftedDiagonalOpen 0 | |
| · exact y_mem_shiftedDiagonalOpen 1 | |
| · change y 2 / y 3 ∈ shiftedDiagonalSectionOpen | |
| have he : y 2 / y 3 = ratioQ * y 0 * (y 1)⁻¹ := by | |
| unfold ratioQ | |
| field_simp [y_ne_zero] | |
| rw [he] | |
| exact shiftedDiagonalSectionOpen.mul_mem | |
| (shiftedDiagonalSectionOpen.mul_mem ratioQ_mem_shiftedDiagonalOpen (y_mem_shiftedDiagonalOpen 0)) | |
| y1_inv_mem_shiftedDiagonalOpen | |
| lemma remainingRoot_inv_mem_shiftedDiagonalOpen (i : Fin 3) : | |
| (KummerShiftedDiagonal.remainingRoot 7 i)⁻¹ ∈ shiftedDiagonalSectionOpen := by | |
| fin_cases i | |
| · exact y0_inv_mem_shiftedDiagonalOpen | |
| · exact y1_inv_mem_shiftedDiagonalOpen | |
| · change (y 2 / y 3)⁻¹ ∈ shiftedDiagonalSectionOpen | |
| have he : (y 2 / y 3)⁻¹ = ratioQ⁻¹ * (y 0)⁻¹ * y 1 := by | |
| unfold ratioQ | |
| field_simp [y_ne_zero] | |
| rw [he] | |
| exact shiftedDiagonalSectionOpen.mul_mem | |
| (shiftedDiagonalSectionOpen.mul_mem ratioQ_inv_mem_shiftedDiagonalOpen y0_inv_mem_shiftedDiagonalOpen) | |
| (y_mem_shiftedDiagonalOpen 1) | |
| lemma shiftedDiagonal_bDenominator_image : | |
| algebraMap (KummerShiftedDiagonal.B 7) L (KummerShiftedDiagonal.bDenominator 7) = | |
| KummerShiftedDiagonal.remainingRoot 7 0 ^ 7 * KummerShiftedDiagonal.remainingRoot 7 1 ^ 7 * | |
| KummerShiftedDiagonal.remainingRoot 7 2 ^ 7 := by | |
| change algebraMap (KummerShiftedDiagonal.B 7) L | |
| (algebraMap KummerShiftedDiagonal.C (KummerShiftedDiagonal.B 7) KummerShiftedDiagonal.chartDenominator) = _ | |
| rw [← IsScalarTower.algebraMap_apply KummerShiftedDiagonal.C (KummerShiftedDiagonal.B 7) L] | |
| change algebraMap KummerShiftedDiagonal.C L | |
| (KummerShiftedDiagonal.remainingForm 0 * KummerShiftedDiagonal.remainingForm 1 * KummerShiftedDiagonal.remainingForm 2) = _ | |
| simp only [map_mul, KummerShiftedDiagonal.remainingRoot_pow] | |
| lemma bDenominator_inv_mem_shiftedDiagonalOpen : | |
| (algebraMap (KummerShiftedDiagonal.B 7) L (KummerShiftedDiagonal.bDenominator 7))⁻¹ ∈ shiftedDiagonalSectionOpen := by | |
| rw [shiftedDiagonal_bDenominator_image, mul_inv_rev, mul_inv_rev, ← inv_pow, ← inv_pow, ← inv_pow] | |
| exact shiftedDiagonalSectionOpen.mul_mem (shiftedDiagonalSectionOpen.pow_mem (remainingRoot_inv_mem_shiftedDiagonalOpen 2) 7) | |
| (shiftedDiagonalSectionOpen.mul_mem (shiftedDiagonalSectionOpen.pow_mem (remainingRoot_inv_mem_shiftedDiagonalOpen 1) 7) | |
| (shiftedDiagonalSectionOpen.pow_mem (remainingRoot_inv_mem_shiftedDiagonalOpen 0) 7)) | |
| lemma S_mem_shiftedDiagonalOpen (s : KummerShiftedDiagonal.S 7) : | |
| algebraMap (KummerShiftedDiagonal.S 7) L s ∈ shiftedDiagonalSectionOpen := by | |
| apply FieldPrincipalOpen.localizationImage_mem shiftedDiagonalSectionOpen (KummerShiftedDiagonal.bDenominator 7) | |
| ((isUnit_iff_ne_zero).mp (KummerShiftedDiagonal.bDenominator_unit_in_L 7)) | |
| (fun b => B_mem_shiftedDiagonalOpen b) bDenominator_inv_mem_shiftedDiagonalOpen | |
| lemma shiftedDiagonalRegular_le_sectionOpen : shiftedDiagonalRegularAlgebra ≤ shiftedDiagonalSectionOpen := by | |
| intro t ht | |
| change t ∈ Algebra.adjoin (KummerShiftedDiagonal.S 7) (KummerShiftedDiagonal.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_shiftedDiagonalOpen i | |
| | algebraMap s => exact S_mem_shiftedDiagonalOpen s | |
| | add x y hx hy h₁ h₂ => exact shiftedDiagonalSectionOpen.add_mem h₁ h₂ | |
| | mul x y hx hy h₁ h₂ => exact shiftedDiagonalSectionOpen.mul_mem h₁ h₂ | |
| /-- The literal polarization chart, localized at a*b*q, is exactly the | |
| regular normalization of the literal shiftedDiagonal-point blowup open, within the | |
| same original function field. -/ | |
| theorem shiftedDiagonalSectionOpen_eq : shiftedDiagonalSectionOpen = shiftedDiagonalRegularAlgebra := | |
| le_antisymm shiftedDiagonalSectionOpen_le shiftedDiagonalRegular_le_sectionOpen | |
| theorem sectionChart_shiftedDiagonalOpen_regular : | |
| IsRegularRing (Localization.Away shiftedDiagonalSectionDenominator) := by | |
| have : IsRegularRing shiftedDiagonalRegularAlgebra := KummerShiftedDiagonal.chartRootAlgebra_regular 7 | |
| exact FieldPrincipalOpen.regular_away_of_eq sectionChart shiftedDiagonalSectionDenominator | |
| shiftedDiagonalSectionDenominator_ne_zero shiftedDiagonalRegularAlgebra shiftedDiagonalSectionOpen_eq | |
| end ExplicitCone | |
| end | |
| noncomputable section | |
| open Algebra MvPolynomial | |
| namespace KummerNode | |
| open KummerLines | |
| variable (p : ℕ) [Fact p.Prime] | |
| local instance : IsScalarTower ℂ R (L p) := IsScalarTower.of_algebraMap_eq' rfl | |
| def coordinateRoot : Fin 2 → L p := | |
| ![KummerCover.fieldRoot (p := p) radicand 0, | |
| KummerCover.fieldRoot (p := p) radicand 3] | |
| def shiftedCoordinate : Fin 2 → R := ![X 0, X 1 - 1] | |
| lemma shiftedCoordinate_independent : AlgebraicIndependent ℂ shiftedCoordinate := by | |
| apply _root_.OAI.AlgebraicIndependent.of_polynomial_expressions (algebraicIndependent_X (Fin 2) ℂ) | |
| intro i | |
| fin_cases i | |
| · exact Algebra.subset_adjoin ⟨0, rfl⟩ | |
| · have hx : X (1 : Fin 2) - 1 ∈ Algebra.adjoin ℂ (Set.range shiftedCoordinate) := | |
| Algebra.subset_adjoin ⟨1, rfl⟩ | |
| simpa using (Algebra.adjoin ℂ (Set.range shiftedCoordinate)).add_mem hx | |
| (Subalgebra.one_mem _) | |
| lemma coordinateRoot_pow (i : Fin 2) : | |
| coordinateRoot p i ^ p = algebraMap R (L p) (shiftedCoordinate i) := by | |
| fin_cases i | |
| · exact KummerCover.fieldRoot_pow (p := p) radicand 0 | |
| · exact KummerCover.fieldRoot_pow (p := p) radicand 3 | |
| lemma coordinateRoot_independent : AlgebraicIndependent ℂ (coordinateRoot p) := by | |
| have hR : 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 := shiftedCoordinate_independent.map (f := IsScalarTower.toAlgHom ℂ R (L p)) hR.injOn | |
| have he : (fun i => coordinateRoot p i ^ p) = | |
| (IsScalarTower.toAlgHom ℂ R (L p)) ∘ shiftedCoordinate := by | |
| funext i | |
| exact coordinateRoot_pow p i | |
| rw [← he] at h | |
| exact _root_.OAI.AlgebraicIndependent.of_powers (fun _ => p) h | |
| /-- The ramified coordinate part of the literal cover at (x,y)=(0,1). -/ | |
| def coordinateAlgebra : Subalgebra ℂ (L p) := | |
| Algebra.adjoin ℂ (Set.range (coordinateRoot p)) | |
| abbrev B := coordinateAlgebra p | |
| def planeEquiv : R ≃ₐ[ℂ] B p := (coordinateRoot_independent p).aevalEquiv | |
| instance : IsRegularRing (B p) := | |
| IsRegularRing.of_ringEquiv (planeEquiv p).toRingEquiv | |
| instance : IsIntegrallyClosed (B p) := by | |
| have hR : IsIntegrallyClosed R := UniqueFactorizationMonoid.instIsIntegrallyClosed | |
| exact IsIntegrallyClosed.of_equiv (R := R) (S := B p) (planeEquiv p).toRingEquiv | |
| def bRoot (i : Fin 2) : B p := | |
| ⟨coordinateRoot p i, Algebra.subset_adjoin (Set.mem_range_self i)⟩ | |
| /-- The original plane map sends x to u^p and y to v^p+1; its inclusion | |
| in the original five-root field is exactly the source one. -/ | |
| def planeMap : R →ₐ[ℂ] B p := MvPolynomial.aeval ![bRoot p 0 ^ p, bRoot p 1 ^ p + 1] | |
| lemma planeMap_comp : (coordinateAlgebra p).val.comp (planeMap p) = | |
| IsScalarTower.toAlgHom ℂ R (L p) := by | |
| apply MvPolynomial.algHom_ext | |
| intro i | |
| simp only [AlgHom.comp_apply, planeMap, MvPolynomial.aeval_X] | |
| fin_cases i | |
| · change coordinateRoot p 0 ^ p = algebraMap R (L p) (X 0) | |
| exact coordinateRoot_pow p 0 | |
| · change coordinateRoot p 1 ^ p + 1 = algebraMap R (L p) (X 1) | |
| have h := coordinateRoot_pow p 1 | |
| change coordinateRoot p 1 ^ p = algebraMap R (L p) (X 1 - 1) at h | |
| rw [h, map_sub, map_one] | |
| ring | |
| instance : Algebra R (B p) := (planeMap p).toRingHom.toAlgebra | |
| instance : IsScalarTower ℂ R (B p) := IsScalarTower.of_algebraMap_eq' | |
| (AlgHom.comp_algebraMap (planeMap p)).symm | |
| instance : IsScalarTower R (B p) (L p) := IsScalarTower.of_algebraMap_eq' (by | |
| exact congrArg AlgHom.toRingHom (planeMap_comp p).symm) | |
| lemma root_integral (i : Fin 5) : | |
| IsIntegral R (KummerCover.fieldRoot (p := p) radicand i) := by | |
| refine ⟨Polynomial.X ^ p - Polynomial.C (lineForm i), | |
| Polynomial.monic_X_pow_sub_C _ (NeZero.ne p), ?_⟩ | |
| change Polynomial.aeval (KummerCover.fieldRoot (p := p) radicand i) | |
| (Polynomial.X ^ p - Polynomial.C (lineForm i)) = 0 | |
| simp only [map_sub, map_pow, Polynomial.aeval_X, Polynomial.aeval_C] | |
| exact sub_eq_zero.mpr (KummerCover.fieldRoot_pow radicand i) | |
| instance : Algebra.IsIntegral R (B p) := by | |
| have hB : coordinateAlgebra p ≤ (integralClosure R (L p)).restrictScalars ℂ := by | |
| apply Algebra.adjoin_le | |
| rintro z ⟨i, rfl⟩ | |
| fin_cases i | |
| · exact root_integral p 0 | |
| · exact root_integral p 3 | |
| constructor | |
| intro b | |
| have hi : IsIntegral R (b : L p) := hB b.property | |
| exact (isIntegral_algHom_iff (IsScalarTower.toAlgHom R (B p) (L p)) | |
| Subtype.val_injective).mp hi | |
| instance : Algebra.FiniteType ℂ (B p) := by | |
| exact Algebra.FiniteType.of_surjective (planeEquiv p).toAlgHom (planeEquiv p).surjective | |
| instance : Algebra.FiniteType R (B p) := Algebra.FiniteType.of_restrictScalars_finiteType ℂ R (B p) | |
| instance : Module.Finite R (B p) := Algebra.IsIntegral.finite | |
| end KummerNode | |
| end | |
| noncomputable section | |
| open Algebra MvPolynomial | |
| namespace KummerAffineExtra | |
| open KummerLines | |
| variable (p : ℕ) [Fact p.Prime] | |
| local instance : IsScalarTower ℂ R (L p) := IsScalarTower.of_algebraMap_eq' rfl | |
| /-- The other ordinary affine node, and the open part of the diagonal. | |
| Together with the node (0,1), these will cover the complement of the two | |
| actual affine triple points. -/ | |
| def coordinateIndex : Fin 2 → Fin 2 → Fin 5 := ![![1, 2], ![0, 4]] | |
| def coordinateRoot (j : Fin 2) (i : Fin 2) : L p := | |
| KummerCover.fieldRoot (p := p) radicand (coordinateIndex j i) | |
| def coordinateForm (j : Fin 2) (i : Fin 2) : R := lineForm (coordinateIndex j i) | |
| lemma coordinateForm_independent (j : Fin 2) : AlgebraicIndependent ℂ (coordinateForm j) := by | |
| apply _root_.OAI.AlgebraicIndependent.of_polynomial_expressions (algebraicIndependent_X (Fin 2) ℂ) | |
| have h0 : coordinateForm j 0 ∈ Algebra.adjoin ℂ (Set.range (coordinateForm j)) := | |
| Algebra.subset_adjoin (Set.mem_range_self 0) | |
| have h1 : coordinateForm j 1 ∈ Algebra.adjoin ℂ (Set.range (coordinateForm j)) := | |
| Algebra.subset_adjoin (Set.mem_range_self 1) | |
| intro i | |
| fin_cases j <;> fin_cases i | |
| · change X (0 : Fin 2) ∈ _ | |
| change X (0 : Fin 2) - 1 ∈ _ at h1 | |
| simpa using (Algebra.adjoin ℂ (Set.range (coordinateForm 0))).add_mem h1 | |
| (Subalgebra.one_mem _) | |
| · exact h0 | |
| · exact h0 | |
| · change X (1 : Fin 2) ∈ _ | |
| change X (0 : Fin 2) ∈ _ at h0 | |
| change X (0 : Fin 2) - X (1 : Fin 2) ∈ _ at h1 | |
| simpa using (Algebra.adjoin ℂ (Set.range (coordinateForm 1))).sub_mem h0 h1 | |
| lemma coordinateRoot_pow (j i : Fin 2) : | |
| coordinateRoot p j i ^ p = algebraMap R (L p) (coordinateForm j i) := | |
| KummerCover.fieldRoot_pow radicand (coordinateIndex j i) | |
| lemma coordinateRoot_independent (j : Fin 2) : AlgebraicIndependent ℂ (coordinateRoot p j) := by | |
| have hR : 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 := (coordinateForm_independent j).map | |
| (f := IsScalarTower.toAlgHom ℂ R (L p)) hR.injOn | |
| have he : (fun i => coordinateRoot p j i ^ p) = | |
| (IsScalarTower.toAlgHom ℂ R (L p)) ∘ coordinateForm j := by | |
| funext i | |
| exact coordinateRoot_pow p j i | |
| rw [← he] at h | |
| exact _root_.OAI.AlgebraicIndependent.of_powers (fun _ => p) h | |
| def coordinateAlgebra (j : Fin 2) : Subalgebra ℂ (L p) := | |
| Algebra.adjoin ℂ (Set.range (coordinateRoot p j)) | |
| abbrev B (j : Fin 2) := coordinateAlgebra p j | |
| def planeEquiv (j : Fin 2) : R ≃ₐ[ℂ] B p j := (coordinateRoot_independent p j).aevalEquiv | |
| instance (j : Fin 2) : IsRegularRing (B p j) := | |
| IsRegularRing.of_ringEquiv (planeEquiv p j).toRingEquiv | |
| instance (j : Fin 2) : IsIntegrallyClosed (B p j) := by | |
| have hR : IsIntegrallyClosed R := UniqueFactorizationMonoid.instIsIntegrallyClosed | |
| exact IsIntegrallyClosed.of_equiv (R := R) (S := B p j) (planeEquiv p j).toRingEquiv | |
| def bRoot (j i : Fin 2) : B p j := | |
| ⟨coordinateRoot p j i, Algebra.subset_adjoin (Set.mem_range_self i)⟩ | |
| def planeMap (j : Fin 2) : R →ₐ[ℂ] B p j := | |
| MvPolynomial.aeval (if j = 0 then ![bRoot p j 1 ^ p + 1, bRoot p j 0 ^ p] | |
| else ![bRoot p j 0 ^ p, bRoot p j 0 ^ p - bRoot p j 1 ^ p]) | |
| lemma planeMap_comp (j : Fin 2) : (coordinateAlgebra p j).val.comp (planeMap p j) = | |
| IsScalarTower.toAlgHom ℂ R (L p) := by | |
| apply MvPolynomial.algHom_ext | |
| intro i | |
| simp only [AlgHom.comp_apply, planeMap, MvPolynomial.aeval_X] | |
| fin_cases j <;> fin_cases i | |
| · change coordinateRoot p 0 1 ^ p + 1 = algebraMap R (L p) (X 0) | |
| rw [coordinateRoot_pow] | |
| change algebraMap R (L p) (X 0 - 1) + 1 = _ | |
| rw [map_sub, map_one] | |
| ring | |
| · change coordinateRoot p 0 0 ^ p = algebraMap R (L p) (X 1) | |
| exact coordinateRoot_pow p 0 0 | |
| · change coordinateRoot p 1 0 ^ p = algebraMap R (L p) (X 0) | |
| exact coordinateRoot_pow p 1 0 | |
| · change coordinateRoot p 1 0 ^ p - coordinateRoot p 1 1 ^ p = | |
| algebraMap R (L p) (X 1) | |
| rw [coordinateRoot_pow, coordinateRoot_pow] | |
| change algebraMap R (L p) (X 0) - algebraMap R (L p) (X 0 - X 1) = _ | |
| rw [map_sub] | |
| ring | |
| instance (j : Fin 2) : Algebra R (B p j) := (planeMap p j).toRingHom.toAlgebra | |
| instance (j : Fin 2) : IsScalarTower ℂ R (B p j) := IsScalarTower.of_algebraMap_eq' | |
| (AlgHom.comp_algebraMap (planeMap p j)).symm | |
| instance (j : Fin 2) : IsScalarTower R (B p j) (L p) := IsScalarTower.of_algebraMap_eq' (by | |
| exact congrArg AlgHom.toRingHom (planeMap_comp p j).symm) | |
| instance (j : Fin 2) : Algebra.IsIntegral R (B p j) := by | |
| have hB : coordinateAlgebra p j ≤ (integralClosure R (L p)).restrictScalars ℂ := by | |
| apply Algebra.adjoin_le | |
| rintro z ⟨i, rfl⟩ | |
| exact KummerNode.root_integral p (coordinateIndex j i) | |
| constructor | |
| intro b | |
| have hi : IsIntegral R (b : L p) := hB b.property | |
| exact (isIntegral_algHom_iff (IsScalarTower.toAlgHom R (B p j) (L p)) | |
| Subtype.val_injective).mp hi | |
| instance (j : Fin 2) : Algebra.FiniteType ℂ (B p j) := | |
| Algebra.FiniteType.of_surjective (planeEquiv p j).toAlgHom (planeEquiv p j).surjective | |
| instance (j : Fin 2) : Algebra.FiniteType R (B p j) := | |
| Algebra.FiniteType.of_restrictScalars_finiteType ℂ R (B p j) | |
| instance (j : Fin 2) : Module.Finite R (B p j) := Algebra.IsIntegral.finite | |
| end KummerAffineExtra | |
| end | |
| noncomputable section | |
| open Algebra MvPolynomial | |
| open nonZeroDivisors | |
| namespace KummerAffineExtra | |
| open KummerLines | |
| variable (p : ℕ) [Fact p.Prime] (j : Fin 2) | |
| local instance : IsScalarTower ℂ R (L p) := IsScalarTower.of_algebraMap_eq' rfl | |
| def remainingIndex : Fin 2 → Fin 3 → Fin 5 := ![![0, 3, 4], ![1, 2, 3]] | |
| def chartDenominator : R := | |
| lineForm (remainingIndex j 0) * lineForm (remainingIndex j 1) * lineForm (remainingIndex j 2) | |
| lemma chartDenominator_ne_zero : chartDenominator j ≠ 0 := | |
| mul_ne_zero (mul_ne_zero (prime_lineForm (remainingIndex j 0)).ne_zero | |
| (prime_lineForm (remainingIndex j 1)).ne_zero) (prime_lineForm (remainingIndex j 2)).ne_zero | |
| lemma planeMap_injective : Function.Injective (planeMap p j) := by | |
| have hR : 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) | |
| intro a b h | |
| apply hR | |
| exact congrArg (fun g : R →ₐ[ℂ] L p => g a) (planeMap_comp p j).symm |>.trans | |
| ((congrArg (fun z : B p j => (z : L p)) h).trans | |
| (congrArg (fun g : R →ₐ[ℂ] L p => g b) (planeMap_comp p j))) | |
| def bDenominator : B p j := planeMap p j (chartDenominator j) | |
| lemma bDenominator_ne_zero : bDenominator p j ≠ 0 := | |
| (map_ne_zero_iff _ (planeMap_injective p j)).mpr (chartDenominator_ne_zero j) | |
| lemma bPowers_le : Submonoid.powers (bDenominator p j) ≤ (B p j)⁰ := by | |
| rintro _ ⟨n, rfl⟩ | |
| exact mem_nonZeroDivisors_of_ne_zero (pow_ne_zero n (bDenominator_ne_zero p j)) | |
| def S := Localization.Away (bDenominator p j) | |
| instance : CommRing (S p j) := inferInstanceAs (CommRing (Localization.Away (bDenominator p j))) | |
| instance : Algebra (B p j) (S p j) := | |
| OreLocalization.instAlgebra (R := B p j) (R₀ := B p j) | |
| (S := Submonoid.powers (bDenominator p j)) | |
| instance : IsLocalization.Away (bDenominator p j) (S p j) := Localization.isLocalization | |
| instance : IsDomain (S p j) := | |
| IsLocalization.isDomain_of_le_nonZeroDivisors _ (bPowers_le p j) | |
| instance : IsIntegrallyClosed (S p j) := | |
| isIntegrallyClosed_of_isLocalization (S p j) (Submonoid.powers (bDenominator p j)) (bPowers_le p j) | |
| instance : Algebra.Etale (B p j) (S p j) := | |
| Algebra.Etale.of_isLocalizationAway (bDenominator p j) | |
| instance : IsRegularRing (S p j) := EtaleRegular.regular (B p j) (S p j) | |
| lemma bDenominator_unit_in_L : IsUnit (algebraMap (B p j) (L p) (bDenominator p j)) := by | |
| apply isUnit_iff_ne_zero.mpr | |
| exact (map_ne_zero_iff _ (Subtype.val_injective)).mpr (bDenominator_ne_zero p j) | |
| instance : Algebra (S p j) (L p) := | |
| (IsLocalization.Away.lift (bDenominator p j) (bDenominator_unit_in_L p j) : S p j →+* L p).toAlgebra | |
| instance : IsScalarTower (B p j) (S p j) (L p) := | |
| IsScalarTower.of_algebraMap_eq' (R := B p j) (S := S p j) (A := L p) | |
| (IsLocalization.Away.lift_comp (S := S p j) (bDenominator p j) (bDenominator_unit_in_L p j)).symm | |
| instance : Module.IsTorsionFree (S p j) (L p) := by | |
| apply Module.isTorsionFree_iff_algebraMap_injective.mpr | |
| change Function.Injective (IsLocalization.Away.lift (bDenominator p j) (bDenominator_unit_in_L p j)) | |
| apply (IsLocalization.lift_injective_iff _).mpr | |
| intro a b | |
| rw [(IsLocalization.injective (S p j) (bPowers_le p j)).eq_iff] | |
| change a = b ↔ (a : L p) = (b : L p) | |
| exact Subtype.val_injective.eq_iff.symm | |
| instance : Algebra R (S p j) := (algebraMap (B p j) (S p j)).comp (algebraMap R (B p j)) |>.toAlgebra | |
| instance : IsScalarTower R (B p j) (S p j) := | |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := B p j) (A := S p j) rfl | |
| instance : IsScalarTower R (S p j) (L p) := | |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := S p j) (A := L p) (by | |
| rw [IsScalarTower.algebraMap_eq R (B p j) (L p), IsScalarTower.algebraMap_eq (B p j) (S p j) (L p)] | |
| rfl) | |
| lemma remaining_dvd (i : Fin 3) : lineForm (remainingIndex j i) ∣ chartDenominator j := by | |
| fin_cases i <;> simp only [chartDenominator, Fin.isValue] | |
| · 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 R (S p j) (lineForm (remainingIndex j i))) := | |
| IsLocalization.Away.isUnit_of_dvd (S := S p j) (bDenominator p j) | |
| (map_dvd (planeMap p j) (remaining_dvd j i)) | |
| lemma exponent_unit : IsUnit (p : S p j) := by | |
| have hC : IsUnit (p : ℂ) := isUnit_iff_ne_zero.mpr (by exact_mod_cast (NeZero.ne p)) | |
| have hB : IsUnit (p : B p j) := by simpa using hC.map (algebraMap ℂ (B p j)) | |
| simpa using hB.map (algebraMap (B p j) (S p j)) | |
| def remainingRoots : Finset (L p) := by | |
| classical | |
| exact Finset.univ.image (fun i : Fin 3 => KummerCover.fieldRoot (p := p) radicand (remainingIndex j i)) | |
| abbrev chartRootAlgebra := Algebra.adjoin (S p j) (remainingRoots p j : Set (L p)) | |
| theorem chartRootAlgebra_finiteFreeEtale : | |
| Algebra.Etale (S p j) (chartRootAlgebra p j) ∧ | |
| Module.Finite (S p j) (chartRootAlgebra p j) ∧ | |
| Module.Free (S p j) (chartRootAlgebra p j) ∧ | |
| IsIntegrallyClosed (chartRootAlgebra p j) := by | |
| apply KummerEtale.finite_unit_roots p (NeZero.pos p) (exponent_unit p j) | |
| intro x hx | |
| classical | |
| obtain ⟨i, -, rfl⟩ := Finset.mem_image.mp (show x ∈ Finset.univ.image _ from hx) | |
| refine ⟨(remaining_unit p j i).unit, ?_⟩ | |
| rw [IsUnit.unit_spec, ← IsScalarTower.algebraMap_apply R (S p j) (L p)] | |
| exact KummerCover.fieldRoot_pow radicand (remainingIndex j i) | |
| theorem chartRootAlgebra_regular : IsRegularRing (chartRootAlgebra p j) := by | |
| have := (chartRootAlgebra_finiteFreeEtale p j).1 | |
| exact EtaleRegular.regular (S p j) (chartRootAlgebra p j) | |
| end KummerAffineExtra | |
| end | |
| noncomputable section | |
| open Algebra MvPolynomial | |
| open nonZeroDivisors | |
| namespace KummerAffineExtra | |
| open KummerLines | |
| variable (p : ℕ) [Fact p.Prime] (j : Fin 2) | |
| /-- The two other explicit affine opens of the original plane. -/ | |
| def T := Localization.Away (chartDenominator j) | |
| instance : CommRing (T j) := inferInstanceAs (CommRing (Localization.Away (chartDenominator j))) | |
| instance : Algebra R (T j) := OreLocalization.instAlgebra (R := R) (R₀ := R) | |
| (S := Submonoid.powers (chartDenominator j)) | |
| instance : IsLocalization.Away (chartDenominator j) (T j) := Localization.isLocalization | |
| instance coordinateMappedLocalization : | |
| IsLocalization (Algebra.algebraMapSubmonoid (B p j) (Submonoid.powers (chartDenominator j))) (S p j) := by | |
| change IsLocalization ((Submonoid.powers (chartDenominator j)).map (algebraMap R (B p j))) (S p j) | |
| rw [Submonoid.map_powers] | |
| exact inferInstanceAs (IsLocalization.Away (bDenominator p j) (S p j)) | |
| instance : Algebra (T j) (S p j) := localizationAlgebra (Submonoid.powers (chartDenominator j)) (B p j) | |
| instance : IsScalarTower R (T j) (S p j) := | |
| isScalarTower_localizationAlgebra (Submonoid.powers (chartDenominator j)) (B p j) | |
| instance : Algebra (T j) (L p) := ((algebraMap (S p j) (L p)).comp (algebraMap (T j) (S p j))).toAlgebra | |
| instance : IsScalarTower (T j) (S p j) (L p) := | |
| IsScalarTower.of_algebraMap_eq' (R := (T j)) (S := S p j) (A := L p) rfl | |
| instance : IsScalarTower R (T j) (L p) := | |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := (T j)) (A := L p) (by | |
| rw [IsScalarTower.algebraMap_eq R (S p j) (L p), IsScalarTower.algebraMap_eq R (T j) (S p j)] | |
| rfl) | |
| instance : Algebra.IsIntegral (T j) (S p j) := ⟨isIntegral_localization⟩ | |
| instance : Module.Finite (T j) (S p j) := | |
| Module.Finite.of_isLocalizedModule (Submonoid.powers (chartDenominator j)) | |
| (IsScalarTower.toAlgHom R (B p j) (S p j)).toLinearMap | |
| instance : Algebra (T j) (chartRootAlgebra p j) := | |
| ((algebraMap (S p j) (chartRootAlgebra p j)).comp (algebraMap (T j) (S p j))).toAlgebra | |
| instance : IsScalarTower (T j) (S p j) (chartRootAlgebra p j) := | |
| IsScalarTower.of_algebraMap_eq' (R := (T j)) (S := S p j) (A := chartRootAlgebra p j) rfl | |
| instance : IsScalarTower (T j) (chartRootAlgebra p j) (L p) := | |
| IsScalarTower.of_algebraMap_eq' (R := (T j)) (S := chartRootAlgebra p j) (A := L p) (by | |
| rw [IsScalarTower.algebraMap_eq (T j) (S p j) (L p), | |
| IsScalarTower.algebraMap_eq (S p j) (chartRootAlgebra p j) (L p)] | |
| rfl) | |
| instance : Algebra R (chartRootAlgebra p j) := | |
| ((algebraMap (S p j) (chartRootAlgebra p j)).comp (algebraMap R (S p j))).toAlgebra | |
| instance : IsScalarTower R (S p j) (chartRootAlgebra p j) := | |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := S p j) (A := chartRootAlgebra p j) rfl | |
| instance : IsScalarTower R (chartRootAlgebra p j) (L p) := | |
| IsScalarTower.of_algebraMap_eq' (R := R) (S := chartRootAlgebra p j) (A := L p) (by | |
| rw [IsScalarTower.algebraMap_eq R (S p j) (L p), | |
| IsScalarTower.algebraMap_eq (S p j) (chartRootAlgebra p j) (L p)] | |
| rfl) | |
| instance : Module.Finite (S p j) (chartRootAlgebra p j) := (chartRootAlgebra_finiteFreeEtale p j).2.1 | |
| instance : Module.Finite (T j) (chartRootAlgebra p j) := Module.Finite.trans (S p j) (chartRootAlgebra p j) | |
| instance : IsIntegrallyClosed (chartRootAlgebra p j) := (chartRootAlgebra_finiteFreeEtale p j).2.2.2 | |
| lemma coordinateRoot_mem_chartRootAlgebra (i : Fin 2) : | |
| coordinateRoot p j i ∈ chartRootAlgebra p j := by | |
| have h := (chartRootAlgebra p j).algebraMap_mem (algebraMap (B p j) (S p j) (bRoot p j i)) | |
| rw [← IsScalarTower.algebraMap_apply (B p j) (S p j) (L p)] at h | |
| exact h | |
| lemma remainingRoot_mem_chartRootAlgebra (i : Fin 3) : | |
| KummerCover.fieldRoot (p := p) radicand (remainingIndex j i) ∈ chartRootAlgebra p j := by | |
| apply Algebra.subset_adjoin | |
| classical | |
| exact Finset.mem_image.mpr ⟨i, Finset.mem_univ i, rfl⟩ | |
| lemma allRoots_mem_chartRootAlgebra (i : Fin 5) : | |
| KummerCover.fieldRoot (p := p) radicand i ∈ chartRootAlgebra p j := by | |
| fin_cases j <;> fin_cases i | |
| · exact remainingRoot_mem_chartRootAlgebra p 0 0 | |
| · exact coordinateRoot_mem_chartRootAlgebra p 0 0 | |
| · exact coordinateRoot_mem_chartRootAlgebra p 0 1 | |
| · exact remainingRoot_mem_chartRootAlgebra p 0 1 | |
| · exact remainingRoot_mem_chartRootAlgebra p 0 2 | |
| · exact coordinateRoot_mem_chartRootAlgebra p 1 0 | |
| · exact remainingRoot_mem_chartRootAlgebra p 1 0 | |
| · exact remainingRoot_mem_chartRootAlgebra p 1 1 | |
| · exact remainingRoot_mem_chartRootAlgebra p 1 2 | |
| · exact coordinateRoot_mem_chartRootAlgebra p 1 1 | |
| instance : IsFractionRing (chartRootAlgebra p j) (L p) := by | |
| apply KummerEtale.fractionRing_of_generators (K := K) | |
| ((chartRootAlgebra p j).restrictScalars R) | |
| (Set.range (KummerCover.fieldRoot (p := p) radicand)) | |
| (KummerCover.fieldRoot_generates radicand) | |
| rintro x ⟨i, rfl⟩ | |
| exact allRoots_mem_chartRootAlgebra p j i | |
| /-- The entire normalization over this actual affine chart open is the | |
| regular algebra of the two ramified coordinates and three unit roots. -/ | |
| theorem chart_normalization : integralClosure (T j) (L p) = | |
| (chartRootAlgebra p j).restrictScalars (T j) := by | |
| apply le_antisymm | |
| · intro x hx | |
| have hx' : IsIntegral (chartRootAlgebra p j) x := | |
| ((mem_integralClosure_iff (T j) (L p)).mp hx).tower_top | |
| obtain ⟨a, ha⟩ := (isIntegrallyClosed_iff (L p)).mp | |
| (inferInstance : IsIntegrallyClosed (chartRootAlgebra p j)) hx' | |
| change (a : L p) = x at ha | |
| exact ha ▸ a.property | |
| · intro x hx | |
| exact (mem_integralClosure_iff (T j) (L p)).mpr | |
| ((Algebra.IsIntegral.isIntegral (R := (T j)) (⟨x, hx⟩ : chartRootAlgebra p j)).map | |
| (IsScalarTower.toAlgHom (T j) (chartRootAlgebra p j) (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 j) (L p)) := by | |
| let : IsRegularRing ((chartRootAlgebra p j).restrictScalars (T j)) := chartRootAlgebra_regular p j | |
| exact IsRegularRing.of_ringEquiv | |
| (Subalgebra.equivOfEq _ _ (chart_normalization p j).symm).toRingEquiv | |
| open scoped TensorProduct | |
| /-- This same normalization is the actual restriction of the original | |
| normalized five-root affine cover, not a newly chosen function field. -/ | |
| def chartRestrictionEquiv : | |
| (T j) ⊗[R] integralClosure R (L p) ≃ₐ[(T j)] integralClosure (T j) (L p) := by | |
| have : Algebra.Etale R (T j) := Algebra.Etale.of_isLocalizationAway (chartDenominator j) | |
| exact (AlgEquiv.ofBijective (TensorProduct.toIntegralClosure R (T j) (L p)) | |
| TensorProduct.toIntegralClosure_bijective_of_smooth).trans | |
| (IsLocalization.algebraLid (Submonoid.powers (chartDenominator j)) (T j) (L p)).mapIntegralClosure | |
| theorem normalization_chart_regular : IsRegularRing ((T j) ⊗[R] integralClosure R (L p)) := by | |
| have : IsRegularRing (integralClosure (T j) (L p)) := chart_normalization_regular p j | |
| exact IsRegularRing.of_ringEquiv | |
| (R := integralClosure (T j) (L p)) (chartRestrictionEquiv p j).symm.toRingEquiv | |
| end KummerAffineExtra | |
| end | |
| noncomputable section | |
| namespace RegularLocalization | |
| variable {A S : Type*} [CommRing A] [CommRing S] [Algebra A S] | |
| /-- Regularity is preserved under an arbitrary localization, proved by | |
| identifying every prime local ring rather than asserting smoothness. -/ | |
| theorem regular (M : Submonoid A) [IsLocalization M S] [IsRegularRing A] : | |
| IsRegularRing S := by | |
| have : IsNoetherianRing S := IsLocalization.isNoetherianRing M S inferInstance | |
| apply isRegularRing_iff.mpr | |
| intro q hq | |
| let p := q.comap (algebraMap A S) | |
| have : p.IsPrime := Ideal.IsPrime.comap (algebraMap A S) | |
| have : IsLocalization.AtPrime (Localization.AtPrime q) p := | |
| IsLocalization.isLocalization_isLocalization_atPrime_isLocalization M | |
| (Localization.AtPrime q) q | |
| exact IsRegularLocalRing.of_ringEquiv | |
| (IsLocalization.algEquiv p.primeCompl (Localization.AtPrime p) | |
| (Localization.AtPrime q)).toRingEquiv | |
| end RegularLocalization | |
| end | |
| end OAI | |