lean/OAI/AlgebraicGeometry/SurfaceCones/KummerProjChart.lean

import OAI.AlgebraicGeometry.SurfaceCones.SectionCompletion

namespace OAI


noncomputable section
namespace ExplicitCone
open Polynomial

lemma sectionCoefficient_mem_piece (i : Fin 6 × Fin 3) :
    sectionCoefficient i ∈ pieces 1 := by
  change IsIntegral polynomialAlgebra (monomial 1 (sectionCoefficient i))
  have hp : polynomialGenerator i ∈ polynomialAlgebra :=
    Algebra.subset_adjoin (Set.mem_range_self i)
  have hi := isIntegral_algebraMap (R := polynomialAlgebra) (A := L[X])
    (x := (⟨_,hp⟩ : polynomialAlgebra))
  change IsIntegral polynomialAlgebra (polynomialGenerator i) at hi
  rw [← Polynomial.C_mul_X_pow_eq_monomial]
  simpa only [polynomialGenerator, pow_one] using hi

abbrev projBaseSection := SectionCompletion.linearSection pieces
  (sectionCoefficient (0,0)) (sectionCoefficient_mem_piece (0,0))
abbrev projBaseChart := SectionCompletion.homogeneousChart pieces
  (sectionCoefficient (0,0)) (sectionCoefficient_mem_piece (0,0))

/-- The actual degree-zero homogeneous localization in Proj of the WHOLE
normalized cone, not a surrogate affine model, is the literal smooth H-chart. -/
def projBaseChartEquiv : projBaseChart ≃ₐ[ℂ] sectionChart :=
  SectionCompletion.homogeneousChartAlgEquivOfAdjoin pieces (sectionCoefficient (0,0))
    (sectionCoefficient_mem_piece (0,0)) sectionCoefficient_base_ne_zero sectionCoefficient
    sectionCoefficient_mem_piece normalized_coefficient_mem_sectionChart

theorem projBaseChart_regular : IsRegularRing projBaseChart := by
  let := sectionChart_regular
  exact IsRegularRing.of_ringEquiv projBaseChartEquiv.symm.toRingEquiv

theorem projBaseChart_smooth : Algebra.Smooth ℂ projBaseChart := by
  let := sectionChart_smooth
  exact Algebra.Smooth.of_equiv projBaseChartEquiv.symm

lemma functionField_trdeg : Algebra.trdeg ℂ L = 2 := by
  have hK : Algebra.trdeg ℂ KummerLines.K = 2 := by
    rw [SmallCM.trdeg_fractionRing ℂ KummerLines.R KummerLines.K]
    simp [KummerLines.R, MvPolynomial.trdeg_of_isDomain]
  have h := trdeg_add_eq ℂ KummerLines.K (A := L)
  simpa only [hK, Cardinal.lift_ofNat, trdeg_eq_zero, add_zero] using h.symm

theorem sectionChart_dimension : ringKrullDim sectionChart = 2 := by
  apply SmallCM.dimension_of_trdeg ℂ sectionChart 2
  rw [← SmallCM.trdeg_fractionRing ℂ sectionChart L]
  exact functionField_trdeg

theorem projBaseChart_dimension : ringKrullDim projBaseChart = 2 :=
  projBaseChartEquiv.toRingEquiv.ringKrullDim.trans sectionChart_dimension

open AlgebraicGeometry CategoryTheory
/-- A genuine scheme isomorphism from the distinguished basic open of the
actual Proj of normalized coefficients to the explicit Kummer H-chart. -/
def projBaseOpenIso :
    (Proj.basicOpen (SectionCompletion.homogeneous pieces) projBaseSection).toScheme ≅
      Spec (CommRingCat.of sectionChart) :=
  (Proj.basicOpenIsoSpec (SectionCompletion.homogeneous pieces) projBaseSection
    (SectionCompletion.linearSection_homogeneous pieces _ _) (by norm_num : 0 < (1 : ℕ))) ≪≫
    (Scheme.Spec.mapIso (projBaseChartEquiv.symm.toRingEquiv.toCommRingCatIso).op)

end ExplicitCone


open nonZeroDivisors
namespace SmallCM

lemma finite_normalization_in_field_of_finite_type (k B F : Type*) [Field k] [CharZero k]
    [CommRing B] [IsDomain B] [Algebra k B] [Algebra.FiniteType k B]
    [Field F] [Algebra B F] [IsFractionRing B F] :
    Module.Finite B (integralClosure B F) := by
  obtain ⟨n, f, hf, hfin⟩ := exists_finite_inj_algHom_of_fg k B
  let P := MvPolynomial (Fin n) k
  let : Algebra P B := f.toRingHom.toAlgebra
  let : Module.Finite P B := hfin
  let : FaithfulSMul P B := (faithfulSMul_iff_algebraMap_injective P B).mpr hf
  let : Algebra P F := ((algebraMap B F).comp f.toRingHom).toAlgebra
  let : IsScalarTower P B F := IsScalarTower.of_algebraMap_eq (fun _ => rfl)
  let : FaithfulSMul P F := .trans P B F
  let : Algebra (FractionRing P) F := FractionRing.liftAlgebra P F
  let : IsScalarTower P (FractionRing P) F := FractionRing.isScalarTower_liftAlgebra P F
  let : Algebra.IsAlgebraic (FractionRing P) F :=
    isAlgebraic_of_isFractionRing P B (FractionRing P) F
  let : IsLocalization (Algebra.algebraMapSubmonoid B P⁰) F := by
    infer_instance
  let : FiniteDimensional (FractionRing P) F :=
    Module.Finite.of_isLocalization P B P⁰
  let C := integralClosure B F
  let : Algebra P C := (algebraMap B C).comp f.toRingHom |>.toAlgebra
  let : IsScalarTower P B C := IsScalarTower.of_algebraMap_eq (fun _ => rfl)
  let : IsScalarTower P C F := IsScalarTower.to₁₃₄ P B C F
  let : IsIntegralClosure C P F :=
    ⟨IsIntegralClosure.algebraMap_injective C B _, fun {x} => by
      rw [← IsIntegralClosure.isIntegral_iff (A := C) (R := B)]
      exact ⟨fun h => h.tower_top, fun h => isIntegral_trans x h⟩⟩
  let : CharZero (FractionRing P) := inferInstance
  let : Module.Finite P C := IsIntegralClosure.finite P (FractionRing P) F C
  exact Module.Finite.of_restrictScalars_finite P B C

end SmallCM

namespace GradedNormalization
variable {k L : Type} [Field k] [CharZero k] [Field L] [Algebra k L]
open Polynomial
variable (B : Subalgebra k L[X]) [Algebra.FiniteType k B]
    [IsFractionRing B (RatFunc L)]

lemma finite_polynomial_normalization : Module.Finite B (integralClosure B L[X]) := by
  let N := integralClosure B L[X]
  let NF := integralClosure B (RatFunc L)
  let : Module.Finite B NF := SmallCM.finite_normalization_in_field_of_finite_type k B (RatFunc L)
  let : IsScalarTower N L[X] (RatFunc L) := inferInstance
  let : IsScalarTower B N (RatFunc L) := IsScalarTower.to₁₂₄ B N L[X] (RatFunc L)
  let : IsIntegralClosure N B (RatFunc L) :=
    IsIntegralClosure.of_isIntegralClosure_of_isIntegrallyClosedIn B N L[X] (RatFunc L)
  exact Module.Finite.equiv (IsIntegralClosure.equiv B NF (RatFunc L) N).toLinearEquiv

omit [CharZero k] [Algebra.FiniteType k B] [IsFractionRing B (RatFunc L)] in
lemma normal_polynomial_normalization : IsIntegrallyClosed (integralClosure B L[X]) :=
  IsIntegrallyClosed.of_isIntegrallyClosed_of_isIntegrallyClosedIn
    (R := integralClosure B L[X]) (S := L[X])

end GradedNormalization

end


noncomputable section
namespace GradedNormalization
open Polynomial
variable {k L : Type} [Field k] [Field L] [Algebra k L]
variable {σ : Type} (v : σ → L) (d : σ → ℕ)

lemma monomial_algebra_scale (a : k) :
    ∀ p ∈ Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i))),
      scale a p ∈ Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i))) := by
  let B := Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i)))
  change B ≤ B.comap (scale a)
  apply Algebra.adjoin_le
  rintro _ ⟨i, rfl⟩
  change scale a (monomial (d i) (v i)) ∈ B
  rw [scale_monomial]
  exact B.smul_mem (Algebra.subset_adjoin ⟨i, rfl⟩) _

lemma positive_monomial_constantCoeff (hd : ∀ i, d i ≠ 0) :
    ∀ p ∈ Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i))),
      p.coeff 0 ∈ (⊥ : Subalgebra k L) := by
  let φ : L[X] →ₐ[k] L := (Polynomial.aeval (0 : L)).restrictScalars k
  have h : Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i))) ≤
      (⊥ : Subalgebra k L).comap φ := by
    apply Algebra.adjoin_le
    rintro _ ⟨i, rfl⟩
    change Polynomial.eval 0 (monomial (d i) (v i)) ∈ (⊥ : Subalgebra k L)
    simp [hd i]
  intro p hp
  have hh := h hp
  change Polynomial.eval 0 p ∈ (⊥ : Subalgebra k L) at hh
  rwa [← coeff_zero_eq_eval_zero] at hh
end GradedNormalization

namespace ExplicitCone
open Polynomial GradedNormalization

lemma polynomialGenerator_eq_monomial (i : Fin 6 × Fin 3) :
    polynomialGenerator i = monomial 1 (sectionCoefficient i) := by
  simp [polynomialGenerator, ← C_mul_X_pow_eq_monomial]

lemma polynomialAlgebra_scale (a : ℂ) :
    ∀ p ∈ polynomialAlgebra, scale a p ∈ polynomialAlgebra := by
  change ∀ p ∈ Algebra.adjoin ℂ (Set.range polynomialGenerator),
    scale a p ∈ Algebra.adjoin ℂ (Set.range polynomialGenerator)
  simp_rw [show polynomialGenerator = (fun i => monomial 1 (sectionCoefficient i)) from
    funext polynomialGenerator_eq_monomial]
  exact monomial_algebra_scale sectionCoefficient (fun _ => 1) a

lemma polynomialAlgebra_constantCoeff :
    ∀ p ∈ polynomialAlgebra, p.coeff 0 ∈ (⊥ : Subalgebra ℂ L) := by
  change ∀ p ∈ Algebra.adjoin ℂ (Set.range polynomialGenerator), _
  simp_rw [show polynomialGenerator = (fun i => monomial 1 (sectionCoefficient i)) from
    funext polynomialGenerator_eq_monomial]
  exact positive_monomial_constantCoeff sectionCoefficient (fun _ => 1) (fun _ => one_ne_zero)

end ExplicitCone
namespace GradedNormalization
open Polynomial
variable {k L : Type} [Field k] [CharZero k] [Field L] [Algebra k L]
variable (B : Subalgebra k L[X])

lemma polynomial_piece_eq (hB : ∀ a : k, ∀ p ∈ B, scale a p ∈ B) :
    SectionCompletion.polynomials (piece B) = (integralClosure B L[X]).restrictScalars k := by
  ext p
  change (∀ n, IsIntegral B (monomial n (p.coeff n))) ↔ IsIntegral B p
  constructor
  · intro h
    rw [p.as_sum_range]
    exact (integralClosure B L[X]).sum_mem (fun n _ => h n)
  · intro h n
    exact integral_monomial B hB h n

lemma polynomialPiece_finiteType [Algebra.FiniteType k B]
    [IsFractionRing B (RatFunc L)]
    (hB : ∀ a : k, ∀ p ∈ B, scale a p ∈ B) :
    Algebra.FiniteType k (SectionCompletion.polynomials (piece B)) := by
  rw [polynomial_piece_eq B hB]
  let : Module.Finite B (integralClosure B L[X]) := finite_polynomial_normalization B
  change Algebra.FiniteType k (integralClosure B L[X])
  exact Algebra.FiniteType.trans (inferInstance : Algebra.FiniteType k B)
    (inferInstance : Algebra.FiniteType B (integralClosure B L[X]))

lemma polynomialPiece_normalIn
    (hB : ∀ a : k, ∀ p ∈ B, scale a p ∈ B) :
    IsIntegrallyClosedIn (SectionCompletion.polynomials (piece B)) L[X] := by
  rw [polynomial_piece_eq B hB]
  change IsIntegrallyClosedIn (integralClosure B L[X]) L[X]
  infer_instance

end GradedNormalization

open AlgebraicGeometry CategoryTheory
private theorem proper_comp_iso {X Y Z : Scheme} (f : X ⟶ Y) (e : Y ≅ Z)
    [IsProper f] : IsProper (f ≫ e.hom) := by infer_instance

namespace ExplicitCone
open AlgebraicGeometry CategoryTheory

lemma zero_piece : pieces 0 = LinearMap.range (Algebra.linearMap ℂ L) :=
  GradedNormalization.piece_zero polynomialAlgebra polynomialAlgebra_constantCoeff

instance completedRing_isLocalRing : IsLocalRing completedRing :=
  SectionCompletion.isLocalRing pieces (SectionCompletion.zero_piece_closed_inv pieces zero_piece)

instance normalizedPolynomialsFiniteType :
    Algebra.FiniteType ℂ (SectionCompletion.polynomials pieces) :=
  GradedNormalization.polynomialPiece_finiteType polynomialAlgebra polynomialAlgebra_scale

/-- Actual proper Proj of the entire normalized coefficient algebra. -/
abbrev projectiveSurface : Scheme := SectionCompletion.proj pieces

def degreeZeroEquiv : ℂ ≃ₐ[ℂ] SectionCompletion.homogeneous pieces 0 :=
  SectionCompletion.zeroEquiv pieces fun a ha => by
    rw [zero_piece] at ha
    exact ha

def degreeZeroSpecIso :
    Spec (CommRingCat.of (SectionCompletion.homogeneous pieces 0)) ≅
      Spec (CommRingCat.of ℂ) :=
  Scheme.Spec.mapIso degreeZeroEquiv.toRingEquiv.toCommRingCatIso.op

def projectiveSurfaceToComplex : projectiveSurface ⟶ Spec (CommRingCat.of ℂ) :=
  Proj.toSpecZero (SectionCompletion.homogeneous pieces) ≫ degreeZeroSpecIso.hom

instance projectiveSurfaceProper : IsProper projectiveSurfaceToComplex :=
  (MorphismProperty.cancel_right_of_respectsIso @IsProper
    (Proj.toSpecZero (SectionCompletion.homogeneous pieces)) degreeZeroSpecIso.hom).mpr
      (SectionCompletion.projProper pieces)

end ExplicitCone

end


noncomputable section
namespace SectionChartSeries
variable {k L : Type*} [Field k] [Field L] [Algebra k L]
variable (T : ℕ → Submodule k L) [SetLike.GradedMonoid T]
variable (A : Subalgebra k L) (c : L)
variable (h : ∀ n a, a ∈ T n → a / c ^ n ∈ A)

def localSeries (f : SectionCompletion.series T) : PowerSeries A :=
  PowerSeries.mk fun n => ⟨PowerSeries.coeff n f.val / c ^ n, h n _ (f.property n)⟩

lemma map_localSeries (f : SectionCompletion.series T) :
    PowerSeries.map A.val.toRingHom (localSeries T A c h f) =
      PowerSeries.rescale c⁻¹ f.val := by
  ext n
  simp only [localSeries, PowerSeries.coeff_map, PowerSeries.coeff_mk,
    PowerSeries.coeff_rescale, inv_pow, div_eq_mul_inv, mul_comm]
  rfl

def hom : SectionCompletion.series T →ₐ[k] PowerSeries A where
  toFun := localSeries T A c h
  map_zero' := by
    apply PowerSeries.map_injective A.val.toRingHom Subtype.val_injective
    rw [map_localSeries, map_zero]
    exact map_zero _
  map_one' := by
    apply PowerSeries.map_injective A.val.toRingHom Subtype.val_injective
    rw [map_localSeries, map_one]
    exact map_one _
  map_add' f g := by
    apply PowerSeries.map_injective A.val.toRingHom Subtype.val_injective
    rw [map_localSeries, map_add, map_localSeries, map_localSeries]
    exact map_add _ _ _
  map_mul' f g := by
    apply PowerSeries.map_injective A.val.toRingHom Subtype.val_injective
    rw [map_localSeries, map_mul, map_localSeries, map_localSeries]
    exact map_mul _ _ _
  commutes' a := by
    apply PowerSeries.map_injective A.val.toRingHom Subtype.val_injective
    rw [map_localSeries]
    change PowerSeries.rescale c⁻¹ (algebraMap k (PowerSeries L) a) =
      PowerSeries.map A.val.toRingHom (algebraMap k (PowerSeries A) a)
    ext n
    simp only [PowerSeries.coeff_rescale, PowerSeries.coeff_map,
      PowerSeries.algebraMap_apply, PowerSeries.coeff_C]
    by_cases hn : n = 0
    · subst n; simp
    · simp [hn]


lemma hom_injective (hc : c ≠ 0) : Function.Injective (hom T A c h) := by
  intro f g hfg
  apply Subtype.ext
  apply PowerSeries.rescale_injective (inv_ne_zero hc)
  rw [← map_localSeries T A c h f, ← map_localSeries T A c h g]
  exact congrArg (PowerSeries.map A.val.toRingHom) hfg

lemma coeff_hom (f : SectionCompletion.series T) (n : ℕ) :
    ((PowerSeries.coeff n (hom T A c h f) : A) : L) = PowerSeries.coeff n f.val / c ^ n := by
  simp [hom, localSeries]

end SectionChartSeries


namespace SectionGenerated
open scoped BigOperators
variable {k K σ : Type*} [Field k] [Field K] [Algebra k K] [Fintype σ]
variable (v : σ → K) (d : σ → ℕ)

noncomputable def genSeries (i : σ) : PowerSeries K := PowerSeries.C (v i) * PowerSeries.X ^ d i

lemma hasSubst (hd : ∀ i, d i ≠ 0) : MvPowerSeries.HasSubst (genSeries v d) where
  const_coeff i := by
    change IsNilpotent (PowerSeries.constantCoeff (genSeries v d i))
    simp [genSeries, hd i]
  coeff_zero _ := Set.toFinite _

omit [Fintype σ] in
lemma monomial_subst (e : σ →₀ ℕ) :
    e.prod (fun i n => (genSeries v d i)^n) =
      PowerSeries.C (e.prod (fun i n => v i^n)) * PowerSeries.X^(Finsupp.weight d e) := by
  classical
  simp only [genSeries, mul_pow, ← map_pow, Finsupp.prod, Finset.prod_mul_distrib,
    ← map_prod, ← pow_mul, Finset.prod_pow_eq_pow_sum, Finsupp.weight_apply, Finsupp.sum,
    smul_eq_mul]
  congr 2
  apply Finset.sum_congr rfl
  intro i _
  exact Nat.mul_comm _ _

lemma coeff_subst (hd : ∀ i, d i ≠ 0) (f : MvPowerSeries σ k) (n : ℕ) :
    PowerSeries.coeff n (MvPowerSeries.subst (genSeries v d) f) =
      ∑ᶠ e : σ →₀ ℕ, if Finsupp.weight d e = n then
        MvPowerSeries.coeff e f • e.prod (fun i j => v i ^ j) else 0 := by
  classical
  rw [PowerSeries.coeff, MvPowerSeries.coeff_subst (hasSubst v d hd)]
  apply finsum_congr
  intro e
  rw [monomial_subst]
  change MvPowerSeries.coeff e f •
    PowerSeries.coeff n (PowerSeries.C _ * PowerSeries.X ^ _) = _
  rw [PowerSeries.coeff_C_mul_X_pow]
  split_ifs <;> simp_all
end SectionGenerated
namespace SectionGenerated
open scoped BigOperators
variable {k K σ : Type*} [Field k] [Field K] [Algebra k K] [Fintype σ]
variable (v : σ → K) (d : σ → ℕ)

lemma coeff_subst_fiber (hd : ∀ i, d i ≠ 0) (f : MvPowerSeries σ k) (n : ℕ) :
    PowerSeries.coeff n (MvPowerSeries.subst (genSeries v d) f) =
      ∑ᶠ e : {e : σ →₀ ℕ // Finsupp.weight d e = n},
        MvPowerSeries.coeff e.val f • e.val.prod (fun i j => v i ^ j) := by
  rw [coeff_subst v d hd]
  simpa only [finsum_eq_if] using (finsum_subtype_eq_finsum_cond
    (f := fun e : σ →₀ ℕ => MvPowerSeries.coeff e f • e.prod (fun i j => v i ^ j))
    (fun e => Finsupp.weight d e = n)).symm

lemma exists_subst_of_coeff_span (hd : ∀ i, d i ≠ 0) (p : PowerSeries K)
    (hp : ∀ n, PowerSeries.coeff n p ∈ Submodule.span k
      (Set.range (fun e : {e : σ →₀ ℕ // Finsupp.weight d e = n} =>
        e.val.prod (fun i j => v i ^ j)))) :
    ∃ f : MvPowerSeries σ k, MvPowerSeries.subst (genSeries v d) f = p := by
  classical
  have hc := fun n => Finsupp.mem_span_range_iff_exists_finsupp.mp (hp n)
  choose c hc using hc
  let f : MvPowerSeries σ k := fun e => c (Finsupp.weight d e) ⟨e, rfl⟩
  refine ⟨f, PowerSeries.ext fun n => ?_⟩
  rw [coeff_subst_fiber v d hd]
  calc
    _ = ∑ᶠ e : {e : σ →₀ ℕ // Finsupp.weight d e = n},
        c n e • e.val.prod (fun i j => v i ^ j) := by
      apply finsum_congr
      intro e
      congr 1
      change c (Finsupp.weight d e.val) ⟨e.val, rfl⟩ = c n e
      rcases e with ⟨e, he⟩
      cases he
      rfl
    _ = (c n).sum (fun e a => a • e.val.prod (fun i j => v i ^ j)) := by
      apply finsum_eq_sum_of_support_subset
      intro e he
      exact Finsupp.mem_support_iff.mpr (fun hz => he (by simp [hz]))
    _ = _ := hc n
end SectionGenerated
namespace SectionGenerated
open scoped BigOperators
variable {k K σ : Type*} [Field k] [Field K] [Algebra k K] [Fintype σ]
variable (T : ℕ → Submodule k K) [SetLike.GradedMonoid T]
variable (v : σ → K) (d : σ → ℕ)

lemma subst_mem (hd : ∀ i, d i ≠ 0) (hv : ∀ i, v i ∈ T (d i))
    (f : MvPowerSeries σ k) : MvPowerSeries.subst (genSeries v d) f ∈ SectionCompletion.series T := by
  classical
  intro n
  rw [coeff_subst_fiber v d hd]
  let : Fintype {e : σ →₀ ℕ // Finsupp.weight d e = n} :=
    (Finsupp.finite_of_nat_weight_eq d hd n).fintype
  rw [finsum_eq_sum_of_fintype]
  apply Submodule.sum_mem
  intro e _
  apply Submodule.smul_mem
  have h := SetLike.prod_pow_mem_graded T d v (fun i => e.val i)
    (F := e.val.support) (fun i _ => hv i)
  have he : (∑ i ∈ e.val.support, e.val i • d i) = n := by
    simpa only [Finsupp.weight_apply, Finsupp.sum] using e.property
  rw [he] at h
  exact h

noncomputable def substHom (hd : ∀ i, d i ≠ 0) (hv : ∀ i, v i ∈ T (d i)) :
    MvPowerSeries σ k →ₐ[k] SectionCompletion.series T :=
  (MvPowerSeries.substAlgHom (R := k) (hasSubst v d hd)).codRestrict
    (SectionCompletion.series T) (fun f => by
      simpa only [MvPowerSeries.substAlgHom_apply] using subst_mem T v d hd hv f)

lemma substHom_surjective (hd : ∀ i, d i ≠ 0) (hv : ∀ i, v i ∈ T (d i))
    (hgen : ∀ n, T n = Submodule.span k
      (Set.range (fun e : {e : σ →₀ ℕ // Finsupp.weight d e = n} =>
        e.val.prod (fun i j => v i ^ j)))) :
    Function.Surjective (substHom T v d hd hv) := by
  intro p
  obtain ⟨f, hf⟩ := exists_subst_of_coeff_span v d hd p.val (fun n => by
    rw [← hgen n]
    exact p.property n)
  refine ⟨f, Subtype.ext ?_⟩
  change (MvPowerSeries.substAlgHom (R := k) (hasSubst v d hd)) f = p.val
  simpa only [MvPowerSeries.substAlgHom_apply] using hf

lemma isNoetherianRing (hd : ∀ i, d i ≠ 0) (hv : ∀ i, v i ∈ T (d i))
    (hgen : ∀ n, T n = Submodule.span k
      (Set.range (fun e : {e : σ →₀ ℕ // Finsupp.weight d e = n} =>
        e.val.prod (fun i j => v i ^ j)))) :
    IsNoetherianRing (SectionCompletion.series T) :=
  isNoetherianRing_of_surjective _ _ (substHom T v d hd hv).toRingHom
    (substHom_surjective T v d hd hv hgen)
end SectionGenerated


lemma precomplete_of_surjective {R S : Type*} [CommRing R] [CommRing S]
    (I : Ideal R) (f : R →+* S) (hf : Function.Surjective f) [IsPrecomplete I R] :
    IsPrecomplete (I.map f) S := by
  let : Algebra R S := f.toAlgebra
  change IsPrecomplete (I.map (algebraMap R S)) S
  rw [IsPrecomplete.map_algebraMap_iff]
  apply AdicCompletion.of_surjective_iff.mp
  intro x
  obtain ⟨y, hy⟩ := AdicCompletion.map_surjective I (f := Algebra.linearMap R S) hf x
  obtain ⟨a, ha⟩ := AdicCompletion.of_surjective I R y
  refine ⟨f a, ?_⟩
  rw [← hy, ← ha]
  rw [AdicCompletion.map_of]
  rfl

lemma complete_local_of_surjective {R S : Type*} [CommRing R] [CommRing S]
    [IsNoetherianRing S] [IsLocalRing R] [IsLocalRing S]
    (f : R →+* S) (hf : Function.Surjective f)
    [IsAdicComplete (IsLocalRing.maximalIdeal R) R] :
    IsAdicComplete (IsLocalRing.maximalIdeal S) S := by
  have h := precomplete_of_surjective (IsLocalRing.maximalIdeal R) f hf
  rw [IsLocalRing.map_maximalIdeal_of_surjective f hf] at h
  exact { toIsPrecomplete := h, toIsHausdorff := inferInstance }

open IsLocalRing
open scoped BigOperators

lemma mvPowerSeries_constantCoeff_zero_mem_vars
    {σ K : Type*} [Fintype σ] [CommRing K] (f : MvPowerSeries σ K)
    (hf : MvPowerSeries.constantCoeff f = 0) :
    f ∈ Ideal.span (Set.range (MvPowerSeries.X : σ → MvPowerSeries σ K)) := by
  classical
  let p : σ → MvPowerSeries σ K := fun i d =>
    if h : d ≠ 0 then if i = (Finsupp.ne_iff.mp h).choose then f d else 0 else 0
  have hp : ∀ i, MvPowerSeries.X i ∣ p i := by
    intro i
    apply MvPowerSeries.X_dvd_iff.mpr
    intro d hdi
    change (if h : d ≠ 0 then if i = (Finsupp.ne_iff.mp h).choose then f d else 0 else 0) = 0
    split_ifs with hd hi
    · have hne := (Finsupp.ne_iff.mp hd).choose_spec
      rw [← hi] at hne
      exact (hne hdi).elim
    · rfl
    · rfl
  have hsum : f = ∑ i, p i := by
    apply MvPowerSeries.ext
    intro d
    rw [map_sum]
    change f d = ∑ i, p i d
    by_cases hd : d = 0
    · subst d
      change f 0 = 0 at hf
      simpa [p] using hf
    · simp [p, hd]
  rw [hsum]
  apply Ideal.sum_mem
  intro i _
  obtain ⟨g, hg⟩ := hp i
  rw [hg]
  exact Ideal.mul_mem_right _ _ (Ideal.subset_span (Set.mem_range_self i))

lemma mvPowerSeries_vars_eq_maximal
    {σ K : Type*} [Fintype σ] [Field K] :
    Ideal.span (Set.range (MvPowerSeries.X : σ → MvPowerSeries σ K)) =
      maximalIdeal (MvPowerSeries σ K) := by
  apply le_antisymm
  · apply Ideal.span_le.mpr
    rintro _ ⟨i, rfl⟩
    change MvPowerSeries.X i ∈ maximalIdeal (MvPowerSeries σ K)
    rw [mem_maximalIdeal]
    change ¬ IsUnit (MvPowerSeries.X i : MvPowerSeries σ K)
    rw [MvPowerSeries.isUnit_iff_constantCoeff]
    simp
  · intro f hf
    apply mvPowerSeries_constantCoeff_zero_mem_vars
    rw [mem_maximalIdeal] at hf
    change ¬ IsUnit f at hf
    rwa [MvPowerSeries.isUnit_iff_constantCoeff, isUnit_iff_ne_zero, not_not] at hf

namespace SectionGenerated
open scoped BigOperators
variable {k K σ : Type*} [Field k] [Field K] [Algebra k K] [Fintype σ]
variable (T : ℕ → Submodule k K) [SetLike.GradedMonoid T]
variable (v : σ → K) (d : σ → ℕ)

lemma adicComplete [IsLocalRing (SectionCompletion.series T)]
    (hd : ∀ i, d i ≠ 0) (hv : ∀ i, v i ∈ T (d i))
    (hgen : ∀ n, T n = Submodule.span k
      (Set.range (fun e : {e : σ →₀ ℕ // Finsupp.weight d e = n} =>
        e.val.prod (fun i j => v i ^ j)))) :
    IsAdicComplete (IsLocalRing.maximalIdeal (SectionCompletion.series T))
      (SectionCompletion.series T) := by
  let := isNoetherianRing T v d hd hv hgen
  have : IsAdicComplete (IsLocalRing.maximalIdeal (MvPowerSeries σ k)) (MvPowerSeries σ k) := by
    rw [← mvPowerSeries_vars_eq_maximal]
    infer_instance
  exact complete_local_of_surjective (substHom T v d hd hv).toRingHom
    (substHom_surjective T v d hd hv hgen)
end SectionGenerated

end


noncomputable section
open Polynomial
open scoped BigOperators
namespace HomogeneousGeneration
variable {k L : Type} [Field k] [Field L] [Algebra k L]

lemma exists_positive_generators (A : Subalgebra k L[X]) [Algebra.FiniteType k A]
    (hA : ∀ p ∈ A, ∀ n, monomial n (p.coeff n) ∈ A)
    (hzero : ∀ p ∈ A, p.coeff 0 ∈ (⊥ : Subalgebra k L)) :
    ∃ (σ : Type) (_ : Fintype σ) (v : σ → L) (d : σ → ℕ),
      (∀ i, d i ≠ 0) ∧
      A = Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i))) := by
  classical
  obtain ⟨s, hs⟩ := (Subalgebra.fg_iff_finiteType A).mpr inferInstance
  let σ := Σ p : (s : Set L[X]), Fin p.val.natDegree
  let v : σ → L := fun i => i.1.val.coeff (i.2.val + 1)
  let d : σ → ℕ := fun i => i.2.val + 1
  refine ⟨σ, inferInstance, v, d, fun i => by simp [d], ?_⟩
  let B := Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i)))
  apply le_antisymm
  · rw [← hs]
    apply Algebra.adjoin_le
    intro p hp
    rw [p.as_sum_range]
    apply B.sum_mem
    intro n hn
    by_cases hn0 : n = 0
    · subst n
      rw [monomial_zero_left]
      obtain ⟨a, ha⟩ := hzero p (hs ▸ Algebra.subset_adjoin hp)
      rw [← ha]
      exact B.algebraMap_mem a
    · apply Algebra.subset_adjoin
      refine ⟨⟨⟨p, hp⟩, ⟨n-1, ?_⟩⟩, ?_⟩
      · change n-1 < p.natDegree
        have := Finset.mem_range.mp hn
        omega
      · change monomial (n-1+1) (p.coeff (n-1+1)) = monomial n (p.coeff n)
        rw [Nat.sub_add_cancel (Nat.one_le_iff_ne_zero.mpr hn0)]
  · apply Algebra.adjoin_le
    rintro _ ⟨i, rfl⟩
    exact hA i.1.val (hs ▸ Algebra.subset_adjoin i.1.property) _

/-- Multiplicative homogeneous monomials describing every degree-n coefficient. -/
def spanPiece {σ : Type} (v : σ → L) (d : σ → ℕ) (n : ℕ) : Submodule k L :=
  Submodule.span k (Set.range (fun e : {e : σ →₀ ℕ // Finsupp.weight d e = n} =>
    e.val.prod (fun i j => v i ^ j)))

lemma monomial_prod {σ : Type} (v : σ → L) (d : σ → ℕ) (e : σ →₀ ℕ) :
    e.prod (fun i j => (monomial (d i) (v i) : L[X]) ^ j) =
      monomial (Finsupp.weight d e) (e.prod (fun i j => v i ^ j)) := by
  classical
  simp only [← C_mul_X_pow_eq_monomial, mul_pow, ← map_pow, Finsupp.prod,
    Finset.prod_mul_distrib, ← map_prod, ← pow_mul, Finset.prod_pow_eq_pow_sum,
    Finsupp.weight_apply, Finsupp.sum, smul_eq_mul]
  congr 2
  apply Finset.sum_congr rfl
  intro i _
  exact Nat.mul_comm _ _

lemma coeff_mem_span {σ : Type} (v : σ → L) (d : σ → ℕ)
    {p : L[X]} (hp : p ∈ Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i))))
    (n : ℕ) : p.coeff n ∈ spanPiece (k := k) v d n := by
  classical
  rw [Algebra.adjoin_range_eq_range_aeval] at hp
  obtain ⟨q, rfl⟩ := hp
  rw [MvPolynomial.as_sum q, map_sum, finsetSum_coeff]
  apply Submodule.sum_mem
  intro e _
  change ((MvPolynomial.aeval (fun i => monomial (d i) (v i)))
    (MvPolynomial.monomial e (q.coeff e))).coeff n ∈ _
  rw [MvPolynomial.aeval_monomial, monomial_prod]
  rw [Polynomial.algebraMap_apply, coeff_C_mul, coeff_monomial]
  split_ifs with he
  · subst n
    simpa only [Algebra.smul_def] using (spanPiece (k := k) v d _).smul_mem (q.coeff e) (Submodule.subset_span ⟨⟨e, rfl⟩, rfl⟩)
  · simp

end HomogeneousGeneration

namespace HomogeneousGeneration
open Polynomial
variable {k L : Type} [Field k] [Field L] [Algebra k L]

lemma piece_eq_span {σ : Type} (v : σ → L) (d : σ → ℕ)
    (T : ℕ → Submodule k L) (A : Subalgebra k L[X])
    (hA : A = Algebra.adjoin k (Set.range (fun i => monomial (d i) (v i))))
    (hT : ∀ n c, c ∈ T n ↔ monomial n c ∈ A) (n : ℕ) :
    T n = spanPiece v d n := by
  classical
  apply le_antisymm
  · intro c hc
    have h := (hT n c).mp hc
    rw [hA] at h
    simpa using coeff_mem_span v d h n
  · apply Submodule.span_le.mpr
    rintro _ ⟨⟨e, he⟩, rfl⟩
    apply (hT n _).mpr
    change monomial n (e.prod (fun i j => v i ^ j)) ∈ A
    rw [← he, ← monomial_prod]
    apply A.prod_mem
    intro i _
    apply A.pow_mem
    rw [hA]
    exact Algebra.subset_adjoin ⟨i, rfl⟩

end HomogeneousGeneration

end


noncomputable section
namespace SectionCompletion
open Polynomial
variable {k K : Type} [Field k] [Field K] [Algebra k K]
variable (T : ℕ → Submodule k K) [SetLike.GradedMonoid T]

lemma finite_positive_presentation [Algebra.FiniteType k (polynomials T)]
    (hzero : T 0 = LinearMap.range (Algebra.linearMap k K)) :
    ∃ (σ : Type) (_ : Fintype σ) (v : σ → K) (d : σ → ℕ),
      (∀ i, d i ≠ 0) ∧ (∀ i, v i ∈ T (d i)) ∧
      ∀ n, T n = Submodule.span k
        (Set.range (fun e : {e : σ →₀ ℕ // Finsupp.weight d e = n} =>
          e.val.prod (fun i j => v i ^ j))) := by
  have hh : ∀ p ∈ polynomials T, ∀ n,
      Polynomial.monomial n (p.coeff n) ∈ polynomials T := by
    intro p hp n
    exact (monomial_mem_polynomials T n _).mpr (hp n)
  have hz : ∀ p ∈ polynomials T, p.coeff 0 ∈ (⊥ : Subalgebra k K) := by
    intro p hp
    have hc := hp 0
    rw [hzero, LinearMap.mem_range] at hc
    obtain ⟨a, ha⟩ := hc
    exact ⟨a, ha⟩
  obtain ⟨σ, hσ, v, d, hd, hA⟩ :=
    HomogeneousGeneration.exists_positive_generators (polynomials T) hh hz
  let := hσ
  refine ⟨σ, hσ, v, d, hd, ?_, ?_⟩
  · intro i
    apply (monomial_mem_polynomials T _ _).mp
    rw [hA]
    exact Algebra.subset_adjoin ⟨i, rfl⟩
  · intro n
    exact HomogeneousGeneration.piece_eq_span v d T (polynomials T) hA
      (fun n c => (monomial_mem_polynomials T n c).symm) n


end SectionCompletion


namespace CompletedCartierChart
variable {k L : Type} [Field k] [Field L] [Algebra k L]
variable (T : ℕ → Submodule k L) [SetLike.GradedMonoid T]
variable (A : Subalgebra k L) (c : L)
variable (h : ∀ n a, a ∈ T n → a / c ^ n ∈ A)

abbrev seriesMap := SectionChartSeries.hom T A c h
abbrev constants : A →ₐ[k] PowerSeries A := IsScalarTower.toAlgHom k A (PowerSeries A)

def chart : Subalgebra k (PowerSeries A) :=
  (seriesMap T A c h).range ⊔ (constants A).range

def sourceHom : SectionCompletion.series T →ₐ[k] chart T A c h :=
  (seriesMap T A c h).codRestrict _ fun _ => (show (seriesMap T A c h).range ≤ chart T A c h from le_sup_left)
    (AlgHom.mem_range_self _ _)

def constantHom : A →ₐ[k] chart T A c h :=
  (constants A).codRestrict _ fun _ => (show (constants A).range ≤ chart T A c h from le_sup_right)
    (AlgHom.mem_range_self _ _)

def evaluation : chart T A c h →ₐ[k] A where
  toRingHom := PowerSeries.constantCoeff.comp (chart T A c h).val.toRingHom
  commutes' a := by simp [PowerSeries.algebraMap_apply]

@[simp] lemma evaluation_constant (a : A) :
    evaluation T A c h (constantHom T A c h a) = a := by
  change PowerSeries.constantCoeff (PowerSeries.C a) = a
  simp

lemma evaluation_surjective : Function.Surjective (evaluation T A c h) :=
  fun a => ⟨constantHom T A c h a, evaluation_constant T A c h a⟩

lemma variable_mem (hc : c ∈ T 1) (hc0 : c ≠ 0) :
    (PowerSeries.X : PowerSeries A) ∈ chart T A c h := by
  let p : SectionCompletion.series T := ⟨PowerSeries.monomial 1 c, by
    intro n; by_cases hn : n = 1
    · subst n; simpa using hc
    · simp [PowerSeries.coeff_monomial, hn]⟩
  have hp : seriesMap T A c h p = PowerSeries.X := by
    ext n
    rw [SectionChartSeries.coeff_hom]
    change PowerSeries.coeff n (PowerSeries.monomial 1 c) / c ^ n =
      ((PowerSeries.coeff n (PowerSeries.X : PowerSeries A) : A) : L)
    by_cases hn : n = 1
    · subst n; simp [hc0]
    · simp [PowerSeries.coeff_monomial, PowerSeries.coeff_X, hn]
  rw [← hp]
  exact (show (seriesMap T A c h).range ≤ chart T A c h from le_sup_left)
    (AlgHom.mem_range_self _ _)

def parameter (hc : c ∈ T 1) (hc0 : c ≠ 0) : chart T A c h :=
  ⟨PowerSeries.X, variable_mem T A c h hc hc0⟩

lemma parameter_ne_zero (hc : c ∈ T 1) (hc0 : c ≠ 0) :
    parameter T A c h hc hc0 ≠ 0 := by
  intro he
  have hh := congrArg Subtype.val he
  exact PowerSeries.X_ne_zero hh

@[simp] lemma evaluation_parameter (hc : c ∈ T 1) (hc0 : c ≠ 0) :
    evaluation T A c h (parameter T A c h hc hc0) = 0 := by
  change PowerSeries.constantCoeff PowerSeries.X = 0
  simp

lemma span_parameter_le_ker (hc : c ∈ T 1) (hc0 : c ≠ 0) :
    Ideal.span {parameter T A c h hc hc0} ≤ RingHom.ker (evaluation T A c h) := by
  apply Ideal.span_le.mpr
  rintro _ rfl
  exact evaluation_parameter T A c h hc hc0

lemma source_generator {σ : Type} [Fintype σ] (v : σ → L) (d : σ → ℕ)
    (hd : ∀ i, d i ≠ 0) (hv : ∀ i, v i ∈ T (d i))
    (hc : c ∈ T 1) (hc0 : c ≠ 0) (i : σ) :
    sourceHom T A c h (SectionGenerated.substHom T v d hd hv (MvPowerSeries.X i)) =
      constantHom T A c h ⟨v i / c ^ d i, h _ _ (hv i)⟩ *
        parameter T A c h hc hc0 ^ d i := by
  apply Subtype.ext
  apply PowerSeries.ext
  intro n
  apply Subtype.ext
  change ((PowerSeries.coeff n (seriesMap T A c h
      (SectionGenerated.substHom T v d hd hv (MvPowerSeries.X i))) : A) : L) = _
  rw [SectionChartSeries.coeff_hom]
  have hs : (SectionGenerated.substHom T v d hd hv
      (MvPowerSeries.X i : MvPowerSeries σ k)).val = SectionGenerated.genSeries v d i := by
    change MvPowerSeries.substAlgHom (R := k) (SectionGenerated.hasSubst v d hd)
      (MvPowerSeries.X i) = _
    rw [MvPowerSeries.substAlgHom_apply, MvPowerSeries.subst_X (SectionGenerated.hasSubst v d hd)]
  rw [hs]
  change PowerSeries.coeff n (SectionGenerated.genSeries v d i) / c ^ n =
    ((PowerSeries.coeff n (PowerSeries.C (⟨v i / c ^ d i, h _ _ (hv i)⟩ : A) *
      PowerSeries.X ^ d i) : A) : L)
  simp only [SectionGenerated.genSeries, PowerSeries.coeff_C_mul_X_pow]
  by_cases hn : n = d i
  · subst n; simp
  · simp [hn]

lemma source_generator_mem_span {σ : Type} [Fintype σ] (v : σ → L) (d : σ → ℕ)
    (hd : ∀ i, d i ≠ 0) (hv : ∀ i, v i ∈ T (d i))
    (hc : c ∈ T 1) (hc0 : c ≠ 0) (i : σ) :
    sourceHom T A c h (SectionGenerated.substHom T v d hd hv (MvPowerSeries.X i)) ∈
      Ideal.span {parameter T A c h hc hc0} := by
  rw [source_generator]
  apply Ideal.mul_mem_left
  exact Ideal.pow_mem_of_mem _ (Ideal.subset_span (Set.mem_singleton _)) _
    (Nat.pos_of_ne_zero (hd i))

lemma source_sub_constant_mem_span_of_generators {σ : Type} [Fintype σ]
    (v : σ → L) (d : σ → ℕ) (hd : ∀ i, d i ≠ 0) (hv : ∀ i, v i ∈ T (d i))
    (hg : ∀ n, T n = HomogeneousGeneration.spanPiece v d n)
    (hc : c ∈ T 1) (hc0 : c ≠ 0) (f : SectionCompletion.series T) :
    sourceHom T A c h f -
      constantHom T A c h (evaluation T A c h (sourceHom T A c h f)) ∈
        Ideal.span {parameter T A c h hc hc0} := by
  let ψ := (sourceHom T A c h).comp (SectionGenerated.substHom T v d hd hv)
  let I : Ideal (chart T A c h) := Ideal.span {parameter T A c h hc hc0}
  have hvars : Ideal.span (Set.range (MvPowerSeries.X : σ → MvPowerSeries σ k)) ≤
      I.comap ψ.toRingHom := by
    apply Ideal.span_le.mpr
    rintro _ ⟨i,rfl⟩
    exact source_generator_mem_span T A c h v d hd hv hc hc0 i
  obtain ⟨g,rfl⟩ := SectionGenerated.substHom_surjective T v d hd hv hg f
  have hzero : MvPowerSeries.constantCoeff (g - MvPowerSeries.C
      (MvPowerSeries.constantCoeff g)) = 0 := by simp
  have hm := hvars (mvPowerSeries_constantCoeff_zero_mem_vars _ hzero)
  change ψ (g - MvPowerSeries.C (MvPowerSeries.constantCoeff g)) ∈ I at hm
  have hcst : ψ (MvPowerSeries.C (MvPowerSeries.constantCoeff g)) =
      algebraMap k (chart T A c h) (MvPowerSeries.constantCoeff g) := ψ.commutes _
  rw [map_sub, hcst] at hm
  have he := span_parameter_le_ker T A c h hc hc0 hm
  change evaluation T A c h (ψ g -
    algebraMap k (chart T A c h) (MvPowerSeries.constantCoeff g)) = 0 at he
  rw [map_sub, AlgHom.commutes, sub_eq_zero] at he
  change ψ g - constantHom T A c h (evaluation T A c h (ψ g)) ∈ I
  rw [he, AlgHom.commutes]
  exact hm

lemma source_sub_constant_mem_span [Algebra.FiniteType k (SectionCompletion.polynomials T)]
    (hz : T 0 = LinearMap.range (Algebra.linearMap k L))
    (hc : c ∈ T 1) (hc0 : c ≠ 0) (f : SectionCompletion.series T) :
    sourceHom T A c h f -
      constantHom T A c h (evaluation T A c h (sourceHom T A c h f)) ∈
        Ideal.span {parameter T A c h hc hc0} := by
  obtain ⟨σ,hσ,v,d,hd,hv,hg⟩ := SectionCompletion.finite_positive_presentation T hz
  let := hσ
  exact source_sub_constant_mem_span_of_generators T A c h v d hd hv hg hc hc0 f

lemma generators_sup_top :
    (sourceHom T A c h).range ⊔ (constantHom T A c h).range = ⊤ := by
  apply Subalgebra.map_injective (f := (chart T A c h).val) Subtype.val_injective
  rw [Algebra.map_sup, Algebra.map_top, Subalgebra.range_val,
    ← AlgHom.range_comp, ← AlgHom.range_comp]
  rfl

lemma sub_constant_mem_span [Algebra.FiniteType k (SectionCompletion.polynomials T)]
    (hz : T 0 = LinearMap.range (Algebra.linearMap k L))
    (hc : c ∈ T 1) (hc0 : c ≠ 0) (b : chart T A c h) :
    b - constantHom T A c h (evaluation T A c h b) ∈
      Ideal.span {parameter T A c h hc hc0} := by
  let I : Ideal (chart T A c h) := Ideal.span {parameter T A c h hc hc0}
  let q := Ideal.Quotient.mkₐ k I
  have he : q = (q.comp (constantHom T A c h)).comp (evaluation T A c h) := by
    apply AlgHom.equalizer_eq_top.mp
    apply top_unique
    rw [← generators_sup_top T A c h]
    apply sup_le
    · rintro _ ⟨f,rfl⟩
      apply Ideal.Quotient.eq.mpr
      exact source_sub_constant_mem_span T A c h hz hc hc0 f
    · rintro _ ⟨a,rfl⟩
      change q (constantHom T A c h a) =
        q (constantHom T A c h (evaluation T A c h (constantHom T A c h a)))
      rw [evaluation_constant]
  exact Ideal.Quotient.eq.mp (DFunLike.congr_fun he b)

lemma ker_evaluation [Algebra.FiniteType k (SectionCompletion.polynomials T)]
    (hz : T 0 = LinearMap.range (Algebra.linearMap k L))
    (hc : c ∈ T 1) (hc0 : c ≠ 0) :
    RingHom.ker (evaluation T A c h) = Ideal.span {parameter T A c h hc hc0} := by
  apply le_antisymm
  · intro b hb
    have he : evaluation T A c h b = 0 := hb
    have hh := sub_constant_mem_span T A c h hz hc hc0 b
    simpa only [he, map_zero, sub_zero] using hh
  · exact span_parameter_le_ker T A c h hc hc0

noncomputable def exceptionalEquiv
    [Algebra.FiniteType k (SectionCompletion.polynomials T)]
    (hz : T 0 = LinearMap.range (Algebra.linearMap k L))
    (hc : c ∈ T 1) (hc0 : c ≠ 0) :
    (chart T A c h ⧸ Ideal.span {parameter T A c h hc hc0}) ≃ₐ[k] A :=
  (Ideal.quotientEquivAlgOfEq k (ker_evaluation T A c h hz hc hc0).symm).trans
    (Ideal.quotientKerAlgEquivOfSurjective (evaluation_surjective T A c h))

end CompletedCartierChart

namespace ExplicitCone

lemma actualCompletion_noetherian : IsNoetherianRing completedRing := by
  obtain ⟨σ,hσ,v,d,hd,hv,hg⟩ := SectionCompletion.finite_positive_presentation pieces zero_piece
  let := hσ
  exact SectionGenerated.isNoetherianRing pieces v d hd hv hg

end ExplicitCone


end

end OAI