lean/OAI/AlgebraicGeometry/RelativeTriviality/BaseChange.lean

import Mathlib
import OAI.AlgebraicGeometry.RelativeTriviality.Coordinates
import OAI.AlgebraicGeometry.RelativeTriviality.Charts

namespace OAI

noncomputable section

namespace CampanaPeternellSix.RelativeLineCharts
open CategoryTheory AlgebraicGeometry
open scoped Polynomial
universe u
variable (R : Type u) [CommRing R]
attribute [local instance] MvPolynomial.gradedAlgebra

lemma rightChartEquiv_constant (a : R) :
    rightChartEquiv R (HomogeneousLocalization.fromZeroRingHom (grading R) _
      (constants R a)) = Polynomial.C a := by
  rw [← chartSwap_constant R a]
  change chartEquiv R ((chartSwap R).symm ((chartSwap R) _)) = _
  rw [RingEquiv.symm_apply_apply, chartEquiv_constant]

def chartRing (i : Fin 2) := HomogeneousLocalization.Away (grading R) (MvPolynomial.X i)
instance (i : Fin 2) : CommRing (chartRing R i) := inferInstanceAs (CommRing (HomogeneousLocalization.Away _ _))
def chartConstants (i : Fin 2) : R →+* chartRing R i :=
  (HomogeneousLocalization.fromZeroRingHom (grading R) _).comp (constants R)
def chartCoordinate (i : Fin 2) : chartRing R i :=
  HomogeneousLocalization.Away.mk (grading R) (MvPolynomial.isHomogeneous_X R i) 1
    (MvPolynomial.X ((Equiv.swap (0 : Fin 2) 1) i))
    (by simpa using MvPolynomial.isHomogeneous_X R ((Equiv.swap (0 : Fin 2) 1) i))
def chartEquivalence (i : Fin 2) : chartRing R i ≃+* R[X] :=
  Fin.cases (chartEquiv R) (fun j : Fin 1 => Fin.cases (rightChartEquiv R) (fun k => Fin.elim0 k) j) i

lemma chartEquivalence_constant (i : Fin 2) (a : R) :
    chartEquivalence R i (chartConstants R i a) = Polynomial.C a := by
  fin_cases i
  · exact chartEquiv_constant R a
  · exact rightChartEquiv_constant R a

lemma chartEquivalence_coordinate (i : Fin 2) :
    chartEquivalence R i (chartCoordinate R i) = Polynomial.X := by
  fin_cases i
  · convert chartEquiv_coordinate R using 1
    simp [chartEquivalence, chartCoordinate, coordinate]
    rfl
  · convert rightChartEquiv_coordinate R using 1
    simp [chartEquivalence, chartCoordinate, rightCoordinate]
    rfl

lemma chartEquivalence_symm_C (i : Fin 2) (a : R) :
    (chartEquivalence R i).symm (Polynomial.C a) = chartConstants R i a :=
  (RingEquiv.symm_apply_eq (chartEquivalence R i)).mpr (chartEquivalence_constant R i a).symm

lemma chartEquivalence_symm_X (i : Fin 2) :
    (chartEquivalence R i).symm Polynomial.X = chartCoordinate R i :=
  (RingEquiv.symm_apply_eq (chartEquivalence R i)).mpr (chartEquivalence_coordinate R i).symm

end CampanaPeternellSix.RelativeLineCharts
namespace CampanaPeternellSix.RelativeProjectiveBaseChange
section
open CategoryTheory AlgebraicGeometry Limits ProjectiveSpectrum HomogeneousIdeal
open CampanaPeternellSix.RelativePolynomialEvaluation
attribute [local instance] MvPolynomial.gradedAlgebra
universe u
variable {R S : Type u} [CommRing R] [CommRing S]

def coefficientMap (f : R →+* S) (n : ℕ) : grading R n →+*ᵍ grading S n where
  __ := MvPolynomial.map f
  map_mem h := MvPolynomial.IsHomogeneous.map h f

lemma irrelevant_le_map_coefficientMap (f : R →+* S) (n : ℕ) :
    irrelevant (grading S n) ≤ (irrelevant (grading R n)).map (coefficientMap f n) := by
  apply toIdeal_le_toIdeal_iff.mp
  refine le_trans ?_ (show MvPolynomial.idealOfVars (Fin (n+1)) S ≤ _ from ?_)
  · rw [toIdeal_irrelevant_le]
    intro i hi a ha
    rw [← pow_one (MvPolynomial.idealOfVars _ _)]
    apply (MvPolynomial.mem_pow_idealOfVars_iff 1 a).mpr
    intro k hk
    have hk' : a.coeff k ≠ 0 := MvPolynomial.mem_support_iff.mp hk
    change a.IsHomogeneous i at ha
    have hdeg := ha hk'
    change 1 ≤ ∑ j ∈ k.support, k j
    simpa [Finsupp.weight_apply, Finsupp.sum] using (Nat.succ_le_iff.mpr hi).trans_eq hdeg.symm
  · apply Ideal.span_le.mpr
    rintro _ ⟨i, rfl⟩
    have h := Ideal.mem_map_of_mem (coefficientMap f n).toRingHom
      (mem_irrelevant_of_mem (grading R n) (by decide : 0 < 1)
        (MvPolynomial.isHomogeneous_X R i))
    change MvPolynomial.X i ∈ Ideal.map (coefficientMap f n).toRingHom _
    simpa [coefficientMap] using h

def baseMap (f : R →+* S) (n : ℕ) : space S n ⟶ space R n :=
  AlgebraicGeometry.Proj.map (coefficientMap f n) (irrelevant_le_map_coefficientMap f n)

lemma baseMap_coordinates (f : R →+* S) (n : ℕ) :
    CampanaPeternellSix.ProjectiveCoordinates.HasCoordinatePullback
      (grading R n) (grading S n) (MvPolynomial.map f) (baseMap f n) := by
  constructor
  · intro p; rfl
  · intro U s p h
    let : ((baseMap f n).base p.1).1.toIdeal.IsPrime := ((baseMap f n).base p.1).isPrime
    let : p.1.1.toIdeal.IsPrime := p.1.isPrime
    change (HomogeneousLocalization.localRingHom (coefficientMap f n) _ _ _
      (s.val ⟨(baseMap f n).base p.1, p.2⟩)).val = _
    erw [HomogeneousLocalization.val_localRingHom]
    rfl

lemma baseMap_overBase (f : R →+* S) (n : ℕ) :
    baseMap f n ≫ toBase R n = toBase S n ≫ Spec.map (CommRingCat.ofHom f) := by
  apply ext_to_Spec
  simp only [Scheme.Γ_map_op, Scheme.Hom.comp_appTop]
  apply CommRingCat.hom_ext
  apply RingHom.ext
  intro a
  have hnat := Scheme.ΓSpecIso_inv_naturality (CommRingCat.ofHom f)
  have he : ((Scheme.ΓSpecIso (.of R)).inv ≫ (Spec.map (CommRingCat.ofHom f)).appTop ≫
        (toBase S n).appTop) a =
      (((Scheme.ΓSpecIso (.of S)).inv ≫ (toBase S n).appTop) (f a)) := by
    rw [← Category.assoc, ← hnat, Category.assoc]
    rfl
  erw [he]
  apply Subtype.ext
  funext p
  let e := baseMap f n
  let s := ((Scheme.ΓSpecIso (.of R)).inv ≫ (toBase R n).appTop) a
  change (((e.c.app (Opposite.op ⊤)) s).val p) =
    ((((Scheme.ΓSpecIso (.of S)).inv ≫ (toBase S n).appTop) (f a)).val p)
  apply HomogeneousLocalization.val_injective
  let h := baseMap_coordinates f n
  erw [h.2 ⊤ s p (h.1 p.1)]
  let : (e.base p.1).1.toIdeal.IsPrime := (e.base p.1).isPrime
  let : p.1.1.toIdeal.IsPrime := p.1.isPrime
  change Localization.localRingHom (e.base p.1).1.toIdeal p.1.1.toIdeal
    (MvPolynomial.map f) (h.1 p.1)
    (s.val ⟨e.base p.1, trivial⟩).val = _
  dsimp only [s]
  erw [toBase_section R n a, toBase_section S n (f a) p.1]
  change Localization.localRingHom (e.base p.1).1.toIdeal p.1.1.toIdeal
    (MvPolynomial.map f) (h.1 p.1)
      (Localization.mk (MvPolynomial.C a) 1) = Localization.mk (MvPolynomial.C (f a)) 1
  simp
  rfl
end
section
open CategoryTheory AlgebraicGeometry Limits ProjectiveSpectrum HomogeneousLocalization
open CampanaPeternellSix.RelativePolynomialEvaluation
open CampanaPeternellSix.RelativeLineCharts (chartRing chartConstants chartCoordinate chartEquivalence
  chartEquivalence_constant chartEquivalence_coordinate chartEquivalence_symm_C chartEquivalence_symm_X)
attribute [local instance] MvPolynomial.gradedAlgebra
universe u
variable {R S : Type u} [CommRing R] [CommRing S]

def chartMap (f : R →+* S) (i : Fin 2) : chartRing R i →+* chartRing S i :=
  HomogeneousLocalization.map (coefficientMap f 1) (by
    rintro a ⟨k, rfl⟩
    change MvPolynomial.map f (MvPolynomial.X i ^ k) ∈ Submonoid.powers (MvPolynomial.X i)
    simpa [coefficientMap] using Submonoid.pow_mem (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) S))
      (Submonoid.mem_powers _) k)

lemma chartMap_constants (f : R →+* S) (i : Fin 2) (a : R) :
    chartMap f i (chartConstants R i a) = chartConstants S i (f a) := by
  apply HomogeneousLocalization.val_injective
  change (HomogeneousLocalization.map (coefficientMap f 1) _
    (HomogeneousLocalization.Away.mk (grading R 1) (MvPolynomial.isHomogeneous_X R i) 0 (MvPolynomial.C a) _)).val =
    (HomogeneousLocalization.Away.mk (grading S 1) (MvPolynomial.isHomogeneous_X S i) 0 (MvPolynomial.C (f a)) _).val
  simp [HomogeneousLocalization.Away.mk, HomogeneousLocalization.map_mk, coefficientMap]
  change Localization.mk (MvPolynomial.map f (MvPolynomial.C a)) _ = _
  simp

lemma chartMap_coordinate (f : R →+* S) (i : Fin 2) :
    chartMap f i (chartCoordinate R i) = chartCoordinate S i := by
  apply HomogeneousLocalization.val_injective
  change (HomogeneousLocalization.map (coefficientMap f 1) _
    (HomogeneousLocalization.Away.mk (grading R 1) (MvPolynomial.isHomogeneous_X R i) 1
      (MvPolynomial.X ((Equiv.swap (0 : Fin 2) 1) i)) _)).val =
    (HomogeneousLocalization.Away.mk (grading S 1) (MvPolynomial.isHomogeneous_X S i) 1
      (MvPolynomial.X ((Equiv.swap (0 : Fin 2) 1) i)) _).val
  simp only [HomogeneousLocalization.Away.mk]
  rw [HomogeneousLocalization.map_mk]
  change Localization.mk (MvPolynomial.map f (MvPolynomial.X ((Equiv.swap (0 : Fin 2) 1) i)))
      ⟨MvPolynomial.map f (MvPolynomial.X i ^ 1), _⟩ =
    Localization.mk (MvPolynomial.X ((Equiv.swap (0 : Fin 2) 1) i)) ⟨MvPolynomial.X i ^ 1, _⟩
  simp

lemma chartMap_polynomial (f : R →+* S) (i : Fin 2) :
    (chartEquivalence S i).toRingHom.comp (chartMap f i) =
      (Polynomial.mapRingHom f).comp (chartEquivalence R i).toRingHom := by
  have h : ((chartEquivalence S i).toRingHom.comp (chartMap f i)).comp
      (chartEquivalence R i).symm.toRingHom = Polynomial.mapRingHom f := by
    apply Polynomial.ringHom_ext
    · intro a
      simp only [RingHom.comp_apply, RingEquiv.toRingHom_eq_coe, RingHom.coe_coe,
        chartEquivalence_symm_C, chartMap_constants, chartEquivalence_constant]
      simp
    · simp only [RingHom.comp_apply, RingEquiv.toRingHom_eq_coe, RingHom.coe_coe,
        chartEquivalence_symm_X, chartMap_coordinate, chartEquivalence_coordinate]
      simp
  apply RingHom.ext
  intro x
  have hx := DFunLike.congr_fun h (chartEquivalence R i x)
  simpa using hx

end
section
open CategoryTheory AlgebraicGeometry Limits ProjectiveSpectrum HomogeneousLocalization
open CampanaPeternellSix.RelativePolynomialEvaluation
open CampanaPeternellSix.RelativeLineCharts (chartRing chartConstants chartCoordinate chartEquivalence
  chartEquivalence_constant chartEquivalence_coordinate chartEquivalence_symm_C chartEquivalence_symm_X)
attribute [local instance] MvPolynomial.gradedAlgebra
universe u
variable {R S : Type u} [CommRing R] [CommRing S]

lemma chartMap_pushout (f : R →+* S) (i : Fin 2) :
    IsPushout (CommRingCat.ofHom f) (CommRingCat.ofHom (chartConstants R i))
      (CommRingCat.ofHom (chartConstants S i)) (CommRingCat.ofHom (chartMap f i)) := by
  have H : IsPushout (CommRingCat.ofHom f)
      (CommRingCat.ofHom (Polynomial.C : R →+* Polynomial R))
      (CommRingCat.ofHom (Polynomial.C : S →+* Polynomial S))
      (CommRingCat.ofHom (Polynomial.mapRingHom f)) := by
    algebraize [f, Polynomial.mapRingHom f]
    exact CommRingCat.isPushout_of_isPushout R S (Polynomial R) (Polynomial S)
  refine H.of_iso (Iso.refl _) (Iso.refl _)
    (chartEquivalence R i).symm.toCommRingCatIso
    (chartEquivalence S i).symm.toCommRingCatIso (by simp) ?_ ?_ ?_
  · ext a
    exact chartEquivalence_symm_C R i a
  · ext a
    exact chartEquivalence_symm_C S i a
  · apply CommRingCat.hom_ext
    apply RingHom.ext
    intro x
    apply (chartEquivalence S i).injective
    have h := DFunLike.congr_fun (chartMap_polynomial f i) ((chartEquivalence R i).symm x)
    simpa using h.symm

lemma chartMap_pullback (f : R →+* S) (i : Fin 2) :
    IsPullback (Spec.map (CommRingCat.ofHom (chartMap f i)))
      (Spec.map (CommRingCat.ofHom (chartConstants S i)))
      (Spec.map (CommRingCat.ofHom (chartConstants R i)))
      (Spec.map (CommRingCat.ofHom f)) :=
  (isPullback_SpecMap_of_isPushout _ _ _ _ (chartMap_pushout f i)).flip

variable (R) in
def chartInclusion (i : Fin 2) : Spec (.of (chartRing R i)) ⟶ space R 1 :=
  AlgebraicGeometry.Proj.awayι (grading R 1) (MvPolynomial.X i)
    (MvPolynomial.isHomogeneous_X R i) (by decide : 0 < 1)

private lemma isOpenImmersion_iso_inv_comp {X Y Z : Scheme} (e : X ≅ Y)
    (f : X ⟶ Z) [IsOpenImmersion f] : IsOpenImmersion (e.inv ≫ f) :=
  IsOpenImmersion.comp _ _

instance (i : Fin 2) : IsOpenImmersion (chartInclusion R i) := by
  exact isOpenImmersion_iso_inv_comp (AlgebraicGeometry.Proj.basicOpenIsoSpec (grading R 1)
    (MvPolynomial.X i) (MvPolynomial.isHomogeneous_X R i) (by decide : 0 < 1))
    (AlgebraicGeometry.Proj.basicOpen (grading R 1) (MvPolynomial.X i)).ι

@[reassoc] lemma chartInclusion_toBase (i : Fin 2) :
    chartInclusion R i ≫ toBase R 1 = Spec.map (CommRingCat.ofHom (chartConstants R i)) := by
  erw [chartInclusion, toBase, ← Category.assoc, AlgebraicGeometry.Proj.awayι_toSpecZero,
    ← Spec.map_comp]
  rfl

@[simp] lemma coefficientMap_X (f : R →+* S) (n : ℕ) (i : Fin (n+1)) :
    coefficientMap f n (MvPolynomial.X i) = MvPolynomial.X i := by
  change MvPolynomial.map f (MvPolynomial.X i) = _
  simp

lemma awayInclusion_coefficientMap (f : R →+* S) (i : Fin 2)
    (t : MvPolynomial (Fin 2) S) (ht : t ∈ grading S 1 1)
    (he : coefficientMap f 1 (MvPolynomial.X i) = t)
    (hp : Submonoid.powers (MvPolynomial.X i) ≤
      (Submonoid.powers t).comap (coefficientMap f 1)) :
    AlgebraicGeometry.Proj.awayι (grading S 1) t ht (by decide : 0 < 1) ≫ baseMap f 1 =
      Spec.map (CommRingCat.ofHom (HomogeneousLocalization.map (coefficientMap f 1) hp)) ≫
        chartInclusion R i := by
  subst t
  exact AlgebraicGeometry.Proj.awayι_comp_map (coefficientMap f 1)
    (irrelevant_le_map_coefficientMap f 1) (by decide : 0 < 1)
    (MvPolynomial.X i) (MvPolynomial.isHomogeneous_X R i)

@[reassoc] lemma chartInclusion_baseMap (f : R →+* S) (i : Fin 2) :
    chartInclusion S i ≫ baseMap f 1 =
      Spec.map (CommRingCat.ofHom (chartMap f i)) ≫ chartInclusion R i := by
  exact awayInclusion_coefficientMap f i (MvPolynomial.X i)
    (MvPolynomial.isHomogeneous_X S i) (coefficientMap_X f 1 i) _

lemma chartInclusion_cartesian (f : R →+* S) (i : Fin 2) :
    IsPullback (Spec.map (CommRingCat.ofHom (chartMap f i))) (chartInclusion S i)
      (chartInclusion R i) (baseMap f 1) := by
  apply IsOpenImmersion.isPullback
  · exact chartInclusion_baseMap f i
  · dsimp only [chartInclusion, baseMap]
    erw [AlgebraicGeometry.Proj.opensRange_awayι, AlgebraicGeometry.Proj.opensRange_awayι,
      AlgebraicGeometry.Proj.map_preimage_basicOpen, coefficientMap_X]

end
open CategoryTheory AlgebraicGeometry Limits ProjectiveSpectrum HomogeneousIdeal
open CampanaPeternellSix.RelativePolynomialEvaluation
open CampanaPeternellSix.RelativeLineCharts (chartRing chartConstants)
attribute [local instance] MvPolynomial.gradedAlgebra
universe u
variable (R : Type u) [CommRing R]

lemma irrelevant_le_span_variables (n : ℕ) :
    (irrelevant (grading R n)).toIdeal ≤ Ideal.span (Set.range (MvPolynomial.X : Fin (n+1) → MvPolynomial (Fin (n+1)) R)) := by
  rw [toIdeal_irrelevant_le]
  intro i hi a ha
  change a ∈ MvPolynomial.idealOfVars (Fin (n+1)) R
  rw [← pow_one (MvPolynomial.idealOfVars _ _)]
  apply (MvPolynomial.mem_pow_idealOfVars_iff 1 a).mpr
  intro k hk
  have hk' : a.coeff k ≠ 0 := MvPolynomial.mem_support_iff.mp hk
  change a.IsHomogeneous i at ha
  have hdeg := ha hk'
  change 1 ≤ ∑ j ∈ k.support, k j
  simpa [Finsupp.weight_apply, Finsupp.sum] using (Nat.succ_le_iff.mpr hi).trans_eq hdeg.symm

def twoChartCover : (space R 1).OpenCover :=
  (AlgebraicGeometry.Proj.affineOpenCoverOfIrrelevantLESpan (grading R 1)
    (MvPolynomial.X : Fin 2 → MvPolynomial (Fin 2) R)
    (MvPolynomial.isHomogeneous_X R) (fun _ => by decide : ∀ _ : Fin 2, 0 < 1)
    (irrelevant_le_span_variables R 1)).openCover

variable {R} {S : Type u} [CommRing S]

lemma baseMap_isPullback (f : R →+* S) :
    IsPullback (baseMap f 1) (toBase S 1) (toBase R 1)
      (Spec.map (CommRingCat.ofHom f)) := by
  apply Scheme.isPullback_of_openCover _ _ _ _ (twoChartCover R)
  intro i
  change IsPullback (pullback.snd (baseMap f 1) (chartInclusion R i))
    (pullback.fst (baseMap f 1) (chartInclusion R i) ≫ toBase S 1)
    (chartInclusion R i ≫ toBase R 1) (Spec.map (CommRingCat.ofHom f))
  have h := (chartInclusion_cartesian f i).flip
  refine (chartMap_pullback f i).of_iso h.isoPullback (Iso.refl _) (Iso.refl _) (Iso.refl _)
    ?_ ?_ ?_ (by simp)
  · simp
  · simp only [Iso.refl_hom, Category.comp_id, ← Category.assoc,
      h.isoPullback_hom_fst]
    exact (chartInclusion_toBase (R := S) i).symm
  · simp only [Iso.refl_hom, Category.comp_id, Category.id_comp]
    exact (chartInclusion_toBase (R := R) i).symm

 

theorem projectiveLine_cartesian (R S : Type u) [CommRing R] [CommRing S]
    (f : R →+* S) :
    ∃ g : space S 1 ⟶ space R 1,
      IsPullback g (toBase S 1) (toBase R 1) (Spec.map (CommRingCat.ofHom f)) ∧
      CampanaPeternellSix.ProjectiveCoordinates.HasCoordinatePullback
        (grading R 1) (grading S 1) (MvPolynomial.map f) g :=
  ⟨baseMap f 1, baseMap_isPullback f, baseMap_coordinates f 1⟩

end CampanaPeternellSix.RelativeProjectiveBaseChange

end

end OAI