import Mathlib
import OAI.Algebra.FiniteTensor.CoordinateEquivalences

namespace OAI

/-! Finite coordinate charts, coefficient extensions and nilpotent deformation equivalences. -/

noncomputable section
open scoped BigOperators

namespace PD4Tensor.FiniteCoordinates
noncomputable section
variable (K σ τ : Type*) [CommRing K] (e : σ → ℕ) (f : τ → ℕ)

def leftInclusion : Ring K σ e →ₐ[K] Ring K (σ ⊕ τ) (Sum.elim e f) :=
  evaluate (fun i => coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inl i))
    (fun i => coord_pow K (σ ⊕ τ) (Sum.elim e f) (Sum.inl i))

def leftRestriction (hf : ∀ j, 0<f j) :
    Ring K (σ ⊕ τ) (Sum.elim e f) →ₐ[K] Ring K σ e :=
  evaluate (Sum.elim (coord K σ e) (fun _ => 0)) (by
    intro i
    cases i with
    | inl i => exact coord_pow K σ e i
    | inr j => exact zero_pow (Nat.ne_of_gt (hf j)))

@[simp] theorem leftInclusion_coord (i : σ) :
    leftInclusion K σ τ e f (coord K σ e i)=
      coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inl i) := by
  change (MvPolynomial.aeval _) (MvPolynomial.X i)=_
  exact MvPolynomial.aeval_X _ i

@[simp] theorem leftRestriction_coord (hf : ∀ j, 0<f j) (i : σ ⊕ τ) :
    leftRestriction K σ τ e f hf (coord K (σ ⊕ τ) (Sum.elim e f) i)=
      Sum.elim (coord K σ e) (fun _ => 0) i := by
  exact evaluate_coord _ _ i

def rightIdeal : Ideal (Ring K (σ ⊕ τ) (Sum.elim e f)) :=
  Ideal.span (Set.range (fun j => coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inr j)))

@[simp] theorem leftRestriction_leftInclusion (hf : ∀ j, 0<f j) (a : Ring K σ e) :
    leftRestriction K σ τ e f hf (leftInclusion K σ τ e f a)=a := by
  have h : (leftRestriction K σ τ e f hf).comp (leftInclusion K σ τ e f)=AlgHom.id K _ := by
    apply hom_ext
    intro i
    simp only [AlgHom.comp_apply,leftInclusion_coord,leftRestriction_coord,
      Sum.elim_inl,AlgHom.id_apply]
  exact DFunLike.congr_fun h a

theorem leftRestriction_surjective (hf : ∀ j, 0<f j) :
    Function.Surjective (leftRestriction K σ τ e f hf) := by
  intro a
  exact ⟨leftInclusion K σ τ e f a,leftRestriction_leftInclusion K σ τ e f hf a⟩

 
theorem leftRestriction_ker (hf : ∀ j, 0<f j) :
    RingHom.ker (leftRestriction K σ τ e f hf).toRingHom=rightIdeal K σ τ e f := by
  apply le_antisymm
  · intro a ha
    change leftRestriction K σ τ e f hf a=0 at ha
    have he := error_mem (rightIdeal K σ τ e f)
      ((leftInclusion K σ τ e f).comp (leftRestriction K σ τ e f hf)) (by
        intro i
        cases i with
        | inl i => simp only [AlgHom.comp_apply,leftRestriction_coord,Sum.elim_inl,
            leftInclusion_coord,sub_self,Ideal.zero_mem]
        | inr j =>
          simp only [AlgHom.comp_apply,leftRestriction,evaluate_coord,Sum.elim_inr,
            map_zero,sub_zero]
          exact Ideal.subset_span (Set.mem_range_self j)) a
    simpa only [AlgHom.comp_apply,ha,map_zero,sub_zero] using he
  · apply Ideal.span_le.mpr
    rintro _ ⟨j,rfl⟩
    change leftRestriction K σ τ e f hf (coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inr j))=0
    simp [leftRestriction]

 

theorem graphRestriction_ker (hf : ∀ j, 0<f j)
    (g : Ring K (σ ⊕ τ) (Sum.elim e f) ≃ₐ[K] Ring K (σ ⊕ τ) (Sum.elim e f)) :
    RingHom.ker ((leftRestriction K σ τ e f hf).comp g.toAlgHom).toRingHom =
      Ideal.span (Set.range (fun j =>
        g.symm (coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inr j)))) := by
  have hmap : (rightIdeal K σ τ e f).map g.symm.toRingHom =
      Ideal.span (Set.range (fun j =>
        g.symm (coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inr j)))) := by
    rw [rightIdeal,Ideal.map_span]
    congr 1
    exact Set.range_comp g.symm _ |>.symm
  rw [←hmap]
  ext a
  rw [Ideal.mem_map_iff_of_surjective (g.symm.toRingHom) g.symm.surjective]
  constructor
  · intro ha
    refine ⟨g a,?_,g.symm_apply_apply a⟩
    rw [←leftRestriction_ker K σ τ e f hf]
    exact ha
  · rintro ⟨b,hb,rfl⟩
    change leftRestriction K σ τ e f hf (g (g.symm b))=0
    rw [g.apply_symm_apply]
    rw [←leftRestriction_ker K σ τ e f hf] at hb
    exact hb

end
end PD4Tensor.FiniteCoordinates

namespace PD4Tensor.FiniteCoordinates
noncomputable section
open scoped TensorProduct
variable (K σ τ : Type*) [CommRing K] (e : σ → ℕ) (f : τ → ℕ)

def rightInclusion : Ring K τ f →ₐ[K] Ring K (σ ⊕ τ) (Sum.elim e f) :=
  evaluate (fun j => coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inr j))
    (fun j => coord_pow K (σ ⊕ τ) (Sum.elim e f) (Sum.inr j))

@[simp] theorem rightInclusion_coord (j : τ) :
    rightInclusion K σ τ e f (coord K τ f j)=coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inr j) := by
  change (MvPolynomial.aeval _) (MvPolynomial.X j)=_
  exact MvPolynomial.aeval_X _ j

def toTensor : Ring K (σ ⊕ τ) (Sum.elim e f) →ₐ[K] Ring K σ e ⊗[K] Ring K τ f :=
  evaluate (Sum.elim
    (fun i => Algebra.TensorProduct.includeLeft (R:=K) (S:=K) (coord K σ e i))
    (fun j => Algebra.TensorProduct.includeRight (R:=K) (coord K τ f j))) (by
      intro u
      cases u with
      | inl i => change (Algebra.TensorProduct.includeLeft (R:=K) (S:=K) (coord K σ e i))^e i=0
                 rw [←map_pow,coord_pow,map_zero]
      | inr j => change (Algebra.TensorProduct.includeRight (R:=K) (coord K τ f j))^f j=0
                 rw [←map_pow,coord_pow,map_zero])

def fromTensor : Ring K σ e ⊗[K] Ring K τ f →ₐ[K] Ring K (σ ⊕ τ) (Sum.elim e f) :=
  Algebra.TensorProduct.lift (leftInclusion K σ τ e f) (rightInclusion K σ τ e f)
    (fun _ _ => Commute.all _ _)

@[simp] theorem toTensor_inl (i : σ) :
    toTensor K σ τ e f (coord K (σ ⊕ τ) (Sum.elim e f) (.inl i)) =
      coord K σ e i ⊗ₜ[K] (1 : Ring K τ f) := evaluate_coord _ _ _
@[simp] theorem toTensor_inr (j : τ) :
    toTensor K σ τ e f (coord K (σ ⊕ τ) (Sum.elim e f) (.inr j)) =
      (1 : Ring K σ e) ⊗ₜ[K] coord K τ f j := evaluate_coord _ _ _
@[simp] theorem fromTensor_tmul (a : Ring K σ e) (b : Ring K τ f) :
    fromTensor K σ τ e f (a ⊗ₜ[K] b)=leftInclusion K σ τ e f a * rightInclusion K σ τ e f b := by
  simp [fromTensor]

theorem from_toTensor : (fromTensor K σ τ e f).comp (toTensor K σ τ e f)=AlgHom.id _ _ := by
  apply hom_ext
  intro u
  cases u <;> simp

theorem to_fromTensor : (toTensor K σ τ e f).comp (fromTensor K σ τ e f)=AlgHom.id _ _ := by
  apply Algebra.TensorProduct.ext
  · apply Ideal.Quotient.algHom_ext
    apply MvPolynomial.algHom_ext
    intro i
    change toTensor K σ τ e f (fromTensor K σ τ e f (coord K σ e i ⊗ₜ[K] 1))=coord K σ e i ⊗ₜ[K] 1
    simp
  · apply Ideal.Quotient.algHom_ext
    apply MvPolynomial.algHom_ext
    intro j
    change toTensor K σ τ e f (fromTensor K σ τ e f (1 ⊗ₜ[K] coord K τ f j))=1 ⊗ₜ[K] coord K τ f j
    simp

 

def sumTensorEquiv : Ring K (σ ⊕ τ) (Sum.elim e f) ≃ₐ[K] Ring K σ e ⊗[K] Ring K τ f :=
  { toTensor K σ τ e f with
    invFun := fromTensor K σ τ e f
    left_inv := fun a => AlgHom.congr_fun (from_toTensor K σ τ e f) a
    right_inv := fun a => AlgHom.congr_fun (to_fromTensor K σ τ e f) a }

end
end PD4Tensor.FiniteCoordinates

namespace PD4Tensor.FiniteCoordinates
noncomputable section
open scoped TensorProduct
variable (K R σ : Type*) [CommRing K] [CommRing R] [Algebra K R] (e : σ → ℕ)

def coefficientMap : Ring K σ e →ₐ[K] Ring R σ e :=
  evaluate (coord R σ e) (coord_pow R σ e)

@[simp] theorem coefficientMap_coord (i : σ) :
    coefficientMap K R σ e (coord K σ e i)=coord R σ e i := evaluate_coord _ _ _

def baseToTensor : Ring R σ e →ₐ[R] R ⊗[K] Ring K σ e :=
  evaluate (fun i => Algebra.TensorProduct.includeRight (A:=R) (coord K σ e i)) (by
    intro i
    rw [←map_pow,coord_pow,map_zero])

def baseFromTensor : R ⊗[K] Ring K σ e →ₐ[R] Ring R σ e :=
  Algebra.TensorProduct.lift (Algebra.ofId R (Ring R σ e)) (coefficientMap K R σ e)
    (fun _ _ => Commute.all _ _)

@[simp] theorem baseToTensor_coord (i : σ) :
    baseToTensor K R σ e (coord R σ e i)=(1 : R) ⊗ₜ[K] coord K σ e i := evaluate_coord _ _ _

@[simp] theorem baseFromTensor_tmul (r : R) (a : Ring K σ e) :
    baseFromTensor K R σ e (r ⊗ₜ[K] a)=r • coefficientMap K R σ e a := by
  change algebraMap R (Ring R σ e) r * coefficientMap K R σ e a=r • coefficientMap K R σ e a
  exact (Algebra.smul_def r _).symm

theorem baseFrom_toTensor :
    (baseFromTensor K R σ e).comp (baseToTensor K R σ e)=AlgHom.id R _ := by
  apply hom_ext
  intro i
  simp

theorem baseTo_fromTensor :
    (baseToTensor K R σ e).comp (baseFromTensor K R σ e)=AlgHom.id R _ := by
  apply Algebra.TensorProduct.ext'
  intro r a
  change baseToTensor K R σ e (baseFromTensor K R σ e (r ⊗ₜ[K] a))=r ⊗ₜ[K] a
  rw [baseFromTensor_tmul,map_smul]
  have h : ((baseToTensor K R σ e).restrictScalars K).comp (coefficientMap K R σ e) =
      Algebra.TensorProduct.includeRight (R:=K) (A:=R) (B:=Ring K σ e) := by
    apply Ideal.Quotient.algHom_ext
    apply MvPolynomial.algHom_ext
    intro i
    change baseToTensor K R σ e (coefficientMap K R σ e (coord K σ e i))=(1 : R) ⊗ₜ[K] coord K σ e i
    rw [coefficientMap_coord,baseToTensor_coord]
  have ha := AlgHom.congr_fun h a
  change baseToTensor K R σ e (coefficientMap K R σ e a)=(1 : R) ⊗ₜ[K] a at ha
  rw [ha,TensorProduct.smul_tmul']
  simp

 

def baseChangeEquiv : Ring R σ e ≃ₐ[R] R ⊗[K] Ring K σ e :=
  { baseToTensor K R σ e with
    invFun := baseFromTensor K R σ e
    left_inv := fun a => AlgHom.congr_fun (baseFrom_toTensor K R σ e) a
    right_inv := fun a => AlgHom.congr_fun (baseTo_fromTensor K R σ e) a }

 

def extendEquiv (g : Ring K σ e ≃ₐ[K] Ring K σ e) : Ring R σ e ≃ₐ[R] Ring R σ e :=
  (baseChangeEquiv K R σ e).trans
    ((Algebra.TensorProduct.congr ((AlgEquiv.refl : R ≃ₐ[R] R)) g).trans (baseChangeEquiv K R σ e).symm)

@[simp] theorem extendEquiv_coord (g : Ring K σ e ≃ₐ[K] Ring K σ e) (i : σ) :
    extendEquiv K R σ e g (coord R σ e i)=coefficientMap K R σ e (g (coord K σ e i)) := by
  change baseFromTensor K R σ e
    ((Algebra.TensorProduct.congr ((AlgEquiv.refl : R ≃ₐ[R] R)) g) (baseToTensor K R σ e (coord R σ e i)))=_
  simp

end
end PD4Tensor.FiniteCoordinates

namespace PD4Tensor.FiniteCoordinates
noncomputable section
open scoped TensorProduct
variable (K σ τ : Type*) [CommRing K] (e : σ → ℕ) (f : τ → ℕ)

def rightRestriction (he : ∀ i, 0<e i) :
    Ring K (σ ⊕ τ) (Sum.elim e f) →ₐ[K] Ring K τ f :=
  evaluate (Sum.elim (fun _ => 0) (coord K τ f)) (by
    intro i
    cases i with
    | inl i => exact zero_pow (Nat.ne_of_gt (he i))
    | inr j => exact coord_pow K τ f j)

@[simp] theorem rightRestriction_coord (he : ∀ i, 0<e i) (i : σ ⊕ τ) :
    rightRestriction K σ τ e f he (coord K (σ ⊕ τ) (Sum.elim e f) i)=
      Sum.elim (fun _ => 0) (coord K τ f) i := evaluate_coord _ _ _

def leftIdeal : Ideal (Ring K (σ ⊕ τ) (Sum.elim e f)) :=
  Ideal.span (Set.range (fun i => coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inl i)))

theorem rightRestriction_ker (he : ∀ i, 0<e i) :
    RingHom.ker (rightRestriction K σ τ e f he).toRingHom=leftIdeal K σ τ e f := by
  apply le_antisymm
  · intro a ha
    change rightRestriction K σ τ e f he a=0 at ha
    have herr := error_mem (leftIdeal K σ τ e f)
      ((rightInclusion K σ τ e f).comp (rightRestriction K σ τ e f he)) (by
        intro i
        cases i with
        | inl i =>
          simp only [AlgHom.comp_apply,rightRestriction_coord,Sum.elim_inl,map_zero,sub_zero]
          exact Ideal.subset_span (Set.mem_range_self i)
        | inr j =>
          simp only [AlgHom.comp_apply,rightRestriction_coord,Sum.elim_inr,
            rightInclusion_coord,sub_self,Ideal.zero_mem]) a
    simpa only [AlgHom.comp_apply,ha,map_zero,sub_zero] using herr
  · apply Ideal.span_le.mpr
    rintro _ ⟨i,rfl⟩
    change rightRestriction K σ τ e f he (coord K (σ ⊕ τ) (Sum.elim e f) (Sum.inl i))=0
    simp

 

def mixedEquiv : Ring K (σ ⊕ τ) (Sum.elim e f) ≃ₐ[K] Ring (Ring K σ e) τ f :=
  (sumTensorEquiv K σ τ e f).trans
    ((baseChangeEquiv K (Ring K σ e) τ f).symm.restrictScalars K)

@[simp] theorem mixedEquiv_inl (i : σ) :
    mixedEquiv K σ τ e f (coord K (σ ⊕ τ) (Sum.elim e f) (.inl i))=
      algebraMap (Ring K σ e) (Ring (Ring K σ e) τ f) (coord K σ e i) := by
  change baseFromTensor K (Ring K σ e) τ f (toTensor K σ τ e f
    (coord K (σ ⊕ τ) (Sum.elim e f) (.inl i)))=_
  rw [toTensor_inl,baseFromTensor_tmul,map_one]
  exact (Algebra.algebraMap_eq_smul_one (A:=Ring (Ring K σ e) τ f) (coord K σ e i)).symm

@[simp] theorem mixedEquiv_inr (j : τ) :
    mixedEquiv K σ τ e f (coord K (σ ⊕ τ) (Sum.elim e f) (.inr j))=coord (Ring K σ e) τ f j := by
  change baseFromTensor K (Ring K σ e) τ f (toTensor K σ τ e f
    (coord K (σ ⊕ τ) (Sum.elim e f) (.inr j)))=_
  rw [toTensor_inr,baseFromTensor_tmul,one_smul,coefficientMap_coord]

def coefficientSpecialization (he : ∀ i, 0<e i) : Ring (Ring K σ e) τ f →ₐ[K] Ring K τ f :=
  (rightRestriction K σ τ e f he).comp (mixedEquiv K σ τ e f).symm.toAlgHom

@[simp] theorem coefficientSpecialization_coord (he : ∀ i, 0<e i) (j : τ) :
    coefficientSpecialization K σ τ e f he (coord (Ring K σ e) τ f j)=coord K τ f j := by
  rw [←mixedEquiv_inr K σ τ e f j]
  change rightRestriction K σ τ e f he
    ((mixedEquiv K σ τ e f).symm (mixedEquiv K σ τ e f _))=_
  rw [AlgEquiv.symm_apply_apply,rightRestriction_coord]
  rfl

@[simp] theorem coefficientSpecialization_coefficientMap (he : ∀ i, 0<e i) (a : Ring K τ f) :
    coefficientSpecialization K σ τ e f he (coefficientMap K (Ring K σ e) τ f a)=a := by
  have hh : (coefficientSpecialization K σ τ e f he).comp (coefficientMap K (Ring K σ e) τ f)=
      AlgHom.id K _ := by
    apply Ideal.Quotient.algHom_ext
    apply MvPolynomial.algHom_ext
    intro j
    change coefficientSpecialization K σ τ e f he
      (coefficientMap K (Ring K σ e) τ f (coord K τ f j))=coord K τ f j
    rw [coefficientMap_coord,coefficientSpecialization_coord]
  exact AlgHom.congr_fun hh a

@[simp] theorem coefficientSpecialization_parameter (he : ∀ i, 0<e i) (i : σ) :
    coefficientSpecialization K σ τ e f he
      (algebraMap (Ring K σ e) (Ring (Ring K σ e) τ f) (coord K σ e i))=0 := by
  rw [←mixedEquiv_inl K σ τ e f i]
  change rightRestriction K σ τ e f he
    ((mixedEquiv K σ τ e f).symm (mixedEquiv K σ τ e f _))=0
  rw [AlgEquiv.symm_apply_apply,rightRestriction_coord]
  rfl

def coefficientIdeal : Ideal (Ring (Ring K σ e) τ f) :=
  Ideal.span (Set.range (fun i =>
    algebraMap (Ring K σ e) (Ring (Ring K σ e) τ f) (coord K σ e i)))

 

theorem coefficientSpecialization_ker (he : ∀ i, 0<e i) :
    RingHom.ker (coefficientSpecialization K σ τ e f he).toRingHom=coefficientIdeal K σ τ e f := by
  have hm : (leftIdeal K σ τ e f).map (mixedEquiv K σ τ e f).toRingHom=
      coefficientIdeal K σ τ e f := by
    rw [leftIdeal,coefficientIdeal,Ideal.map_span]
    congr 1
    ext a
    simp only [Set.mem_image,Set.mem_range]
    constructor
    · rintro ⟨_,⟨i,rfl⟩,rfl⟩
      exact ⟨i,(mixedEquiv_inl K σ τ e f i).symm⟩
    · rintro ⟨i,rfl⟩
      exact ⟨_,⟨i,rfl⟩,mixedEquiv_inl K σ τ e f i⟩
  rw [←hm]
  ext a
  rw [Ideal.mem_map_iff_of_surjective (mixedEquiv K σ τ e f).toRingHom (mixedEquiv K σ τ e f).surjective]
  constructor
  · intro ha
    refine ⟨(mixedEquiv K σ τ e f).symm a,?_,(mixedEquiv K σ τ e f).apply_symm_apply a⟩
    rw [←rightRestriction_ker K σ τ e f he]
    exact ha
  · rintro ⟨b,hb,rfl⟩
    change rightRestriction K σ τ e f he
      ((mixedEquiv K σ τ e f).symm (mixedEquiv K σ τ e f b))=0
    rw [AlgEquiv.symm_apply_apply]
    rw [←rightRestriction_ker K σ τ e f he] at hb
    exact hb

theorem coefficientIdeal_nilpotent [Fintype σ] : IsNilpotent (coefficientIdeal K σ τ e f) := by
  have hfg : (coefficientIdeal K σ τ e f).FG := Submodule.fg_span (Set.finite_range _)
  apply hfg.isNilpotent_iff_le_nilradical.mpr
  apply Ideal.span_le.mpr
  rintro _ ⟨i,rfl⟩
  exact mem_nilradical.mpr ((show IsNilpotent (coord K σ e i) from ⟨e i,coord_pow K σ e i⟩).map _)

end
end PD4Tensor.FiniteCoordinates

namespace PD4Tensor
noncomputable section
variable {K A : Type*} [CommRing K] [CommRing A] [Algebra K A]

 

theorem bijective_of_nilpotent_deformation {ι : Type*} (z : ι → A)
    (f : A →ₐ[K] A) (c : A ≃ₐ[K] A)
    (hfz : ∀ i, f (z i)=z i) (hcz : ∀ i, c (z i)=z i)
    (he : ∀ a, c a-f a∈Ideal.span (Set.range z))
    (hn : IsNilpotent (Ideal.span (Set.range z))) : Function.Bijective f := by
  let g := f.comp c.symm.toAlgHom
  have hg₀ (a : A) : a-g a∈Ideal.span (Set.range z) := by
    simpa only [g,AlgHom.comp_apply,AlgEquiv.coe_toAlgHom,AlgEquiv.apply_symm_apply] using he (c.symm a)
  have hg₁ (i : ι) : z i-g (z i)∈Ideal.span (Set.range z)^2 := by
    have hci : c.symm (z i)=z i := by
      apply c.injective
      simp only [c.apply_symm_apply,hcz]
    simp only [g,AlgHom.comp_apply,AlgEquiv.coe_toAlgHom,hci,hfz,sub_self]
    exact Ideal.zero_mem _
  obtain ⟨N,hN⟩ := hn
  have hg := bijective_of_identity_tangent (Ideal.span (Set.range z)) g hg₀
    (coordinate_error_on_span z g hg₀ hg₁) N hN
  exact (Function.Bijective.of_comp_iff _ c.symm.bijective).mp hg

end
end PD4Tensor

namespace PD4Tensor.FiniteCoordinates
noncomputable section
variable {K σ : Type*} [CommRing K] {e : σ → ℕ}
  {B : Type*} [CommRing B] [Algebra K B]

 

theorem difference_mem (J : Ideal B) (f g : Ring K σ e →ₐ[K] B)
    (hz : ∀ i, f (coord K σ e i)-g (coord K σ e i)∈J) (a : Ring K σ e) :
    f a-g a∈J := by
  refine Quotient.inductionOn' a ?_
  intro q
  change f (Ideal.Quotient.mk (ideal K σ e) q)-g (Ideal.Quotient.mk (ideal K σ e) q)∈J
  induction q using MvPolynomial.induction_on with
  | C c =>
    change f (algebraMap K (Ring K σ e) c)-g (algebraMap K (Ring K σ e) c)∈J
    simp
  | add q r hq hr =>
    simpa only [map_add,add_sub_add_comm] using J.add_mem hq hr
  | mul_X q i hq =>
    change f (Ideal.Quotient.mk _ q * coord K σ e i)-g (Ideal.Quotient.mk _ q * coord K σ e i)∈J
    have h := J.add_mem
      (Ideal.mul_mem_left J (f (Ideal.Quotient.mk (ideal K σ e) q)) (hz i))
      (Ideal.mul_mem_right (g (coord K σ e i)) J hq)
    convert h using 1
    simp only [map_mul]
    ring

end
end PD4Tensor.FiniteCoordinates

namespace PD4Tensor.FiniteCoordinates
noncomputable section
variable (K σ τ : Type*) [CommRing K] [Fintype σ] (e : σ → ℕ) (f : τ → ℕ)

 

theorem bijective_of_central_equiv (he : ∀ i, 0<e i)
    (c : Ring K τ f ≃ₐ[K] Ring K τ f)
    (F : Ring (Ring K σ e) τ f →ₐ[Ring K σ e] Ring (Ring K σ e) τ f)
    (hF : ∀ j, coefficientSpecialization K σ τ e f he (F (coord (Ring K σ e) τ f j))=
      c (coord K τ f j)) : Function.Bijective F := by
  let z (i : σ) := algebraMap (Ring K σ e) (Ring (Ring K σ e) τ f) (coord K σ e i)
  let cE := extendEquiv K (Ring K σ e) τ f c
  apply bijective_of_nilpotent_deformation z F cE
  · intro i
    exact F.commutes _
  · intro i
    exact cE.commutes _
  · intro a
    apply difference_mem (Ideal.span (Set.range z)) cE.toAlgHom F _ a
    intro j
    change cE (coord (Ring K σ e) τ f j)-F (coord (Ring K σ e) τ f j)∈coefficientIdeal K σ τ e f
    rw [←coefficientSpecialization_ker K σ τ e f he]
    change coefficientSpecialization K σ τ e f he
      (cE (coord (Ring K σ e) τ f j)-F (coord (Ring K σ e) τ f j))=0
    rw [map_sub,show cE (coord (Ring K σ e) τ f j)=
      coefficientMap K (Ring K σ e) τ f (c (coord K τ f j)) from extendEquiv_coord _ _ _ _ _ _,
      coefficientSpecialization_coefficientMap,hF,sub_self]
  · exact coefficientIdeal_nilpotent K σ τ e f

end
end PD4Tensor.FiniteCoordinates
end

end OAI