lean/OAI/NumberTheory/PiExponent/LocalAlgebra/ConeLocalLength.lean

import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.Polynomial.Laurent
import Mathlib.RingTheory.Flat.Localization
import Mathlib.RingTheory.Length
import Mathlib.RingTheory.Localization.LocalizationLocalization
import Mathlib.RingTheory.Polynomial.Basic
import OAI.NumberTheory.PiExponent.LocalAlgebra.FlatLocalLength

namespace OAI

noncomputable section

namespace PiExponentSiegel.W17.ConeLocalLength

attribute [local instance] Localization.AtPrime.algebraOfLiesOver

section ExtendedPrime

variable {A B : Type*} [CommRing A] [CommRing B] [Algebra A B]
    (P : Ideal A) [P.IsPrime] (Q : Ideal B) [Q.IsPrime] [Q.LiesOver P]

theorem localized_maximalIdeal_map_eq (hQ : Q = P.map (algebraMap A B)) :
    (IsLocalRing.maximalIdeal (Localization.AtPrime P)).map
      (algebraMap (Localization.AtPrime P) (Localization.AtPrime Q)) =
    IsLocalRing.maximalIdeal (Localization.AtPrime Q) := by
  rw [← IsLocalization.AtPrime.map_eq_maximalIdeal P (Localization.AtPrime P),
    Ideal.map_map, ← IsScalarTower.algebraMap_eq A (Localization.AtPrime P)
      (Localization.AtPrime Q),
    IsScalarTower.algebraMap_eq A B (Localization.AtPrime Q), ← Ideal.map_map, ← hQ]
  exact IsLocalization.AtPrime.map_eq_maximalIdeal Q (Localization.AtPrime Q)

theorem localized_flat [Module.Flat A B] :
    Module.Flat (Localization.AtPrime P) (Localization.AtPrime Q) := inferInstance

end ExtendedPrime

section PolynomialExtension

variable (A : Type*) [CommRing A] (P : Ideal A) [P.IsPrime]

abbrev polynomialPrime : Ideal (Polynomial A) := P.map Polynomial.C

omit [P.IsPrime] in
theorem polynomialPrime_comap :
    (polynomialPrime A P).comap (algebraMap A (Polynomial A)) = P := by
  ext a
  change Polynomial.C a ∈ P.map Polynomial.C ↔ a ∈ P
  rw [Ideal.mem_map_C_iff]
  constructor
  · intro h
    simpa using h 0
  · intro ha n
    by_cases hn : n = 0
    · subst n
      simpa using ha
    · simp [Polynomial.coeff_C, hn]

instance polynomialPrime_liesOver : (polynomialPrime A P).LiesOver P :=
  (Ideal.liesOver_iff _ _).mpr (polynomialPrime_comap A P).symm

theorem polynomialLocal_flat :
    Module.Flat (Localization.AtPrime P)
      (Localization.AtPrime (polynomialPrime A P)) := inferInstance

theorem polynomialLocal_maximalIdeal_map_eq :
    (IsLocalRing.maximalIdeal (Localization.AtPrime P)).map
      (algebraMap (Localization.AtPrime P)
        (Localization.AtPrime (polynomialPrime A P))) =
    IsLocalRing.maximalIdeal (Localization.AtPrime (polynomialPrime A P)) :=
  localized_maximalIdeal_map_eq P (polynomialPrime A P) rfl

end PolynomialExtension

section LaurentExtension

variable (A : Type*) [CommRing A] (P : Ideal A) [P.IsPrime]

abbrev laurentPrime : Ideal (LaurentPolynomial A) := P.map LaurentPolynomial.C

instance laurent_polynomial_tower : IsScalarTower A (Polynomial A) (LaurentPolynomial A) :=
  IsScalarTower.of_algebraMap_eq (fun a => by
    simp [LaurentPolynomial.algebraMap_eq_toLaurent, Polynomial.algebraMap_eq,
      ← LaurentPolynomial.C_eq_algebraMap])

theorem polynomialPrime_disjoint_powers_X :
    Disjoint (Submonoid.powers (Polynomial.X : Polynomial A) : Set (Polynomial A))
      (polynomialPrime A P : Set (Polynomial A)) := by
  apply Set.disjoint_left.mpr
  rintro f ⟨n, rfl⟩ hf
  have hc := (Ideal.mem_map_C_iff.mp hf) n
  exact P.one_notMem (by simpa using hc)

omit [P.IsPrime] in
theorem laurentPrime_eq_map_polynomialPrime :
    laurentPrime A P = (polynomialPrime A P).map
      (algebraMap (Polynomial A) (LaurentPolynomial A)) := by
  have hc : (algebraMap (Polynomial A) (LaurentPolynomial A)).comp
      (Polynomial.C : A →+* Polynomial A) = LaurentPolynomial.C := by
    apply RingHom.ext
    intro a
    exact Polynomial.toLaurent_C a
  change P.map LaurentPolynomial.C =
    (P.map Polynomial.C).map (algebraMap (Polynomial A) (LaurentPolynomial A))
  rw [Ideal.map_map, hc]

instance laurentPrime_isPrime : (laurentPrime A P).IsPrime := by
  rw [laurentPrime_eq_map_polynomialPrime]
  exact IsLocalization.isPrime_of_isPrime_disjoint
    (Submonoid.powers (Polynomial.X : Polynomial A)) (LaurentPolynomial A)
    (polynomialPrime A P) inferInstance (polynomialPrime_disjoint_powers_X A P)

theorem laurentPrime_comap :
    (laurentPrime A P).comap (algebraMap A (LaurentPolynomial A)) = P := by
  rw [IsScalarTower.algebraMap_eq A (Polynomial A) (LaurentPolynomial A),
    ← Ideal.comap_comap, laurentPrime_eq_map_polynomialPrime,
    show Ideal.comap (algebraMap (Polynomial A) (LaurentPolynomial A))
        ((polynomialPrime A P).map (algebraMap (Polynomial A) (LaurentPolynomial A))) =
        polynomialPrime A P from
      IsLocalization.under_map_of_isPrime_disjoint
        (Submonoid.powers (Polynomial.X : Polynomial A)) (LaurentPolynomial A)
        (show (polynomialPrime A P).IsPrime from inferInstance)
        (polynomialPrime_disjoint_powers_X A P)]
  exact polynomialPrime_comap A P

instance laurentPrime_liesOver : (laurentPrime A P).LiesOver P :=
  (Ideal.liesOver_iff _ _).mpr (laurentPrime_comap A P).symm

instance laurent_flat : Module.Flat A (LaurentPolynomial A) := by
  let : Module.Flat (Polynomial A) (LaurentPolynomial A) :=
    IsLocalization.flat (LaurentPolynomial A) (Submonoid.powers (Polynomial.X : Polynomial A))
  exact Module.Flat.trans A (Polynomial A) (LaurentPolynomial A)

theorem laurentLocal_flat :
    Module.Flat (Localization.AtPrime P)
      (Localization.AtPrime (laurentPrime A P)) := inferInstance

theorem laurentLocal_maximalIdeal_map_eq :
    (IsLocalRing.maximalIdeal (Localization.AtPrime P)).map
      (algebraMap (Localization.AtPrime P)
        (Localization.AtPrime (laurentPrime A P))) =
    IsLocalRing.maximalIdeal (Localization.AtPrime (laurentPrime A P)) :=
  localized_maximalIdeal_map_eq P (laurentPrime A P) rfl

theorem laurentLocal_quotient_length
    (I : Ideal (Localization.AtPrime P))
    (hI : IsFiniteLength (Localization.AtPrime P) (Localization.AtPrime P ⧸ I)) :
    Module.length (Localization.AtPrime (laurentPrime A P))
      (Localization.AtPrime (laurentPrime A P) ⧸ I.map
        (algebraMap (Localization.AtPrime P)
          (Localization.AtPrime (laurentPrime A P)))) =
    Module.length (Localization.AtPrime P) (Localization.AtPrime P ⧸ I) :=
  PiExponentJets.W25.length_quotient_map_of_flat_local
    (laurentLocal_maximalIdeal_map_eq A P) I hI

end LaurentExtension

variable (k σ : Type*) [CommRing k]

abbrev AffineRing := MvPolynomial σ k
abbrev ConeRing := MvPolynomial (Option σ) k
abbrev ConeAway := Localization.Away (MvPolynomial.X none : ConeRing k σ)
abbrev LaurentChart := LaurentPolynomial (AffineRing k σ)

def coneHomogenizingUnit : (ConeAway k σ)ˣ :=
  (IsLocalization.Away.algebraMap_isUnit
    (S := ConeAway k σ) (MvPolynomial.X none : ConeRing k σ)).unit

@[simp] theorem coneHomogenizingUnit_val :
    (coneHomogenizingUnit k σ : ConeAway k σ) =
      algebraMap (ConeRing k σ) (ConeAway k σ) (MvPolynomial.X none) :=
  IsUnit.unit_spec _

@[simp] theorem coneHomogenizingUnit_inv_mul :
    (↑(coneHomogenizingUnit k σ)⁻¹ : ConeAway k σ) *
      algebraMap (ConeRing k σ) (ConeAway k σ) (MvPolynomial.X none) = 1 := by
  rw [← coneHomogenizingUnit_val]
  exact Units.inv_mul (coneHomogenizingUnit k σ)

def affineToConeAway : AffineRing k σ →+* ConeAway k σ :=
  MvPolynomial.eval₂Hom
    ((algebraMap (ConeRing k σ) (ConeAway k σ)).comp MvPolynomial.C)
    (fun i => algebraMap (ConeRing k σ) (ConeAway k σ) (MvPolynomial.X (some i)) *
      ↑(coneHomogenizingUnit k σ)⁻¹)

@[simp] theorem affineToConeAway_C (a : k) :
    affineToConeAway k σ (MvPolynomial.C a) =
      algebraMap (ConeRing k σ) (ConeAway k σ) (MvPolynomial.C a) := by
  simp [affineToConeAway]

@[simp] theorem affineToConeAway_X (i : σ) :
    affineToConeAway k σ (MvPolynomial.X i) =
      algebraMap (ConeRing k σ) (ConeAway k σ) (MvPolynomial.X (some i)) *
        ↑(coneHomogenizingUnit k σ)⁻¹ := by
  simp [affineToConeAway]

def coneToLaurent : ConeRing k σ →+* LaurentChart k σ :=
  MvPolynomial.eval₂Hom (LaurentPolynomial.C.comp MvPolynomial.C)
    (fun i => i.elim (LaurentPolynomial.T 1)
      (fun j => LaurentPolynomial.C (MvPolynomial.X j) * LaurentPolynomial.T 1))

@[simp] theorem coneToLaurent_C (a : k) :
    coneToLaurent k σ (MvPolynomial.C a) =
      LaurentPolynomial.C (MvPolynomial.C a) := by simp [coneToLaurent]

@[simp] theorem coneToLaurent_X_none :
    coneToLaurent k σ (MvPolynomial.X none) = LaurentPolynomial.T 1 := by
  simp [coneToLaurent]

@[simp] theorem coneToLaurent_X_some (i : σ) :
    coneToLaurent k σ (MvPolynomial.X (some i)) =
      LaurentPolynomial.C (MvPolynomial.X i) * LaurentPolynomial.T 1 := by
  simp [coneToLaurent]

def coneAwayToLaurent : ConeAway k σ →+* LaurentChart k σ :=
  IsLocalization.Away.lift (MvPolynomial.X none : ConeRing k σ)
    (g := coneToLaurent k σ) (by simpa using LaurentPolynomial.isUnit_T (R := AffineRing k σ) 1)

@[simp] theorem coneAwayToLaurent_algebraMap (p : ConeRing k σ) :
    coneAwayToLaurent k σ (algebraMap (ConeRing k σ) (ConeAway k σ) p) =
      coneToLaurent k σ p := by simp [coneAwayToLaurent]

def laurentToConeAway : LaurentChart k σ →+* ConeAway k σ :=
  LaurentPolynomial.eval₂ (affineToConeAway k σ) (coneHomogenizingUnit k σ)

@[simp] theorem laurentToConeAway_C (p : AffineRing k σ) :
    laurentToConeAway k σ (LaurentPolynomial.C p) = affineToConeAway k σ p := by
  simp [laurentToConeAway]

@[simp] theorem laurentToConeAway_T :
    laurentToConeAway k σ (LaurentPolynomial.T 1) = coneHomogenizingUnit k σ := by
  simp [laurentToConeAway]

theorem laurentToConeAway_comp_coneToLaurent :
    (laurentToConeAway k σ).comp (coneToLaurent k σ) =
      algebraMap (ConeRing k σ) (ConeAway k σ) := by
  apply MvPolynomial.ringHom_ext
  · intro a
    simp
  · intro i
    cases i with
    | none => simp
    | some i => simp [mul_assoc]

theorem laurentToConeAway_comp_coneAwayToLaurent :
    (laurentToConeAway k σ).comp (coneAwayToLaurent k σ) = RingHom.id _ := by
  apply IsLocalization.ringHom_ext
    (Submonoid.powers (MvPolynomial.X none : ConeRing k σ))
  apply RingHom.ext
  intro p
  change laurentToConeAway k σ
    (coneAwayToLaurent k σ (algebraMap _ _ p)) = algebraMap _ _ p
  rw [coneAwayToLaurent_algebraMap]
  exact RingHom.congr_fun (laurentToConeAway_comp_coneToLaurent k σ) p

theorem coneAwayToLaurent_comp_affineToConeAway :
    (coneAwayToLaurent k σ).comp (affineToConeAway k σ) = LaurentPolynomial.C := by
  apply MvPolynomial.ringHom_ext
  · intro a
    simp
  · intro i
    change coneAwayToLaurent k σ (affineToConeAway k σ (MvPolynomial.X i)) =
      LaurentPolynomial.C (MvPolynomial.X i)
    apply (LaurentPolynomial.isUnit_T (R := AffineRing k σ) 1).mul_left_inj.mp
    have hu : coneAwayToLaurent k σ (coneHomogenizingUnit k σ) =
        LaurentPolynomial.T 1 := by simp
    calc
      coneAwayToLaurent k σ (affineToConeAway k σ (MvPolynomial.X i)) *
          LaurentPolynomial.T 1 =
          coneAwayToLaurent k σ
            (affineToConeAway k σ (MvPolynomial.X i) * coneHomogenizingUnit k σ) := by
        rw [map_mul, hu]
      _ = LaurentPolynomial.C (MvPolynomial.X i) * LaurentPolynomial.T 1 := by
        simp [mul_assoc]

theorem coneAwayToLaurent_comp_laurentToConeAway :
    (coneAwayToLaurent k σ).comp (laurentToConeAway k σ) = RingHom.id _ := by
  apply IsLocalization.ringHom_ext
    (Submonoid.powers (Polynomial.X : Polynomial (AffineRing k σ)))
  apply Polynomial.ringHom_ext
  · intro a
    change coneAwayToLaurent k σ
      (laurentToConeAway k σ (algebraMap _ _ (Polynomial.C a))) =
        algebraMap _ _ (Polynomial.C a)
    simp only [LaurentPolynomial.algebraMap_eq_toLaurent, Polynomial.toLaurent_C,
      laurentToConeAway_C]
    exact RingHom.congr_fun (coneAwayToLaurent_comp_affineToConeAway k σ) a
  · change coneAwayToLaurent k σ
      (laurentToConeAway k σ (algebraMap _ _ Polynomial.X)) =
        algebraMap _ _ Polynomial.X
    simp [LaurentPolynomial.algebraMap_eq_toLaurent]

def coneLaurentEquiv : ConeAway k σ ≃+* LaurentChart k σ :=
  RingEquiv.ofRingHom (coneAwayToLaurent k σ) (laurentToConeAway k σ)
    (coneAwayToLaurent_comp_laurentToConeAway k σ)
    (laurentToConeAway_comp_coneAwayToLaurent k σ)

end PiExponentSiegel.W17.ConeLocalLength

end

end OAI