import Mathlib
import OAI.AlgebraicGeometry.NumericalDimension.IntersectionLengths
import OAI.AlgebraicGeometry.NumericalDimension.SmoothParameters

namespace OAI

/-! Prime Specialization. -/

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory

theorem maximal_comap_of_finiteType {A B : Type*} [CommRing A] [CommRing B]
    [IsJacobsonRing A] (f : A →+* B) (hf : f.FiniteType)
    (p : Ideal B) [p.IsMaximal] : (p.comap f).IsMaximal := by
  let : Field (B ⧸ p) := Ideal.Quotient.field p
  let φ := (Ideal.Quotient.mk p).comp f
  have hφ : φ.FiniteType := (RingHom.FiniteType.of_surjective _ Ideal.Quotient.mk_surjective).comp hf
  have hfin : φ.Finite := RingHom.finite_iff_finiteType_of_isJacobsonRing.mpr hφ
  have hi : φ.IsIntegral := by
    let : Algebra A (B ⧸ p) := φ.toAlgebra
    have : Module.Finite A (B ⧸ p) := hfin
    exact Algebra.IsIntegral.isIntegral
  have hm := Ideal.isMaximal_comap_of_isIntegral_of_isMaximal φ hi (⊥ : Ideal (B ⧸ p))
  change ((⊥ : Ideal (B ⧸ p)).comap ((Ideal.Quotient.mk p).comp f)).IsMaximal at hm
  rw [← Ideal.comap_comap, ← RingHom.ker_eq_comap_bot, Ideal.mk_ker] at hm
  exact hm

universe u

theorem coheight_eq_of_smooth_closed
    {k : Type u} [Field k] {X : Scheme.{u}}
    (sX : X ⟶ Spec (.of k)) (n : ℕ)
    [SmoothOfRelativeDimension n sX] (x : X) (hx : IsClosed ({x} : Set X)) :
    Order.coheight x = n := by
  apply le_antisymm (coheight_le_of_smooth_dimension sX n x)
  obtain ⟨U, hU, hxU, hs⟩ := exists_standard_smooth_chart sX n x
  obtain ⟨g, _, hg⟩ := hs.exists_etale_mvPolynomial
  let A := MvPolynomial (Fin n) k
  let B := Γ(X,U)
  let : Algebra A B := g.toAlgebra
  have : Algebra.Etale A B := hg
  let p := (hU.primeIdealOf ⟨x,hxU⟩).asIdeal
  have : p.IsMaximal := hU.primeIdealOf_isMaximal_of_isClosed ⟨x,hxU⟩ hx
  let q := p.comap g
  have : q.IsMaximal := maximal_comap_of_finiteType g
    (RingHom.finiteType_algebraMap.mpr (inferInstance : Algebra.FiniteType A B)) p
  have : p.LiesOver q := ⟨rfl⟩
  have : IsNoetherianRing B := Algebra.FiniteType.isNoetherianRing A B
  have hh : q.height ≤ p.height := by
    rw [Ideal.height_eq_height_add_of_liesOver_of_hasGoingDown q p]
    exact le_self_add
  rw [polynomial_maximal_height k n q] at hh
  have he : p.height = Order.coheight x := by
    let y : U := ⟨x,hxU⟩
    let := TopCat.Presheaf.algebra_section_stalk X.presheaf y
    let := hU.isLocalization_stalk y
    have h := IsLocalization.AtPrime.ringKrullDim_eq_height (hU.primeIdealOf y).asIdeal
      (A := X.presheaf.stalk x)
    rw [ringKrullDim_stalk_eq_coheight] at h
    exact WithBot.coe_injective h.symm
  exact he ▸ hh
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory TopologicalSpace
variable {X Y : Scheme} (f : X ⟶ Y) [QuasiCompact f]

theorem schemeTheoreticallyDominant_toImage :
    IsSchemeTheoreticallyDominant f.toImage := by
  constructor
  apply Scheme.IdealSheafData.ext_of_iSup_eq_top
    (fun U : Y.affineOpens => ⟨f.imageι ⁻¹ᵁ U.1, U.2.preimage _⟩)
  · rw [← Scheme.Hom.preimage_iSup, iSup_affineOpens_eq_top, Scheme.Hom.preimage_top]
  · intro U
    rw [Scheme.Hom.ker_apply, Scheme.IdealSheafData.ideal_bot]
    exact (RingHom.injective_iff_ker_eq_bot _).mp (f.toImage_app_injective U)

theorem reduced_image [IsReduced X] : IsReduced f.image := by
  let := schemeTheoreticallyDominant_toImage f
  exact IsSchemeTheoreticallyDominant.isReduced f.toImage

theorem integral_image [IsIntegral X] : IsIntegral f.image := by
  let := reduced_image f
  have : IrreducibleSpace f.image :=
    { isPreirreducible_univ := by
        rw [← f.toImage.denseRange.closure_eq, ← Set.image_univ]
        exact (PreirreducibleSpace.isPreirreducible_univ.image f.toImage
          f.toImage.continuous.continuousOn).closure
      toNonempty := Nonempty.map f.toImage inferInstance }
  exact isIntegral_of_irreducibleSpace_of_isReduced _
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory TopologicalSpace
variable {X : Scheme}

noncomputable def pointClosure (x : X) : Scheme := (X.fromSpecResidueField x).image
noncomputable def pointClosureι (x : X) : pointClosure x ⟶ X :=
  (X.fromSpecResidueField x).imageι

instance pointClosure_integral (x : X) : IsIntegral (pointClosure x) := by
  have : QuasiCompact (X.fromSpecResidueField x) := quasiCompact_of_noetherianSpace_source _
  exact integral_image (X.fromSpecResidueField x)
instance pointClosure_closedImmersion (x : X) : IsClosedImmersion (pointClosureι x) := by
  change IsClosedImmersion (X.fromSpecResidueField x).imageι
  infer_instance
lemma pointClosure_range (x : X) :
    Set.range (pointClosureι x) = closure ({x} : Set X) := by
  change Set.range (X.fromSpecResidueField x).ker.subschemeι = _
  rw [Scheme.IdealSheafData.range_subschemeι, Scheme.Hom.support_ker,
    Scheme.range_fromSpecResidueField]
lemma pointClosure_nontrivial (x : X) (hx : ¬ IsClosed ({x} : Set X)) :
    Nontrivial (pointClosure x) := by
  classical
  by_contra hn
  have : Subsingleton (pointClosure x) := not_nontrivial_iff_subsingleton.mp hn
  have hmem : x ∈ Set.range (pointClosureι x) := by
    rw [pointClosure_range]
    exact subset_closure (Set.mem_singleton _)
  obtain ⟨z,hz⟩ := hmem
  have he : Set.range (pointClosureι x) = {x} := by
    ext y
    constructor
    · rintro ⟨t,rfl⟩
      rw [Subsingleton.elim t z, hz]
      rfl
    · rintro rfl
      exact ⟨z,hz⟩
  exact hx (he ▸ (pointClosureι x).isClosedEmbedding.isClosed_range)
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory TopologicalSpace
universe u
variable {k : Type u} [Field k] [IsAlgClosed k] [CharZero k]
variable {X : Scheme.{u}} (sX : X ⟶ Spec (.of k))
variable [SmoothOfRelativeDimension 2 sX] [IsProper sX]
variable (p : X) (hp : Order.coheight p = 1)

include sX hp in
omit [IsProper sX] [IsAlgClosed k] [CharZero k] in

theorem surface_pointClosure_nontrivial : Nontrivial (pointClosure p) := by
  apply pointClosure_nontrivial
  intro hc
  have h := coheight_eq_of_smooth_closed sX 2 p hc
  rw [hp] at h
  norm_num at h

include sX hp in
omit [IsProper sX] [IsAlgClosed k] [CharZero k] in

theorem surface_pointClosure_coheight (x : pointClosure p) : Order.coheight x ≤ 1 := by
  have : Nonempty X := ⟨p⟩
  apply coheight_le_one_of_bounded_embedding (pointClosureι p)
    (strictMono_of_locallyQuasiFinite _) p _ hp (coheight_le_of_smooth_dimension sX 2) x
  intro y
  apply specializes_iff_mem_closure.mpr
  rw [← pointClosure_range p]
  exact ⟨y,rfl⟩

include hp in

theorem surface_prime_normalization_smooth :
    SmoothOfRelativeDimension 1
      (( (pointClosure p).fromSpecStalk (genericPoint (pointClosure p))).fromNormalization ≫
        pointClosureι p ≫ sX) := by
  have : Nontrivial (pointClosure p) := surface_pointClosure_nontrivial sX p hp
  have : IsProper (pointClosureι p ≫ sX) := inferInstance
  have : IsLocallyNoetherian (pointClosure p) :=
    LocallyOfFiniteType.isLocallyNoetherian (pointClosureι p ≫ sX)
  have : CompactSpace (pointClosure p) :=
    QuasiCompact.compactSpace_of_compactSpace (pointClosureι p ≫ sX)
  have : AlgebraicGeometry.IsNoetherian (pointClosure p) := ⟨⟩
  exact smooth_genericNormalization (pointClosureι p ≫ sX)
    (surface_pointClosure_coheight sX p hp)

omit [IsAlgClosed k] [SmoothOfRelativeDimension 2 sX] in

theorem surface_prime_normalization_proper :
    IsProper
      (((pointClosure p).fromSpecStalk (genericPoint (pointClosure p))).fromNormalization ≫
        pointClosureι p ≫ sX) := by
  have : IsProper (pointClosureι p ≫ sX) := inferInstance
  have : IsLocallyNoetherian (pointClosure p) :=
    LocallyOfFiniteType.isLocallyNoetherian (pointClosureι p ≫ sX)
  have : CompactSpace (pointClosure p) :=
    QuasiCompact.compactSpace_of_compactSpace (pointClosureι p ≫ sX)
  have : AlgebraicGeometry.IsNoetherian (pointClosure p) := ⟨⟩
  exact proper_genericNormalization (pointClosureι p ≫ sX)
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
lemma isClosed_point_of_isClosed_image {C X : Scheme} (f : C ⟶ X)
    [LocallyQuasiFinite f] (y : C) (hy : IsClosed ({f y} : Set X)) :
    IsClosed ({y} : Set C) := by
  apply isClosed_of_subset_discrete_closed (t := f ⁻¹' {f y}) _
    (f.isDiscrete_preimage_singleton (f y)) (hy.preimage f.continuous)
  rintro _ rfl
  rfl

variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
  [Nontrivial X] [QuasiSeparatedSpace X]

theorem localOrder_eq_normalizedSchemeOrders (sX : X ⟶ Spec (.of ℂ))
    [LocallyOfFiniteType sX] (hd : ∀ x : X, Order.coheight x ≤ 1)
    (x : X) (hx : IsClosed ({x} : Set X))
    (a : X.presheaf.stalk x) (ha : a ≠ 0) :
    let N := (X.fromSpecStalk (genericPoint X)).normalization
    let f := (X.fromSpecStalk (genericPoint X)).fromNormalization
    letI : AlgebraicGeometry.IsFinite f := finite_genericNormalization sX
    letI : IsLocallyNoetherian N := LocallyOfFiniteType.isLocallyNoetherian f
    ((Ring.ord (X.presheaf.stalk x) a).toNat : ℤ) =
      ∑ᶠ y : {y : N // f y = x},
        N.ord (algebraMap (N.presheaf.stalk y.1) N.functionField
          (fiberStalkMap f x y a)) y.1 := by
  let N := (X.fromSpecStalk (genericPoint X)).normalization
  let f := (X.fromSpecStalk (genericPoint X)).fromNormalization
  have : AlgebraicGeometry.IsFinite f := finite_genericNormalization sX
  have : IsIntegral N := integral_genericNormalization
  have : SmoothOfRelativeDimension 1 (f ≫ sX) := smooth_genericNormalization sX hd
  have : IsLocallyNoetherian N := LocallyOfFiniteType.isLocallyNoetherian (f ≫ sX)
  apply (localOrder_int_eq_normalizationFiber sX x hx (hd x) a ha).trans
  apply finsum_congr
  intro y
  have hyclosed : IsClosed ({y.1} : Set N) :=
    isClosed_point_of_isClosed_image f y.1 (y.2.symm ▸ hx)
  have hyheight : Order.coheight y.1 = 1 :=
    coheight_eq_of_smooth_closed (f ≫ sX) 1 y.1 hyclosed
  have hn : fiberStalkMap f x y a ≠ 0 := by
    let : Algebra (X.presheaf.stalk x) (N.presheaf.stalk y.1) :=
      (fiberStalkMap f x y).toAlgebra
    let hf := genericNormalization_bijective_functionField (X := X)
    let : Algebra (N.presheaf.stalk y.1) X.functionField :=
      (birationalStalkToField f hf y.1).toAlgebra
    have : IsScalarTower (X.presheaf.stalk x) (N.presheaf.stalk y.1) X.functionField :=
      birationalFiberStalk_tower f hf x y
    intro hz
    apply ha
    apply IsFractionRing.injective (X.presheaf.stalk x) X.functionField
    rw [map_zero, IsScalarTower.algebraMap_apply (X.presheaf.stalk x)
      (N.presheaf.stalk y.1) X.functionField]
    change algebraMap (N.presheaf.stalk y.1) X.functionField (fiberStalkMap f x y a) = 0
    rw [hz, map_zero]
  exact (scheme_order_of_stalk_element y.1 hyheight _ hn).symm
end NumericalDimensionOne

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

namespace NumericalDimensionOne

theorem finsum_fiberwise {α β M : Type*} [AddCommMonoid M]
    (f : α → β) (w : α → M) (hw : Function.HasFiniteSupport w) :
    (∑ᶠ x : β, ∑ᶠ y : {y : α // f y = x}, w y.1) = ∑ᶠ y, w y := by
  classical
  let s := hw.toFinset
  have hinner (x : β) : (∑ᶠ y : {y : α // f y = x}, w y.1) =
      ∑ y ∈ s with f y = x, w y := by
    rw [finsum_subtype_eq_finsum_cond]
    apply finsum_cond_eq_sum_of_cond_iff
    intro y hy
    simp only [Finset.mem_filter]
    exact ⟨fun h => ⟨hw.mem_toFinset.mpr hy, h⟩, And.right⟩
  simp_rw [hinner]
  rw [finsum_eq_sum_of_support_subset _ (s.support_of_fiberwise_sum_subset_image w f),
    Finset.sum_fiberwise_of_maps_to (t := s.image f) _ w]
  · exact (finsum_eq_sum w hw).symm
  · intro y hy
    exact Finset.mem_image.mpr ⟨y,hy,rfl⟩
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
abbrev ClosedCurvePoint (X : Scheme) := {x : X // IsClosed ({x} : Set X)}
variable {C X : Scheme} (sC : C ⟶ Spec (.of ℂ)) [SmoothOfRelativeDimension 1 sC]
include sC in
lemma curvePrime_isClosed (p : PrimeDivisor C) : IsClosed ({p.1} : Set C) := by
  exact isClosed_point_of_max_coheight (coheight_le_of_smooth_dimension sC 1) p.1 p.2

noncomputable def finiteCurvePrimeImage (f : C ⟶ X) [IsFinite f]
    (p : PrimeDivisor C) : ClosedCurvePoint X :=
  ⟨f p.1, by simpa only [Set.image_singleton] using
    f.isClosedMap {p.1} (curvePrime_isClosed sC p)⟩

noncomputable def finiteCurvePrimeFiberEquiv (f : C ⟶ X) [IsFinite f]
    (x : ClosedCurvePoint X) :
    {p : PrimeDivisor C // finiteCurvePrimeImage sC f p = x} ≃
      {y : C // f y = x.1} := by
  refine
    { toFun := fun p => ⟨p.1.1, congrArg Subtype.val p.2⟩
      invFun := fun y => ⟨⟨y.1, ?_⟩, ?_⟩
      left_inv := ?_
      right_inv := ?_ }
  · exact coheight_eq_of_smooth_closed sC 1 y.1
      (isClosed_point_of_isClosed_image f y.1 (y.2.symm ▸ x.2))
  · exact Subtype.ext y.2
  · intro p
    rfl
  · intro y
    rfl
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
universe u
section StalkGenerization
variable {X : Scheme.{u}}

@[instance_reducible]
noncomputable def stalkGenerizationAlgebra {x y : X} (h : x ⤳ y) :
    Algebra (X.presheaf.stalk y) (X.presheaf.stalk x) :=
  (X.presheaf.stalkSpecializes h).hom.toAlgebra

lemma open_stalk_generization_tower {x y : X} (h : x ⤳ y)
    (U : X.Opens) (hy : y ∈ U) :
    letI := TopCat.Presheaf.algebra_section_stalk X.presheaf ⟨y, hy⟩
    letI := TopCat.Presheaf.algebra_section_stalk X.presheaf
      ⟨x, h.mem_open U.isOpen hy⟩
    letI := stalkGenerizationAlgebra h
    IsScalarTower Γ(X, U) (X.presheaf.stalk y) (X.presheaf.stalk x) := by
  let := TopCat.Presheaf.algebra_section_stalk X.presheaf ⟨y, hy⟩
  let := TopCat.Presheaf.algebra_section_stalk X.presheaf ⟨x, h.mem_open U.isOpen hy⟩
  let := stalkGenerizationAlgebra h
  apply IsScalarTower.of_algebraMap_eq
  intro a
  exact (congrArg (fun f : Γ(X, U) ⟶ X.presheaf.stalk x => f a)
    (X.presheaf.germ_stalkSpecializes hy h)).symm

end StalkGenerization
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
universe u
variable {X : Scheme.{u}}

lemma functionField_stalkGenerization_tower [IrreducibleSpace X]
    {x y : X} (h : x ⤳ y) :
    letI := stalkGenerizationAlgebra h
    IsScalarTower (X.presheaf.stalk y) (X.presheaf.stalk x) X.functionField := by
  let := stalkGenerizationAlgebra h
  apply IsScalarTower.of_algebraMap_eq'
  change (X.presheaf.stalkSpecializes
    ((genericPoint_spec X).specializes (show y ∈ Set.univ from trivial))).hom =
    ((X.presheaf.stalkSpecializes
      ((genericPoint_spec X).specializes (show x ∈ Set.univ from trivial))).hom).comp
      (X.presheaf.stalkSpecializes h).hom
  exact congrArg CommRingCat.Hom.hom
    (X.presheaf.stalkSpecializes_comp
      ((genericPoint_spec X).specializes (show x ∈ Set.univ from trivial)) h).symm

theorem isLocalization_stalkGenerization [IsIntegral X]
    {x y : X} (h : x ⤳ y) :
    letI := stalkGenerizationAlgebra h
    IsLocalization.AtPrime (X.presheaf.stalk x)
      ((IsLocalRing.maximalIdeal (X.presheaf.stalk x)).comap
        (X.presheaf.stalkSpecializes h).hom) := by
  let := stalkGenerizationAlgebra h
  obtain ⟨U, hU, hy, _⟩ := exists_isAffineOpen_mem_and_subset
    (show y ∈ (⊤ : X.Opens) from trivial)
  let := TopCat.Presheaf.algebra_section_stalk X.presheaf ⟨y, hy⟩
  let := TopCat.Presheaf.algebra_section_stalk X.presheaf ⟨x, h.mem_open U.isOpen hy⟩
  let := open_stalk_generization_tower h U hy
  let := hU.isLocalization_stalk ⟨x, h.mem_open U.isOpen hy⟩
  let := functionField_stalkGenerization_tower h
  apply LocalizationTower.atPrime_of_localized_base
    (hU.primeIdealOf ⟨x, h.mem_open U.isOpen hy⟩).asIdeal.primeCompl
  intro a b he
  apply IsFractionRing.injective (X.presheaf.stalk y) X.functionField
  rw [IsScalarTower.algebraMap_apply (X.presheaf.stalk y) (X.presheaf.stalk x)
    X.functionField, IsScalarTower.algebraMap_apply (X.presheaf.stalk y)
    (X.presheaf.stalk x) X.functionField, he]
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
universe u
variable {X : Scheme.{u}}

noncomputable def generizationPrime {x y : X} (h : x ⤳ y) :
    Ideal (X.presheaf.stalk y) :=
  (IsLocalRing.maximalIdeal (X.presheaf.stalk x)).comap
    (X.presheaf.stalkSpecializes h).hom

instance generizationPrime_isPrime {x y : X} (h : x ⤳ y) :
    (generizationPrime h).IsPrime := Ideal.comap_isPrime _ _

lemma generizationPrime_height [IsIntegral X] {x y : X} (h : x ⤳ y)
    (hx : Order.coheight x = 1) : (generizationPrime h).height = 1 := by
  let := stalkGenerizationAlgebra h
  let : IsLocalization.AtPrime (X.presheaf.stalk x) (generizationPrime h) :=
    isLocalization_stalkGenerization h
  have hd := IsLocalization.AtPrime.ringKrullDim_eq_height
    (generizationPrime h) (X.presheaf.stalk x)
  rw [ringKrullDim_stalk_eq_coheight, hx] at hd
  exact WithBot.coe_injective hd.symm

lemma generizationPrime_affine {x y : X} (h : x ⤳ y) {U : X.Opens}
    (hU : IsAffineOpen U) (hy : y ∈ U) :
    (generizationPrime h).comap (X.presheaf.germ U y hy).hom =
      (hU.primeIdealOf ⟨x, h.mem_open U.isOpen hy⟩).asIdeal := by
  rw [generizationPrime, Ideal.comap_comap]
  have he := congrArg CommRingCat.Hom.hom (X.presheaf.germ_stalkSpecializes hy h)
  change (X.presheaf.stalkSpecializes h).hom.comp (X.presheaf.germ U y hy).hom =
    (X.presheaf.germ U x (h.mem_open U.isOpen hy)).hom at he
  rw [he]
  exact (congrArg PrimeSpectrum.asIdeal
    (hU.primeIdealOf_eq_map_closedPoint ⟨x, h.mem_open U.isOpen hy⟩)).symm

lemma generizationPrime_injective {x z y : X} (hxy : x ⤳ y) (hzy : z ⤳ y)
    (he : generizationPrime hxy = generizationPrime hzy) : x = z := by
  obtain ⟨U, hU, hy, _⟩ := exists_isAffineOpen_mem_and_subset
    (show y ∈ (⊤ : X.Opens) from trivial)
  have he' := congrArg (Ideal.comap (X.presheaf.germ U y hy).hom) he
  rw [generizationPrime_affine hxy hU hy, generizationPrime_affine hzy hU hy] at he'
  have hp := PrimeSpectrum.ext he'
  have hh := congrArg hU.fromSpec hp
  simpa only [hU.fromSpec_primeIdealOf] using hh
end NumericalDimensionOne

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

namespace NumericalDimensionOne
namespace FactorialUniformizers
variable {A : Type*} [CommRing A] [hdom : IsDomain A] [IsNoetherianRing A]
omit hdom in

theorem order_generator (p q : Ideal A) [p.IsPrime] [q.IsPrime]
    (hp : p.height = 1) (hq : q.height = 1) (a : A) (ha : p = Ideal.span {a}) :
    Ring.ord (Localization.AtPrime q) (algebraMap A (Localization.AtPrime q) a) =
      if p = q then 1 else 0 := by
  classical
  by_cases he : p = q
  · subst q
    simp only [ite_true]
    have hm : Ideal.span {algebraMap A (Localization.AtPrime p) a} =
        IsLocalRing.maximalIdeal (Localization.AtPrime p) := by
      rw [← Localization.AtPrime.map_eq_maximalIdeal]
      conv_rhs => arg 2; rw [ha]
      rw [Ideal.map_span, Set.image_singleton]
    rw [Ring.ord, hm]
    have : IsSimpleModule (Localization.AtPrime p)
        (Localization.AtPrime p ⧸ IsLocalRing.maximalIdeal (Localization.AtPrime p)) :=
      isSimpleModule_iff_isCoatom.mpr
        (Ideal.isMaximal_def.mp (IsLocalRing.maximalIdeal.isMaximal _))
    exact Module.length_eq_one _ _
  · simp only [ite_eq_right he]
    apply Ring.ord_of_isUnit
    apply IsLocalization.map_units (Localization.AtPrime q) (M := q.primeCompl) ⟨a, ?_⟩
    intro hmem
    have hle : p ≤ q := by
      rw [ha]
      exact q.span_singleton_le_iff_mem.mpr hmem
    exact he (Ideal.eq_of_le_of_height_le p hle (by rw [hp, hq]))
end FactorialUniformizers
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
universe u
variable {X : Scheme.{u}} [IsIntegral X] [IsLocallyNoetherian X]

open scoped Classical in

theorem order_stalk_generator {x y z : X} (hxy : x ⤳ y) (hzy : z ⤳ y)
    (hx : Order.coheight x = 1) (hz : Order.coheight z = 1)
    (a : X.presheaf.stalk y) (ha : generizationPrime hxy = Ideal.span {a}) :
    X.ord (algebraMap (X.presheaf.stalk y) X.functionField a) z =
      if x = z then 1 else 0 := by
  classical
  let := stalkGenerizationAlgebra hzy
  let : IsLocalization.AtPrime (X.presheaf.stalk z) (generizationPrime hzy) :=
    isLocalization_stalkGenerization hzy
  let := functionField_stalkGenerization_tower hzy
  have ha0 : a ≠ 0 := by
    intro he
    have hp := (generizationPrime hxy).ne_bot_of_height_eq_one
      (generizationPrime_height hxy hx)
    exact hp (by simpa only [he, Ideal.span_singleton_zero] using ha)
  have hay : algebraMap (X.presheaf.stalk y) X.functionField a ≠ 0 :=
    (map_ne_zero_iff _ (IsFractionRing.injective _ _)).mpr ha0
  have haz : algebraMap (X.presheaf.stalk y) (X.presheaf.stalk z) a ≠ 0 := by
    intro he
    apply hay
    rw [IsScalarTower.algebraMap_apply (X.presheaf.stalk y) (X.presheaf.stalk z)
      X.functionField, he, map_zero]
  have ho := scheme_order_of_stalk_element z hz
    (algebraMap (X.presheaf.stalk y) (X.presheaf.stalk z) a) haz
  rw [← IsScalarTower.algebraMap_apply] at ho
  let e := IsLocalization.algEquiv (generizationPrime hzy).primeCompl
    (Localization.AtPrime (generizationPrime hzy)) (X.presheaf.stalk z)
  have he := ringOrder_equiv e.toRingEquiv
    (algebraMap (X.presheaf.stalk y) (Localization.AtPrime (generizationPrime hzy)) a)
  have hec : e.toRingEquiv
      (algebraMap (X.presheaf.stalk y) (Localization.AtPrime (generizationPrime hzy)) a) =
      algebraMap (X.presheaf.stalk y) (X.presheaf.stalk z) a := e.commutes a
  rw [hec, FactorialUniformizers.order_generator (generizationPrime hxy)
    (generizationPrime hzy) (generizationPrime_height hxy hx)
    (generizationPrime_height hzy hz) a ha] at he
  rw [he] at ho
  have hp : generizationPrime hxy = generizationPrime hzy ↔ x = z := by
    constructor
    · exact generizationPrime_injective hxy hzy
    · rintro rfl; rfl
  simpa only [hp, apply_ite ENat.toNat, ENat.toNat_one, ENat.toNat_zero,
    Int.cast_ofNat, Nat.cast_ite, Nat.cast_one, Nat.cast_zero] using ho
end NumericalDimensionOne

end OAI