import Mathlib
import OAI.AlgebraicGeometry.NumericalDimension.CanonicalChains
import OAI.AlgebraicGeometry.NumericalDimension.DifferentialBaseChange

namespace OAI

/-! Terminal Models. -/

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

namespace NumericalDimensionOne
theorem smooth_relative_canonical_strict
    (X Y : ComplexProjectiveVariety) (n : ℕ)
    (hX : IsSmoothNfold X n) (hY : IsSmoothNfold Y n)
    (f : X.scheme ⟶ Y.scheme) [IsDominant f]
    (hb : IsBirationalMorphism f)
    (hf : f ≫ Y.structureMap = X.structureMap)
    (ω : rationalTopForms (.of ℂ) Y.structureMap n)
    (DX : WeilDivisor X.scheme) (DY : WeilDivisor Y.scheme)
    (hDX : IsCanonicalDivisorOf (.of ℂ) X.structureMap n
      (rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n ω) DX)
    (hDY : IsCanonicalDivisorOf (.of ℂ) Y.structureMap n ω DY)
    (P : WeilDivisor X.scheme) (hP : IsCartierPullback f DY P) :
    ∀ p : PrimeDivisor X.scheme, 1 < Order.coheight (f p.1) → 0 < (DX - P) p := by
  classical
  let : SmoothOfRelativeDimension n X.structureMap := hX
  let : SmoothOfRelativeDimension n Y.structureMap := hY
  let : StalkwiseNormal X.scheme := smoothNormal X hX
  let : StalkwiseNormal Y.scheme := smoothNormal Y hY
  let := schemeFieldAlgebra (.of ℂ) X.structureMap
  let := schemeFieldAlgebra (.of ℂ) Y.structureMap
  let : Algebra Y.scheme.functionField X.scheme.functionField :=
    (dominantFunctionFieldMap f).toAlgebra
  let : IsScalarTower ℂ Y.scheme.functionField X.scheme.functionField :=
    IsScalarTower.of_algebraMap_eq (fun a =>
      (dominantFunctionFieldMap_scalar (.of ℂ) X.structureMap Y.structureMap f hf a).symm)
  intro p hp
  change 0 < DX p - P p
  obtain ⟨U, hU, hpU, hs⟩ := exists_standard_smooth_chart Y.structureMap n (f p.1)
  let : Nonempty U := ⟨⟨f p.1, hpU⟩⟩
  let := schemeOpenAlgebra Y.structureMap U
  let : Algebra.IsStandardSmoothOfRelativeDimension n ℂ Γ(Y.scheme, U) := hs
  let : Algebra.IsStandardSmooth ℂ Γ(Y.scheme, U) :=
    Algebra.IsStandardSmoothOfRelativeDimension.isStandardSmooth n
  let := open_field_scalar_tower Y.structureMap U
  let := functionField_isFractionRing_of_isAffineOpen Y.scheme U hU
  let : Algebra.FormallyEtale Γ(Y.scheme, U) Y.scheme.functionField :=
    Algebra.FormallyEtale.of_isLocalization (nonZeroDivisors Γ(Y.scheme, U))
  obtain ⟨bU⟩ := nonempty_topDifferential_basis ℂ Γ(Y.scheme, U) n
  let bF := (topDifferential_isBaseChange ℂ Γ(Y.scheme, U) Y.scheme.functionField n).basis bU
  let a := bF.repr ω 0
  have heq : ω = a • topDifferentialMap ℂ Γ(Y.scheme, U) Y.scheme.functionField n (bU 0) := by
    simpa only [bF, IsBaseChange.basis_apply] using basis_singleton_repr bF ω
  have ha : a ≠ 0 := by
    intro h
    exact hDY.1 (by simpa [h] using heq)
  have hDa := canonical_chart_equation Y.structureMap n hDY U hU hs bU a ha heq
  have hPa := hP.order_eq_of_equation ha hDa p hpU
  let := schemeStalkAlgebra (.of ℂ) X.structureMap p.1
  let := stalk_field_scalar_tower (.of ℂ) X.structureMap p.1
  let u : U := ⟨f p.1, hpU⟩
  let := schemeStalkAlgebra (.of ℂ) Y.structureMap (f p.1)
  let := TopCat.Presheaf.algebra_section_stalk Y.scheme.presheaf u
  let := open_stalk_scalar_tower Y.structureMap U u
  let : Algebra Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) :=
    ((f.stalkMap p.1).hom.comp (Y.scheme.presheaf.germ U (f p.1) hpU).hom).toAlgebra
  let : IsScalarTower ℂ Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) := by
    apply IsScalarTower.of_algebraMap_eq
    intro z
    change schemeStalkScalar (.of ℂ) X.structureMap p.1 z =
      f.stalkMap p.1 (algebraMap Γ(Y.scheme, U) (Y.scheme.presheaf.stalk (f p.1))
        (algebraMap ℂ Γ(Y.scheme, U) z))
    rw [← IsScalarTower.algebraMap_apply]
    exact (dominant_stalk_scalar (.of ℂ) X.structureMap Y.structureMap f hf p.1 z).symm
  let : Algebra Γ(Y.scheme, U) X.scheme.functionField :=
    ((dominantFunctionFieldMap f).comp (Y.scheme.germToFunctionField U).hom).toAlgebra
  let : IsScalarTower Γ(Y.scheme, U) Y.scheme.functionField X.scheme.functionField := by
    apply IsScalarTower.of_algebraMap_eq
    intro z
    rfl
  let : IsScalarTower ℂ Γ(Y.scheme, U) X.scheme.functionField := by
    apply IsScalarTower.of_algebraMap_eq
    intro z
    change algebraMap ℂ X.scheme.functionField z =
      dominantFunctionFieldMap f
        (algebraMap Γ(Y.scheme, U) Y.scheme.functionField (algebraMap ℂ Γ(Y.scheme, U) z))
    rw [← IsScalarTower.algebraMap_apply]
    exact (dominantFunctionFieldMap_scalar (.of ℂ) X.structureMap Y.structureMap f hf z).symm
  let : IsScalarTower Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) X.scheme.functionField := by
    apply IsScalarTower.of_algebraMap_eq
    intro z
    change dominantFunctionFieldMap f (Y.scheme.germToFunctionField U z) =
      algebraMap (X.scheme.presheaf.stalk p.1) X.scheme.functionField
        (f.stalkMap p.1 (Y.scheme.presheaf.germ U (f p.1) hpU z))
    rw [← dominantFunctionFieldMap_algebraMap, Y.scheme.algebraMap_germ_eq_germToFunctionField]
  obtain ⟨bp⟩ := nonempty_smooth_canonical_stalk_basis X.structureMap n p.1
  let v := topDifferentialMap ℂ Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) n (bU 0)
  let c := bp.repr v 0
  have hc : v = c • bp 0 := basis_singleton_repr bp v
  dsimp only [v] at hc
  let cf := algebraMap (X.scheme.presheaf.stalk p.1) X.scheme.functionField c
  have hpull : rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n ω =
      (dominantFunctionFieldMap f a * cf) •
        topDifferentialMap ℂ (X.scheme.presheaf.stalk p.1) X.scheme.functionField n (bp 0) := by
    change topDifferentialMap ℂ Y.scheme.functionField X.scheme.functionField n ω = _
    rw [heq, map_smul, ← IsScalarTower.algebraMap_smul X.scheme.functionField a]
    have hcomp₁ := LinearMap.congr_fun (topDifferentialMap_comp ℂ Γ(Y.scheme, U)
      Y.scheme.functionField X.scheme.functionField n) (bU 0)
    have hcomp₂ := LinearMap.congr_fun (topDifferentialMap_comp ℂ Γ(Y.scheme, U)
      (X.scheme.presheaf.stalk p.1) X.scheme.functionField n) (bU 0)
    simp only [LinearMap.comp_apply, LinearMap.restrictScalars_apply] at hcomp₁ hcomp₂
    change _ • _ = _
    rw [hcomp₁, ← hcomp₂, hc, map_smul,
      ← IsScalarTower.algebraMap_smul X.scheme.functionField c, ← mul_smul]
    rfl
  have hprod : dominantFunctionFieldMap f a * cf ≠ 0 := by
    intro h
    exact hDX.1 (by simpa [h] using hpull)
  have hcf : cf ≠ 0 := (mul_ne_zero_iff.mp hprod).2
  obtain ⟨cp, a', ha', heq', hDXp⟩ := hDX.2 p
  have hDXord := canonical_local_order_unique X.structureMap n p _ cp bp a'
    (dominantFunctionFieldMap f a * cf) hDX.1 ha' hprod heq' hpull
  rw [hDXp, hDXord, X.scheme.ord_mul ((map_ne_zero _).mpr ha) hcf, hPa]
  have hcpos : 0 ≤ X.scheme.ord cf p.1 :=
    (ord_nonnegative_iff_regular p cf hcf).mpr ⟨c, rfl⟩
  suffices h : 0 < X.scheme.ord cf p.1 by omega
  by_contra hn
  have hz : X.scheme.ord cf p.1 = 0 := by omega
  have hi : 0 ≤ X.scheme.ord cf⁻¹ p.1 := by
    rw [order_inv cf hcf, hz]
    simp
  obtain ⟨d, hd⟩ := (ord_nonnegative_iff_regular p cf⁻¹ (inv_ne_zero hcf)).mp hi
  have hunit : IsUnit c := by
    apply IsUnit.of_mul_eq_one d
    apply IsFractionRing.injective (X.scheme.presheaf.stalk p.1) X.scheme.functionField
    rw [map_mul, hd, map_one]
    exact mul_inv_cancel₀ hcf
  obtain ⟨bA⟩ := nonempty_standardSmooth_differential_basis ℂ Γ(Y.scheme, U) n
  obtain ⟨bB⟩ := nonempty_smooth_stalk_differential_basis X.structureMap n p.1
  let : Algebra.FormallyUnramified Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) :=
    formallyUnramified_of_topDifferential_unit ℂ Γ(Y.scheme, U)
      (X.scheme.presheaf.stalk p.1) n bA bB bp (bU 0) hunit
  let : Algebra (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1) :=
    (f.stalkMap p.1).hom.toAlgebra
  let : IsScalarTower Γ(Y.scheme, U) (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) := IsScalarTower.of_algebraMap_eq (fun _ => rfl)
  let : Algebra.FormallyUnramified (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) :=
    Algebra.FormallyUnramified.of_restrictScalars Γ(Y.scheme, U)
      (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1)
  let : LocallyOfFiniteType (f ≫ Y.structureMap) := hf.symm ▸ inferInstance
  let : LocallyOfFiniteType f := locallyOfFiniteType_of_comp f Y.structureMap
  let : Algebra.EssFiniteType (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1) :=
    LocallyOfFiniteType.stalkMap f p.1
  have hcod := birational_quasiFinite_stalk_coheight f hb p.1 inferInstance
  rw [hcod, p.2] at hp
  exact lt_irrefl _ hp
end NumericalDimensionOne

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

namespace NumericalDimensionOne

theorem smooth_isTerminalModel {n : ℕ} (Y : CanonicalModel n)
    (hY : IsSmoothNfold Y.toComplexProjectiveVariety n) : IsTerminalModel Y := by
  let : StalkwiseNormal Y.scheme := Y.normal
  intro W hW f hdom _hbProper hbir hf KW hKW Q hQ p hp
  let : IsDominant f := hdom
  obtain ⟨P, hP⟩ := exists_cartierPullback f Y.canonical (canonicalModel_isCartier Y hY)
  rw [IsQCartierPullback.eq_integral hP hQ]
  have h := smooth_relative_canonical_strict W Y.toComplexProjectiveVariety n hW hY
    f hbir hf Y.form KW Y.canonical hKW Y.canonical_of_form P hP p hp
  change 0 < KW p - P p at h
  change (0 : ℚ) < (KW p : ℚ) - (P p : ℚ)
  exact_mod_cast h
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 canonical_coefficient_of_stalk_iso
    (X Y : ComplexProjectiveVariety) (n : ℕ) (hY : IsSmoothNfold Y n)
    (f : X.scheme ⟶ Y.scheme) [IsDominant f]
    (hf : f ≫ Y.structureMap = X.structureMap)
    (ω : rationalTopForms (.of ℂ) Y.structureMap n)
    (DX : WeilDivisor X.scheme) (DY : WeilDivisor Y.scheme)
    (hDX : IsCanonicalDivisorOf (.of ℂ) X.structureMap n
      (rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n ω) DX)
    (hDY : IsCanonicalDivisorOf (.of ℂ) Y.structureMap n ω DY)
    (p : PrimeDivisor X.scheme) [IsIso (f.stalkMap p.1)]
    (hp : Order.coheight (f p.1) = 1) : DX p = DY ⟨f p.1,hp⟩ := by
  let : SmoothOfRelativeDimension n Y.structureMap := hY
  let := schemeStalkAlgebra (.of ℂ) Y.structureMap (f p.1)
  let := schemeStalkAlgebra (.of ℂ) X.structureMap p.1
  let := schemeFieldAlgebra (.of ℂ) Y.structureMap
  let := schemeFieldAlgebra (.of ℂ) X.structureMap
  let := stalk_field_scalar_tower (.of ℂ) Y.structureMap (f p.1)
  let := stalk_field_scalar_tower (.of ℂ) X.structureMap p.1
  let : Algebra Y.scheme.functionField X.scheme.functionField :=
    (dominantFunctionFieldMap f).toAlgebra
  let : IsScalarTower ℂ Y.scheme.functionField X.scheme.functionField :=
    IsScalarTower.of_algebraMap_eq (fun a =>
      (dominantFunctionFieldMap_scalar (.of ℂ) X.structureMap Y.structureMap f hf a).symm)
  let : Algebra (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1) :=
    (f.stalkMap p.1).hom.toAlgebra
  let : IsScalarTower ℂ (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) :=
    IsScalarTower.of_algebraMap_eq (fun a =>
      (dominant_stalk_scalar (.of ℂ) X.structureMap Y.structureMap f hf p.1 a).symm)
  let : Algebra (Y.scheme.presheaf.stalk (f p.1)) X.scheme.functionField :=
    ((dominantFunctionFieldMap f).comp
      (algebraMap (Y.scheme.presheaf.stalk (f p.1)) Y.scheme.functionField)).toAlgebra
  let : IsScalarTower (Y.scheme.presheaf.stalk (f p.1))
      Y.scheme.functionField X.scheme.functionField :=
    IsScalarTower.of_algebraMap_eq (fun _ => rfl)
  let : IsScalarTower (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) X.scheme.functionField :=
    IsScalarTower.of_algebraMap_eq (fun a => dominantFunctionFieldMap_algebraMap f p.1 a)
  let : IsScalarTower ℂ (Y.scheme.presheaf.stalk (f p.1)) X.scheme.functionField := by
    apply IsScalarTower.of_algebraMap_eq
    intro a
    change algebraMap ℂ X.scheme.functionField a =
      dominantFunctionFieldMap f
        (algebraMap (Y.scheme.presheaf.stalk (f p.1)) Y.scheme.functionField
          (algebraMap ℂ (Y.scheme.presheaf.stalk (f p.1)) a))
    rw [← IsScalarTower.algebraMap_apply]
    exact (dominantFunctionFieldMap_scalar (.of ℂ) X.structureMap Y.structureMap f hf a).symm
  let : Module.Free (Y.scheme.presheaf.stalk (f p.1))
      Ω[Y.scheme.presheaf.stalk (f p.1)⁄ℂ] :=
    smooth_stalk_differentials_free Y.structureMap n (f p.1)
  let e := AlgEquiv.ofBijective
    (Algebra.ofId (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1))
    (ConcreteCategory.bijective_of_isIso (f.stalkMap p.1))
  let : Algebra.FormallyEtale (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) := Algebra.FormallyEtale.of_equiv e
  obtain ⟨b,a,ha,hω,hDYp⟩ := hDY.2 ⟨f p.1,hp⟩
  let bp := (topDifferential_isBaseChange ℂ (Y.scheme.presheaf.stalk (f p.1))
    (X.scheme.presheaf.stalk p.1) n).basis b
  have hωp : rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n ω =
      dominantFunctionFieldMap f a • topDifferentialMap ℂ (X.scheme.presheaf.stalk p.1)
        X.scheme.functionField n (bp 0) := by
    change topDifferentialMap ℂ Y.scheme.functionField X.scheme.functionField n ω = _
    rw [hω,map_smul,← IsScalarTower.algebraMap_smul X.scheme.functionField a]
    rw [(topDifferential_isBaseChange ℂ (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) n).basis_apply]
    have h₁ := LinearMap.congr_fun (topDifferentialMap_comp ℂ
      (Y.scheme.presheaf.stalk (f p.1)) Y.scheme.functionField X.scheme.functionField n) (b 0)
    have h₂ := LinearMap.congr_fun (topDifferentialMap_comp ℂ
      (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1)
        X.scheme.functionField n) (b 0)
    exact congrArg (fun z => dominantFunctionFieldMap f a • z) (h₁.trans h₂.symm)
  obtain ⟨c,a',ha',hω',hDXp⟩ := hDX.2 p
  rw [hDXp,canonical_local_order_unique X.structureMap n p _ c bp a'
    (dominantFunctionFieldMap f a) hDX.1 ha' ((map_ne_zero _).mpr ha) hω' hωp,
    order_dominantFunctionFieldMap_of_stalk_iso f p hp a ha,hDYp]
lemma canonical_comparison_strict_source_primes {n : ℕ}
    (X Y : CanonicalModel n) (hX : IsSmoothNfold X.toComplexProjectiveVariety n)
    (hY : IsTerminalModel Y) (W : ComplexProjectiveVariety) (hW : IsSmoothNfold W n)
    (p : W.scheme ⟶ X.scheme) (q : W.scheme ⟶ Y.scheme)
    [IsDominant p] [IsDominant q] [IsProper p] [IsProper q]
    (hpb : IsBirationalMorphism p) (hqb : IsBirationalMorphism q)
    (hp : p ≫ X.structureMap = W.structureMap) (hq : q ≫ Y.structureMap = W.structureMap)
    (KW : WeilDivisor W.scheme)
    (hKp : IsCanonicalDivisorOf (.of ℂ) W.structureMap n
      (rationalTopFormPullback (.of ℂ) W.structureMap X.structureMap p hp n X.form) KW)
    (hKq : IsCanonicalDivisorOf (.of ℂ) W.structureMap n
      (rationalTopFormPullback (.of ℂ) W.structureMap Y.structureMap q hq n Y.form) KW)
    (P Q : QWeilDivisor W.scheme)
    (hP : IsQCartierPullback p (rationalWeilDivisor X.canonical) P)
    (hQ : IsQCartierPullback q (rationalWeilDivisor Y.canonical) Q)
    (F : PrimeDivisor W.scheme) (hFp : Order.coheight (p F.1) = 1)
    (hFq : 1 < Order.coheight (q F.1)) : 0 < (P - Q) F := by
  obtain ⟨G,_hG,hiso,hunique⟩ := exists_unique_prime_over_of_proper_birational
    p hpb ⟨p F.1,hFp⟩
  have hFG : F = G := Subtype.ext (hunique F.1 rfl)
  subst G
  let : IsIso (p.stalkMap F.1) := hiso
  have hKW := canonical_coefficient_of_stalk_iso W X.toComplexProjectiveVariety n hX
    p hp X.form KW X.canonical hKp X.canonical_of_form F hFp
  obtain ⟨A,hA⟩ := exists_cartierPullback p X.canonical (canonicalModel_isCartier X hX)
  have hPa := IsQCartierPullback.eq_integral hA hP
  have hPF : P F = (KW F : ℚ) := by
    rw [hPa]
    change (A F : ℚ) = (KW F : ℚ)
    exact congrArg (fun z : ℤ => (z : ℚ))
      ((hA.coeff_eq_of_stalk_iso p F hFp).trans hKW.symm)
  have ht := hY W hW q inferInstance inferInstance hqb hq KW hKq Q hQ F hFq
  change 0 < P F - Q F
  rw [hPF]
  exact ht
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open scoped TensorProduct
lemma Kaehler_free_of_algebraMap_bijective (k A B : Type*)
    [CommRing k] [CommRing A] [CommRing B]
    [Algebra k A] [Algebra k B] [Algebra A B] [IsScalarTower k A B]
    [Module.Free B Ω[B⁄k]] (he : Function.Bijective (algebraMap A B)) :
    Module.Free A Ω[A⁄k] := by
  let e := AlgEquiv.ofBijective (Algebra.ofId A B) he
  let : Algebra.FormallyEtale A B := Algebra.FormallyEtale.of_equiv e
  let : Module.Free A B := Module.Free.of_equiv e.toLinearEquiv
  let : Module.Free A Ω[B⁄k] := Module.Free.trans (S := B)
  let h := KaehlerDifferential.isBaseChange_of_formallyEtale k A B
  let u := (TensorProduct.congr e.symm.toLinearEquiv (LinearEquiv.refl A Ω[A⁄k])).trans
    (TensorProduct.lid A Ω[A⁄k])
  exact Module.Free.of_equiv ((h.equiv.restrictScalars A).symm.trans u)
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 canonical_coefficient_of_smooth_source_stalk_iso
    (X Y : ComplexProjectiveVariety) (n : ℕ) (hX : IsSmoothNfold X n)
    (f : X.scheme ⟶ Y.scheme) [IsDominant f]
    (hf : f ≫ Y.structureMap = X.structureMap)
    (ω : rationalTopForms (.of ℂ) Y.structureMap n)
    (DX : WeilDivisor X.scheme) (DY : WeilDivisor Y.scheme)
    (hDX : IsCanonicalDivisorOf (.of ℂ) X.structureMap n
      (rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n ω) DX)
    (hDY : IsCanonicalDivisorOf (.of ℂ) Y.structureMap n ω DY)
    (p : PrimeDivisor X.scheme) [IsIso (f.stalkMap p.1)]
    (hp : Order.coheight (f p.1) = 1) : DX p = DY ⟨f p.1,hp⟩ := by
  let : SmoothOfRelativeDimension n X.structureMap := hX
  let := schemeStalkAlgebra (.of ℂ) Y.structureMap (f p.1)
  let := schemeStalkAlgebra (.of ℂ) X.structureMap p.1
  let := schemeFieldAlgebra (.of ℂ) Y.structureMap
  let := schemeFieldAlgebra (.of ℂ) X.structureMap
  let := stalk_field_scalar_tower (.of ℂ) Y.structureMap (f p.1)
  let := stalk_field_scalar_tower (.of ℂ) X.structureMap p.1
  let : Algebra Y.scheme.functionField X.scheme.functionField :=
    (dominantFunctionFieldMap f).toAlgebra
  let : IsScalarTower ℂ Y.scheme.functionField X.scheme.functionField :=
    IsScalarTower.of_algebraMap_eq (fun a =>
      (dominantFunctionFieldMap_scalar (.of ℂ) X.structureMap Y.structureMap f hf a).symm)
  let : Algebra (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1) :=
    (f.stalkMap p.1).hom.toAlgebra
  let : IsScalarTower ℂ (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) :=
    IsScalarTower.of_algebraMap_eq (fun a =>
      (dominant_stalk_scalar (.of ℂ) X.structureMap Y.structureMap f hf p.1 a).symm)
  let : Algebra (Y.scheme.presheaf.stalk (f p.1)) X.scheme.functionField :=
    ((dominantFunctionFieldMap f).comp
      (algebraMap (Y.scheme.presheaf.stalk (f p.1)) Y.scheme.functionField)).toAlgebra
  let : IsScalarTower (Y.scheme.presheaf.stalk (f p.1))
      Y.scheme.functionField X.scheme.functionField :=
    IsScalarTower.of_algebraMap_eq (fun _ => rfl)
  let : IsScalarTower (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) X.scheme.functionField :=
    IsScalarTower.of_algebraMap_eq (fun a => dominantFunctionFieldMap_algebraMap f p.1 a)
  let : IsScalarTower ℂ (Y.scheme.presheaf.stalk (f p.1)) X.scheme.functionField := by
    apply IsScalarTower.of_algebraMap_eq
    intro a
    change algebraMap ℂ X.scheme.functionField a =
      dominantFunctionFieldMap f
        (algebraMap (Y.scheme.presheaf.stalk (f p.1)) Y.scheme.functionField
          (algebraMap ℂ (Y.scheme.presheaf.stalk (f p.1)) a))
    rw [← IsScalarTower.algebraMap_apply]
    exact (dominantFunctionFieldMap_scalar (.of ℂ) X.structureMap Y.structureMap f hf a).symm
  let : Module.Free (X.scheme.presheaf.stalk p.1)
      Ω[X.scheme.presheaf.stalk p.1⁄ℂ] :=
    smooth_stalk_differentials_free X.structureMap n p.1
  let : Module.Free (Y.scheme.presheaf.stalk (f p.1))
      Ω[Y.scheme.presheaf.stalk (f p.1)⁄ℂ] :=
    Kaehler_free_of_algebraMap_bijective ℂ (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) (ConcreteCategory.bijective_of_isIso (f.stalkMap p.1))
  let e := AlgEquiv.ofBijective
    (Algebra.ofId (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1))
    (ConcreteCategory.bijective_of_isIso (f.stalkMap p.1))
  let : Algebra.FormallyEtale (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) := Algebra.FormallyEtale.of_equiv e
  obtain ⟨b,a,ha,hω,hDYp⟩ := hDY.2 ⟨f p.1,hp⟩
  let bp := (topDifferential_isBaseChange ℂ (Y.scheme.presheaf.stalk (f p.1))
    (X.scheme.presheaf.stalk p.1) n).basis b
  have hωp : rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n ω =
      dominantFunctionFieldMap f a • topDifferentialMap ℂ (X.scheme.presheaf.stalk p.1)
        X.scheme.functionField n (bp 0) := by
    change topDifferentialMap ℂ Y.scheme.functionField X.scheme.functionField n ω = _
    rw [hω,map_smul,← IsScalarTower.algebraMap_smul X.scheme.functionField a]
    rw [(topDifferential_isBaseChange ℂ (Y.scheme.presheaf.stalk (f p.1))
      (X.scheme.presheaf.stalk p.1) n).basis_apply]
    have h₁ := LinearMap.congr_fun (topDifferentialMap_comp ℂ
      (Y.scheme.presheaf.stalk (f p.1)) Y.scheme.functionField X.scheme.functionField n) (b 0)
    have h₂ := LinearMap.congr_fun (topDifferentialMap_comp ℂ
      (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1)
        X.scheme.functionField n) (b 0)
    exact congrArg (fun z => dominantFunctionFieldMap f a • z) (h₁.trans h₂.symm)
  obtain ⟨c,a',ha',hω',hDXp⟩ := hDX.2 p
  rw [hDXp,canonical_local_order_unique X.structureMap n p _ c bp a'
    (dominantFunctionFieldMap f a) hDX.1 ha' ((map_ne_zero _).mpr ha) hω' hωp,
    order_dominantFunctionFieldMap_of_stalk_iso f p hp a ha,hDYp]
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
lemma IsQCartierPullback.coeff_eq_of_stalk_iso
    {X Y : Scheme} [IsIntegral X] [IsIntegral Y]
    [IsLocallyNoetherian X] [IsLocallyNoetherian Y]
    (f : X ⟶ Y) [IsDominant f] (q : PrimeDivisor X)
    [IsIso (f.stalkMap q.1)] (hp : Order.coheight (f q.1) = 1)
    {D : QWeilDivisor Y} {P : QWeilDivisor X} (hP : IsQCartierPullback f D P) :
    P q = D ⟨f q.1,hp⟩ := by
  obtain ⟨m,hm,A,B,_hA,hD,hB,hAB⟩ := hP
  have hb := DFunLike.congr_fun hB q
  have hd := DFunLike.congr_fun hD ⟨f q.1,hp⟩
  change (m : ℚ) * P q = (B q : ℚ) at hb
  change (m : ℚ) * D ⟨f q.1,hp⟩ = (A ⟨f q.1,hp⟩ : ℚ) at hd
  apply mul_left_cancel₀ (show (m : ℚ) ≠ 0 by exact_mod_cast hm.ne')
  exact hb.trans ((congrArg (fun z : ℤ => (z : ℚ))
    (hAB.coeff_eq_of_stalk_iso f q hp)).trans hd.symm)
lemma relativeCanonical_vanishes_over_prime {n : ℕ}
    (Y : CanonicalModel n) (W : ComplexProjectiveVariety) (hW : IsSmoothNfold W n)
    (q : W.scheme ⟶ Y.scheme) [IsDominant q] [IsProper q]
    (hqb : IsBirationalMorphism q) (hq : q ≫ Y.structureMap = W.structureMap)
    (KW : WeilDivisor W.scheme)
    (hKq : IsCanonicalDivisorOf (.of ℂ) W.structureMap n
      (rationalTopFormPullback (.of ℂ) W.structureMap Y.structureMap q hq n Y.form) KW)
    (Q : QWeilDivisor W.scheme)
    (hQ : IsQCartierPullback q (rationalWeilDivisor Y.canonical) Q)
    (F : PrimeDivisor W.scheme) (hF : Order.coheight (q F.1) = 1) :
    (rationalWeilDivisor KW - Q) F = 0 := by
  obtain ⟨G,_hG,hiso,hunique⟩ := exists_unique_prime_over_of_proper_birational
    q hqb ⟨q F.1,hF⟩
  have hFG : F = G := Subtype.ext (hunique F.1 rfl)
  subst G
  let : IsIso (q.stalkMap F.1) := hiso
  have hKW := canonical_coefficient_of_smooth_source_stalk_iso W Y.toComplexProjectiveVariety
    n hW q hq Y.form KW Y.canonical hKq Y.canonical_of_form F hF
  have hQF := hQ.coeff_eq_of_stalk_iso q F hF
  change (KW F : ℚ) - Q F = 0
  rw [hQF]
  change (KW F : ℚ) - (Y.canonical ⟨q F.1,hF⟩ : ℚ) = 0
  rw [hKW,sub_self]
lemma relativeCanonical_effective_terminal {n : ℕ}
    (Y : CanonicalModel n) (hY : IsTerminalModel Y)
    (W : ComplexProjectiveVariety) (hW : IsSmoothNfold W n)
    (q : W.scheme ⟶ Y.scheme) [IsDominant q] [IsProper q]
    (hqb : IsBirationalMorphism q) (hq : q ≫ Y.structureMap = W.structureMap)
    (KW : WeilDivisor W.scheme)
    (hKq : IsCanonicalDivisorOf (.of ℂ) W.structureMap n
      (rationalTopFormPullback (.of ℂ) W.structureMap Y.structureMap q hq n Y.form) KW)
    (Q : QWeilDivisor W.scheme)
    (hQ : IsQCartierPullback q (rationalWeilDivisor Y.canonical) Q) :
    0 ≤ rationalWeilDivisor KW - Q ∧
      (∀ F : PrimeDivisor W.scheme, (rationalWeilDivisor KW - Q) F ≠ 0 ↔
        1 < Order.coheight (q F.1)) := by
  have hpos (F : PrimeDivisor W.scheme) : 0 < Order.coheight (q F.1) := by
    apply pos_iff_ne_zero.mpr
    intro he
    have hsp : q F.1 ⤳ genericPoint Y.scheme :=
      (Order.coheight_eq_zero.mp he) (genericPoint_specializes (q F.1))
    have heq := (hsp.antisymm (genericPoint_specializes (q F.1))).eq
    have hFη := birational_generic_fiber q hqb F.1 heq
    have h0 : Order.coheight F.1 = 0 := by
      rw [hFη]
      exact Order.coheight_eq_zero.mpr (fun x _ => genericPoint_specializes x)
    rw [F.2] at h0
    exact one_ne_zero h0
  have hone (F : PrimeDivisor W.scheme) : 1 ≤ Order.coheight (q F.1) :=
    Order.one_le_iff_ne_zero.mpr (ne_of_gt (hpos F))
  have hzero (F : PrimeDivisor W.scheme) (hF : Order.coheight (q F.1) = 1) :=
    relativeCanonical_vanishes_over_prime Y W hW q hqb hq KW hKq Q hQ F hF
  have hstrict (F : PrimeDivisor W.scheme) (hF : 1 < Order.coheight (q F.1)) :=
    hY W hW q inferInstance inferInstance hqb hq KW hKq Q hQ F hF
  constructor
  · intro F
    rcases (hone F).eq_or_lt with hF | hF
    · exact le_of_eq (hzero F hF.symm).symm
    · exact (hstrict F hF).le
  · intro F
    constructor
    · intro hn
      exact lt_of_le_of_ne (hone F) (fun he => hn (hzero F he.symm))
    · intro hF
      exact ne_of_gt (hstrict F hF)
end NumericalDimensionOne

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

namespace NumericalDimensionOne
open scoped TensorProduct
lemma topDifferentialMap_bijective_of_algebraMap_bijective (k A B : Type*)
    [CommRing k] [CommRing A] [CommRing B]
    [Algebra k A] [Algebra k B] [Algebra A B] [IsScalarTower k A B]
    [Module.Free A Ω[A⁄k]] (he : Function.Bijective (algebraMap A B)) (n : ℕ) :
    Function.Bijective (topDifferentialMap k A B n) := by
  let e := AlgEquiv.ofBijective (Algebra.ofId A B) he
  let : Algebra.FormallyEtale A B := Algebra.FormallyEtale.of_equiv e
  let h := topDifferential_isBaseChange k A B n
  let u := (TensorProduct.congr e.symm.toLinearEquiv
    (LinearEquiv.refl A (⋀[A]^n Ω[A⁄k]))).trans (TensorProduct.lid A (⋀[A]^n Ω[A⁄k]))
  let v := u.symm.trans (h.equiv.restrictScalars A)
  have hu (x : ⋀[A]^n Ω[A⁄k]) : u (1 ⊗ₜ[A] x) = x := by
    simp [u]
  have hv (x : ⋀[A]^n Ω[A⁄k]) : v x = topDifferentialMap k A B n x := by
    show h.equiv (u.symm x) = _
    have hs : u.symm x = 1 ⊗ₜ[A] x := (u.symm_apply_eq).mpr (hu x).symm
    rw [hs,IsBaseChange.equiv_tmul,one_smul]
  exact (show (v : (⋀[A]^n Ω[A⁄k]) → (⋀[B]^n Ω[B⁄k])) =
    topDifferentialMap k A B n from funext hv) ▸ v.bijective
end NumericalDimensionOne

end OAI