import OAI.AlgebraicGeometry.SurfaceCones.KummerUnramifiedNormalization

namespace OAI

noncomputable section
open Algebra MvPolynomial
open nonZeroDivisors
namespace KummerTriple
open KummerLines
variable (p : ℕ) [Fact p.Prime]

/-- The actual blowup chart open containing s=t=0 (the intersection of
its exceptional divisor with the strict transform of y=0). -/
def cX (i : Fin 2) : C := X i
def chartDenominator : C := (cX 0 - 1) * (cX 0 * cX 1 - 1) * (1 - cX 1)
lemma chartDenominator_ne_zero : chartDenominator ≠ 0 := by
  let f : C →+* ℂ := MvPolynomial.eval ![(0 : ℂ), 2]
  have hf (i : Fin 2) : f (cX i) = ![(0 : ℂ), 2] i := by
    exact MvPolynomial.eval_X i
  intro hz
  have he := congrArg f hz
  simp only [chartDenominator, map_mul, map_sub, map_one, map_zero, hf] at he
  norm_num at he
lemma planeMap_injective : Function.Injective (planeMap p) := by
  intro a b h
  apply chartMap_injective p
  exact congrArg (fun g : C →ₐ[ℂ] L p => g a) (planeMap_comp p).symm |>.trans
    ((congrArg (fun z : B p => (z : L p)) h).trans
      (congrArg (fun g : C →ₐ[ℂ] L p => g b) (planeMap_comp p)))

def bDenominator : B p := planeMap p chartDenominator
lemma bDenominator_ne_zero : bDenominator p ≠ 0 :=
  (map_ne_zero_iff _ (planeMap_injective p)).mpr chartDenominator_ne_zero
lemma bPowers_le : Submonoid.powers (bDenominator p) ≤ (B p)⁰ := by
  rintro _ ⟨n, rfl⟩
  exact mem_nonZeroDivisors_of_ne_zero (pow_ne_zero n (bDenominator_ne_zero p))

def S := Localization.Away (bDenominator p)
instance : CommRing (S p) := inferInstanceAs (CommRing (Localization.Away (bDenominator p)))
instance : Algebra (B p) (S p) :=
  OreLocalization.instAlgebra (R := B p) (R₀ := B p)
    (S := Submonoid.powers (bDenominator p))
instance : IsLocalization.Away (bDenominator p) (S p) := Localization.isLocalization
instance : IsDomain (S p) :=
  IsLocalization.isDomain_of_le_nonZeroDivisors _ (bPowers_le p)
instance : IsIntegrallyClosed (S p) :=
  isIntegrallyClosed_of_isLocalization (S p) (Submonoid.powers (bDenominator p)) (bPowers_le p)
instance : Algebra.Etale (B p) (S p) :=
  Algebra.Etale.of_isLocalizationAway (bDenominator p)
instance : IsRegularRing (S p) := EtaleRegular.regular (B p) (S p)

lemma bDenominator_unit_in_L : IsUnit (algebraMap (B p) (L p) (bDenominator p)) := by
  apply isUnit_iff_ne_zero.mpr
  exact (map_ne_zero_iff _ (Subtype.val_injective)).mpr (bDenominator_ne_zero p)

instance : Algebra (S p) (L p) :=
  (IsLocalization.Away.lift (bDenominator p) (bDenominator_unit_in_L p) : S p →+* L p).toAlgebra
instance : IsScalarTower (B p) (S p) (L p) :=
  IsScalarTower.of_algebraMap_eq' (R := B p) (S := S p) (A := L p)
    (IsLocalization.Away.lift_comp (S := S p) (bDenominator p) (bDenominator_unit_in_L p)).symm
instance : Module.IsTorsionFree (S p) (L p) := by
  apply Module.isTorsionFree_iff_algebraMap_injective.mpr
  change Function.Injective (IsLocalization.Away.lift (bDenominator p) (bDenominator_unit_in_L p))
  apply (IsLocalization.lift_injective_iff _).mpr
  intro a b
  rw [(IsLocalization.injective (S p) (bPowers_le p)).eq_iff]
  change a = b ↔ (a : L p) = (b : L p)
  exact Subtype.val_injective.eq_iff.symm
instance : Algebra C (S p) := (algebraMap (B p) (S p)).comp (algebraMap C (B p)) |>.toAlgebra
instance : IsScalarTower C (B p) (S p) :=
  IsScalarTower.of_algebraMap_eq' (R := C) (S := B p) (A := S p) rfl
instance : IsScalarTower C (S p) (L p) :=
  IsScalarTower.of_algebraMap_eq' (R := C) (S := S p) (A := L p) (by
  rw [IsScalarTower.algebraMap_eq C (B p) (L p), IsScalarTower.algebraMap_eq (B p) (S p) (L p)]
  rfl)

def remainingRoot : Fin 3 → L p := ![root p 2, root p 3, root p 4 / root p 0]
def remainingForm : Fin 3 → C := ![cX 0 - 1, cX 0 * cX 1 - 1, 1 - cX 1]
lemma remaining_dvd (i : Fin 3) : remainingForm i ∣ chartDenominator := by
  fin_cases i <;> simp only [remainingForm, chartDenominator]
  · exact dvd_mul_of_dvd_left (dvd_mul_right _ _) _
  · exact dvd_mul_of_dvd_left (dvd_mul_left _ _) _
  · exact dvd_mul_left _ _
lemma remaining_unit (i : Fin 3) : IsUnit (algebraMap C (S p) (remainingForm i)) :=
  IsLocalization.Away.isUnit_of_dvd (S := S p) (bDenominator p)
    (map_dvd (planeMap p) (remaining_dvd i))
lemma chartMap_X (i : Fin 2) : chartMap p (cX i) =
    ![algebraMap R (L p) (X 0),
      algebraMap R (L p) (X 1) / algebraMap R (L p) (X 0)] i := by
  change MvPolynomial.aeval _ (X i) = _
  exact MvPolynomial.aeval_X _ _
lemma remainingRoot_pow (i : Fin 3) : remainingRoot p i ^ p =
    algebraMap C (L p) (remainingForm i) := by
  fin_cases i
  · change root p 2 ^ p = chartMap p (cX 0 - 1)
    rw [root_pow, map_sub, map_one]
    rw [chartMap_X] 
    change algebraMap R (L p) (X 0 - 1) = _
    rw [map_sub, map_one]
    rfl
  · change root p 3 ^ p = chartMap p (cX 0 * cX 1 - 1)
    rw [root_pow, map_sub, map_one, map_mul]
    rw [chartMap_X, chartMap_X]
    change algebraMap R (L p) (X 1 - 1) = algebraMap R (L p) (X 0) *
      (algebraMap R (L p) (X 1) / algebraMap R (L p) (X 0)) - 1
    rw [map_sub, map_one]
    have hx : algebraMap R (L p) (X 0) ≠ 0 := by
      change algebraMap R (L p) (lineForm 0) ≠ 0
      rw [← root_pow p 0]
      exact pow_ne_zero _ (root_ne_zero p 0)
    rw [mul_div_cancel₀ _ hx]
  · change (root p 4 / root p 0) ^ p = chartMap p (1 - cX 1)
    rw [div_pow, root_pow, root_pow, map_sub, map_one]
    rw [chartMap_X]
    change algebraMap R (L p) (X 0 - X 1) / algebraMap R (L p) (X 0) =
      1 - algebraMap R (L p) (X 1) / algebraMap R (L p) (X 0)
    rw [map_sub, sub_div]
    have hx : algebraMap R (L p) (X 0) ≠ 0 := by
      change algebraMap R (L p) (lineForm 0) ≠ 0
      rw [← root_pow p 0]
      exact pow_ne_zero _ (root_ne_zero p 0)
    rw [div_self hx]
lemma exponent_unit : IsUnit (p : S p) := by
  have hC : IsUnit (p : ℂ) := isUnit_iff_ne_zero.mpr (by exact_mod_cast (NeZero.ne p))
  have hB : IsUnit (p : B p) := by simpa using hC.map (algebraMap ℂ (B p))
  simpa using hB.map (algebraMap (B p) (S p))

def remainingRoots : Finset (L p) := by
  classical
  exact Finset.univ.image (fun i : Fin 3 => remainingRoot p i)
abbrev chartRootAlgebra := Algebra.adjoin (S p) (remainingRoots p : Set (L p))

theorem chartRootAlgebra_finiteFreeEtale :
    Algebra.Etale (S p) (chartRootAlgebra p) ∧
    Module.Finite (S p) (chartRootAlgebra p) ∧
    Module.Free (S p) (chartRootAlgebra p) ∧
    IsIntegrallyClosed (chartRootAlgebra p) := by
  apply KummerEtale.finite_unit_roots (R := S p) (L := L p) p
    (NeZero.pos p) (exponent_unit p) (remainingRoots p)
  intro x hx
  classical
  obtain ⟨i, -, rfl⟩ := Finset.mem_image.mp (show x ∈ Finset.univ.image _ from hx)
  refine ⟨(remaining_unit p i).unit, ?_⟩
  rw [IsUnit.unit_spec, ← IsScalarTower.algebraMap_apply C (S p) (L p)]
  exact remainingRoot_pow p i

theorem chartRootAlgebra_regular : IsRegularRing (chartRootAlgebra p) := by
  have := (chartRootAlgebra_finiteFreeEtale p).1
  exact EtaleRegular.regular (S p) (chartRootAlgebra p)
end KummerTriple

end


noncomputable section
namespace KummerEtale
variable {R K L : Type*} [CommRing R] [Field K] [Field L]
  [Algebra R K] [IsFractionRing R K] [Algebra R L] [Algebra K L]
  [IsScalarTower R K L]
/-- A subalgebra of the same function field containing the original finite
field generators has that field as its fraction field. The subalgebra is
allowed to contain additional polynomial coordinates and inverted units. -/
theorem fractionRing_of_generators (C : Subalgebra R L) (s : Set L)
    (hs : Algebra.adjoin K s = ⊤) (hC : s ⊆ C) : IsFractionRing C L := by
  let g : FractionRing C →+* L := IsFractionRing.lift (g := C.val.toRingHom)
    (K := FractionRing C) Subtype.val_injective
  have hg (x : C) : g (algebraMap C (FractionRing C) x) = (x : L) :=
    IsFractionRing.lift_algebraMap Subtype.val_injective x
  have hK (x : K) : algebraMap K L x ∈ g.fieldRange := by
    obtain ⟨a, b, hb, rfl⟩ := IsFractionRing.div_surjective R x
    rw [map_div₀]
    apply g.fieldRange.div_mem
    · refine ⟨algebraMap C (FractionRing C) (algebraMap R C a), ?_⟩
      rw [hg]
      exact IsScalarTower.algebraMap_apply R K L a
    · refine ⟨algebraMap C (FractionRing C) (algebraMap R C b), ?_⟩
      rw [hg]
      exact IsScalarTower.algebraMap_apply R K L b
  let D : Subalgebra K L := { g.fieldRange.toSubring with algebraMap_mem' := hK }
  have hD : Algebra.adjoin K s ≤ D := by
    refine Algebra.adjoin_le ?_
    intro x hx
    exact ⟨algebraMap C (FractionRing C) ⟨x, hC hx⟩, hg _⟩
  have hsurj : Function.Surjective g := by
    intro x
    exact hD (by rw [hs]; trivial)
  have : FaithfulSMul C L := (faithfulSMul_iff_algebraMap_injective C L).mpr
    Subtype.val_injective
  apply IsFractionRing.of_field
  intro x
  obtain ⟨y, rfl⟩ := hsurj x
  obtain ⟨a, b, hb, rfl⟩ := IsFractionRing.div_surjective C y
  exact ⟨a, b, by rw [map_div₀, hg, hg]; rfl⟩
end KummerEtale


open Algebra MvPolynomial
open nonZeroDivisors
namespace KummerTriple
open KummerLines
variable (p : ℕ) [Fact p.Prime]
instance : IsDomain C := inferInstanceAs (IsDomain (MvPolynomial (Fin 2) ℂ))
instance : Module.IsTorsionFree C (L p) :=
  Module.isTorsionFree_iff_algebraMap_injective.mpr (chartMap_injective p)

/-- The actual open D((s−1)(st−1)(1−t)) of the blowup chart. -/
def T := Localization.Away chartDenominator
instance : CommRing T := inferInstanceAs (CommRing (Localization.Away chartDenominator))
instance : Algebra C T := OreLocalization.instAlgebra (R := C) (R₀ := C)
  (S := Submonoid.powers chartDenominator)
instance : IsLocalization.Away chartDenominator T := Localization.isLocalization
instance coordinateMappedLocalization :
    IsLocalization (Algebra.algebraMapSubmonoid (B p) (Submonoid.powers chartDenominator)) (S p) := by
  change IsLocalization ((Submonoid.powers chartDenominator).map (algebraMap C (B p))) (S p)
  rw [Submonoid.map_powers]
  exact inferInstanceAs (IsLocalization.Away (bDenominator p) (S p))
instance : Algebra T (S p) := localizationAlgebra (Submonoid.powers chartDenominator) (B p)
instance : IsScalarTower C T (S p) :=
  isScalarTower_localizationAlgebra (Submonoid.powers chartDenominator) (B p)
instance : Algebra T (L p) := ((algebraMap (S p) (L p)).comp (algebraMap T (S p))).toAlgebra
instance : IsScalarTower T (S p) (L p) :=
  IsScalarTower.of_algebraMap_eq' (R := T) (S := S p) (A := L p) rfl
instance : IsScalarTower C T (L p) :=
  IsScalarTower.of_algebraMap_eq' (R := C) (S := T) (A := L p) (by
  rw [IsScalarTower.algebraMap_eq C (S p) (L p), IsScalarTower.algebraMap_eq C T (S p)]
  rfl)
instance : Algebra.IsIntegral T (S p) := ⟨isIntegral_localization⟩
instance : Module.Finite T (S p) :=
  Module.Finite.of_isLocalizedModule (Submonoid.powers chartDenominator)
    (IsScalarTower.toAlgHom C (B p) (S p)).toLinearMap

instance : Algebra T (chartRootAlgebra p) :=
  ((algebraMap (S p) (chartRootAlgebra p)).comp (algebraMap T (S p))).toAlgebra
instance : IsScalarTower T (S p) (chartRootAlgebra p) :=
  IsScalarTower.of_algebraMap_eq' (R := T) (S := S p) (A := chartRootAlgebra p) rfl
instance : IsScalarTower T (chartRootAlgebra p) (L p) :=
  IsScalarTower.of_algebraMap_eq' (R := T) (S := chartRootAlgebra p) (A := L p) (by
  rw [IsScalarTower.algebraMap_eq T (S p) (L p),
    IsScalarTower.algebraMap_eq (S p) (chartRootAlgebra p) (L p)]
  rfl)
instance : Algebra C (chartRootAlgebra p) :=
  ((algebraMap (S p) (chartRootAlgebra p)).comp (algebraMap C (S p))).toAlgebra
instance : IsScalarTower C (S p) (chartRootAlgebra p) :=
  IsScalarTower.of_algebraMap_eq' (R := C) (S := S p) (A := chartRootAlgebra p) rfl
instance : IsScalarTower C (chartRootAlgebra p) (L p) :=
  IsScalarTower.of_algebraMap_eq' (R := C) (S := chartRootAlgebra p) (A := L p) (by
  rw [IsScalarTower.algebraMap_eq C (S p) (L p),
    IsScalarTower.algebraMap_eq (S p) (chartRootAlgebra p) (L p)]
  rfl)
instance : Module.Finite (S p) (chartRootAlgebra p) := (chartRootAlgebra_finiteFreeEtale p).2.1
instance : Module.Finite T (chartRootAlgebra p) := Module.Finite.trans (S p) (chartRootAlgebra p)
instance : IsIntegrallyClosed (chartRootAlgebra p) := (chartRootAlgebra_finiteFreeEtale p).2.2.2

lemma coordinateRoot_mem_chartRootAlgebra (i : Fin 2) :
    coordinateRoot p i ∈ chartRootAlgebra p := by
  have h := (chartRootAlgebra p).algebraMap_mem (algebraMap (B p) (S p) (bRoot p i))
  rw [← IsScalarTower.algebraMap_apply (B p) (S p) (L p)] at h
  exact h
lemma remainingRoot_mem_chartRootAlgebra (i : Fin 3) :
    remainingRoot p i ∈ chartRootAlgebra p := by
  apply Algebra.subset_adjoin
  classical
  exact Finset.mem_image.mpr ⟨i, Finset.mem_univ i, rfl⟩
lemma allRoots_mem_chartRootAlgebra (i : Fin 5) :
    root p i ∈ chartRootAlgebra p := by
  fin_cases i
  · exact coordinateRoot_mem_chartRootAlgebra p 0
  · change root p 1 ∈ chartRootAlgebra p
    rw [original_root_one p]
    exact Subalgebra.mul_mem _ (coordinateRoot_mem_chartRootAlgebra p 0)
      (coordinateRoot_mem_chartRootAlgebra p 1)
  · exact remainingRoot_mem_chartRootAlgebra p 0
  · exact remainingRoot_mem_chartRootAlgebra p 1
  · change root p 4 ∈ chartRootAlgebra p
    have he : root p 4 = coordinateRoot p 0 * remainingRoot p 2 := by
      change root p 4 = root p 0 * (root p 4 / root p 0)
      exact (mul_div_cancel₀ _ (root_ne_zero p 0)).symm
    rw [he]
    exact Subalgebra.mul_mem _ (coordinateRoot_mem_chartRootAlgebra p 0)
      (remainingRoot_mem_chartRootAlgebra p 2)

/- The fraction field is the SAME original Kummer field, not a proper
subcover of it. The blowdown supplies the original plane action. -/
instance : Algebra R (S p) :=
  ((algebraMap C (S p)).comp (algebraMap R C)).toAlgebra
instance : IsScalarTower R C (S p) :=
  IsScalarTower.of_algebraMap_eq' (R := R) (S := C) (A := S p) rfl
instance : IsScalarTower R (S p) (L p) :=
  IsScalarTower.of_algebraMap_eq' (R := R) (S := S p) (A := L p) (by
    rw [IsScalarTower.algebraMap_eq R C (L p), IsScalarTower.algebraMap_eq C (S p) (L p)]
    rfl)
instance : Algebra R (chartRootAlgebra p) :=
  ((algebraMap (S p) (chartRootAlgebra p)).comp (algebraMap R (S p))).toAlgebra
instance : IsScalarTower R (S p) (chartRootAlgebra p) :=
  IsScalarTower.of_algebraMap_eq' (R := R) (S := S p) (A := chartRootAlgebra p) rfl
instance : IsScalarTower R (chartRootAlgebra p) (L p) :=
  IsScalarTower.of_algebraMap_eq' (R := R) (S := chartRootAlgebra p) (A := L p) (by
    rw [IsScalarTower.algebraMap_eq R (S p) (L p),
      IsScalarTower.algebraMap_eq (S p) (chartRootAlgebra p) (L p)]
    rfl)
instance : IsFractionRing (chartRootAlgebra p) (L p) := by
  apply KummerEtale.fractionRing_of_generators ((chartRootAlgebra p).restrictScalars R)
    (Set.range (KummerCover.fieldRoot (p := p) radicand))
    (KummerCover.fieldRoot_generates radicand)
  rintro x ⟨i, rfl⟩
  exact allRoots_mem_chartRootAlgebra p i

/-- The entire normalization over this actual triple-point blowup open is the
regular algebra of the two ramified coordinates and three unit roots. -/
theorem chart_normalization : integralClosure T (L p) =
    (chartRootAlgebra p).restrictScalars T := by
  apply le_antisymm
  · intro x hx
    have hx' : IsIntegral (chartRootAlgebra p) x :=
      ((mem_integralClosure_iff T (L p)).mp hx).tower_top
    obtain ⟨a, ha⟩ := (isIntegrallyClosed_iff (L p)).mp
      (inferInstance : IsIntegrallyClosed (chartRootAlgebra p)) hx'
    change (a : L p) = x at ha
    exact ha ▸ a.property
  · intro x hx
    exact (mem_integralClosure_iff T (L p)).mpr
      ((Algebra.IsIntegral.isIntegral (R := T) (⟨x, hx⟩ : chartRootAlgebra p)).map
        (IsScalarTower.toAlgHom T (chartRootAlgebra p) (L p)))

/-- Regularity is asserted for the actual integral closure, not just a
subextension or the conditional diagonal coordinate algebra. -/
theorem chart_normalization_regular : IsRegularRing (integralClosure T (L p)) := by
  let : IsRegularRing ((chartRootAlgebra p).restrictScalars T) := chartRootAlgebra_regular p
  exact IsRegularRing.of_ringEquiv
    (Subalgebra.equivOfEq _ _ (chart_normalization p).symm).toRingEquiv
open scoped TensorProduct
/-- This normalization is the actual restriction of the normalization of
the blowup chart in the original five-root field. -/
def chartRestrictionEquiv :
    T ⊗[C] integralClosure C (L p) ≃ₐ[T] integralClosure T (L p) := by
  have : Algebra.Etale C T := Algebra.Etale.of_isLocalizationAway chartDenominator
  exact (AlgEquiv.ofBijective (TensorProduct.toIntegralClosure C T (L p))
      TensorProduct.toIntegralClosure_bijective_of_smooth).trans
    (IsLocalization.algebraLid (Submonoid.powers chartDenominator) T (L p)).mapIntegralClosure

theorem normalization_chart_regular : IsRegularRing (T ⊗[C] integralClosure C (L p)) := by
  have : IsRegularRing (integralClosure T (L p)) := chart_normalization_regular p
  exact IsRegularRing.of_ringEquiv
    (R := integralClosure T (L p)) (chartRestrictionEquiv p).symm.toRingEquiv
end KummerTriple


end


section

noncomputable section

namespace ExplicitCone
open scoped BigOperators
open Polynomial
abbrev L := KummerLines.L 7
abbrev R := KummerLines.R
abbrev K := KummerLines.K
abbrev y (i : Fin 5) : L := KummerCover.fieldRoot (p := 7) KummerLines.radicand i

def z : Fin 6 → L := Fin.cases 1 y

def pairs : Fin 3 → Fin 6 × Fin 6 := ![(1, 4), (2, 3), (5, 0)]

lemma y_ne_zero (i : Fin 5) : y i ≠ 0 := by
  intro h
  have hh := KummerCover.fieldRoot_pow (p := 7) KummerLines.radicand i
  change y i ^ 7 = algebraMap K L (KummerLines.radicand i) at hh
  rw [h, zero_pow (by decide : 7 ≠ 0)] at hh
  have hr : KummerLines.radicand i ≠ 0 := by
    simpa only [KummerLines.radicand, map_zero] using
      (IsFractionRing.injective R K).ne (KummerLines.prime_lineForm i).ne_zero
  exact hr ((algebraMap K L).injective (by simpa using hh.symm))

lemma z_ne_zero (i : Fin 6) : z i ≠ 0 := by
  refine Fin.cases ?_ (fun j => ?_) i
  · simp [z]
  · exact y_ne_zero j

lemma roots_generate_over_complex : IntermediateField.adjoin ℂ (Set.range y) = ⊤ := by
  let S := IntermediateField.adjoin ℂ (Set.range y)
  have hymem (i : Fin 5) : y i ∈ S := IntermediateField.subset_adjoin _ _ ⟨i, rfl⟩
  have hx (i : Fin 2) : algebraMap R L (MvPolynomial.X i) ∈ S := by
    fin_cases i
    · have hh := pow_mem (hymem 0) 7
      have he : y 0 ^ 7 = algebraMap R L (MvPolynomial.X 0) := by
        rw [KummerCover.fieldRoot_pow]
        exact (IsScalarTower.algebraMap_apply R K L (MvPolynomial.X 0)).symm
      exact he ▸ hh
    · have hh := pow_mem (hymem 1) 7
      have he : y 1 ^ 7 = algebraMap R L (MvPolynomial.X 1) := by
        rw [KummerCover.fieldRoot_pow]
        exact (IsScalarTower.algebraMap_apply R K L (MvPolynomial.X 1)).symm
      exact he ▸ hh
  have hR (a : R) : algebraMap R L a ∈ S := by
    induction a using MvPolynomial.induction_on with
    | C c => exact S.algebraMap_mem c
    | add p q hp hq => simpa only [map_add] using S.add_mem hp hq
    | mul_X p i hp => simpa only [map_mul] using S.mul_mem hp (hx i)
  have hK (a : K) : algebraMap K L a ∈ S := by
    obtain ⟨p, q, -, rfl⟩ := IsFractionRing.div_surjective R a
    simpa only [map_div₀, ← IsScalarTower.algebraMap_apply] using S.div_mem (hR p) (hR q)
  apply top_unique
  intro a ha
  clear ha
  have hh : a ∈ Algebra.adjoin K (Set.range y) := by
    rw [KummerCover.fieldRoot_generates]; trivial
  induction hh using Algebra.adjoin_induction with
  | mem a ha => exact IntermediateField.subset_adjoin ℂ _ ha
  | algebraMap a => exact hK a
  | add a b ha hb h₁ h₂ => exact S.add_mem h₁ h₂
  | mul a b ha hb h₁ h₂ => exact S.mul_mem h₁ h₂

/-- The eighteen degree-one sections in the chosen rational trivialization of H.
The original y-indexing is shifted by one, so z₀=1 is the sixth line. -/
def sectionCoefficient (i : Fin 6 × Fin 3) : L :=
  z i.1 * z (pairs i.2).1 * z (pairs i.2).2

def generator (i : Fin 6 × Fin 3) : RatFunc L :=
  RatFunc.C (sectionCoefficient i) * RatFunc.X

abbrev algebra := Algebra.adjoin ℂ (Set.range generator)

instance finiteType : Algebra.FiniteType ℂ algebra :=
  Algebra.FiniteType.adjoin_of_finite (Set.finite_range generator)

instance noetherian : IsNoetherianRing algebra := Algebra.FiniteType.isNoetherianRing ℂ algebra

lemma generators_field : IntermediateField.adjoin ℂ (Set.range generator) = ⊤ := by
  let S := IntermediateField.adjoin ℂ (Set.range generator)
  have hg (i : Fin 6 × Fin 3) : generator i ∈ S :=
    IntermediateField.subset_adjoin ℂ _ ⟨i, rfl⟩
  have hc (i : Fin 6) : RatFunc.C (z i) ∈ S := by
    have hu : (RatFunc.C (z (pairs 0).1 * z (pairs 0).2) * RatFunc.X : RatFunc L) ≠ 0 :=
      mul_ne_zero ((by simpa only [map_zero] using RatFunc.C_injective.ne (mul_ne_zero (z_ne_zero (pairs 0).1) (z_ne_zero (pairs 0).2))))
        RatFunc.X_ne_zero
    have hh : RatFunc.C (z i) = generator (i, 0) / generator (0, 0) := by
      change RatFunc.C (z i) =
        (RatFunc.C (z i * z (pairs 0).1 * z (pairs 0).2) * RatFunc.X) /
        (RatFunc.C (1 * z (pairs 0).1 * z (pairs 0).2) * RatFunc.X)
      apply (eq_div_iff (by simpa only [one_mul] using hu)).mpr
      simp only [one_mul, map_mul]
      ring
    rw [hh]
    exact S.div_mem (hg (i, 0)) (hg (0, 0))
  have hCL (a : L) : RatFunc.C a ∈ S := by
    have hroot : IntermediateField.adjoin ℂ (Set.range y) ≤ S.comap (IsScalarTower.toAlgHom ℂ L (RatFunc L)) := by
      apply IntermediateField.adjoin_le_iff.mpr
      rintro _ ⟨i, rfl⟩
      exact hc i.succ
    rw [roots_generate_over_complex] at hroot
    exact hroot (show a ∈ (⊤ : IntermediateField ℂ L) from trivial)
  have hX : (RatFunc.X : RatFunc L) ∈ S := by
    have hn : RatFunc.C (z (pairs 0).1 * z (pairs 0).2) ≠ (0 : RatFunc L) :=
      (by simpa only [map_zero] using RatFunc.C_injective.ne (mul_ne_zero (z_ne_zero (pairs 0).1) (z_ne_zero (pairs 0).2)))
    have he : (RatFunc.X : RatFunc L) = generator (0, 0) / RatFunc.C (z (pairs 0).1 * z (pairs 0).2) := by
      change RatFunc.X = RatFunc.C (1 * z (pairs 0).1 * z (pairs 0).2) * RatFunc.X /
        RatFunc.C (z (pairs 0).1 * z (pairs 0).2)
      simp only [one_mul]
      rw [mul_div_cancel_left₀ _ hn]
    rw [he]
    exact S.div_mem (hg (0, 0)) (hCL _)
  have hP (p : L[X]) : algebraMap L[X] (RatFunc L) p ∈ S := by
    induction p using Polynomial.induction_on' with
    | add p q hp hq => simpa only [map_add] using S.add_mem hp hq
    | monomial n a =>
      rw [← Polynomial.C_mul_X_pow_eq_monomial, map_mul, map_pow, RatFunc.algebraMap_C,
        RatFunc.algebraMap_X]
      exact S.mul_mem (hCL a) (pow_mem hX n)
  apply top_unique
  intro a _
  obtain ⟨p, q, -, rfl⟩ := IsFractionRing.div_surjective L[X] a
  exact S.div_mem (hP p) (hP q)

instance fractionRing : IsFractionRing algebra (RatFunc L) :=
  IsFractionRing.of_field algebra (RatFunc L) fun a => by
    have ha : a ∈ IntermediateField.adjoin ℂ (Set.range generator) := by
      rw [generators_field]; trivial
    obtain ⟨x, hx, y, hy, h⟩ := IntermediateField.mem_adjoin_iff_div.mp ha
    exact ⟨⟨x, hx⟩, ⟨y, hy⟩, h⟩

end ExplicitCone

end


noncomputable section
namespace ExplicitCone
open MvPolynomial

/-- The literal affine coordinate functions for the degree-one section
z₀z₁z₄ in the fixed H=3J−E linear system. -/
def sectionRatio (i : Fin 6 × Fin 3) : L :=
  sectionCoefficient i / sectionCoefficient (0, 0)
def sectionChart : Subalgebra ℂ L := Algebra.adjoin ℂ (Set.range sectionRatio)
def ratioQ : L := y 1 * y 2 / (y 0 * y 3)
def ratioR : L := y 4 / (y 0 * y 3)

lemma sectionCoefficient_base : sectionCoefficient (0, 0) = y 0 * y 3 := by
  change 1 * y 0 * y 3 = y 0 * y 3
  rw [one_mul]
lemma sectionCoefficient_base_ne_zero : sectionCoefficient (0, 0) ≠ 0 := by
  rw [sectionCoefficient_base]
  exact mul_ne_zero (y_ne_zero 0) (y_ne_zero 3)
lemma sectionRatio_zero (i : Fin 6) : sectionRatio (i, 0) = z i := by
  unfold sectionRatio
  rw [sectionCoefficient_base]
  change z i * y 0 * y 3 / (y 0 * y 3) = z i
  rw [mul_assoc, mul_div_cancel_right₀ _ (mul_ne_zero (y_ne_zero 0) (y_ne_zero 3))]
lemma sectionRatio_one (i : Fin 6) : sectionRatio (i, 1) = z i * ratioQ := by
  unfold sectionRatio ratioQ
  rw [sectionCoefficient_base]
  change z i * y 1 * y 2 / (y 0 * y 3) = _
  ring
lemma sectionRatio_two (i : Fin 6) : sectionRatio (i, 2) = z i * ratioR := by
  unfold sectionRatio ratioR
  rw [sectionCoefficient_base]
  change z i * y 4 * 1 / (y 0 * y 3) = _
  ring
lemma y_mem_sectionChart (i : Fin 5) : y i ∈ sectionChart := by
  have h : sectionRatio (i.succ, 0) ∈ sectionChart :=
    Algebra.subset_adjoin (Set.mem_range_self _)
  simpa only [sectionRatio_zero, z, Fin.cases_succ] using h
lemma ratioQ_mem_sectionChart : ratioQ ∈ sectionChart := by
  have h : sectionRatio (0, 1) ∈ sectionChart :=
    Algebra.subset_adjoin (Set.mem_range_self _)
  simpa only [sectionRatio_one, z, Fin.cases_zero, one_mul] using h
lemma ratioR_mem_sectionChart : ratioR ∈ sectionChart := by
  have h : sectionRatio (0, 2) ∈ sectionChart :=
    Algebra.subset_adjoin (Set.mem_range_self _)
  simpa only [sectionRatio_two, z, Fin.cases_zero, one_mul] using h

/-- Equality for the actual coefficient ratios, with no change of roots,
polarization, field, or exponent. -/
theorem sectionChart_eq : sectionChart =
    Algebra.adjoin ℂ (Set.range y ∪ {ratioQ, ratioR}) := by
  apply le_antisymm
  · apply Algebra.adjoin_le
    rintro _ ⟨⟨i,j⟩, rfl⟩
    have hi : z i ∈ Algebra.adjoin ℂ (Set.range y ∪ {ratioQ, ratioR}) := by
      refine Fin.cases ?_ (fun k => ?_) i
      · exact Subalgebra.one_mem _
      · exact Algebra.subset_adjoin (Or.inl (Set.mem_range_self k))
    have hq : ratioQ ∈ Algebra.adjoin ℂ (Set.range y ∪ {ratioQ, ratioR}) :=
      Algebra.subset_adjoin (Or.inr (by simp))
    have hr : ratioR ∈ Algebra.adjoin ℂ (Set.range y ∪ {ratioQ, ratioR}) :=
      Algebra.subset_adjoin (Or.inr (by simp))
    fin_cases j
    · change sectionRatio (i, 0) ∈ _
      rw [sectionRatio_zero]; exact hi
    · change sectionRatio (i, 1) ∈ _
      rw [sectionRatio_one]; exact Subalgebra.mul_mem _ hi hq
    · change sectionRatio (i, 2) ∈ _
      rw [sectionRatio_two]; exact Subalgebra.mul_mem _ hi hr
  · apply Algebra.adjoin_le
    rintro t (⟨i,rfl⟩ | ht)
    · exact y_mem_sectionChart i
    · rcases (show t = ratioQ ∨ t = ratioR from by simpa using ht) with rfl | rfl
      · exact ratioQ_mem_sectionChart
      · exact ratioR_mem_sectionChart

/-- The two redundant-looking coordinates record the resolved triple
points, and the Fermat identity guarantees their opens cover. -/
lemma ratioQ_product : y 0 * y 3 * ratioQ = y 1 * y 2 := by
  exact mul_div_cancel₀ _ (mul_ne_zero (y_ne_zero 0) (y_ne_zero 3))
lemma ratioR_product : y 0 * y 3 * ratioR = y 4 := by
  exact mul_div_cancel₀ _ (mul_ne_zero (y_ne_zero 0) (y_ne_zero 3))
lemma y_power (i : Fin 5) : y i ^ 7 = algebraMap R L (KummerLines.lineForm i) := by
  rw [KummerCover.fieldRoot_pow]
  exact (IsScalarTower.algebraMap_apply R K L _).symm
lemma y_power_zero : y 0 ^ 7 = algebraMap R L (X 0) := y_power 0
lemma y_power_one : y 1 ^ 7 = algebraMap R L (X 1) := y_power 1
lemma y_power_two : y 2 ^ 7 = algebraMap R L (X 0) - 1 := by
  have h := y_power 2
  change y 2 ^ 7 = algebraMap R L (X 0 - 1) at h
  simpa only [map_sub, map_one] using h
lemma y_power_three : y 3 ^ 7 = algebraMap R L (X 1) - 1 := by
  simpa [KummerLines.lineForm, map_sub, map_one] using y_power 3
lemma y_power_four : y 4 ^ 7 = algebraMap R L (X 0) - algebraMap R L (X 1) := by
  simpa [KummerLines.lineForm, map_sub] using y_power 4
lemma ratioQ_power : ratioQ ^ 7 =
    algebraMap R L (X 1) * (algebraMap R L (X 0) - 1) /
      (algebraMap R L (X 0) * (algebraMap R L (X 1) - 1)) := by
  rw [ratioQ, div_pow, mul_pow, mul_pow, y_power_zero, y_power_one,
    y_power_two, y_power_three]
lemma ratioR_power : ratioR ^ 7 =
    (algebraMap R L (X 0) - algebraMap R L (X 1)) /
      (algebraMap R L (X 0) * (algebraMap R L (X 1) - 1)) := by
  rw [ratioR, div_pow, mul_pow, y_power_zero, y_power_three, y_power_four]
lemma ratio_fermat : ratioQ ^ 7 - ratioR ^ 7 = 1 := by
  rw [ratioQ_power, ratioR_power, ← sub_div]
  have h0 : algebraMap R L (X 0) ≠ 0 := by
    rw [← y_power_zero]; exact pow_ne_zero _ (y_ne_zero 0)
  have h1 : algebraMap R L (X 1) - 1 ≠ 0 := by
    rw [← y_power_three]; exact pow_ne_zero _ (y_ne_zero 3)
  rw [div_eq_one_iff_eq (mul_ne_zero h0 h1)]
  ring

/-- Six functions suffice: the fifth original root is reconstructed. -/
def chartCoordinates : Fin 6 → L := ![y 0, y 1, y 2, y 3, ratioQ, ratioR]
lemma chartCoordinates_mem (i : Fin 6) : chartCoordinates i ∈ sectionChart := by
  fin_cases i
  · exact y_mem_sectionChart 0
  · exact y_mem_sectionChart 1
  · exact y_mem_sectionChart 2
  · exact y_mem_sectionChart 3
  · exact ratioQ_mem_sectionChart
  · exact ratioR_mem_sectionChart

theorem sectionChart_eq_six : sectionChart = Algebra.adjoin ℂ (Set.range chartCoordinates) := by
  apply le_antisymm
  · rw [sectionChart_eq]
    apply Algebra.adjoin_le
    have hm (i : Fin 6) : chartCoordinates i ∈ Algebra.adjoin ℂ (Set.range chartCoordinates) :=
      Algebra.subset_adjoin (Set.mem_range_self i)
    rintro t (⟨i,rfl⟩ | ht)
    · fin_cases i
      · exact hm 0
      · exact hm 1
      · exact hm 2
      · exact hm 3
      · change y 4 ∈ _
        rw [← ratioR_product]
        exact Subalgebra.mul_mem _ (Subalgebra.mul_mem _ (hm 0) (hm 3)) (hm 5)
    · rcases (show t = ratioQ ∨ t = ratioR from by simpa using ht) with rfl | rfl
      · exact hm 4
      · exact hm 5
  · exact Algebra.adjoin_le (by rintro _ ⟨i,rfl⟩; exact chartCoordinates_mem i)

instance sectionChart_finiteType : Algebra.FiniteType ℂ sectionChart := by
  rw [sectionChart_eq_six]
  exact Algebra.FiniteType.adjoin_of_finite (Set.finite_range chartCoordinates)

instance sectionChart_fractionRing : IsFractionRing sectionChart L :=
  IsFractionRing.of_field sectionChart L fun t => by
    have ht : t ∈ IntermediateField.adjoin ℂ (Set.range y) := by
      rw [roots_generate_over_complex]; trivial
    obtain ⟨a,ha,b,hb,h⟩ := IntermediateField.mem_adjoin_iff_div.mp ht
    have hle : Algebra.adjoin ℂ (Set.range y) ≤ sectionChart :=
      Algebra.adjoin_le (by rintro _ ⟨i,rfl⟩; exact y_mem_sectionChart i)
    exact ⟨⟨a,hle ha⟩,⟨b,hle hb⟩,h⟩

end ExplicitCone

end

end


noncomputable section
open nonZeroDivisors
namespace FieldPrincipalOpen
variable {k L : Type*} [Field k] [Field L] [Algebra k L]
variable (A : Subalgebra k L) [IsFractionRing A L] (d : A) (hd : d ≠ 0)

include hd in
omit [IsFractionRing A L] in
lemma powers_le : Submonoid.powers d ≤ A⁰ := by
  rintro _ ⟨n, rfl⟩
  exact mem_nonZeroDivisors_of_ne_zero (pow_ne_zero n hd)

/-- A principal open as an actual subalgebra of the fixed function field. -/
def away : Subalgebra k L :=
  (Localization.subalgebra.ofField L (Submonoid.powers d) (powers_le A d hd)).restrictScalars k

instance : Algebra A (away A d hd) :=
  inferInstanceAs (Algebra A (Localization.subalgebra.ofField L (Submonoid.powers d)
    (powers_le A d hd)))
instance : IsLocalization.Away d (away A d hd) :=
  inferInstanceAs (IsLocalization.Away d (Localization.subalgebra.ofField L (Submonoid.powers d)
    (powers_le A d hd)))

lemma mem_away_iff (x : L) : x ∈ away A d hd ↔
    ∃ (a : A) (n : ℕ), x = (a : L) / (d : L) ^ n := by
  change (∃ (a s : A) (_ : s ∈ Submonoid.powers d),
    x = (a : L) * (s : L)⁻¹) ↔ _
  constructor
  · rintro ⟨a, _, ⟨n,rfl⟩, h⟩
    exact ⟨a,n,by simpa only [Subalgebra.coe_pow, div_eq_mul_inv] using h⟩
  · rintro ⟨a,n,h⟩
    exact ⟨a,d ^ n,⟨n,rfl⟩,by simpa only [Subalgebra.coe_pow, div_eq_mul_inv] using h⟩

lemma le_away : A ≤ away A d hd := by
  intro a ha
  exact (mem_away_iff A d hd a).mpr ⟨⟨a,ha⟩,0,by simp⟩
lemma inv_mem_away : (d : L)⁻¹ ∈ away A d hd := by
  exact (mem_away_iff A d hd _).mpr ⟨1,1,by simp⟩

lemma away_le_iff (B : Subalgebra k L) : away A d hd ≤ B ↔
    A ≤ B ∧ (d : L)⁻¹ ∈ B := by
  constructor
  · intro h
    exact ⟨(le_away A d hd).trans h, h (inv_mem_away A d hd)⟩
  · rintro ⟨hA,hd'⟩ x hx
    obtain ⟨a,n,rfl⟩ := (mem_away_iff A d hd x).mp hx
    rw [div_eq_mul_inv, ← inv_pow]
    exact B.mul_mem (hA a.property) (B.pow_mem hd' n)

lemma away_eq_adjoin : away A d hd = Algebra.adjoin k ((A : Set L) ∪ {(d : L)⁻¹}) := by
  apply le_antisymm
  · apply (away_le_iff A d hd _).mpr
    exact ⟨fun _ hx => Algebra.subset_adjoin (Or.inl hx),
      Algebra.subset_adjoin (Or.inr (Set.mem_singleton _))⟩
  · apply Algebra.adjoin_le
    rintro x (hx | hx)
    · exact le_away A d hd hx
    · exact (Set.mem_singleton_iff.mp hx) ▸ inv_mem_away A d hd

lemma regular_away_of_eq (B : Subalgebra k L) [IsRegularRing B]
    (h : away A d hd = B) : IsRegularRing (Localization.Away d) := by
  have : IsRegularRing (away A d hd) :=
    IsRegularRing.of_ringEquiv (Subalgebra.equivOfEq _ _ h.symm).toRingEquiv
  exact IsRegularRing.of_ringEquiv
    (IsLocalization.algEquiv (Submonoid.powers d) (away A d hd) (Localization.Away d)).toRingEquiv

end FieldPrincipalOpen

end


noncomputable section
open Algebra MvPolynomial
namespace KummerTriple
open KummerLines
variable (p : ℕ) [Fact p.Prime]

lemma remainingRoot_inv_mem (i : Fin 3) : (remainingRoot p i)⁻¹ ∈ chartRootAlgebra p := by
  let z : chartRootAlgebra p := ⟨remainingRoot p i, remainingRoot_mem_chartRootAlgebra p i⟩
  have hz : z ^ p = algebraMap (S p) (chartRootAlgebra p)
      (algebraMap C (S p) (remainingForm i)) := by
    apply Subtype.ext
    exact (remainingRoot_pow p i).trans
      (IsScalarTower.algebraMap_apply C (S p) (L p) _)
  have hu : IsUnit (z ^ p) := by
    rw [hz]
    exact (remaining_unit p i).map (algebraMap (S p) (chartRootAlgebra p))
  exact Submonoid.inv_mem_of_isUnit ((isUnit_pow_iff (NeZero.ne p)).mp hu)
end KummerTriple

namespace FieldPrincipalOpen
variable {k L : Type*} [Field k] [Field L] [Algebra k L]
lemma inv_left_mem (A : Subalgebra k L) {x y : L} (hy : y ≠ 0)
    (hyA : y ∈ A) (hi : (x * y)⁻¹ ∈ A) : x⁻¹ ∈ A := by
  have h := A.mul_mem hi hyA
  have he : (x * y)⁻¹ * y = x⁻¹ := by
    simp [mul_inv_rev, mul_assoc, mul_left_comm, hy]
  exact he ▸ h

lemma localizationImage_mem {R S : Type*} [CommRing R] [CommRing S]
    [Algebra R S] [Algebra R L] [Algebra S L] [IsScalarTower R S L]
    (A : Subalgebra k L) (d : R) [IsLocalization.Away d S]
    (hd : algebraMap R L d ≠ 0)
    (hR : ∀ a : R, algebraMap R L a ∈ A)
    (hi : (algebraMap R L d)⁻¹ ∈ A) (s : S) : algebraMap S L s ∈ A := by
  obtain ⟨n,a,h⟩ := IsLocalization.Away.surj d s
  have he := congrArg (algebraMap S L) h
  simp only [map_mul, map_pow, ← IsScalarTower.algebraMap_apply] at he
  have he' : algebraMap S L s = algebraMap R L a / (algebraMap R L d) ^ n :=
    (eq_div_iff (pow_ne_zero n hd)).mpr he
  rw [he', div_eq_mul_inv, ← inv_pow]
  exact A.mul_mem (hR a) (A.pow_mem hi n)
end FieldPrincipalOpen

namespace ExplicitCone

lemma ratioR_ne_zero : ratioR ≠ 0 :=
  div_ne_zero (y_ne_zero 4) (mul_ne_zero (y_ne_zero 0) (y_ne_zero 3))
lemma ratioQ_ne_zero : ratioQ ≠ 0 :=
  div_ne_zero (mul_ne_zero (y_ne_zero 1) (y_ne_zero 2))
    (mul_ne_zero (y_ne_zero 0) (y_ne_zero 3))

def tripleSectionDenominator : sectionChart :=
  ⟨y 2 * y 3 * ratioR, sectionChart.mul_mem
    (sectionChart.mul_mem (y_mem_sectionChart 2) (y_mem_sectionChart 3)) ratioR_mem_sectionChart⟩
lemma tripleSectionDenominator_ne_zero : tripleSectionDenominator ≠ 0 := by
  intro h
  exact mul_ne_zero (mul_ne_zero (y_ne_zero 2) (y_ne_zero 3)) ratioR_ne_zero
    (congrArg Subtype.val h)
def tripleSectionOpen : Subalgebra ℂ L :=
  FieldPrincipalOpen.away sectionChart tripleSectionDenominator tripleSectionDenominator_ne_zero

def tripleRegularAlgebra : Subalgebra ℂ L where
  toSubsemiring := (KummerTriple.chartRootAlgebra 7).toSubsemiring
  algebraMap_mem' c := by
    have h := (KummerTriple.chartRootAlgebra 7).algebraMap_mem
      (algebraMap (KummerTriple.B 7) (KummerTriple.S 7)
        (algebraMap ℂ (KummerTriple.B 7) c))
    rw [← IsScalarTower.algebraMap_apply (KummerTriple.B 7) (KummerTriple.S 7) L] at h
    exact h

lemma y_mem_tripleRegular (i : Fin 5) : y i ∈ tripleRegularAlgebra :=
  KummerTriple.allRoots_mem_chartRootAlgebra 7 i
lemma unitRoot_inv_mem_tripleRegular (i : Fin 3) :
    (KummerTriple.remainingRoot 7 i)⁻¹ ∈ tripleRegularAlgebra :=
  KummerTriple.remainingRoot_inv_mem 7 i

lemma ratioQ_mem_tripleRegular : ratioQ ∈ tripleRegularAlgebra := by
  have h0 : y 1 / y 0 ∈ tripleRegularAlgebra :=
    KummerTriple.coordinateRoot_mem_chartRootAlgebra 7 1
  have h1 : (y 3)⁻¹ ∈ tripleRegularAlgebra := unitRoot_inv_mem_tripleRegular 1
  have he : ratioQ = (y 1 / y 0) * y 2 * (y 3)⁻¹ := by
    unfold ratioQ
    field_simp [y_ne_zero]
  rw [he]
  exact tripleRegularAlgebra.mul_mem
    (tripleRegularAlgebra.mul_mem h0 (y_mem_tripleRegular 2)) h1
lemma ratioR_mem_tripleRegular : ratioR ∈ tripleRegularAlgebra := by
  have h0 : y 4 / y 0 ∈ tripleRegularAlgebra :=
    KummerTriple.remainingRoot_mem_chartRootAlgebra 7 2
  have h1 : (y 3)⁻¹ ∈ tripleRegularAlgebra := unitRoot_inv_mem_tripleRegular 1
  have he : ratioR = (y 4 / y 0) * (y 3)⁻¹ := by
    unfold ratioR
    field_simp [y_ne_zero]
  rw [he]
  exact tripleRegularAlgebra.mul_mem h0 h1
lemma sectionChart_le_tripleRegular : sectionChart ≤ tripleRegularAlgebra := by
  rw [sectionChart_eq]
  apply Algebra.adjoin_le
  rintro t (⟨i,rfl⟩ | ht)
  · exact y_mem_tripleRegular i
  · rcases (show t = ratioQ ∨ t = ratioR from by simpa using ht) with rfl | rfl
    · exact ratioQ_mem_tripleRegular
    · exact ratioR_mem_tripleRegular
lemma ratioR_inv_mem_tripleRegular : ratioR⁻¹ ∈ tripleRegularAlgebra := by
  have h0 : (y 4 / y 0)⁻¹ ∈ tripleRegularAlgebra := unitRoot_inv_mem_tripleRegular 2
  have he : ratioR⁻¹ = (y 4 / y 0)⁻¹ * y 3 := by
    unfold ratioR
    field_simp [y_ne_zero]
  rw [he]
  exact tripleRegularAlgebra.mul_mem h0 (y_mem_tripleRegular 3)
lemma tripleSectionOpen_le : tripleSectionOpen ≤ tripleRegularAlgebra := by
  apply (FieldPrincipalOpen.away_le_iff sectionChart tripleSectionDenominator
    tripleSectionDenominator_ne_zero tripleRegularAlgebra).mpr
  refine ⟨sectionChart_le_tripleRegular, ?_⟩
  change (y 2 * y 3 * ratioR)⁻¹ ∈ tripleRegularAlgebra
  rw [mul_inv_rev, mul_inv_rev]
  exact tripleRegularAlgebra.mul_mem ratioR_inv_mem_tripleRegular
    (tripleRegularAlgebra.mul_mem (unitRoot_inv_mem_tripleRegular 1)
      (unitRoot_inv_mem_tripleRegular 0))

lemma sectionChart_le_tripleOpen : sectionChart ≤ tripleSectionOpen :=
  FieldPrincipalOpen.le_away sectionChart tripleSectionDenominator tripleSectionDenominator_ne_zero
lemma y_mem_tripleOpen (i : Fin 5) : y i ∈ tripleSectionOpen :=
  sectionChart_le_tripleOpen (y_mem_sectionChart i)
lemma ratioQ_mem_tripleOpen : ratioQ ∈ tripleSectionOpen :=
  sectionChart_le_tripleOpen ratioQ_mem_sectionChart
lemma ratioR_mem_tripleOpen : ratioR ∈ tripleSectionOpen :=
  sectionChart_le_tripleOpen ratioR_mem_sectionChart
lemma tripleProduct_inv_mem : (y 2 * y 3 * ratioR)⁻¹ ∈ tripleSectionOpen :=
  FieldPrincipalOpen.inv_mem_away sectionChart tripleSectionDenominator tripleSectionDenominator_ne_zero
lemma y2_inv_mem_tripleOpen : (y 2)⁻¹ ∈ tripleSectionOpen := by
  apply FieldPrincipalOpen.inv_left_mem tripleSectionOpen
    (mul_ne_zero (y_ne_zero 3) ratioR_ne_zero)
    (tripleSectionOpen.mul_mem (y_mem_tripleOpen 3) ratioR_mem_tripleOpen)
  simpa only [mul_assoc] using tripleProduct_inv_mem
lemma y3_inv_mem_tripleOpen : (y 3)⁻¹ ∈ tripleSectionOpen := by
  apply FieldPrincipalOpen.inv_left_mem tripleSectionOpen
    (mul_ne_zero (y_ne_zero 2) ratioR_ne_zero)
    (tripleSectionOpen.mul_mem (y_mem_tripleOpen 2) ratioR_mem_tripleOpen)
  simpa only [mul_assoc, mul_comm, mul_left_comm] using tripleProduct_inv_mem
lemma ratioR_inv_mem_tripleOpen : ratioR⁻¹ ∈ tripleSectionOpen := by
  apply FieldPrincipalOpen.inv_left_mem tripleSectionOpen
    (mul_ne_zero (y_ne_zero 2) (y_ne_zero 3))
    (tripleSectionOpen.mul_mem (y_mem_tripleOpen 2) (y_mem_tripleOpen 3))
  simpa only [mul_assoc, mul_comm, mul_left_comm] using tripleProduct_inv_mem

lemma coordinateRoot_mem_tripleOpen (i : Fin 2) :
    KummerTriple.coordinateRoot 7 i ∈ tripleSectionOpen := by
  fin_cases i
  · exact y_mem_tripleOpen 0
  · change y 1 / y 0 ∈ tripleSectionOpen
    have he : y 1 / y 0 = ratioQ * y 3 * (y 2)⁻¹ := by
      unfold ratioQ
      field_simp [y_ne_zero]
    rw [he]
    exact tripleSectionOpen.mul_mem
      (tripleSectionOpen.mul_mem ratioQ_mem_tripleOpen (y_mem_tripleOpen 3))
      y2_inv_mem_tripleOpen
lemma B_mem_tripleOpen (b : KummerTriple.B 7) : (b : L) ∈ tripleSectionOpen := by
  have h := b.property
  change (b : L) ∈ Algebra.adjoin ℂ (Set.range (KummerTriple.coordinateRoot 7)) at h
  exact (Algebra.adjoin_le (by rintro _ ⟨i,rfl⟩; exact coordinateRoot_mem_tripleOpen i)) h
lemma remainingRoot_mem_tripleOpen (i : Fin 3) :
    KummerTriple.remainingRoot 7 i ∈ tripleSectionOpen := by
  fin_cases i
  · exact y_mem_tripleOpen 2
  · exact y_mem_tripleOpen 3
  · change y 4 / y 0 ∈ tripleSectionOpen
    have he : y 4 / y 0 = ratioR * y 3 := by
      unfold ratioR
      field_simp [y_ne_zero]
    rw [he]
    exact tripleSectionOpen.mul_mem ratioR_mem_tripleOpen (y_mem_tripleOpen 3)
lemma remainingRoot_inv_mem_tripleOpen (i : Fin 3) :
    (KummerTriple.remainingRoot 7 i)⁻¹ ∈ tripleSectionOpen := by
  fin_cases i
  · exact y2_inv_mem_tripleOpen
  · exact y3_inv_mem_tripleOpen
  · change (y 4 / y 0)⁻¹ ∈ tripleSectionOpen
    have he : (y 4 / y 0)⁻¹ = ratioR⁻¹ * (y 3)⁻¹ := by
      unfold ratioR
      field_simp [y_ne_zero]
    rw [he]
    exact tripleSectionOpen.mul_mem ratioR_inv_mem_tripleOpen y3_inv_mem_tripleOpen

lemma bDenominator_image :
    algebraMap (KummerTriple.B 7) L (KummerTriple.bDenominator 7) =
    KummerTriple.remainingRoot 7 0 ^ 7 * KummerTriple.remainingRoot 7 1 ^ 7 *
      KummerTriple.remainingRoot 7 2 ^ 7 := by
  change algebraMap (KummerTriple.B 7) L
    (algebraMap KummerTriple.C (KummerTriple.B 7) KummerTriple.chartDenominator) = _
  rw [← IsScalarTower.algebraMap_apply KummerTriple.C (KummerTriple.B 7) L]
  change algebraMap KummerTriple.C L
    (KummerTriple.remainingForm 0 * KummerTriple.remainingForm 1 * KummerTriple.remainingForm 2) = _
  simp only [map_mul, KummerTriple.remainingRoot_pow]
lemma bDenominator_inv_mem_tripleOpen :
    (algebraMap (KummerTriple.B 7) L (KummerTriple.bDenominator 7))⁻¹ ∈ tripleSectionOpen := by
  rw [bDenominator_image, mul_inv_rev, mul_inv_rev, ← inv_pow, ← inv_pow, ← inv_pow]
  exact tripleSectionOpen.mul_mem (tripleSectionOpen.pow_mem (remainingRoot_inv_mem_tripleOpen 2) 7)
    (tripleSectionOpen.mul_mem (tripleSectionOpen.pow_mem (remainingRoot_inv_mem_tripleOpen 1) 7)
      (tripleSectionOpen.pow_mem (remainingRoot_inv_mem_tripleOpen 0) 7))
lemma S_mem_tripleOpen (s : KummerTriple.S 7) :
    algebraMap (KummerTriple.S 7) L s ∈ tripleSectionOpen := by
  apply FieldPrincipalOpen.localizationImage_mem tripleSectionOpen (KummerTriple.bDenominator 7)
    ((isUnit_iff_ne_zero).mp (KummerTriple.bDenominator_unit_in_L 7))
    (fun b => B_mem_tripleOpen b) bDenominator_inv_mem_tripleOpen
lemma tripleRegular_le_sectionOpen : tripleRegularAlgebra ≤ tripleSectionOpen := by
  intro t ht
  change t ∈ Algebra.adjoin (KummerTriple.S 7) (KummerTriple.remainingRoots 7 : Set L) at ht
  induction ht using Algebra.adjoin_induction with
  | mem x hx =>
    classical
    obtain ⟨i,-,rfl⟩ := Finset.mem_image.mp (show x ∈ Finset.univ.image _ from hx)
    exact remainingRoot_mem_tripleOpen i
  | algebraMap s => exact S_mem_tripleOpen s
  | add x y hx hy h₁ h₂ => exact tripleSectionOpen.add_mem h₁ h₂
  | mul x y hx hy h₁ h₂ => exact tripleSectionOpen.mul_mem h₁ h₂

/-- The literal polarization chart, localized at c*d*r, is exactly the
regular normalization of the literal triple-point blowup open, within the
same original function field. -/
theorem tripleSectionOpen_eq : tripleSectionOpen = tripleRegularAlgebra :=
  le_antisymm tripleSectionOpen_le tripleRegular_le_sectionOpen

theorem sectionChart_tripleOpen_regular :
    IsRegularRing (Localization.Away tripleSectionDenominator) := by
  have : IsRegularRing tripleRegularAlgebra := KummerTriple.chartRootAlgebra_regular 7
  exact FieldPrincipalOpen.regular_away_of_eq sectionChart tripleSectionDenominator
    tripleSectionDenominator_ne_zero tripleRegularAlgebra tripleSectionOpen_eq

end ExplicitCone

end

end OAI