| import Mathlib |
| import OAI.AlgebraicGeometry.SectionFields.NormalDivisors |
| import OAI.AlgebraicGeometry.SectionFields.TensorAlgebra |
|
|
| namespace OAI |
|
|
| /-! Constants and function fields under geometric integrality and open charts. -/ |
|
|
| noncomputable section |
| open AlgebraicGeometry CategoryTheory CategoryTheory.Limits TopologicalSpace Order Polynomial |
| open scoped TensorProduct WithZero |
| universe u |
|
|
| namespace RelativeDenominators |
|
|
| |
|
|
| theorem global_constants_surjective_of_geometricallyIntegral |
| (K : Type u) [Field K] {X : Scheme.{u}} |
| (f : X ⟶ Spec (.of K)) [UniversallyClosed f] [GeometricallyIntegral f] : |
| Function.Surjective (((Scheme.ΓSpecIso (.of K)).inv ≫ f.appTop).hom) := by |
| let : IsIntegral X := GeometricallyIntegral.isIntegral_of_subsingleton f |
| let : CompactSpace X := (quasiCompact_iff_compactSpace f).mp inferInstance |
| let A := Γ(X, ⊤) |
| let : Field A := (isField_of_universallyClosed K f).toField |
| let F : CommRingCat.of K ⟶ A := (Scheme.ΓSpecIso (.of K)).inv ≫ f.appTop |
| let : Algebra K A := F.hom.toAlgebra |
| have hintegral : F.hom.IsIntegral := by |
| apply RingHom.isIntegral_respectsIso.2 |
| (e := (Scheme.ΓSpecIso (.of K)).symm.commRingCatIsoToRingEquiv) |
| exact isIntegral_appTop_of_universallyClosed f |
| let : Algebra.IsIntegral K A := ⟨hintegral⟩ |
| let g : Spec A ⟶ Spec (.of K) := Spec.map F |
| have hfactor : X.toSpecΓ ≫ g = f := by |
| dsimp [g, F] |
| rw [Spec.map_comp, ← Category.assoc, ← Scheme.toSpecΓ_naturality] |
| rw [Category.assoc, ← Scheme.isoSpec_Spec_inv] |
| simp |
| let P := pullback g g |
| let q : pullback X.toSpecΓ (pullback.fst g g) ⟶ P := |
| pullback.snd X.toSpecΓ (pullback.fst g g) |
| let e : pullback X.toSpecΓ (pullback.fst g g) ≅ pullback f g := |
| pullbackRightPullbackFstIso g g X.toSpecΓ ≪≫ pullback.congrHom hfactor rfl |
| let : IsIntegral (pullback X.toSpecΓ (pullback.fst g g)) := |
| IsIntegral.of_isIso e.inv |
| let : IsSchemeTheoreticallyDominant X.toSpecΓ := |
| IsSchemeTheoreticallyDominant.of_isDominant _ |
| let : IsReduced P := IsSchemeTheoreticallyDominant.isReduced q |
| have hP : IsIrreducible (Set.univ : Set P) := by |
| have h := (IrreducibleSpace.isIrreducible_univ (pullback X.toSpecΓ (pullback.fst g g) : Scheme)).image |
| q q.continuous.continuousOn |
| simpa only [Set.image_univ, q.denseRange.closure_range] using h.closure |
| let : IrreducibleSpace P := (irreducibleSpace_def P).mpr hP |
| let : IsIntegral P := isIntegral_of_irreducibleSpace_of_isReduced P |
| let : IsIntegral (Spec (.of (A ⊗[K] A))) := |
| IsIntegral.of_isIso (pullbackSpecIso K A A).hom |
| let : IsDomain (A ⊗[K] A) := (affine_isIntegral_iff (.of (A ⊗[K] A))).mp inferInstance |
| exact algebraMap_surjective_of_isAlgebraic_tensorSelf_domain K A |
|
|
| |
|
|
| noncomputable def constantToFunctionField |
| (K : Type u) [Field K] {X : Scheme.{u}} [IsIntegral X] |
| (f : X ⟶ Spec (.of K)) : K →+* X.functionField := |
| (X.germToFunctionField ⊤).hom.comp |
| (((Scheme.ΓSpecIso (.of K)).inv ≫ f.appTop).hom) |
|
|
| |
|
|
| theorem rational_function_constant_of_divisor_zero |
| (K : Type u) [Field K] {X : Scheme.{u}} [IsIntegral X] [IsNoetherian X] |
| (f : X ⟶ Spec (.of K)) [UniversallyClosed f] [GeometricallyIntegral f] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (u : X.functionFieldˣ) (hdiv : principalDivisor X u = 0) : |
| ∃ c : Kˣ, constantToFunctionField K f (c : K) = (u : X.functionField) := by |
| obtain ⟨s, hs⟩ := rational_function_eq_global_unit_of_divisor_zero X hNormal u hdiv |
| obtain ⟨c, hc⟩ := global_constants_surjective_of_geometricallyIntegral K f (s : Γ(X, ⊤)) |
| have hc0 : c ≠ 0 := by |
| intro h |
| apply Units.ne_zero s |
| rw [← hc, h, map_zero] |
| refine ⟨Units.mk0 c hc0, ?_⟩ |
| change X.germToFunctionField ⊤ |
| (((Scheme.ΓSpecIso (.of K)).inv ≫ f.appTop) c) = (u : X.functionField) |
| rw [hc] |
| exact hs |
|
|
| |
|
|
| theorem functionFieldPullback_bijective_of_open |
| {X Y : Scheme} [IsIntegral X] [IsIntegral Y] |
| (j : Y ⟶ X) [IsOpenImmersion j] [IsDominant j] : |
| Function.Bijective (functionFieldPullback j) := by |
| let e := X.presheaf.stalkCongr |
| (Inseparable.of_eq (genericPoint_eq_of_dominant j)) |
| have he : X.presheaf.stalkSpecializes |
| (specializes_of_eq (genericPoint_eq_of_dominant j)) = e.inv := rfl |
| have : IsIso (X.presheaf.stalkSpecializes |
| (specializes_of_eq (genericPoint_eq_of_dominant j))) := by rw [he]; infer_instance |
| exact ConcreteCategory.bijective_of_isIso |
| (X.presheaf.stalkSpecializes |
| (specializes_of_eq (genericPoint_eq_of_dominant j)) ≫ j.stalkMap (genericPoint Y)) |
|
|
| noncomputable def functionFieldOpenEquiv |
| {X Y : Scheme} [IsIntegral X] [IsIntegral Y] |
| (j : Y ⟶ X) [IsOpenImmersion j] [IsDominant j] : |
| X.functionField ≃+* Y.functionField := |
| RingEquiv.ofBijective (functionFieldPullback j) (functionFieldPullback_bijective_of_open j) |
|
|
| |
|
|
| noncomputable def chartFunctionFieldEquiv |
| (A M : Type u) [CommRing A] [IsDomain A] [Field M] |
| [Algebra A M] [IsFractionRing A M] |
| {X : Scheme.{u}} [IsIntegral X] |
| (j : Spec (.of A) ⟶ X) [IsOpenImmersion j] [IsDominant j] : |
| M ≃+* X.functionField := by |
| letI : Algebra A (Spec (.of A)).functionField := |
| AlgebraicGeometry.instAlgebraCarrierFunctionFieldSpec (.of A) |
| letI : IsFractionRing A (Spec (.of A)).functionField := |
| functionField_isFractionRing_of_affine (.of A) |
| exact (IsLocalization.algEquiv (nonZeroDivisors A) M |
| (Spec (.of A)).functionField).toRingEquiv.trans (functionFieldOpenEquiv j).symm |
|
|
| lemma chartFunctionFieldEquiv_algebraMap |
| (A M : Type u) [CommRing A] [IsDomain A] [Field M] |
| [Algebra A M] [IsFractionRing A M] |
| {X : Scheme.{u}} [IsIntegral X] |
| (j : Spec (.of A) ⟶ X) [IsOpenImmersion j] [IsDominant j] (a : A) : |
| functionFieldPullback j (chartFunctionFieldEquiv A M j (algebraMap A M a)) = |
| @algebraMap A (Spec (.of A)).functionField _ _ |
| (AlgebraicGeometry.instAlgebraCarrierFunctionFieldSpec (.of A)) a := by |
| let : Algebra A (Spec (.of A)).functionField := |
| AlgebraicGeometry.instAlgebraCarrierFunctionFieldSpec (.of A) |
| let : IsFractionRing A (Spec (.of A)).functionField := |
| functionField_isFractionRing_of_affine (.of A) |
| change (functionFieldOpenEquiv j) |
| ((functionFieldOpenEquiv j).symm |
| ((IsLocalization.algEquiv (nonZeroDivisors A) M |
| (Spec (.of A)).functionField) (algebraMap A M a))) = _ |
| rw [RingEquiv.apply_symm_apply, AlgEquiv.commutes] |
|
|
| lemma functionFieldPullback_comp |
| {X Y Z : Scheme} [IsIntegral X] [IsIntegral Y] [IsIntegral Z] |
| (f : X ⟶ Y) (g : Y ⟶ Z) [IsDominant f] [IsDominant g] : |
| functionFieldPullback (f ≫ g) = (functionFieldPullback f).comp (functionFieldPullback g) := by |
| change (Z.presheaf.stalkSpecializes _ ≫ (f ≫ g).stalkMap _).hom = |
| ((Z.presheaf.stalkSpecializes _ ≫ g.stalkMap _) ≫ |
| (Y.presheaf.stalkSpecializes _ ≫ f.stalkMap _)).hom |
| congr 1 |
| rw [Scheme.Hom.stalkMap_comp, Category.assoc, ← Category.assoc (g.stalkMap _), ← g.stalkSpecializes_stalkMap] |
| simp only [← Category.assoc, TopCat.Presheaf.stalkSpecializes_comp] |
| simp only [Category.assoc] |
| rfl |
|
|
| lemma functionFieldPullback_constant |
| (K : Type u) [Field K] {X Y : Scheme.{u}} [IsIntegral X] [IsIntegral Y] |
| (f : X ⟶ Spec (.of K)) (j : Y ⟶ X) [IsDominant j] (c : K) : |
| functionFieldPullback j (constantToFunctionField K f c) = |
| constantToFunctionField K (j ≫ f) c := by |
| unfold constantToFunctionField |
| simp only [RingHom.comp_apply] |
| rw [functionFieldPullback_germ] |
| change Y.germToFunctionField ⊤ (j.appTop (((Scheme.ΓSpecIso (.of K)).inv ≫ f.appTop) c)) = _ |
| rw [Scheme.Hom.comp_appTop] |
| rfl |
|
|
| lemma constantToFunctionField_spec |
| (K A : Type u) [Field K] [CommRing A] [IsDomain A] [Algebra K A] (c : K) : |
| constantToFunctionField K (Spec.map (CommRingCat.ofHom (algebraMap K A))) c = |
| @algebraMap A (Spec (.of A)).functionField _ _ |
| (AlgebraicGeometry.instAlgebraCarrierFunctionFieldSpec (.of A)) |
| (algebraMap K A c) := by |
| unfold constantToFunctionField |
| rw [← Scheme.ΓSpecIso_inv_naturality] |
| rfl |
|
|
| lemma functionFieldPullback_spec_algebraMap |
| (A B : Type u) [CommRing A] [IsDomain A] [CommRing B] [IsDomain B] |
| (h : A →+* B) [IsDominant (Spec.map (CommRingCat.ofHom h))] (a : A) : |
| functionFieldPullback (Spec.map (CommRingCat.ofHom h)) |
| (@algebraMap A (Spec (.of A)).functionField _ _ |
| (AlgebraicGeometry.instAlgebraCarrierFunctionFieldSpec (.of A)) a) = |
| @algebraMap B (Spec (.of B)).functionField _ _ |
| (AlgebraicGeometry.instAlgebraCarrierFunctionFieldSpec (.of B)) (h a) := by |
| change functionFieldPullback (Spec.map (CommRingCat.ofHom h)) |
| ((Spec (.of A)).germToFunctionField ⊤ ((Scheme.ΓSpecIso (.of A)).inv a)) = _ |
| rw [functionFieldPullback_germ] |
| change (Spec (.of B)).germToFunctionField ⊤ |
| (((Scheme.ΓSpecIso (.of A)).inv ≫ (Spec.map (CommRingCat.ofHom h)).appTop) a) = _ |
| rw [← Scheme.ΓSpecIso_inv_naturality] |
| rfl |
|
|
| end RelativeDenominators |
| end |
|
|
| end OAI |
|
|
