import Mathlib
import OAI.AlgebraicGeometry.NumericalDimension.CurveCoordinates

namespace OAI

/-! Section Coordinates. -/

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
noncomputable section
attribute [local instance] MvPolynomial.gradedAlgebra

lemma homogeneous_eval₂_scale {I R B : Type*} [CommSemiring R] [CommSemiring B]
    (c : R →+* B) (v : I → B) (a : B) {p : MvPolynomial I R} {n : ℕ}
    (hp : p.IsHomogeneous n) :
    p.eval₂ c (fun i => a * v i) = a^n * p.eval₂ c v := by
  classical
  simp only [MvPolynomial.eval₂_eq, Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro d hd
  rw [hp.degree_eq_sum_deg_support hd]
  simp only [mul_pow, Finset.prod_mul_distrib, ← Finset.prod_pow_eq_pow_sum]
  ring

section AwayEval
variable {A B : Type*} [CommRing A] [CommRing B]
variable {σ : Type*} [SetLike σ A] [AddSubgroupClass σ A]
variable (𝒜 : ℕ → σ) [GradedRing 𝒜]

def homogeneousAwayEval (e : A →+* B) (t : A) (ht : IsUnit (e t)) :
    HomogeneousLocalization.Away 𝒜 t →+* B :=
  (Localization.awayLift e t ht).comp (algebraMap _ (Localization.Away t))

lemma homogeneousAwayEval_mk_mul (e : A →+* B) (t : A) (ht : IsUnit (e t))
    {d : ℕ} (hd : t ∈ 𝒜 d) (n : ℕ) (p : A) (hp : p ∈ 𝒜 (n • d)) :
    homogeneousAwayEval 𝒜 e t ht (HomogeneousLocalization.Away.mk 𝒜 hd n p hp) *
      (e t)^n = e p := by
  let l := Localization.awayLift e t ht
  have hEq :
      (HomogeneousLocalization.Away.mk 𝒜 hd n p hp).val *
        algebraMap A (Localization.Away t) (t^n) =
      algebraMap A (Localization.Away t) p := by
    simp only [HomogeneousLocalization.Away.val_mk, Localization.mk_eq_mk']
    exact IsLocalization.mk'_spec (M := Submonoid.powers t) (Localization.Away t) p ⟨t^n,⟨n,rfl⟩⟩
  have he := congrArg l hEq
  simpa [homogeneousAwayEval,l, Localization.awayLift, map_mul, map_pow,
    IsLocalization.Away.lift_eq] using he

lemma homogeneousAwayEval_postcomp {C : Type*} [CommRing C]
    (e : A →+* B) (h : B →+* C) (t : A) (ht : IsUnit (e t))
    {d : ℕ} (hd : t ∈ 𝒜 d) :
    h.comp (homogeneousAwayEval 𝒜 e t ht) =
      homogeneousAwayEval 𝒜 (h.comp e) t (ht.map h) := by
  ext z
  obtain ⟨n,p,hp,rfl⟩ := HomogeneousLocalization.Away.mk_surjective 𝒜 hd z
  apply ((ht.map h).pow n).mul_right_cancel
  have he := congrArg h (homogeneousAwayEval_mk_mul 𝒜 e t ht hd n p hp)
  have hf := homogeneousAwayEval_mk_mul 𝒜 (h.comp e) t (ht.map h) hd n p hp
  simpa only [RingHom.comp_apply, map_mul, map_pow] using he.trans hf.symm

lemma homogeneousAwayEval_awayMap (e : A →+* B) {t u : A}
    {d k : ℕ} (htd : t ∈ 𝒜 d) (huk : u ∈ 𝒜 k)
    (ht : IsUnit (e t)) (hu : IsUnit (e u)) :
    (homogeneousAwayEval 𝒜 e (t*u) (by simpa using ht.mul hu)).comp
      (HomogeneousLocalization.awayMap 𝒜 huk rfl) =
      homogeneousAwayEval 𝒜 e t ht := by
  ext z
  obtain ⟨n,p,hp,rfl⟩ := HomogeneousLocalization.Away.mk_surjective 𝒜 htd z
  apply ((ht.mul hu).pow n).mul_right_cancel
  simp only [RingHom.comp_apply, HomogeneousLocalization.awayMap_mk,
    ← map_mul]
  rw [homogeneousAwayEval_mk_mul, map_mul, map_pow]
  rw [map_mul, mul_pow, ← mul_assoc, homogeneousAwayEval_mk_mul]

lemma homogeneousAwayEval_fromZero (e : A →+* B) (t : A) (ht : IsUnit (e t)) :
    (homogeneousAwayEval 𝒜 e t ht).comp
      (HomogeneousLocalization.fromZeroRingHom 𝒜 (Submonoid.powers t)) =
      e.comp (algebraMap (𝒜 0) A) := by
  ext a
  change (Localization.awayLift e t ht) (algebraMap A (Localization.Away t) a.1) = _
  exact IsLocalization.Away.lift_eq t ht a.1

lemma homogeneousAwayEval_awayMap' (e : A →+* B) {t u x : A}
    {d k : ℕ} (htd : t ∈ 𝒜 d) (huk : u ∈ 𝒜 k)
    (ht : IsUnit (e t)) (hu : IsUnit (e u)) (hx : x = t*u) :
    (homogeneousAwayEval 𝒜 e x (by simpa [hx] using ht.mul hu)).comp
      (HomogeneousLocalization.awayMap 𝒜 huk hx) =
      homogeneousAwayEval 𝒜 e t ht := by
  subst x
  exact homogeneousAwayEval_awayMap 𝒜 e htd huk ht hu

end AwayEval
section FieldCoordinates
variable {I R K : Type*} [CommRing R] [Field K]

lemma homogeneousAwayEval_scale (c : R →+* K) (v : I → K) (a : K) (ha : a ≠ 0)
    (i : I) (hi : v i ≠ 0) :
    homogeneousAwayEval (MvPolynomial.homogeneousSubmodule I R)
      (MvPolynomial.eval₂Hom c (fun j => a*v j)) (MvPolynomial.X i)
      (by simpa using isUnit_iff_ne_zero.mpr (mul_ne_zero ha hi)) =
    homogeneousAwayEval (MvPolynomial.homogeneousSubmodule I R)
      (MvPolynomial.eval₂Hom c v) (MvPolynomial.X i)
      (by simpa using isUnit_iff_ne_zero.mpr hi) := by
  let 𝒜 := MvPolynomial.homogeneousSubmodule I R
  have hd : MvPolynomial.X i ∈ 𝒜 1 := MvPolynomial.isHomogeneous_X R i
  ext z
  obtain ⟨n,p,hp,rfl⟩ := HomogeneousLocalization.Away.mk_surjective 𝒜 hd z
  have hp' : p.IsHomogeneous n := by simpa [𝒜, MvPolynomial.mem_homogeneousSubmodule] using hp
  apply mul_right_cancel₀ (pow_ne_zero n (mul_ne_zero ha hi))
  have hL := homogeneousAwayEval_mk_mul 𝒜
    (MvPolynomial.eval₂Hom c (fun j => a*v j)) _
    (by simpa using isUnit_iff_ne_zero.mpr (mul_ne_zero ha hi)) hd n p hp
  have hR := homogeneousAwayEval_mk_mul 𝒜
    (MvPolynomial.eval₂Hom c v) _ (by simpa using isUnit_iff_ne_zero.mpr hi) hd n p hp
  simp only [MvPolynomial.coe_eval₂Hom, MvPolynomial.eval₂_X] at hL hR
  rw [hL, homogeneous_eval₂_scale c v a hp', mul_pow]
  rw [show (homogeneousAwayEval 𝒜 (MvPolynomial.eval₂Hom c v) (MvPolynomial.X i) _)
      (HomogeneousLocalization.Away.mk 𝒜 hd n p hp) * (a^n * v i^n) =
      a^n * ((homogeneousAwayEval 𝒜 (MvPolynomial.eval₂Hom c v) (MvPolynomial.X i) _)
      (HomogeneousLocalization.Away.mk 𝒜 hd n p hp) * v i^n) by ring, hR]

end FieldCoordinates

section ChartMorphism
universe u v
variable {A : Type u} [CommRing A] {σ : Type v}
variable [SetLike σ A] [AddSubgroupClass σ A] (𝒜 : ℕ → σ) [GradedRing 𝒜]
variable {B : Type u} [CommRing B]

lemma homogeneous_chart_morphism_eq (e : A →+* B) {t u : A}
    {d k : ℕ} (htd : t ∈ 𝒜 d) (huk : u ∈ 𝒜 k) (hd : 0 < d) (hk : 0 < k)
    (ht : IsUnit (e t)) (hu : IsUnit (e u)) :
    Spec.map (CommRingCat.ofHom (homogeneousAwayEval 𝒜 e t ht)) ≫
      Proj.awayι 𝒜 t htd hd =
    Spec.map (CommRingCat.ofHom (homogeneousAwayEval 𝒜 e u hu)) ≫
      Proj.awayι 𝒜 u huk hk := by
  let hxu : IsUnit (e (t*u)) := by simpa using ht.mul hu
  let F := Spec.map (CommRingCat.ofHom (homogeneousAwayEval 𝒜 e (t*u) hxu))
  calc
    _ = F ≫ Spec.map (CommRingCat.ofHom (HomogeneousLocalization.awayMap 𝒜 huk rfl)) ≫
        Proj.awayι 𝒜 t htd hd := by
      rw [← Spec.map_comp_assoc]
      congr 2
      apply CommRingCat.hom_ext
      exact (homogeneousAwayEval_awayMap 𝒜 e htd huk ht hu).symm
    _ = F ≫ Proj.awayι 𝒜 (t*u) (SetLike.mul_mem_graded htd huk) (by omega) := by
      rw [Proj.SpecMap_awayMap_awayι]
    _ = F ≫ Spec.map (CommRingCat.ofHom (HomogeneousLocalization.awayMap 𝒜 htd (mul_comm _ _))) ≫
        Proj.awayι 𝒜 u huk hk := by
      rw [Proj.SpecMap_awayMap_awayι]
      congr! 2; omega
    _ = _ := by
      rw [← Spec.map_comp_assoc]
      congr 2
      apply CommRingCat.hom_ext
      exact homogeneousAwayEval_awayMap' 𝒜 e huk htd hu ht (mul_comm _ _)

end ChartMorphism

section DivisorCoordinates
variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
    [StalkwiseNormal X] [CompactSpace X]

omit [StalkwiseNormal X] in
lemma generated_finite_section_cover (D : WeilDivisor X)
    (hgen : ∀ x : X, IsGeneratedAt D x) :
    ∃ N : ℕ, ∃ s : Fin (N+1) → X.functionField,
      (∀ i, s i ≠ 0 ∧ IsDivisorSection D (s i)) ∧
      (∀ x : X, ∃ i, x ∈ sectionNonvanishing D (s i)) := by
  classical
  choose s hs hsec hx using hgen
  obtain ⟨V,hV⟩ := isCompact_univ.elim_finite_subcover
    (fun x : X => (sectionNonvanishing D (s x) : Set X))
    (fun x => (sectionNonvanishing D (s x)).isOpen)
    (fun x _ => Set.mem_iUnion.mpr ⟨x,hx x⟩)
  let e : Fin (V.card+1) ≃ Option V :=
    (Fintype.equivFinOfCardEq (by simp)).symm
  let point : Option V → X := fun o => o.elim (genericPoint X) Subtype.val
  refine ⟨V.card,fun i => s (point (e i)),fun i => ⟨hs _,hsec _⟩,?_⟩
  intro x
  obtain ⟨y,hy,hxy⟩ := Set.mem_iUnion₂.mp (hV (Set.mem_univ x))
  exact ⟨e.symm (some ⟨y,hy⟩),by simpa [point] using hxy⟩

lemma cartier_section_basicOpen {D : WeilDivisor X} {U : X.Opens} [Nonempty U]
    {g s : X.functionField} (hg : g ≠ 0) (hs : s ≠ 0)
    (hDg : ∀ p : PrimeDivisor X, p.1 ∈ U → D p = X.ord g p.1)
    (a : Γ(X,U)) (ha : X.germToFunctionField U a = s*g) :
    X.basicOpen a = U ⊓ sectionNonvanishing D s := by
  ext x
  constructor
  · intro hxa
    have hxU := X.basicOpen_le a hxa
    refine ⟨hxU,section_nonvanishing_of_local_unit hs hg hDg hxU
      (X.presheaf.germ U x hxU a) ((X.mem_basicOpen a x hxU).mp hxa) ?_⟩
    exact (X.algebraMap_germ_eq_germToFunctionField hxU a).trans ha
  · rintro ⟨hxU,hxs⟩
    obtain ⟨b,hb,heb⟩ := section_unit_stalk hs hg hDg hxU hxs
    have he : X.presheaf.germ U x hxU a = b := by
      apply IsFractionRing.injective (X.presheaf.stalk x) X.functionField
      exact (X.algebraMap_germ_eq_germToFunctionField hxU a).trans (ha.trans heb.symm)
    exact (X.mem_basicOpen a x hxU).mpr (he ▸ hb)

end DivisorCoordinates

structure DivisorProjectiveChart (X : Scheme) [IsIntegral X] [IsLocallyNoetherian X] {I : Type}
    (D : WeilDivisor X) (s : I → X.functionField) where
  domain : X.Opens
  generic_mem : genericPoint X ∈ domain
  equation : X.functionField
  equation_ne_zero : equation ≠ 0
  equation_order : ∀ p : PrimeDivisor X, p.1 ∈ domain → D p = X.ord equation p.1
  coordinate : I → Γ(X,domain)
  coordinate_value : ∀ i, X.presheaf.germ domain (genericPoint X) generic_mem (coordinate i) =
    s i * equation
  unit_index : I
  coordinate_unit : IsUnit (coordinate unit_index)

section LocalChartExistence
variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
    [StalkwiseNormal X] [CompactSpace X]
variable {I : Type} {D : WeilDivisor X} {s : I → X.functionField}

lemma exists_divisorProjectiveChart (hD : IsCartierDivisor D)
    (hs : ∀ i, s i ≠ 0 ∧ IsDivisorSection D (s i)) (x : X)
    (hx : ∃ i, x ∈ sectionNonvanishing D (s i)) :
    ∃ C : DivisorProjectiveChart X D s, x ∈ C.domain := by
  classical
  obtain ⟨i,hix⟩ := hx
  obtain ⟨U,hU,hxU,g,hg,hDg⟩ := hD x
  let : Nonempty U := ⟨⟨x,hxU⟩⟩
  have hvals (j : I) : ∃ a : Γ(X,U), X.germToFunctionField U a = s j*g :=
    (cartier_local_section_iff hU hg hDg (s j)).mp
      ((hs j).2.imp id (fun h p _ => h p))
  choose a ha using hvals
  let V := X.basicOpen (a i)
  have heV : V = U ⊓ sectionNonvanishing D (s i) :=
    cartier_section_basicOpen hg (hs i).1 hDg (a i) (ha i)
  have hxV : x ∈ V := heV ▸ ⟨hxU,hix⟩
  let : Nonempty V := ⟨⟨x,hxV⟩⟩
  let r : Γ(X,U) ⟶ Γ(X,V) := X.presheaf.map (homOfLE (X.basicOpen_le (a i))).op
  refine ⟨⟨V,((genericPoint_spec X).mem_open_set_iff V.isOpen).mpr
    ⟨x,Set.mem_univ x,hxV⟩,g,hg,fun p hp => hDg p (X.basicOpen_le (a i) hp),
    fun j => r (a j),?_,i,X.toRingedSpace.isUnit_res_basicOpen (a i)⟩,hxV⟩
  intro j
  exact (germToFunctionField_restrict (homOfLE (X.basicOpen_le (a i))) (a j)).trans (ha j)

end LocalChartExistence

section OpenScalars
variable {X : Scheme} [IsIntegral X]

lemma openScalar_generic (sX : X ⟶ Spec (.of ℂ)) (U : X.Opens)
    (hU : genericPoint X ∈ U) :
    (X.presheaf.germ U (genericPoint X) hU).hom.comp (schemeOpenScalar sX U) =
      schemeFieldScalar (.of ℂ) sX := by
  ext a
  simp only [schemeOpenScalar, schemeFieldScalar, Scheme.Hom.appLE,
    Scheme.Hom.appTop, RingHom.comp_apply, CommRingCat.hom_comp,
    TopCat.Presheaf.germ_res_apply]
  rfl

omit [IsIntegral X] in
lemma openScalar_toSpec (sX : X ⟶ Spec (.of ℂ)) (U : X.Opens) :
    U.toSpecΓ ≫ Spec.map (CommRingCat.ofHom (schemeOpenScalar sX U)) = U.ι ≫ sX := by
  have he : CommRingCat.ofHom (schemeOpenScalar sX U) =
      (Scheme.ΓSpecIso (.of ℂ)).inv ≫ sX.appTop ≫
        X.presheaf.map (homOfLE le_top).op := rfl
  rw [he, Spec.map_comp, Spec.map_comp]
  simp only [Category.assoc]
  rw [Scheme.Opens.toSpecΓ_SpecMap_presheaf_map_top_assoc]
  rw [← Scheme.toSpecΓ_naturality_assoc,
    toSpecΓ_SpecMap_ΓSpecIso_inv, Category.comp_id]

end OpenScalars

namespace DivisorProjectiveChart
variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
    {N : ℕ} {D : WeilDivisor X} {s : Fin (N+1) → X.functionField}
    (C : DivisorProjectiveChart X D s)

def normalized (i : Fin (N+1)) : Γ(X,C.domain) :=
  ↑C.coordinate_unit.unit⁻¹ * C.coordinate i

lemma normalized_index : C.normalized C.unit_index = 1 := by
  unfold normalized
  simpa only [C.coordinate_unit.unit_spec] using Units.inv_mul C.coordinate_unit.unit

def toMorphism (sX : X ⟶ Spec (.of ℂ)) : C.domain.toScheme ⟶ complexProjectiveSpace N :=
  C.domain.toSpecΓ ≫ projectiveAffineMap (schemeOpenScalar sX C.domain)
    C.normalized C.unit_index C.normalized_index

lemma toMorphism_over (sX : X ⟶ Spec (.of ℂ)) :
    C.toMorphism sX ≫ complexProjectiveSpaceMap N = C.domain.ι ≫ sX := by
  rw [toMorphism,Category.assoc,projectiveAffineMap_over,openScalar_toSpec]

lemma generic_normalized (hs : ∀ i, s i ≠ 0) (j : Fin (N+1)) :
    X.presheaf.germ C.domain (genericPoint X) C.generic_mem (C.normalized j) =
      (s C.unit_index)⁻¹ * s j := by
  have hu := C.coordinate_unit.unit_spec
  have he := congrArg (fun a => X.presheaf.germ C.domain (genericPoint X) C.generic_mem a) hu
  rw [C.coordinate_value] at he
  have hinv : X.presheaf.germ C.domain (genericPoint X) C.generic_mem
      (↑C.coordinate_unit.unit⁻¹) = (s C.unit_index * C.equation)⁻¹ := by
    rw [← he]
    exact map_units_inv _ _
  rw [normalized,map_mul,C.coordinate_value,hinv,mul_inv_rev]
  field_simp [hs C.unit_index,C.equation_ne_zero]

lemma toMorphism_generic (sX : X ⟶ Spec (.of ℂ)) (hs : ∀ i, s i ≠ 0) :
    C.domain.fromSpecStalkOfMem (genericPoint X) C.generic_mem ≫ C.toMorphism sX =
      projectiveFieldMap (schemeFieldScalar (.of ℂ) sX) s C.unit_index (hs _) := by
  rw [toMorphism,← Category.assoc,Scheme.Opens.fromSpecStalkOfMem_toSpecΓ]
  change Spec.map (CommRingCat.ofHom (X.presheaf.germ C.domain (genericPoint X) C.generic_mem).hom) ≫ _ = _
  rw [projectiveAffineMap_naturality]
  simp_rw [openScalar_generic,C.generic_normalized hs]
  rw [← projectiveFieldMap_eq_affine,projectiveFieldMap_scaling]
  exact inv_ne_zero (hs _)
lemma toMorphism_preimage [StalkwiseNormal X] [CompactSpace X]
    (sX : X ⟶ Spec (.of ℂ)) (hs : ∀ i, s i ≠ 0) (i : Fin (N+1)) :
    C.toMorphism sX ⁻¹ᵁ Proj.basicOpen
      (MvPolynomial.homogeneousSubmodule (Fin (N+1)) ℂ) (MvPolynomial.X i) =
      C.domain.ι ⁻¹ᵁ sectionNonvanishing D (s i) := by
  let : Nonempty C.domain := ⟨⟨genericPoint X,C.generic_mem⟩⟩
  trans C.domain.toSpecΓ ⁻¹ᵁ PrimeSpectrum.basicOpen (C.normalized i)
  · exact congrArg (fun U => C.domain.toSpecΓ ⁻¹ᵁ U)
      (projectiveAffineMap_preimage (schemeOpenScalar sX C.domain)
        C.normalized C.unit_index C.normalized_index i)
  rw [Scheme.Opens.toSpecΓ_preimage_basicOpen,normalized,Scheme.basicOpen_mul,
    Scheme.basicOpen_of_isUnit X (Units.isUnit _)]
  have hval : X.germToFunctionField C.domain (C.coordinate i) = s i*C.equation :=
    C.coordinate_value i
  rw [cartier_section_basicOpen C.equation_ne_zero (hs i) C.equation_order _ hval]
  ext x
  change (x.1 ∈ C.domain ∧ x.1 ∈ C.domain ∧ x.1 ∈ sectionNonvanishing D (s i)) ↔ _
  simp only [x.2,true_and]
  rfl

def toPartialMap (sX : X ⟶ Spec (.of ℂ)) : X.PartialMap (complexProjectiveSpace N) where
  domain := C.domain
  dense_domain := by
    rw [dense_iff_closure_eq]
    apply top_unique
    change Set.univ ⊆ _
    rw [← genericPoint_spec X]
    exact closure_mono (Set.singleton_subset_iff.mpr C.generic_mem)
  hom := C.toMorphism sX

lemma toPartialMap_generic (sX : X ⟶ Spec (.of ℂ)) (hs : ∀ i, s i ≠ 0) :
    (C.toPartialMap sX).fromFunctionField =
      projectiveFieldMap (schemeFieldScalar (.of ℂ) sX) s C.unit_index (hs _) :=
  C.toMorphism_generic sX hs

lemma toRationalMap_eq (sX : X ⟶ Spec (.of ℂ)) (hs : ∀ i, s i ≠ 0)
    (C' : DivisorProjectiveChart X D s) :
    (C.toPartialMap sX).toRationalMap = (C'.toPartialMap sX).toRationalMap := by
  apply Scheme.RationalMap.eq_of_fromFunctionField_eq
  simp only [Scheme.RationalMap.fromFunctionField_toRationalMap,
    toPartialMap_generic _ _ hs]
  exact projectiveFieldMap_independent _ s _ _ _ _

end DivisorProjectiveChart

lemma covering_partialMaps_extend {X Y : Scheme} [IsIntegral X] [Y.IsSeparated]
    {I : Type*} [Nonempty I] (P : I → X.PartialMap Y)
    (hcov : ∀ x : X, ∃ i, x ∈ (P i).domain)
    (heq : ∀ i j, (P i).toRationalMap = (P j).toRationalMap) :
    ∃ f : X ⟶ Y, ∀ i, (P i).domain.ι ≫ f = (P i).hom := by
  classical
  let i₀ : I := Classical.choice inferInstance
  let r := (P i₀).toRationalMap
  have hdom : r.domain = ⊤ := by
    apply top_unique
    intro x _
    obtain ⟨i,hi⟩ := hcov x
    exact Scheme.RationalMap.mem_domain.mpr ⟨P i,hi,heq i i₀⟩
  let e : r.domain.toScheme ≅ X := X.isoOfEq hdom ≪≫ X.topIso
  have he : e.hom = r.domain.ι := by
    exact X.isoOfEq_hom_ι hdom
  let f := e.inv ≫ r.toPartialMap.hom
  refine ⟨f,?_⟩
  intro i
  have hle : (P i).domain ≤ r.domain := by
    rw [hdom]; exact le_top
  have hlocal : X.homOfLE hle ≫ r.toPartialMap.hom = (P i).hom := by
    have aux (t : X.RationalMap Y) (ht : (P i).toRationalMap = t)
        (hle : (P i).domain ≤ t.domain) :
        X.homOfLE hle ≫ t.toPartialMap.hom = (P i).hom := by
      subst t
      exact (P i).toPartialMap_toRationalMap_restrict
    exact aux r (heq i i₀) hle
  have hleft : (P i).domain.ι ≫ e.inv = X.homOfLE hle := by
    apply (cancel_mono e.hom).mp
    rw [Category.assoc,e.inv_hom_id,Category.comp_id,he,Scheme.homOfLE_ι]
  exact (Category.assoc _ _ _).symm.trans
    ((congrArg (fun g : (P i).domain.toScheme ⟶ r.domain.toScheme =>
      g ≫ r.toPartialMap.hom) hleft).trans hlocal)
theorem generated_cartier_defines_projective_morphism
    (X : ComplexProjectiveVariety) [StalkwiseNormal X.scheme]
    (D : WeilDivisor X.scheme) (hD : IsCartierDivisor D)
    (hgen : ∀ x : X.scheme, IsGeneratedAt D x) :
    ∃ N : ℕ, ∃ s : Fin (N+1) → X.scheme.functionField,
      (∀ i, s i ≠ 0 ∧ IsDivisorSection D (s i)) ∧
      (∀ x : X.scheme, ∃ i, x ∈ sectionNonvanishing D (s i)) ∧
      ∃ f : X.scheme ⟶ complexProjectiveSpace N,
        f ≫ complexProjectiveSpaceMap N = X.structureMap ∧
        ∀ i, f ⁻¹ᵁ ProjectiveSpectrum.basicOpen
          (MvPolynomial.homogeneousSubmodule (Fin (N+1)) ℂ) (MvPolynomial.X i) =
          sectionNonvanishing D (s i) := by
  classical
  obtain ⟨N,s,hs,hcov⟩ := generated_finite_section_cover D hgen
  let : (complexProjectiveSpace N).IsSeparated := by
    have := complexProjectiveSpace_isProper N
    constructor
    rw [← Limits.terminal.comp_from (complexProjectiveSpaceMap N)]
    infer_instance
  choose C hC using fun x => exists_divisorProjectiveChart hD hs x (hcov x)
  obtain ⟨f,hf⟩ := covering_partialMaps_extend
    (fun x => (C x).toPartialMap X.structureMap)
    (fun x => ⟨x,hC x⟩) (fun x y => (C x).toRationalMap_eq X.structureMap
      (fun i => (hs i).1) (C y))
  refine ⟨N,s,hs,hcov,f,?_,?_⟩
  · let x := genericPoint X.scheme
    have := Opens.isDominant_ι (X := X.scheme) (U := (C x).domain)
      ((C x).toPartialMap X.structureMap).dense_domain
    apply ext_of_isDominant (C x).domain.ι
    rw [← Category.assoc]
    exact (congrArg (fun g => g ≫ complexProjectiveSpaceMap N) (hf x)).trans
      ((C x).toMorphism_over X.structureMap)
  · intro i
    ext x
    have h := congrArg (fun g : (C x).domain.toScheme ⟶ complexProjectiveSpace N =>
        g ⁻¹ᵁ Proj.basicOpen (MvPolynomial.homogeneousSubmodule (Fin (N+1)) ℂ)
          (MvPolynomial.X i)) (hf x)
    change (((C x).domain.ι ≫ f) ⁻¹ᵁ _) = (C x).toMorphism X.structureMap ⁻¹ᵁ _ at h
    erw [Scheme.Hom.comp_preimage,(C x).toMorphism_preimage X.structureMap
      (fun i => (hs i).1)] at h
    exact (congrArg (fun U : (C x).domain.toScheme.Opens => (⟨x,hC x⟩ : (C x).domain) ∈ U) h).to_iff

end
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace
open AlgebraicGeometry CategoryTheory Limits

namespace NumericalDimensionOne
noncomputable section
variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
    [StalkwiseNormal X] [CompactSpace X]
variable {I : Type} {D : WeilDivisor X} {s : I → X.functionField}
lemma exists_affine_divisorProjectiveChart (hD : IsCartierDivisor D)
    (hs : ∀ i, s i ≠ 0 ∧ IsDivisorSection D (s i)) (x : X)
    (hx : ∃ i, x ∈ sectionNonvanishing D (s i)) :
    ∃ C : DivisorProjectiveChart X D s, x ∈ C.domain ∧ IsAffineOpen C.domain := by
  classical
  obtain ⟨i,hix⟩ := hx
  obtain ⟨U,hU,hxU,g,hg,hDg⟩ := hD x
  let : Nonempty U := ⟨⟨x,hxU⟩⟩
  have hvals (j : I) : ∃ a : Γ(X,U), X.germToFunctionField U a = s j*g :=
    (cartier_local_section_iff hU hg hDg (s j)).mp
      ((hs j).2.imp id (fun h p _ => h p))
  choose a ha using hvals
  let V := X.basicOpen (a i)
  have heV : V = U ⊓ sectionNonvanishing D (s i) :=
    cartier_section_basicOpen hg (hs i).1 hDg (a i) (ha i)
  have hxV : x ∈ V := heV ▸ ⟨hxU,hix⟩
  let : Nonempty V := ⟨⟨x,hxV⟩⟩
  let r : Γ(X,U) ⟶ Γ(X,V) := X.presheaf.map (homOfLE (X.basicOpen_le (a i))).op
  refine ⟨⟨V,((genericPoint_spec X).mem_open_set_iff V.isOpen).mpr
    ⟨x,Set.mem_univ x,hxV⟩,g,hg,fun p hp => hDg p (X.basicOpen_le (a i) hp),
    fun j => r (a j),?_,i,X.toRingedSpace.isUnit_res_basicOpen (a i)⟩,hxV,hU.basicOpen (a i)⟩
  intro j
  exact (germToFunctionField_restrict (homOfLE (X.basicOpen_le (a i))) (a j)).trans (ha j)

end
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace
open AlgebraicGeometry CategoryTheory Limits

namespace NumericalDimensionOne
noncomputable section
lemma opens_topIso_inv_restrict {X : Scheme} {U V : X.Opens} (h : U ≤ V) (a : Γ(X,V)) :
    (X.homOfLE h).appTop (V.topIso.inv a) =
      U.topIso.inv (X.presheaf.map (homOfLE h).op a) := by
  simp only [Scheme.homOfLE_appTop,Scheme.Opens.topIso_inv]
  change (X.presheaf.map _ ≫ X.presheaf.map _) a =
    (X.presheaf.map _ ≫ X.presheaf.map _) a
  erw [← Functor.map_comp,← Functor.map_comp]
  rfl

variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
    {N : ℕ} {D : WeilDivisor X} {s : Fin (N+1) → X.functionField}
lemma divisorProjectiveChart_normalized_transition
    (C C' : DivisorProjectiveChart X D s) (hs : ∀ i, s i ≠ 0) :
    ∃ e : Γ(pullback C.domain.ι C'.domain.ι,⊤)ˣ, ∀ j,
      (pullback.fst C.domain.ι C'.domain.ι).appTop (C.domain.topIso.inv (C.normalized j)) =
        e * (pullback.snd C.domain.ι C'.domain.ι).appTop
          (C'.domain.topIso.inv (C'.normalized j)) := by
  let U := C.domain ⊓ C'.domain
  have hU : genericPoint X ∈ U := ⟨C.generic_mem,C'.generic_mem⟩
  let : Nonempty U := ⟨⟨genericPoint X,hU⟩⟩
  let : Nonempty C.domain := ⟨⟨genericPoint X,C.generic_mem⟩⟩
  let : Nonempty C'.domain := ⟨⟨genericPoint X,C'.generic_mem⟩⟩
  let a := X.presheaf.map (homOfLE (show U ≤ C.domain from inf_le_left)).op
  let b := X.presheaf.map (homOfLE (show U ≤ C'.domain from inf_le_right)).op
  have ha (j) : X.germToFunctionField U (a (C.normalized j)) =
      (s C.unit_index)⁻¹ * s j := by
    rw [germToFunctionField_restrict]
    exact C.generic_normalized hs j
  have hb (j) : X.germToFunctionField U (b (C'.normalized j)) =
      (s C'.unit_index)⁻¹ * s j := by
    rw [germToFunctionField_restrict]
    exact C'.generic_normalized hs j
  have hab : a (C.normalized C'.unit_index) * b (C'.normalized C.unit_index) = 1 := by
    apply X.germToFunctionField_injective U
    rw [map_mul,map_one,ha,hb]
    field_simp [hs C.unit_index,hs C'.unit_index]
  let e : Γ(X,U)ˣ := ⟨a (C.normalized C'.unit_index),b (C'.normalized C.unit_index),hab,
    (mul_comm _ _).trans hab⟩
  have hc (j) : a (C.normalized j) = e * b (C'.normalized j) := by
    apply X.germToFunctionField_injective U
    change X.germToFunctionField U (a (C.normalized j)) =
      X.germToFunctionField U (a (C.normalized C'.unit_index) * b (C'.normalized j))
    rw [map_mul,ha,ha,hb]
    field_simp [hs C'.unit_index]
  let i := (isPullback_opens_inf C.domain C'.domain).isoPullback
  let φ := i.inv.appTop.hom.comp U.topIso.inv.hom
  refine ⟨Units.map φ e,fun j => ?_⟩
  have H := congrArg φ (hc j)
  simp only [map_mul,Units.coe_map] at H ⊢
  have hleft (z : Γ(X,C.domain)) :
      φ (a z) = (pullback.fst C.domain.ι C'.domain.ι).appTop (C.domain.topIso.inv z) := by
    dsimp [φ]
    rw [← opens_topIso_inv_restrict,← CommRingCat.comp_apply,← Scheme.Hom.comp_appTop]
    rw [(isPullback_opens_inf C.domain C'.domain).isoPullback_inv_fst]
  have hright (z : Γ(X,C'.domain)) :
      φ (b z) = (pullback.snd C.domain.ι C'.domain.ι).appTop (C'.domain.topIso.inv z) := by
    dsimp [φ]
    rw [← opens_topIso_inv_restrict,← CommRingCat.comp_apply,← Scheme.Hom.comp_appTop]
    rw [(isPullback_opens_inf C.domain C'.domain).isoPullback_inv_snd]
  rwa [hleft,hright] at H
end
end NumericalDimensionOne

end OAI