| import Mathlib.AlgebraicGeometry.Stalk |
| import OAI.NumberTheory.PiExponent.Ampleness.AffineFunctionFieldCompatibility |
| import OAI.NumberTheory.PiExponent.Geometry.CurveNormalizationProper |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace PiExponent.CurveNormalizationModel |
| open CategoryTheory AlgebraicGeometry |
| open scoped Polynomial |
| open PiExponent.CurveZeroPole |
| universe u |
|
|
| private theorem eqToHom_fromSpecStalk (X : Scheme.{u}) {x y : X} (h : x = y) : |
| Spec.map (eqToHom (congrArg (fun z => X.presheaf.stalk z) h)) ≫ |
| X.fromSpecStalk x = X.fromSpecStalk y := by |
| subst y |
| simp |
|
|
| theorem functionFieldRestriction_fromSpecStalk {U X : Scheme.{u}} |
| [IsIntegral U] [IsIntegral X] (i : U ⟶ X) [IsOpenImmersion i] : |
| Spec.map (functionFieldRestriction i) ≫ X.fromSpecStalk (genericPoint X) = |
| U.fromSpecStalk (genericPoint U) ≫ i := by |
| unfold functionFieldRestriction |
| rw [Spec.map_comp, Category.assoc, |
| eqToHom_fromSpecStalk X (genericPoint_eq_of_isOpenImmersion i).symm] |
| exact Scheme.SpecMap_stalkMap_fromSpecStalk i |
|
|
|
|
| theorem affineFunctionFieldEquiv_fromSpecStalk |
| (A E : Type u) [CommRing A] [IsDomain A] [Field E] |
| [Algebra A E] [IsFractionRing A E] : |
| Spec.map (CommRingCat.ofHom (affineFunctionFieldEquiv A E).toRingHom) ≫ |
| (Spec (.of A)).fromSpecStalk (genericPoint (Spec (.of A))) = |
| Spec.map (CommRingCat.ofHom (algebraMap A E)) := by |
| erw [Spec.fromSpecStalk_eq', ← Spec.map_comp] |
| congr 1 |
| apply CommRingCat.hom_ext |
| apply RingHom.ext |
| exact affineFunctionFieldEquiv_toStalk A E |
|
|
| private theorem affineRestriction_fromSpecStalk |
| (A E : Type u) [CommRing A] [IsDomain A] [Field E] |
| [Algebra A E] [IsFractionRing A E] {X : Scheme.{u}} [IsIntegral X] |
| (i : Spec (.of A) ⟶ X) [IsOpenImmersion i] : |
| Spec.map (functionFieldRestriction i ≫ |
| CommRingCat.ofHom (affineFunctionFieldEquiv A E).toRingHom) ≫ |
| X.fromSpecStalk (genericPoint X) = |
| Spec.map (CommRingCat.ofHom (algebraMap A E)) ≫ i := by |
| let e := Spec.map (CommRingCat.ofHom (affineFunctionFieldEquiv A E).toRingHom) |
| let r := Spec.map (functionFieldRestriction i) |
| let q := X.fromSpecStalk (genericPoint X) |
| have hmap := congrArg (fun k => k ≫ q) |
| (Spec.map_comp (functionFieldRestriction i) |
| (CommRingCat.ofHom (affineFunctionFieldEquiv A E).toRingHom)) |
| have hrestrict := congrArg (fun k => e ≫ k) (functionFieldRestriction_fromSpecStalk i) |
| have haffine := congrArg (fun k => k ≫ i) (affineFunctionFieldEquiv_fromSpecStalk A E) |
| have hassoc := Category.assoc e |
| ((Spec (.of A)).fromSpecStalk (genericPoint (Spec (.of A)))) i |
| exact hmap.trans ((Category.assoc e r q).trans |
| (hrestrict.trans (hassoc.symm.trans haffine))) |
|
|
| variable {F E : Type u} [Field F] [Field E] [Algebra F E] |
| variable (f : E) (hf : Transcendental F f) |
|
|
| def parameterChartConstantMap : F →+* parameterChart f hf := |
| letI := parameterPolynomialAlgebra f hf |
| (algebraMap F[X] (parameterChart f hf)).comp Polynomial.C |
|
|
| theorem parameterChartConstantMap_toField : |
| (algebraMap (parameterChart f hf) E).comp (parameterChartConstantMap f hf) = |
| algebraMap F E := by |
| let := parameterPolynomialAlgebra f hf |
| apply RingHom.ext |
| intro c |
| change algebraMap F[X] E (Polynomial.C c) = algebraMap F E c |
| rw [parameterPolynomialAlgebra_map] |
| simp |
|
|
| @[reassoc] theorem zeroChart_structureMap : |
| zeroChartInclusion f hf ≫ parameterCurveStructureMap f hf = |
| Spec.map (CommRingCat.ofHom (parameterChartConstantMap f hf)) := by |
| unfold parameterCurveStructureMap |
| rw [zeroChart_projection_assoc, ProjectiveLine.chartMap_structureMap, |
| parameterChartProjection, ← Spec.map_comp] |
| rfl |
|
|
| variable [FiniteDimensional (IntermediateField.adjoin F {f}) E] |
|
|
| def parameterCurveGenericPoint : Spec (.of E) ⟶ parameterCurve f hf := |
| Spec.map (CommRingCat.ofHom (parameterCurveFunctionFieldEquiv f hf).toRingHom) ≫ |
| (parameterCurve f hf).fromSpecStalk (genericPoint (parameterCurve f hf)) |
|
|
| theorem parameterCurveGenericPoint_eq_zeroChart : |
| parameterCurveGenericPoint f hf = |
| Spec.map (CommRingCat.ofHom (algebraMap (parameterChart f hf) E)) ≫ |
| zeroChartInclusion f hf := by |
| let := parameterAlgebra f hf |
| let := parameterPolynomialAlgebra f hf |
| let := parameter_scalarTower f hf |
| let := parameter_finite f hf |
| change Spec.map (functionFieldRestriction (zeroChartInclusion f hf) ≫ |
| CommRingCat.ofHom (affineFunctionFieldEquiv (parameterChart f hf) E).toRingHom) ≫ |
| (parameterCurve f hf).fromSpecStalk (genericPoint (parameterCurve f hf)) = _ |
| exact affineRestriction_fromSpecStalk (parameterChart f hf) E (zeroChartInclusion f hf) |
|
|
| @[reassoc] theorem parameterCurveGenericPoint_over_base : |
| parameterCurveGenericPoint f hf ≫ parameterCurveStructureMap f hf = |
| Spec.map (CommRingCat.ofHom (algebraMap F E)) := by |
| rw [parameterCurveGenericPoint_eq_zeroChart, Category.assoc, |
| zeroChart_structureMap, ← Spec.map_comp] |
| congr 1 |
| apply CommRingCat.hom_ext |
| exact parameterChartConstantMap_toField f hf |
|
|
| end PiExponent.CurveNormalizationModel |
|
|
| end |
|
|
| end OAI |
|
|
