lean/OAI/AlgebraicGeometry/NumericalDimension/CartierIntersection.lean

import Mathlib
import OAI.AlgebraicGeometry.NumericalDimension.CurveDegrees

namespace OAI

/-! Cartier Intersection. -/

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
variable {C Y : Scheme} [IsIntegral C] [IsIntegral Y]
  [IsLocallyNoetherian C] [IsLocallyNoetherian Y] [StalkwiseNormal Y]
  [CompactSpace C]
variable (sC : C ⟶ Spec (.of ℂ)) [SmoothOfRelativeDimension 1 sC] [IsProper sC]

include sC in
lemma proper_principal_degree_zero (t : C.functionField) :
    complexWeilDegree (principalWeilDivisor t) = 0 := by
  let : AlgebraicGeometry.IsNoetherian C := ⟨⟩
  exact NumericalDimensionOneCurveAux.proper_curve_principal_degree_zero sC t
include sC in
lemma proper_representative_degree_eq {f : C ⟶ Y} {D : WeilDivisor Y}
    {E F : WeilDivisor C} (hE : IsPulledCartierRepresentative f D E)
    (hF : IsPulledCartierRepresentative f D F) :
    complexWeilDegree E = complexWeilDegree F := by
  classical
  obtain ⟨a, _, rfl⟩ := pulledCartierRepresentative_difference hE hF
  change (F + principalWeilDivisor a).sum (fun _ a => a) = _
  rw [Finsupp.sum_add_index (fun _ _ => rfl) (fun _ _ _ _ => rfl)]
  change complexWeilDegree F + complexWeilDegree (principalWeilDivisor a) = _
  rw [proper_principal_degree_zero sC, add_zero]

noncomputable def properCurveDegree (f : C ⟶ Y)
    (D : cartierDivisors (X := Y)) : ℤ :=
  complexWeilDegree (Classical.choose
    (exists_pulledCartierRepresentative f D.1 D.2))

include sC in
lemma properCurveDegree_eq (f : C ⟶ Y) (D : cartierDivisors (X := Y))
    (E : WeilDivisor C) (hE : IsPulledCartierRepresentative f D E) :
    properCurveDegree f D = complexWeilDegree E := by
  exact proper_representative_degree_eq sC
    (Classical.choose_spec (exists_pulledCartierRepresentative f D.1 D.2)) hE
include sC in
lemma properCurveDegree_add (f : C ⟶ Y) (D E : cartierDivisors (X := Y)) :
    properCurveDegree f (D + E) = properCurveDegree f D + properCurveDegree f E := by
  classical
  let F := Classical.choose (exists_pulledCartierRepresentative f D.1 D.2)
  let G := Classical.choose (exists_pulledCartierRepresentative f E.1 E.2)
  have hF := Classical.choose_spec (exists_pulledCartierRepresentative f D.1 D.2)
  have hG := Classical.choose_spec (exists_pulledCartierRepresentative f E.1 E.2)
  rw [properCurveDegree_eq sC f (D + E) (F + G) (hF.add hG)]
  exact Finsupp.sum_add_index (fun _ _ => rfl) (fun _ _ _ _ => rfl)
include sC in
lemma properCurveDegree_zero (f : C ⟶ Y) : properCurveDegree f 0 = 0 := by
  rw [properCurveDegree_eq sC f 0 0 (isPulledCartierRepresentative_zero f)]
  rfl
noncomputable def properCurveDegreeHom (f : C ⟶ Y) : cartierDivisors (X := Y) →+ ℤ where
  toFun := properCurveDegree f
  map_zero' := properCurveDegree_zero sC f
  map_add' := properCurveDegree_add sC f

lemma properCurveDegree_eq_cartierCurveDegree {X : ComplexProjectiveVariety}
    [StalkwiseNormal X.scheme] (T : CurveOn X) (D : cartierDivisors (X := X.scheme)) :
    properCurveDegree T.morphism D = cartierCurveDegree D T := by
  rfl
end NumericalDimensionOne

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

namespace NumericalDimensionOne

theorem ringKrullDim_le_of_quasiFinite (R S : Type*)
    [CommRing R] [CommRing S] [Algebra R S] [Algebra.QuasiFinite R S] :
    ringKrullDim S ≤ ringKrullDim R := by
  apply Order.krullDim_le_of_strictMono (f := PrimeSpectrum.comap (algebraMap R S))
  intro p q hpq
  refine lt_of_le_of_ne (Ideal.comap_mono hpq.le) ?_
  intro heq
  have hd := Algebra.QuasiFinite.isDiscrete_comap_preimage_singleton
    (R := R) (S := S) (PrimeSpectrum.comap (algebraMap R S) p)
  have hsp : p ⤳ q := (PrimeSpectrum.le_iff_specializes p q).mp hpq.le
  have hp : p ∈ PrimeSpectrum.comap (algebraMap R S) ⁻¹'
      {PrimeSpectrum.comap (algebraMap R S) p} := rfl
  have hq : q ∈ PrimeSpectrum.comap (algebraMap R S) ⁻¹'
      {PrimeSpectrum.comap (algebraMap R S) p} := heq.symm
  exact hpq.ne (hd.eq_of_specializes hsp hp hq)

end NumericalDimensionOne

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

namespace NumericalDimensionOne

universe u

theorem coheight_le_of_smooth_dimension
    {k : Type u} [Field k] {X : Scheme.{u}}
    (sX : X ⟶ Spec (.of k)) (n : ℕ)
    [SmoothOfRelativeDimension n sX] (x : X) :
    Order.coheight x ≤ n := by
  obtain ⟨U, hU, hxU, hs⟩ := exists_standard_smooth_chart sX n x
  obtain ⟨g, _, hg⟩ := hs.exists_etale_mvPolynomial
  let : Algebra (MvPolynomial (Fin n) k) Γ(X, U) := g.toAlgebra
  let : Algebra.Etale (MvPolynomial (Fin n) k) Γ(X, U) := hg
  have hdim : ringKrullDim Γ(X, U) ≤ n := by
    have h := ringKrullDim_le_of_quasiFinite (MvPolynomial (Fin n) k) Γ(X, U)
    simpa using h
  let y : U := ⟨x, hxU⟩
  let := TopCat.Presheaf.algebra_section_stalk X.presheaf y
  let := hU.isLocalization_stalk y
  have hstalk : ringKrullDim (X.presheaf.stalk x) ≤ n := by
    rw [IsLocalization.AtPrime.ringKrullDim_eq_height (hU.primeIdealOf y).asIdeal]
    exact (Ideal.height_le_ringKrullDim_of_ne_top
      (hU.primeIdealOf y).isPrime.ne_top).trans hdim
  rw [ringKrullDim_stalk_eq_coheight] at hstalk
  exact WithBot.coe_le_coe.mp hstalk

end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory TopologicalSpace
universe u

lemma finite_closed_of_closed_points {X : Scheme.{u}} [NoetherianSpace X]
    {Z : Set X} (hZ : IsClosed Z) (hpoint : ∀ x ∈ Z, IsClosed ({x} : Set X)) :
    Z.Finite := by
  obtain ⟨T, hT, hc, hi, heq⟩ :=
    NoetherianSpace.exists_finite_set_isClosed_irreducible hZ
  rw [heq]
  apply hT.sUnion
  intro t ht
  obtain ⟨x, hx⟩ := QuasiSober.sober (hi t ht) (hc t ht)
  have hxZ : x ∈ Z := by
    rw [heq]
    exact Set.mem_sUnion.mpr ⟨t, ht, hx.mem⟩
  rw [← hx, (hpoint x hxZ).closure_eq]
  exact Set.finite_singleton _

lemma eq_of_specializes_of_equal_finite_coheight {X : Scheme.{u}}
    {x y : X} (hxy : x ⤳ y) {n : ℕ}
    (hx : Order.coheight x = n) (hy : Order.coheight y = n) : x = y := by
  by_contra hne
  have hlt : y < x := lt_iff_le_not_ge.mpr
    ⟨hxy, fun h => hne (Specializes.antisymm hxy (show y ⤳ x from h)).eq⟩
  have hbound := Order.coheight_add_one_le hlt
  rw [hx, hy] at hbound
  exact (not_le_of_gt ((ENat.lt_add_one_iff (ENat.natCast_ne_top n)).2 le_rfl)) hbound

lemma isClosed_point_of_max_coheight {X : Scheme.{u}} {n : ℕ}
    (hdim : ∀ y : X, Order.coheight y ≤ n) (x : X)
    (hx : Order.coheight x = n) : IsClosed ({x} : Set X) := by
  apply isClosed_of_closure_subset
  intro y hy
  have hxy : x ⤳ y := specializes_iff_mem_closure.mpr hy
  by_contra hne
  have hne' : x ≠ y := fun h => hne (by simpa only [Set.mem_singleton_iff] using h.symm)
  have hlt : y < x := lt_iff_le_not_ge.mpr
    ⟨hxy, fun h => hne' (Specializes.antisymm hxy (show y ⤳ x from h)).eq⟩
  have hb := (Order.coheight_add_one_le hlt).trans (hdim y)
  rw [hx] at hb
  exact (not_le_of_gt ((ENat.lt_add_one_iff (ENat.natCast_ne_top n)).2 le_rfl)) hb

lemma closed_point_of_distinct_prime_intersection {X : Scheme.{u}}
    (hdim : ∀ x : X, Order.coheight x ≤ 2)
    (p q : PrimeDivisor X) (hpq : p ≠ q) (x : X)
    (hp : x ∈ closure ({p.1} : Set X)) (hq : x ∈ closure ({q.1} : Set X)) :
    IsClosed ({x} : Set X) := by
  have hqx : q.1 ⤳ x := specializes_iff_mem_closure.mpr hq
  have hpx : p.1 ⤳ x := specializes_iff_mem_closure.mpr hp
  have hxp : x ≠ p.1 := by
    intro heq
    have hqp := eq_of_specializes_of_equal_finite_coheight (heq ▸ hqx) q.2 p.2
    exact hpq (Subtype.ext hqp.symm)
  have hlt : x < p.1 := lt_iff_le_not_ge.mpr
    ⟨hpx, fun h => hxp (Specializes.antisymm (show x ⤳ p.1 from h) hpx).eq⟩
  have hlow := Order.coheight_add_one_le hlt
  rw [p.2] at hlow
  have heq : Order.coheight x = 2 := le_antisymm (hdim x) (by simpa only [one_add_one_eq_two] using hlow)
  exact isClosed_point_of_max_coheight hdim x heq

theorem finite_divisorSupport_intersection {X : Scheme.{u}} [NoetherianSpace X]
    (hdim : ∀ x : X, Order.coheight x ≤ 2)
    (D E : WeilDivisor X) (hDE : Disjoint D.support E.support) :
    (divisorSupport D ∩ divisorSupport E).Finite := by
  apply finite_closed_of_closed_points
    ((isClosed_divisorSupport D).inter (isClosed_divisorSupport E))
  rintro x ⟨hxD, hxE⟩
  obtain ⟨p, hp, hpx⟩ := Set.mem_iUnion₂.mp hxD
  obtain ⟨q, hq, hqx⟩ := Set.mem_iUnion₂.mp hxE
  have hpq : p ≠ q := by
    intro heq
    exact (Finset.disjoint_left.mp hDE hp) (heq ▸ hq)
  exact closed_point_of_distinct_prime_intersection hdim p q hpq x hpx hqx

theorem finite_divisorSupport_intersection_smooth
    (T : ComplexProjectiveVariety) (hT : IsSmoothNfold T 2)
    (D E : WeilDivisor T.scheme) (hDE : Disjoint D.support E.support) :
    (divisorSupport D ∩ divisorSupport E).Finite := by
  let : SmoothOfRelativeDimension 2 T.structureMap := hT
  let : AlgebraicGeometry.IsNoetherian T.scheme := ⟨⟩
  exact finite_divisorSupport_intersection
    (coheight_le_of_smooth_dimension T.structureMap 2) D E hDE
end NumericalDimensionOne

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

namespace NumericalDimensionOne

def IsGeneratedAt {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
    [CompactSpace X] (D : WeilDivisor X) (x : X) : Prop :=
  ∃ s : X.functionField, s ≠ 0 ∧ IsDivisorSection D s ∧
    x ∈ sectionNonvanishing D s

lemma coefficient_zero_on_divisorComplement {X : Scheme} (D : WeilDivisor X)
    (p : PrimeDivisor X) (hp : p.1 ∈ divisorComplement D) : D p = 0 := by
  classical
  by_contra h
  apply hp
  exact Set.mem_iUnion₂.mpr ⟨p, Finsupp.mem_support_iff.mpr h,
    subset_closure (Set.mem_singleton p.1)⟩

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

lemma section_regular_stalk {D : WeilDivisor X} {s g : X.functionField}
    (hs : IsDivisorSection D s) {U : X.Opens} (hU : IsAffineOpen U)
    (hg : g ≠ 0) (hDg : ∀ p : PrimeDivisor X, p.1 ∈ U → D p = X.ord g p.1)
    {x : X} (hx : x ∈ U) :
    ∃ a : X.presheaf.stalk x,
      algebraMap (X.presheaf.stalk x) X.functionField a = s * g := by
  let : Nonempty U := ⟨⟨x, hx⟩⟩
  have hsU : IsDivisorSectionOn D U s := hs.imp id (fun h p _ => h p)
  obtain ⟨a, ha⟩ := (cartier_local_section_iff hU hg hDg s).mp hsU
  exact ⟨X.presheaf.germ U x hx a, (X.algebraMap_germ_eq_germToFunctionField hx a).trans ha⟩

lemma section_unit_stalk [CompactSpace X] {D : WeilDivisor X} {s g : X.functionField}
    (hs : s ≠ 0) {U : X.Opens} (hg : g ≠ 0)
    (hDg : ∀ p : PrimeDivisor X, p.1 ∈ U → D p = X.ord g p.1)
    {x : X} (hxU : x ∈ U) (hx : x ∈ sectionNonvanishing D s) :
    ∃ a : X.presheaf.stalk x, IsUnit a ∧
      algebraMap (X.presheaf.stalk x) X.functionField a = s * g := by
  let V : X.Opens := U ⊓ sectionNonvanishing D s
  have hzero : ∀ p : PrimeDivisor X, p.1 ∈ V → (0 : WeilDivisor X) p =
      X.ord (s * g) p.1 := by
    intro p hp
    rw [X.ord_mul hs hg, ← hDg p hp.1]
    exact (coefficient_zero_on_divisorComplement (principalWeilDivisor s + D) p hp.2).symm
  obtain ⟨a, ha, hea⟩ := local_equation_ratio_unit (mul_ne_zero hs hg) one_ne_zero
    hzero (fun p (_ : p.1 ∈ V) => by simp only [Finsupp.zero_apply, order_one])
    (show x ∈ V from ⟨hxU, hx⟩) (show x ∈ V from ⟨hxU, hx⟩)
  exact ⟨a, ha, by simpa only [div_one] using hea⟩

end LocalSections

lemma IsPulledCartierRepresentative.exists_nonzero_section
    {Y C : Scheme} [IsIntegral Y] [IsIntegral C]
    [IsLocallyNoetherian Y] [IsLocallyNoetherian C]
    [StalkwiseNormal Y] [StalkwiseNormal C] [CompactSpace Y]
    {f : C ⟶ Y} {D : WeilDivisor Y} {E : WeilDivisor C}
    (hE : IsPulledCartierRepresentative f D E)
    (hgen : IsGeneratedAt D (f (genericPoint C))) :
    ∃ t : C.functionField, t ≠ 0 ∧ IsDivisorSection E t := by
  obtain ⟨s, hs, hsec, hnonvan⟩ := hgen
  obtain ⟨U, _, hηU, g, hg, hDg, hEloc⟩ := hE
  obtain ⟨a, ha, hea⟩ := section_unit_stalk hs hg hDg hηU hnonvan
  refine ⟨f.stalkMap (genericPoint C) a, (ha.map (f.stalkMap (genericPoint C)).hom).ne_zero,
    Or.inr ?_⟩
  intro p
  obtain ⟨V, hV, hpV, h, hh, hDh, b, hb, heb, hebord⟩ := hEloc p.1
  obtain ⟨c, hec⟩ := section_regular_stalk hsec hV hh hDh hpV
  let hsp : genericPoint C ⤳ p.1 := (genericPoint_spec C).specializes trivial
  have heq : a * b = Y.presheaf.stalkSpecializes (f.base.hom.map_specializes hsp) c := by
    apply IsFractionRing.injective (Y.presheaf.stalk (f (genericPoint C))) Y.functionField
    rw [map_mul, hea, heb, algebraMap_stalkSpecializes, hec]
    field_simp
  rw [hebord p hpV, ← C.ord_mul
    (ha.map (f.stalkMap (genericPoint C)).hom).ne_zero
    (hb.map (f.stalkMap (genericPoint C)).hom).ne_zero, ← map_mul, heq,
    f.stalkSpecializes_stalkMap_apply (genericPoint C) p.1 hsp c]
  apply (ord_nonnegative_iff_regular p _ ?_).mpr ⟨f.stalkMap p.1 c, rfl⟩
  change C.presheaf.stalkSpecializes hsp (f.stalkMap p.1 c) ≠ 0
  rw [← f.stalkSpecializes_stalkMap_apply, ← heq, map_mul]
  exact mul_ne_zero (ha.map (f.stalkMap (genericPoint C)).hom).ne_zero
    (hb.map (f.stalkMap (genericPoint C)).hom).ne_zero

theorem cartierCurveDegree_nonneg_of_generatedAt
    {X : ComplexProjectiveVariety} [StalkwiseNormal X.scheme]
    (D : cartierDivisors (X := X.scheme)) (C : CurveOn X)
    (hgen : IsGeneratedAt D.1 (C.morphism (genericPoint C.curve.scheme))) :
    0 ≤ cartierCurveDegree D C := by
  obtain ⟨s, hs, hsec⟩ :=
    (pulledCartierRepresentative_spec C D.1 D.2).exists_nonzero_section hgen
  exact divisor_degree_nonnegative C.curve C.smooth _ s hs hsec

end NumericalDimensionOne

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

namespace NumericalDimensionOne
section NonvanishingLocal
variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
variable [StalkwiseNormal X] [CompactSpace X]

omit [StalkwiseNormal X] in

lemma section_nonvanishing_of_local_unit {D : WeilDivisor X} {s g : X.functionField}
    (hs : s ≠ 0) {U : X.Opens} (hg : g ≠ 0)
    (hDg : ∀ p : PrimeDivisor X, p.1 ∈ U → D p = X.ord g p.1)
    {x : X} (hx : x ∈ U) (a : X.presheaf.stalk x) (ha : IsUnit a)
    (hea : algebraMap (X.presheaf.stalk x) X.functionField a = s * g) :
    x ∈ sectionNonvanishing D s := by
  intro hmem
  obtain ⟨p, hp, hxp⟩ := Set.mem_iUnion₂.mp hmem
  have hsp : p.1 ⤳ x := specializes_iff_mem_closure.mpr hxp
  have hpU : p.1 ∈ U := hsp.mem_open U.isOpen hx
  have hunit := ha.map (X.presheaf.stalkSpecializes hsp).hom
  have heq : algebraMap (X.presheaf.stalk p.1) X.functionField
      (X.presheaf.stalkSpecializes hsp a) = s * g := by
    rw [algebraMap_stalkSpecializes, hea]
  have hord := order_stalk_unit p hunit
  rw [heq, X.ord_mul hs hg, ← hDg p hpU] at hord
  exact (Finsupp.mem_support_iff.mp hp) hord
end NonvanishingLocal
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
universe u

lemma stalkPrime_eq_comap_closedPoint {X : Scheme.{u}} (x : X)
    (p : PrimeSpectrum (X.presheaf.stalk x))
    (h : X.fromSpecStalk x p ⤳ x) :
    p = PrimeSpectrum.comap (X.presheaf.stalkSpecializes h).hom
      (IsLocalRing.closedPoint (X.presheaf.stalk (X.fromSpecStalk x p))) := by
  apply (X.fromSpecStalk x).isEmbedding.injective
  have he := congrArg (fun f : Spec (X.presheaf.stalk (X.fromSpecStalk x p)) ⟶ X =>
    f (IsLocalRing.closedPoint (X.presheaf.stalk (X.fromSpecStalk x p))))
    (X.SpecMap_stalkSpecializes_fromSpecStalk h)
  rw [Scheme.fromSpecStalk_closedPoint] at he
  exact he.symm

section LocalIntersection
variable {X : Scheme.{u}} [IsIntegral X] [IsLocallyNoetherian X]
  [StalkwiseNormal X] [CompactSpace X]

lemma fromSpecStalk_mem_support_of_mem_prime
    (D : WeilDivisor X) (g : X.functionField) (hg : g ≠ 0)
    (U : X.Opens) (hDg : ∀ q : PrimeDivisor X, q.1 ∈ U → D q = X.ord g q.1)
    (x : X) (hx : x ∈ U) (a : X.presheaf.stalk x)
    (ha : algebraMap (X.presheaf.stalk x) X.functionField a = g)
    (p : PrimeSpectrum (X.presheaf.stalk x)) (hap : a ∈ p.asIdeal) :
    X.fromSpecStalk x p ∈ divisorSupport D := by
  have hsp : X.fromSpecStalk x p ⤳ x := X.range_fromSpecStalk.subset ⟨p, rfl⟩
  by_contra hy
  have hone : principalWeilDivisor (1 : X.functionField) = 0 := by
    ext q
    exact order_one q.1
  obtain ⟨v, hv, hev⟩ := section_unit_stalk (D := D) (s := 1) one_ne_zero hg hDg
    (hsp.mem_open U.isOpen hx) (by simpa only [sectionNonvanishing, hone, zero_add, divisorComplement,
      TopologicalSpace.Opens.mem_mk, Set.mem_compl_iff] using hy)
  have hav : X.presheaf.stalkSpecializes hsp a = v := by
    apply IsFractionRing.injective (X.presheaf.stalk (X.fromSpecStalk x p)) X.functionField
    rw [algebraMap_stalkSpecializes, ha, hev, one_mul]
  have hap' : X.presheaf.stalkSpecializes hsp a ∈
      IsLocalRing.maximalIdeal (X.presheaf.stalk (X.fromSpecStalk x p)) := by
    rwa [stalkPrime_eq_comap_closedPoint x p hsp] at hap
  exact (mem_nonunits_iff.mp ((IsLocalRing.mem_maximalIdeal _).mp hap')) (hav ▸ hv)

theorem localIntersection_isFiniteLength
    (hdim : ∀ x : X, Order.coheight x ≤ 2)
    (D E : WeilDivisor X) (hDE : Disjoint D.support E.support)
    (g h : X.functionField) (hg : g ≠ 0) (hh : h ≠ 0)
    (U : X.Opens)
    (hDg : ∀ q : PrimeDivisor X, q.1 ∈ U → D q = X.ord g q.1)
    (hEh : ∀ q : PrimeDivisor X, q.1 ∈ U → E q = X.ord h q.1)
    (x : X) (hx : x ∈ U) (a b : X.presheaf.stalk x)
    (ha : algebraMap (X.presheaf.stalk x) X.functionField a = g)
    (hb : algebraMap (X.presheaf.stalk x) X.functionField b = h) :
    IsFiniteLength (X.presheaf.stalk x)
      ((X.presheaf.stalk x) ⧸ Ideal.span ({a, b} : Set (X.presheaf.stalk x))) := by
  let I : Ideal (X.presheaf.stalk x) := Ideal.span {a, b}
  have hpr : ∀ p : PrimeSpectrum (X.presheaf.stalk x), I ≤ p.asIdeal →
      p = IsLocalRing.closedPoint (X.presheaf.stalk x) := by
    intro p hp
    have hap : a ∈ p.asIdeal := hp (Ideal.subset_span (by simp))
    have hbp : b ∈ p.asIdeal := hp (Ideal.subset_span (by simp))
    have hyD := fromSpecStalk_mem_support_of_mem_prime D g hg U hDg x hx a ha p hap
    have hyE := fromSpecStalk_mem_support_of_mem_prime E h hh U hEh x hx b hb p hbp
    obtain ⟨q, hq, hqy⟩ := Set.mem_iUnion₂.mp hyD
    obtain ⟨r, hr, hry⟩ := Set.mem_iUnion₂.mp hyE
    have hqr : q ≠ r := by
      intro he
      exact Finset.disjoint_left.mp hDE hq (he ▸ hr)
    have hycl := closed_point_of_distinct_prime_intersection hdim q r hqr _ hqy hry
    have hsp : X.fromSpecStalk x p ⤳ x := X.range_fromSpecStalk.subset ⟨p, rfl⟩
    have hexy : x = X.fromSpecStalk x p := by
      have hmem := specializes_iff_mem_closure.mp hsp
      simpa only [hycl.closure_eq, Set.mem_singleton_iff] using hmem
    apply (X.fromSpecStalk x).isEmbedding.injective
    simpa only [Scheme.fromSpecStalk_closedPoint] using hexy.symm
  have : IsArtinianRing ((X.presheaf.stalk x) ⧸ I) := by
    rw [isArtinianRing_iff_krullDimLE_zero, Ring.krullDimLE_zero_iff]
    intro P hP
    let p : PrimeSpectrum (X.presheaf.stalk x) :=
      ⟨P.comap (Ideal.Quotient.mk I), hP.comap _⟩
    have hp : I ≤ p.asIdeal := by
      intro v hv
      change Ideal.Quotient.mk I v ∈ P
      rw [Ideal.Quotient.eq_zero_iff_mem.mpr hv]
      exact P.zero_mem
    have he := congrArg PrimeSpectrum.asIdeal (hpr p hp)
    have hm : (P.comap (Ideal.Quotient.mk I)).IsMaximal := by
      change p.asIdeal.IsMaximal
      rw [he]
      change (IsLocalRing.maximalIdeal (X.presheaf.stalk x)).IsMaximal
      infer_instance
    have him := Ideal.map_eq_top_or_isMaximal_of_surjective (Ideal.Quotient.mk I)
      Ideal.Quotient.mk_surjective hm
    rw [Ideal.map_comap_of_surjective _ Ideal.Quotient.mk_surjective] at him
    exact him.resolve_left hP.ne_top
  rw [isFiniteLength_iff_isNoetherian_isArtinian]
  exact ⟨isNoetherian_quotient I,
    isArtinian_of_surjective_algebraMap (Ideal.Quotient.mk_surjective (I := I))⟩
end LocalIntersection
end NumericalDimensionOne

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

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

structure CartierStalkEquation (D : WeilDivisor X) (x : X) where
  openSet : X.Opens
  mem_openSet : x ∈ openSet
  function : X.functionField
  nonzero : function ≠ 0
  equation : ∀ p : PrimeDivisor X, p.1 ∈ openSet → D p = X.ord function p.1
  regular : X.presheaf.stalk x
  regular_eq : algebraMap (X.presheaf.stalk x) X.functionField regular = function

lemma exists_cartierStalkEquation {D : WeilDivisor X} (hD : IsCartierDivisor D)
    (heff : ∀ p, 0 ≤ D p) (x : X) : Nonempty (CartierStalkEquation D x) := by
  obtain ⟨U, hU, hx, g, hg, heq⟩ := hD x
  have hsec : IsDivisorSection D (1 : X.functionField) :=
    Or.inr (fun p => by simpa only [order_one, zero_add] using heff p)
  obtain ⟨a, ha⟩ := section_regular_stalk hsec hU hg heq hx
  exact ⟨⟨U, hx, g, hg, heq, a, by simpa only [one_mul] using ha⟩⟩

lemma cartierStalkEquation_ideal_eq {D : WeilDivisor X} {x : X}
    (a b : CartierStalkEquation D x) :
    Ideal.span ({a.regular} : Set (X.presheaf.stalk x)) = Ideal.span {b.regular} := by
  obtain ⟨v, hv, hev⟩ := local_equation_ratio_unit a.nonzero b.nonzero
    a.equation b.equation a.mem_openSet b.mem_openSet
  have heq : a.regular = v * b.regular := by
    apply IsFractionRing.injective (X.presheaf.stalk x) X.functionField
    rw [a.regular_eq, map_mul, hev, b.regular_eq, div_mul_cancel₀ _ b.nonzero]
  rw [heq, Ideal.span_singleton_mul_left_unit hv]

noncomputable def effectiveCartierStalkIdeal {D : WeilDivisor X}
    (hD : IsCartierDivisor D) (heff : ∀ p, 0 ≤ D p) (x : X) :
    Ideal (X.presheaf.stalk x) :=
  Ideal.span {(Classical.choice (exists_cartierStalkEquation hD heff x)).regular}

lemma effectiveCartierStalkIdeal_eq {D : WeilDivisor X}
    (hD : IsCartierDivisor D) (heff : ∀ p, 0 ≤ D p) {x : X}
    (a : CartierStalkEquation D x) :
    effectiveCartierStalkIdeal hD heff x = Ideal.span {a.regular} := by
  exact cartierStalkEquation_ideal_eq _ a

noncomputable def effectiveCartierMultiplicity {D E : WeilDivisor X}
    (hD : IsCartierDivisor D) (hE : IsCartierDivisor E)
    (hDeff : ∀ p, 0 ≤ D p) (hEeff : ∀ p, 0 ≤ E p) (x : X) : ℕ∞ :=
  Module.length (X.presheaf.stalk x)
    ((X.presheaf.stalk x) ⧸
      (effectiveCartierStalkIdeal hD hDeff x ⊔ effectiveCartierStalkIdeal hE hEeff x))

lemma effectiveCartierMultiplicity_comm {D E : WeilDivisor X}
    (hD : IsCartierDivisor D) (hE : IsCartierDivisor E)
    (hDeff : ∀ p, 0 ≤ D p) (hEeff : ∀ p, 0 ≤ E p) (x : X) :
    effectiveCartierMultiplicity hD hE hDeff hEeff x =
      effectiveCartierMultiplicity hE hD hEeff hDeff x := by
  exact (Submodule.quotEquivOfEq _ _ (sup_comm
    (effectiveCartierStalkIdeal hD hDeff x)
    (effectiveCartierStalkIdeal hE hEeff x))).length_eq

variable [CompactSpace X]

lemma effectiveCartierStalkIdeal_eq_top {D : WeilDivisor X}
    (hD : IsCartierDivisor D) (heff : ∀ p, 0 ≤ D p) {x : X}
    (hx : x ∉ divisorSupport D) : effectiveCartierStalkIdeal hD heff x = ⊤ := by
  let a := Classical.choice (exists_cartierStalkEquation hD heff x)
  have hone : principalWeilDivisor (1 : X.functionField) = 0 := by
    ext q
    exact order_one q.1
  obtain ⟨v, hv, hev⟩ := section_unit_stalk (D := D) (s := 1) one_ne_zero a.nonzero
    a.equation a.mem_openSet (by simpa only [sectionNonvanishing, hone, zero_add,
      divisorComplement, TopologicalSpace.Opens.mem_mk, Set.mem_compl_iff] using hx)
  have ha : a.regular = v := IsFractionRing.injective (X.presheaf.stalk x) X.functionField
    (a.regular_eq.trans (by simpa only [one_mul] using hev.symm))
  rw [effectiveCartierStalkIdeal_eq hD heff a, Ideal.span_singleton_eq_top]
  exact ha ▸ hv

lemma effectiveCartierMultiplicity_eq_zero {D E : WeilDivisor X}
    (hD : IsCartierDivisor D) (hE : IsCartierDivisor E)
    (hDeff : ∀ p, 0 ≤ D p) (hEeff : ∀ p, 0 ≤ E p) {x : X}
    (hx : x ∉ divisorSupport D ∩ divisorSupport E) :
    effectiveCartierMultiplicity hD hE hDeff hEeff x = 0 := by
  have htop : effectiveCartierStalkIdeal hD hDeff x ⊔
      effectiveCartierStalkIdeal hE hEeff x = ⊤ := by
    by_cases hxD : x ∈ divisorSupport D
    · rw [effectiveCartierStalkIdeal_eq_top hE hEeff (fun hxE => hx ⟨hxD, hxE⟩), sup_top_eq]
    · rw [effectiveCartierStalkIdeal_eq_top hD hDeff hxD, top_sup_eq]
  apply Module.length_eq_zero_iff.mpr
  exact Submodule.Quotient.subsingleton_iff.mpr htop

lemma effectiveCartierMultiplicity_ne_top
    (hdim : ∀ x : X, Order.coheight x ≤ 2)
    {D E : WeilDivisor X} (hD : IsCartierDivisor D) (hE : IsCartierDivisor E)
    (hDeff : ∀ p, 0 ≤ D p) (hEeff : ∀ p, 0 ≤ E p)
    (hDE : Disjoint D.support E.support) (x : X) :
    effectiveCartierMultiplicity hD hE hDeff hEeff x ≠ ⊤ := by
  let a := Classical.choice (exists_cartierStalkEquation hD hDeff x)
  let b := Classical.choice (exists_cartierStalkEquation hE hEeff x)
  rw [effectiveCartierMultiplicity, effectiveCartierStalkIdeal_eq hD hDeff a,
    effectiveCartierStalkIdeal_eq hE hEeff b, ← Ideal.span_insert,
    Module.length_ne_top_iff]
  exact localIntersection_isFiniteLength hdim D E hDE a.function b.function a.nonzero b.nonzero
    (a.openSet ⊓ b.openSet) (fun p hp => a.equation p hp.1) (fun p hp => b.equation p hp.2)
    x ⟨a.mem_openSet, b.mem_openSet⟩ a.regular b.regular a.regular_eq b.regular_eq

lemma effectiveCartierMultiplicity_finite_support
    (hdim : ∀ x : X, Order.coheight x ≤ 2)
    {D E : WeilDivisor X} (hD : IsCartierDivisor D) (hE : IsCartierDivisor E)
    (hDeff : ∀ p, 0 ≤ D p) (hEeff : ∀ p, 0 ≤ E p)
    (hDE : Disjoint D.support E.support) :
    (Function.support (effectiveCartierMultiplicity hD hE hDeff hEeff)).Finite := by
  have : AlgebraicGeometry.IsNoetherian X := ⟨⟩
  apply (finite_divisorSupport_intersection hdim D E hDE).subset
  intro x hx
  by_contra he
  exact hx (effectiveCartierMultiplicity_eq_zero hD hE hDeff hEeff he)
end CartierIntersection
end NumericalDimensionOne

end OAI