import Mathlib
import OAI.AlgebraicGeometry.NumericalDimension.BoundaryDiscrepancies
import OAI.AlgebraicGeometry.NumericalDimension.GenericMembers

namespace OAI

/-! Klt Members. -/

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace
open AlgebraicGeometry CategoryTheory Limits
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct

namespace NumericalDimensionOne
noncomputable section

def IsKltBoundary {n : ℕ} (Y : CanonicalModel n) (Δ : QWeilDivisor Y.scheme) : Prop :=
  0 ≤ Δ ∧ IsQCartierDivisor (rationalWeilDivisor Y.canonical + Δ) ∧
  ∀ W : ComplexProjectiveVariety, IsSmoothNfold W n →
    ∀ f : W.scheme ⟶ Y.scheme, ∀ (_ : IsDominant f),
      IsProper f → IsBirationalMorphism f →
      ∀ hf : f ≫ Y.structureMap = W.structureMap,
        ∀ KW : WeilDivisor W.scheme,
          IsCanonicalDivisorOf (.of ℂ) W.structureMap n
            (rationalTopFormPullback (.of ℂ) W.structureMap Y.structureMap f hf n Y.form) KW →
          ∀ P : QWeilDivisor W.scheme,
            IsQCartierPullback f (rationalWeilDivisor Y.canonical + Δ) P →
            ∀ p : PrimeDivisor W.scheme, -1 < (rationalWeilDivisor KW - P) p

lemma IsCartierPullback.zsmul {X Y : Scheme} [IsIntegral X] [IsIntegral Y]
    [IsLocallyNoetherian X] [IsLocallyNoetherian Y]
    {f : X ⟶ Y} [IsDominant f] {D : WeilDivisor Y} {P : WeilDivisor X}
    (hP : IsCartierPullback f D P) (z : ℤ) : IsCartierPullback f (z • D) (z • P) := by
  cases z with
  | ofNat m =>
      change IsCartierPullback f ((m : ℤ) • D) ((m : ℤ) • P)
      simpa only [natCast_zsmul] using hP.nsmul m
  | negSucc m => simpa only [negSucc_zsmul] using (hP.nsmul (m+1)).neg

lemma IsCartierPullback.rational {X Y : Scheme} [IsIntegral X] [IsIntegral Y]
    [IsLocallyNoetherian X] [IsLocallyNoetherian Y]
    {f : X ⟶ Y} [IsDominant f] {D : WeilDivisor Y} {P : WeilDivisor X}
    (hP : IsCartierPullback f D P) (hD : IsCartierDivisor D) :
    IsQCartierPullback f (rationalWeilDivisor D) (rationalWeilDivisor P) := by
  exact ⟨1,by decide,D,P,hD,by simp,by simp,hP⟩

lemma IsQCartierPullback.smul {X Y : Scheme} [IsIntegral X] [IsIntegral Y]
    [IsLocallyNoetherian X] [IsLocallyNoetherian Y]
    {f : X ⟶ Y} [IsDominant f] {D : QWeilDivisor Y} {P : QWeilDivisor X}
    (hP : IsQCartierPullback f D P) (t : ℚ) : IsQCartierPullback f (t • D) (t • P) := by
  obtain ⟨m,hm,A,B,hA,hAD,hBP,hAB⟩ := hP
  let M : CartierMultiple D := ⟨m,hm,⟨A,hA⟩,hAD⟩
  let N : CartierMultiple P := ⟨m,hm,⟨B,hAB.isCartier⟩,hBP⟩
  exact ⟨(M.smul t).denominator,(M.smul t).positive,(M.smul t).divisor.1,
    (N.smul t).divisor.1,(M.smul t).divisor.2,(M.smul t).equation,
    (N.smul t).equation,hAB.zsmul t.num⟩

theorem smooth_boundary_isKlt
    {n : ℕ} (Y : CanonicalModel n) (hY : IsSmoothNfold Y.toComplexProjectiveVariety n)
    (D : WeilDivisor Y.scheme) (hD : IsSmoothEffectiveCartierDivisor Y.toComplexProjectiveVariety D)
    (ε : ℚ) (hε : 0 ≤ ε) (hε1 : ε < 1) :
    IsKltBoundary Y (ε • rationalWeilDivisor D) := by
  have hK := canonicalModel_isCartier Y hY
  let M : CartierMultiple (rationalWeilDivisor Y.canonical) := ⟨1,by decide,⟨_,hK⟩,by simp⟩
  let N : CartierMultiple (rationalWeilDivisor D) := ⟨1,by decide,⟨_,hD.1⟩,by simp⟩
  let R := M.add (N.smul ε)
  refine ⟨?_,⟨R.denominator,R.positive,R.divisor.1,R.divisor.2,R.equation⟩,?_⟩
  · intro p
    change 0 ≤ ε * (D p : ℚ)
    exact mul_nonneg hε (by exact_mod_cast hD.2.1 p)
  intro W hW f hdom _hproper _hbir hf KW hKW Q hQ p
  let : IsDominant f := hdom
  let : StalkwiseNormal W.scheme := smoothNormal W hW
  obtain ⟨P,hP⟩ := exists_cartierPullback f Y.canonical hK
  obtain ⟨T,hT⟩ := exists_cartierPullback f D hD.1
  have he := hQ.unique ((hP.rational hK).add ((hT.rational hD.1).smul ε))
  rw [he]
  have ha := smooth_relative_canonical_effective W Y.toComplexProjectiveVariety n hW hY
    f hf Y.form KW Y.canonical hKW Y.canonical_of_form P hP p
  have hb := smooth_boundary_discrepancy_bound W Y.toComplexProjectiveVariety n hW hY
    f hf Y.form KW Y.canonical hKW Y.canonical_of_form P hP D hD T hT p
  have haQ : (0 : ℚ) ≤ (KW p : ℚ) - (P p : ℚ) := by exact_mod_cast ha
  have hbQ : (T p : ℚ) ≤ (KW p : ℚ) - (P p : ℚ) + 1 := by exact_mod_cast hb
  have hm := mul_le_mul_of_nonneg_left hbQ hε
  have hs : 0 < (1-ε)*((KW p : ℚ)-(P p : ℚ)+1) :=
    mul_pos (sub_pos.mpr hε1) (by linarith)
  change (-1 : ℚ) < (KW p : ℚ) - ((P p : ℚ) + ε*(T p : ℚ))
  nlinarith
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section
universe u

lemma constructible_constant_near_generic
    {T : Type*} [TopologicalSpace T] {g : T}
    (hg : IsGenericPoint g Set.univ) {S : Set T} (hS : IsConstructible S) :
    ∃ U : Opens T, g ∈ U ∧ ∀ x ∈ U, x ∈ S ↔ g ∈ S := by
  classical
  induction hS using IsConstructible.empty_union_induction with
  | open_retrocompact U hU _ =>
    by_cases h : g ∈ U
    · exact ⟨⟨U,hU⟩,h,fun x hx => iff_of_true hx h⟩
    · refine ⟨⊤,trivial,fun x _ => iff_of_false (fun hx => h ?_) h⟩
      exact (hg.specializes trivial).mem_open hU hx
  | union s hs t ht ihs iht =>
    obtain ⟨U,hU,hUs⟩ := ihs
    obtain ⟨V,hV,hVt⟩ := iht
    refine ⟨U ⊓ V,⟨hU,hV⟩,fun x hx => ?_⟩
    exact or_congr (hUs x hx.1) (hVt x hx.2)
  | compl s hs ih =>
    obtain ⟨U,hU,hUs⟩ := ih
    exact ⟨U,hU,fun x hx => not_congr (hUs x hx)⟩

theorem finiteType_generic_smooth_open
    {k : Type u} [Field k] [CharZero k] {X Y : Scheme.{u}}
    [IsIntegral Y] [NoetherianSpace X] [NoetherianSpace Y]
    (f : X ⟶ Y) (sY : Y ⟶ Spec (.of k))
    [LocallyOfFinitePresentation f] [LocallyOfFiniteType sY]
    [Smooth (f ≫ sY)] :
    ∃ U : Y.Opens, genericPoint Y ∈ U ∧ f ⁻¹ᵁ U ≤ f.smoothLocus := by
  let B : Set X := (f.smoothLocus : Set X)ᶜ
  have hB : IsConstructible B :=
    ((NoetherianSpace.isCompact (f.smoothLocus : Set X)).isConstructible
      f.smoothLocus.isOpen).compl
  obtain ⟨U,hU,hc⟩ := constructible_constant_near_generic (genericPoint_spec Y)
    (f.isConstructible_image hB)
  refine ⟨U,hU,fun x hx => ?_⟩
  by_contra h
  have hh := (hc (f x) hx).mp (Set.mem_image_of_mem f h)
  obtain ⟨z,hz,hzg⟩ := hh
  exact hz (smooth_at_generic_fiber f sY z hzg)
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
universe u v

theorem exists_avoiding_countable_polynomials
    {k : Type u} [Field k] [Uncountable k]
    {ι : Type v} [Countable ι] (n : ℕ)
    (p : ι → MvPolynomial (Fin n) k) (hp : ∀ i, p i ≠ 0) :
    ∃ a : Fin n → k, ∀ i, MvPolynomial.eval a (p i) ≠ 0 := by
  classical
  induction n with
  | zero =>
    let a : Fin 0 → k := Fin.elim0
    refine ⟨a,fun i hi => hp i ?_⟩
    have hinj : Function.Injective (MvPolynomial.aeval a :
        MvPolynomial (Fin 0) k →ₐ[k] k) :=
      MvPolynomial.aeval_injective_iff_of_isEmpty.mpr (RingHom.id k).injective
    apply hinj
    simpa using hi
  | succ n ih =>
    let q (i : ι) := MvPolynomial.finSuccEquiv k n (p i)
    have hq (i : ι) : q i ≠ 0 := by
      exact fun h => hp i ((MvPolynomial.finSuccEquiv k n).injective (by simpa [q] using h))
    obtain ⟨a,ha⟩ := ih (fun i => (q i).leadingCoeff)
      (fun i => Polynomial.leadingCoeff_ne_zero.mpr (hq i))
    let q' (i : ι) := Polynomial.map (MvPolynomial.eval a) (q i)
    have hq' (i : ι) : q' i ≠ 0 := by
      intro h
      have hc := congrArg (fun f : Polynomial k => f.coeff (q i).natDegree) h
      apply ha i
      simpa only [q',Polynomial.coeff_map,Polynomial.coeff_zero,
        Polynomial.coeff_natDegree] using hc
    have hc : (⋃ i, {x : k | Polynomial.IsRoot (q' i) x}).Countable :=
      Set.countable_iUnion (fun i => (Polynomial.finite_setOfPred_isRoot (hq' i)).countable)
    have hn : ∃ x : k, x ∉ ⋃ i, {x : k | Polynomial.IsRoot (q' i) x} := by
      by_contra! h
      exact Set.not_countable_univ (hc.mono (fun x _ => h x))
    obtain ⟨x,hx⟩ := hn
    refine ⟨Fin.cons x a,fun i hi => hx ?_⟩
    apply Set.mem_iUnion.mpr
    refine ⟨i,?_⟩
    change Polynomial.eval x (q' i) = 0
    simpa only [MvPolynomial.eval_eq_eval_mv_eval',q',q] using hi
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section
lemma exists_rational_tuple_in_countable_spec_opens
    {k : Type} [Field k] [Uncountable k] {ι : Type} [Countable ι]
    (n : ℕ) (U : ι → (Spec (.of (MvPolynomial (Fin n) k))).Opens)
    (hU : ∀ i, genericPoint (Spec (.of (MvPolynomial (Fin n) k))) ∈ U i) :
    ∃ a : Fin n → k, ∀ i,
      Set.range (Spec.map (CommRingCat.ofHom (MvPolynomial.eval a))) ⊆ U i := by
  classical
  have hs (i : ι) : ∃ f : MvPolynomial (Fin n) k, f ≠ 0 ∧
      ∀ x : Spec (.of (MvPolynomial (Fin n) k)), x ∈ PrimeSpectrum.basicOpen f → x ∈ U i := by
    obtain ⟨_,⟨f,rfl⟩,hf,hfU⟩ :=
      PrimeSpectrum.isTopologicalBasis_basic_opens.isOpen_iff.mp (U i).isOpen _ (hU i)
    refine ⟨f,?_,hfU⟩
    rw [genericPoint_eq_bot_of_affine] at hf
    change f ∉ (⊥ : PrimeSpectrum (MvPolynomial (Fin n) k)).asIdeal at hf
    simpa only [PrimeSpectrum.asIdeal_bot,Ideal.mem_bot] using hf
  choose f hf hfU using hs
  obtain ⟨a,ha⟩ := exists_avoiding_countable_polynomials n f hf
  refine ⟨a,fun i => ?_⟩
  rintro _ ⟨x,rfl⟩
  apply hfU i
  let point : PrimeSpectrum k := x
  change MvPolynomial.eval a (f i) ∉ point.asIdeal
  simpa only [Ideal.eq_bot_of_prime point.asIdeal,Ideal.mem_bot] using ha i

theorem exists_rational_point_in_countable_affine_opens
    {k : Type} [Field k] [Uncountable k] {ι : Type} [Countable ι]
    (n : ℕ) (U : ι → (𝔸(Fin n;Spec (.of k))).Opens)
    (hU : ∀ i, genericPoint (𝔸(Fin n;Spec (.of k))) ∈ U i) :
    ∃ p : Spec (.of k) ⟶ 𝔸(Fin n;Spec (.of k)),
      p ≫ 𝔸(Fin n;Spec (.of k)) ↘ Spec (.of k) = 𝟙 _ ∧
      ∀ i, Set.range p ⊆ U i := by
  let e := AffineSpace.SpecIso (Fin n) (.of k)
  obtain ⟨a,ha⟩ := exists_rational_tuple_in_countable_spec_opens n
    (fun i => e.inv ⁻¹ᵁ U i) (fun i => by
      change e.inv (genericPoint _) ∈ U i
      rw [genericPoint_eq_of_isOpenImmersion e.inv]
      exact hU i)
  let q := Spec.map (CommRingCat.ofHom (MvPolynomial.eval a))
  refine ⟨q ≫ e.inv,?_,?_⟩
  · rw [Category.assoc,AffineSpace.SpecIso_inv_over,← Spec.map_comp]
    change Spec.map (CommRingCat.ofHom ((MvPolynomial.eval a).comp MvPolynomial.C)) = 𝟙 _
    have he : (MvPolynomial.eval a).comp MvPolynomial.C = RingHom.id k := by
      ext x; simp
    rw [he]
    exact Spec.map_id _
  · intro i
    rintro _ ⟨x,rfl⟩
    exact ha i ⟨x,rfl⟩
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section

theorem exists_smooth_fiber_in_countable_opens
    {k : Type} [Field k] [CharZero k] [Uncountable k]
    {X : Scheme} [NoetherianSpace X] {ι : Type} [Countable ι]
    (n : ℕ) (f : X ⟶ 𝔸(Fin n;Spec (.of k)))
    [LocallyOfFinitePresentation f]
    [Smooth (f ≫ 𝔸(Fin n;Spec (.of k)) ↘ Spec (.of k))]
    (V : ι → (𝔸(Fin n;Spec (.of k))).Opens)
    (hV : ∀ i, genericPoint (𝔸(Fin n;Spec (.of k))) ∈ V i) :
    ∃ p : Spec (.of k) ⟶ 𝔸(Fin n;Spec (.of k)),
      p ≫ 𝔸(Fin n;Spec (.of k)) ↘ Spec (.of k) = 𝟙 _ ∧
      (∀ i, Set.range p ⊆ V i) ∧ Smooth (pullback.snd f p) := by
  have : IsLocallyNoetherian (𝔸(Fin n;Spec (.of k))) :=
    LocallyOfFiniteType.isLocallyNoetherian (𝔸(Fin n;Spec (.of k)) ↘ Spec (.of k))
  have : NoetherianSpace (𝔸(Fin n;Spec (.of k))) :=
    (noetherianSpace_iff_of_homeomorph (AffineSpace.SpecIso (Fin n) (.of k)).hom.homeomorph).mpr inferInstance
  obtain ⟨U,hU,hpre⟩ := finiteType_generic_smooth_open f
    (𝔸(Fin n;Spec (.of k)) ↘ Spec (.of k))
  let W : Option ι → (𝔸(Fin n;Spec (.of k))).Opens := fun i => i.elim U V
  have hW (i : Option ι) : genericPoint _ ∈ W i := by
    cases i with
    | none => exact hU
    | some i => exact hV i
  obtain ⟨p,hp,hpW⟩ := exists_rational_point_in_countable_affine_opens n W hW
  have : Smooth (f ∣_ U) := smooth_morphismRestrict_of_preimage_le f U hpre
  have ha : Set.range p ⊆ Set.range U.ι := by
    rw [Scheme.Opens.range_ι]
    exact hpW none
  let b := IsOpenImmersion.lift U.ι p ha
  have hb : b ≫ U.ι = p := IsOpenImmersion.lift_fac U.ι p ha
  refine ⟨p,hp,(fun i => hpW (some i)),?_⟩
  have hpb := (IsPullback.of_hasPullback (f ∣_ U) b).paste_horiz
    (isPullback_morphismRestrict f U).flip
  rw [hb] at hpb
  let e := hpb.isoIsPullback _ _ (IsPullback.of_hasPullback f p)
  have he : e.hom ≫ pullback.snd f p = pullback.snd (f ∣_ U) b :=
    hpb.isoIsPullback_hom_snd _ _ (IsPullback.of_hasPullback f p)
  have : Smooth (e.hom ≫ pullback.snd f p) := by
    rw [he]
    infer_instance
  have : Smooth (e.inv ≫ e.hom ≫ pullback.snd f p) := inferInstance
  simpa using this
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section

theorem exists_linear_nonvanishing_parameter_open
    {k K : Type} [Field k] [Field K] [Algebra k K]
    {n : Type} [Fintype n] (s : n → K) (i : n) (hi : s i ≠ 0) :
    ∃ U : (𝔸(n;Spec (.of k))).Opens,
      genericPoint _ ∈ U ∧
      ∀ p : Spec (.of k) ⟶ 𝔸(n;Spec (.of k)),
        p ≫ 𝔸(n;Spec (.of k)) ↘ Spec (.of k) = 𝟙 _ →
        Set.range p ⊆ U → parameterLinearCombination s p ≠ 0 := by
  classical
  obtain ⟨L,hL⟩ := Module.Projective.exists_dual_eq_one k hi
  let r : n → Γ(Spec (.of k),⊤) := fun j => (Scheme.ΓSpecIso (.of k)).inv (L (s j))
  have hr : r i = 1 := by simp [r,hL]
  let U := (𝔸(n;Spec (.of k))).basicOpen (universalLinearSection r)
  refine ⟨U,generic_mem_linear_parameter_open r i hr,?_⟩
  intro p hp hpU hz
  have hne := appTop_ne_zero_of_range_basicOpen p (universalLinearSection r) hpU
  apply hne
  apply (Scheme.ΓSpecIso (.of k)).commRingCatIsoToRingEquiv.injective
  rw [map_zero]
  change (Scheme.ΓSpecIso (.of k)).hom
    (p.appTop (universalLinearSection (fun j => (Scheme.ΓSpecIso (.of k)).inv (L (s j))))) = 0
  rw [parameter_evaluate_linear s L p hp,hz,map_zero]
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section
lemma linearMemberSection_evaluate
    {k K n : Type} [Field k] [Field K] [Fintype n]
    {V : Scheme} (sV : V ⟶ Spec (.of k))
    (p : Spec (.of k) ⟶ 𝔸(n;Spec (.of k))) (r : n → Γ(V,⊤))
    (φ : Γ(V,⊤) →+* K) :
    let : Algebra k K := (φ.comp (sV.appTop.hom.comp (Scheme.ΓSpecIso (.of k)).inv.hom)).toAlgebra
    φ (linearMemberSection sV p r) = parameterLinearCombination (φ ∘ r) p := by
  let : Algebra k K := (φ.comp (sV.appTop.hom.comp (Scheme.ΓSpecIso (.of k)).inv.hom)).toAlgebra
  simp only [linearMemberSection,parameterLinearCombination,map_sum,map_mul,
    Function.comp_apply,Algebra.smul_def,parameterCoefficient,RingHom.algebraMap_toAlgebra,
    RingHom.comp_apply,Iso.hom_inv_id_apply]
  apply Finset.sum_congr rfl
  intro j _
  exact mul_comm _ _
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section

theorem exists_parameter_open_avoiding_point
    {k n : Type} [Field k] [Fintype n] {V : Scheme} [IsAffine V]
    (sV : V ⟶ Spec (.of k)) (r : n → Γ(V,⊤)) (i : n) (hi : r i = 1) (x : V) :
    ∃ U : (𝔸(n;Spec (.of k))).Opens, genericPoint _ ∈ U ∧
      ∀ p : Spec (.of k) ⟶ 𝔸(n;Spec (.of k)),
        p ≫ 𝔸(n;Spec (.of k)) ↘ Spec (.of k) = 𝟙 _ → Set.range p ⊆ U →
        x ∉ (Scheme.IdealSheafData.ofIdealTop
          (Ideal.span {linearMemberSection sV p r})).support := by
  let φ : Γ(V,⊤) →+* V.residueField x :=
    (V.residue x).hom.comp (V.presheaf.germ ⊤ x trivial).hom
  let : Algebra k (V.residueField x) :=
    (φ.comp (sV.appTop.hom.comp (Scheme.ΓSpecIso (.of k)).inv.hom)).toAlgebra
  have hi' : (φ ∘ r) i ≠ 0 := by simp [hi]
  obtain ⟨U,hU,hUp⟩ := exists_linear_nonvanishing_parameter_open (k := k) (φ ∘ r) i hi'
  refine ⟨U,hU,fun p hp hpU => ?_⟩
  have hn : φ (linearMemberSection sV p r) ≠ 0 := by
    rw [linearMemberSection_evaluate]
    exact hUp p hp hpU
  have hx : x ∈ V.basicOpen (linearMemberSection sV p r) := by
    rw [Scheme.mem_basicOpen_top]
    exact (IsLocalRing.residue_ne_zero_iff_isUnit _).mp hn
  change x ∉ ((Scheme.IdealSheafData.ofIdealTop
    (Ideal.span {linearMemberSection sV p r})).support : Set V)
  rw [Scheme.IdealSheafData.coe_support_ofIdealTop,Scheme.zeroLocus_span,
    Scheme.zeroLocus_singleton]
  exact fun h => h hx
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section

theorem incidence_parameter_open_avoiding_point
    {k n : Type} [Field k] [Fintype n] {X : Scheme}
    (sX : X ⟶ Spec (.of k)) (V : X.OpenCover) [∀ i, IsAffine (V.X i)]
    (r : ∀ i, n → Γ(V.X i,⊤)) (hn : ∀ i, ∃ j, r i j = 1)
    (J : 𝔸(n;X).IdealSheafData)
    (hJ : ∀ i, J.comap (AffineSpace.map n (V.f i)) =
      Scheme.IdealSheafData.ofIdealTop (Ideal.span {universalLinearSection (r i)}))
    (x : X) :
    ∃ U : (𝔸(n;Spec (.of k))).Opens, genericPoint _ ∈ U ∧
      ∀ p : Spec (.of k) ⟶ 𝔸(n;Spec (.of k)),
        p ≫ 𝔸(n;Spec (.of k)) ↘ Spec (.of k) = 𝟙 _ → Set.range p ⊆ U →
        x ∉ (J.comap (parameterSection sX p)).support := by
  let i := V.idx x
  obtain ⟨y,hy⟩ := V.covers x
  obtain ⟨a,ha⟩ := hn i
  obtain ⟨U,hU,hUp⟩ := exists_parameter_open_avoiding_point (V.f i ≫ sX) (r i) a ha y
  refine ⟨U,hU,fun p hp hpU hx => ?_⟩
  apply hUp p hp hpU
  rw [← parameter_member_chart (V.f i) sX p J (r i) (hJ i),
    Scheme.IdealSheafData.support_comap]
  change V.f i y ∈ (J.comap (parameterSection sX p)).support
  change (V.f (V.idx x)) y ∈ (J.comap (parameterSection sX p)).support
  rwa [hy]
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section
universe u

theorem incidence_smooth_baseChange
    {n : Type u} {X Y : Scheme.{u}} (h : Y ⟶ X)
    (J : 𝔸(n;X).IdealSheafData) [Smooth (J.subschemeι ≫ 𝔸(n;X) ↘ X)] :
    Smooth ((J.comap (AffineSpace.map n h)).subschemeι ≫ 𝔸(n;Y) ↘ Y) := by
  let a := AffineSpace.map n h
  have hp := (IsPullback.of_hasPullback a J.subschemeι).flip.paste_vert
    (AffineSpace.isPullback_map (n := n) h)
  let e := hp.isoIsPullback _ _ (IsPullback.of_hasPullback _ _)
  have he : e.hom ≫ pullback.snd (J.subschemeι ≫ 𝔸(n;X) ↘ X) h =
      pullback.fst a J.subschemeι ≫ 𝔸(n;Y) ↘ Y :=
    hp.isoIsPullback_hom_snd _ _ (IsPullback.of_hasPullback _ _)
  have hs : Smooth (pullback.fst a J.subschemeι ≫ 𝔸(n;Y) ↘ Y) := by
    rw [← he]
    infer_instance
  change Smooth ((J.comap a).subschemeι ≫ 𝔸(n;Y) ↘ Y)
  rw [← J.comapIso_hom_fst a,Category.assoc]
  infer_instance
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section

theorem exists_very_general_incidence_member
    {k : Type} [Field k] [CharZero k] [Uncountable k]
    {n : ℕ} {X : Scheme} [NoetherianSpace X]
    (sX : X ⟶ Spec (.of k)) [Smooth sX]
    (J : 𝔸(Fin n;X).IdealSheafData) [Smooth (J.subschemeι ≫ 𝔸(Fin n;X) ↘ X)]
    {ι : Type} [Countable ι] (V : ι → (𝔸(Fin n;Spec (.of k))).Opens)
    (hV : ∀ i, genericPoint _ ∈ V i) :
    ∃ p : Spec (.of k) ⟶ 𝔸(Fin n;Spec (.of k)),
      p ≫ 𝔸(Fin n;Spec (.of k)) ↘ Spec (.of k) = 𝟙 _ ∧
      (∀ i, Set.range p ⊆ V i) ∧
      Smooth ((J.comap (parameterSection sX p)).subschemeι ≫ sX) := by
  let f := J.subschemeι ≫ AffineSpace.map (Fin n) sX
  let sA := 𝔸(Fin n;Spec (.of k)) ↘ Spec (.of k)
  have hfs : f ≫ sA = (J.subschemeι ≫ 𝔸(Fin n;X) ↘ X) ≫ sX := by
    simp only [f,sA,Category.assoc,AffineSpace.map_over]
  have : Smooth (f ≫ sA) := by rw [hfs]; infer_instance
  have : IsLocallyNoetherian X := LocallyOfFiniteType.isLocallyNoetherian sX
  have : IsLocallyNoetherian (𝔸(Fin n;X)) :=
    LocallyOfFiniteType.isLocallyNoetherian (𝔸(Fin n;X) ↘ X)
  have : CompactSpace (𝔸(Fin n;X)) :=
    QuasiCompact.compactSpace_of_compactSpace (𝔸(Fin n;X) ↘ X)
  have : IsLocallyNoetherian J.subscheme :=
    LocallyOfFiniteType.isLocallyNoetherian J.subschemeι
  have : CompactSpace J.subscheme := QuasiCompact.compactSpace_of_compactSpace J.subschemeι
  have : IsNoetherian J.subscheme := ⟨⟩
  have : IsLocallyNoetherian (𝔸(Fin n;Spec (.of k))) :=
    LocallyOfFiniteType.isLocallyNoetherian sA
  have : LocallyOfFiniteType f := locallyOfFiniteType_of_comp f sA
  have : LocallyOfFinitePresentation f := inferInstance
  obtain ⟨p,hp,hpV,hsm⟩ := exists_smooth_fiber_in_countable_opens n f V hV
  exact ⟨p,hp,hpV,smooth_parameter_member sX p hp 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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
noncomputable section

lemma parameter_member_comap {n : Type*} {V X S : Scheme}
    (g : V ⟶ X) (f : X ⟶ S) (p : S ⟶ 𝔸(n;S)) (J : 𝔸(n;X).IdealSheafData) :
    (J.comap (parameterSection f p)).comap g =
      (J.comap (AffineSpace.map n g)).comap (parameterSection (g ≫ f) p) := by
  rw [← Scheme.IdealSheafData.comap_comp, parameterSection_naturality,
    Scheme.IdealSheafData.comap_comp]

theorem exists_very_general_incidence_member_on_open
    {k : Type} [Field k] [CharZero k] [Uncountable k]
    {n : ℕ} {X : Scheme} [NoetherianSpace X]
    (sX : X ⟶ Spec (.of k)) (U : X.Opens) [AlgebraicGeometry.Smooth (U.ι ≫ sX)]
    (J : 𝔸(Fin n;X).IdealSheafData) [AlgebraicGeometry.Smooth (J.subschemeι ≫ 𝔸(Fin n;X) ↘ X)]
    {ι : Type} [Countable ι] (V : ι → (𝔸(Fin n;Spec (.of k))).Opens)
    (hV : ∀ i, genericPoint _ ∈ V i) :
    ∃ p : Spec (.of k) ⟶ 𝔸(Fin n;Spec (.of k)),
      p ≫ 𝔸(Fin n;Spec (.of k)) ↘ Spec (.of k) = 𝟙 _ ∧
      (∀ i, Set.range p ⊆ V i) ∧
      AlgebraicGeometry.Smooth (((J.comap (parameterSection sX p)).comap U.ι).subschemeι ≫ (U.ι ≫ sX)) := by
  have : NoetherianSpace U := U.ι.isOpenEmbedding.isInducing.noetherianSpace
  let JU : 𝔸(Fin n;U).IdealSheafData := J.comap (AffineSpace.map (Fin n) U.ι)
  have : AlgebraicGeometry.Smooth (JU.subschemeι ≫ 𝔸(Fin n;U) ↘ U) := incidence_smooth_baseChange U.ι J
  obtain ⟨p,hp,hpV,hsm⟩ := exists_very_general_incidence_member (U.ι ≫ sX) JU V hV
  refine ⟨p,hp,hpV,?_⟩
  have hi : (J.comap (parameterSection sX p)).comap U.ι =
      JU.comap (parameterSection (U.ι ≫ sX) p) := parameter_member_comap U.ι sX p J
  exact (congrArg
    (fun ideal : (U : Scheme).IdealSheafData => AlgebraicGeometry.Smooth (ideal.subschemeι ≫ (U.ι ≫ sX)))
    hi).mpr hsm
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
open AlgebraicGeometry CategoryTheory TopologicalSpace Limits
open Algebra KaehlerDifferential IsLocalRing TensorProduct
open AlgebraicGeometry CategoryTheory TensorProduct
open TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology

namespace NumericalDimensionOne
universe u

theorem closed_set_finite_generics {X : Scheme.{u}} [NoetherianSpace X]
    {Z : Set X} (hZ : IsClosed Z) :
    ∃ G : Finset X, ∀ x, x ∈ Z ↔ ∃ g ∈ G, x ∈ closure {g} := by
  classical
  obtain ⟨S,hSf,hSc,hSi,hSZ⟩ := NoetherianSpace.exists_finite_set_isClosed_irreducible hZ
  let : Fintype S := hSf.fintype
  choose g hg using fun T : S => QuasiSober.sober (hSi T T.2) (hSc T T.2)
  refine ⟨Finset.univ.image g,fun x => ?_⟩
  constructor
  · intro hx
    obtain ⟨T,hT,hxT⟩ := Set.mem_sUnion.mp (hSZ ▸ hx)
    refine ⟨g ⟨T,hT⟩,Finset.mem_image.mpr ⟨⟨T,hT⟩,Finset.mem_univ _,rfl⟩,?_⟩
    rw [hg ⟨T,hT⟩]
    exact hxT
  · rintro ⟨z,hz,hxz⟩
    obtain ⟨T,_,rfl⟩ := Finset.mem_image.mp hz
    rw [hg T] at hxz
    rw [hSZ]
    exact Set.mem_sUnion.mpr ⟨T,T.2,hxz⟩

end NumericalDimensionOne

end OAI