import Mathlib

namespace OAI

/-! Squarefree parameter algebras, selectors and formal gradient base change. -/

noncomputable section
open scoped BigOperators

namespace PD4Tensor

open scoped BigOperators

variable (K : Type*) [Field K] (m : ℕ)

 
def squareIdeal : Ideal (MvPolynomial (Fin m) K) :=
  Ideal.span (Set.range (fun i : Fin m => (MvPolynomial.X i : MvPolynomial (Fin m) K) ^ 2))

abbrev T := MvPolynomial (Fin m) K ⧸ squareIdeal K m

def t (i : Fin m) : T K m := Ideal.Quotient.mk (squareIdeal K m) (MvPolynomial.X i)

def augmentation : T K m →+* K :=
  Ideal.Quotient.lift (squareIdeal K m)
    (MvPolynomial.eval₂Hom (RingHom.id K) (fun _ => 0)) (by
      have h : squareIdeal K m ≤
          RingHom.ker (MvPolynomial.eval₂Hom (RingHom.id K) (fun _ : Fin m => 0)) := by
        apply Ideal.span_le.mpr
        rintro _ ⟨i, rfl⟩
        simp
      exact fun a ha => h ha)

def parameterIdeal : Ideal (T K m) := Ideal.span (Set.range (t K m))

end PD4Tensor

namespace PD4Tensor
noncomputable section
variable (K : Type*) [Field K] (m : ℕ)

@[simp] theorem t_sq (i : Fin m) : t K m i ^ 2 = 0 := by
  unfold t
  rw [← map_pow, Ideal.Quotient.eq_zero_iff_mem]
  exact Ideal.subset_span (Set.mem_range_self i)

 
theorem parameterIdeal_le_nilradical : parameterIdeal K m ≤ nilradical (T K m) := by
  apply Ideal.span_le.mpr
  rintro _ ⟨i, rfl⟩
  exact mem_nilradical.mpr ⟨2, t_sq K m i⟩

private theorem squareIdeal_as_monomials : squareIdeal K m =
    Ideal.span ((fun a : Fin m →₀ ℕ => MvPolynomial.monomial a (1 : K)) ''
      Set.range (fun i : Fin m => Finsupp.single i 2)) := by
  unfold squareIdeal
  congr 1
  ext p
  simp only [Set.mem_range, Set.mem_image]
  constructor
  · rintro ⟨i, rfl⟩
    exact ⟨Finsupp.single i 2, ⟨i, rfl⟩, (MvPolynomial.X_pow_eq_monomial).symm⟩
  · rintro ⟨a, ⟨i, rfl⟩, rfl⟩
    exact ⟨i, MvPolynomial.X_pow_eq_monomial⟩

 
theorem squarefree_monomial_ne_zero (a : Fin m →₀ ℕ) (ha : ∀ i, a i ≤ 1) :
    Ideal.Quotient.mk (squareIdeal K m) (MvPolynomial.monomial a 1) ≠ 0 := by
  classical
  rw [ne_eq, Ideal.Quotient.eq_zero_iff_mem, squareIdeal_as_monomials,
    MvPolynomial.mem_ideal_span_monomial_image]
  intro h
  obtain ⟨_, ⟨i, rfl⟩, hi⟩ := h a (by simp [MvPolynomial.support_monomial])
  have htwo : 2 ≤ a i := by simpa using hi i
  have hi1 := ha i
  omega

 
theorem triple_ne_zero (i j k : Fin m) (hij : i ≠ j) (hik : i ≠ k) (hjk : j ≠ k) :
    t K m i * t K m j * t K m k ≠ 0 := by
  unfold t
  rw [← map_mul, ← map_mul]
  change Ideal.Quotient.mk (squareIdeal K m)
    ((MvPolynomial.monomial (Finsupp.single i 1) 1) *
      (MvPolynomial.monomial (Finsupp.single j 1) 1) *
      (MvPolynomial.monomial (Finsupp.single k 1) 1)) ≠ 0
  simp only [MvPolynomial.monomial_mul_monomial, one_mul]
  apply squarefree_monomial_ne_zero
  intro l
  simp only [Finsupp.add_apply, Finsupp.single_apply]
  split_ifs <;> simp_all

 
theorem triple_mul_unit_ne_zero (i j k : Fin m) (hij : i ≠ j) (hik : i ≠ k) (hjk : j ≠ k)
    {b : T K m} (hb : IsUnit b) : (t K m i * t K m j * t K m k) * b ≠ 0 := by
  intro h
  apply triple_ne_zero K m i j k hij hik hjk
  apply hb.mul_left_cancel
  simpa [mul_comm] using h

@[simp] theorem augmentation_t (i : Fin m) : augmentation K m (t K m i)=0 := by
  simp [augmentation,t,Ideal.Quotient.lift_mk]

@[simp] theorem augmentation_algebraMap (c : K) :
    augmentation K m (algebraMap K (T K m) c)=c := by
  change augmentation K m (Ideal.Quotient.mk (squareIdeal K m) (MvPolynomial.C c))=c
  simp [augmentation,Ideal.Quotient.lift_mk]

def augmentationAlg : T K m →ₐ[K] K :=
  { augmentation K m with commutes' := augmentation_algebraMap K m }

 
theorem sub_constant_mem (a : T K m) :
    a - algebraMap K (T K m) (augmentation K m a) ∈ parameterIdeal K m := by
  refine Quotient.inductionOn' a ?_
  intro p
  change Ideal.Quotient.mk (squareIdeal K m) p -
    algebraMap K (T K m) (augmentation K m (Ideal.Quotient.mk (squareIdeal K m) p)) ∈
      parameterIdeal K m
  induction p using MvPolynomial.induction_on with
  | C c =>
      change algebraMap K (T K m) c - algebraMap K (T K m)
        (augmentation K m (algebraMap K (T K m) c)) ∈ parameterIdeal K m
      simp
  | add p q hp hq =>
      simpa only [map_add,add_sub_add_comm] using (parameterIdeal K m).add_mem hp hq
  | mul_X p i _ =>
      simp only [map_mul,show Ideal.Quotient.mk (squareIdeal K m) (MvPolynomial.X i)=t K m i from rfl,
        augmentation_t,mul_zero,map_zero,sub_zero]
      exact Ideal.mul_mem_left _ _ (Ideal.subset_span (Set.mem_range_self i))

 
theorem isUnit_of_augmentation_ne_zero (a : T K m) (ha : augmentation K m a ≠ 0) : IsUnit a := by
  have hn : IsNilpotent (a-algebraMap K (T K m) (augmentation K m a)) :=
    mem_nilradical.mp (parameterIdeal_le_nilradical K m (sub_constant_mem K m a))
  have hu := (isUnit_iff_ne_zero.mpr ha).map (algebraMap K (T K m))
  have h := hn.isUnit_add_left_of_commute hu (Commute.all _ _)
  simpa only [add_sub_cancel] using h

end
end PD4Tensor

namespace PD4Tensor
noncomputable section
variable {K ι : Type*} [Field K]
 
def threeParameters (q : Fin 3 ↪ ι) : ι → T K 3 :=
  Function.extend q (t K 3) (fun _ => 0)

@[simp] theorem threeParameters_selected (q : Fin 3 ↪ ι) (j : Fin 3) :
    threeParameters (K:=K) q (q j) = t K 3 j := q.injective.extend_apply _ _ _

@[simp] theorem threeParameters_other (q : Fin 3 ↪ ι) (i : ι) (hi : i∉Set.range q) :
    threeParameters (K:=K) q i = 0 := Function.extend_apply' _ _ _ hi

theorem threeParameters_sq (q : Fin 3 ↪ ι) (i : ι) :
    threeParameters (K:=K) q i * threeParameters (K:=K) q i=0 := by
  by_cases hi : i∈Set.range q
  · obtain ⟨j,rfl⟩ := hi
    simpa only [threeParameters_selected,← pow_two] using t_sq K 3 j
  · simp [threeParameters_other q i hi]

@[simp] theorem augmentation_threeParameters (q : Fin 3 ↪ ι) (i : ι) :
    augmentation K 3 (threeParameters (K:=K) q i)=0 := by
  by_cases hi : i∈Set.range q
  · obtain ⟨j,rfl⟩ := hi; simp
  · simp [threeParameters_other q i hi]

end
end PD4Tensor

namespace PD4Tensor
noncomputable section
variable (K : Type*) [Field K] (m : ℕ) {ι : Type*}

 

def parameterSelector (active : Fin m ↪ ι) (q : Fin 3 ↪ ι) : T K m →ₐ[K] T K 3 :=
  Ideal.Quotient.liftₐ (squareIdeal K m)
    (MvPolynomial.aeval (fun i => threeParameters (K:=K) q (active i))) (by
      change squareIdeal K m ≤ RingHom.ker (MvPolynomial.aeval (fun i => threeParameters (K:=K) q (active i))).toRingHom
      apply Ideal.span_le.mpr
      rintro _ ⟨i,rfl⟩
      change (MvPolynomial.aeval (fun i => threeParameters (K:=K) q (active i)))
        ((MvPolynomial.X i)^2)=0
      rw [map_pow,MvPolynomial.aeval_X,pow_two,threeParameters_sq])

@[simp] theorem parameterSelector_t (active : Fin m ↪ ι) (q : Fin 3 ↪ ι) (i : Fin m) :
    parameterSelector K m active q (t K m i)=threeParameters (K:=K) q (active i) := by
  change (MvPolynomial.aeval (fun i => threeParameters (K:=K) q (active i))) (MvPolynomial.X i)=_
  exact MvPolynomial.aeval_X _ _

theorem augmentation_parameterSelector (active : Fin m ↪ ι) (q : Fin 3 ↪ ι) (a : T K m) :
    augmentation K 3 (parameterSelector K m active q a)=augmentation K m a := by
  have heq : (augmentationAlg K 3).comp (parameterSelector K m active q)=augmentationAlg K m := by
    apply Ideal.Quotient.algHom_ext
    apply MvPolynomial.algHom_ext
    intro i
    change augmentation K 3 (parameterSelector K m active q (t K m i))=augmentation K m (t K m i)
    simp only [parameterSelector_t,augmentation_threeParameters,augmentation_t]
  exact AlgHom.congr_fun heq a

theorem augmentation_zero_of_mem (a : T K m) (ha : a∈parameterIdeal K m) :
    augmentation K m a=0 := by
  have hle : parameterIdeal K m ≤ RingHom.ker (augmentation K m) := by
    apply Ideal.span_le.mpr
    rintro _ ⟨i,rfl⟩
    exact augmentation_t K m i
  exact hle ha

end
end PD4Tensor

namespace PD4Tensor
noncomputable section
variable {R S σ : Type*} [CommRing R] [CommRing S]

 
theorem map_formal_pderiv (f : R →+* S) (i : σ) (F : MvPowerSeries σ R) :
    MvPowerSeries.map f (MvPowerSeries.pderiv i F)=
      MvPowerSeries.pderiv i (MvPowerSeries.map f F) := by
  ext d
  simp only [MvPowerSeries.coeff_map,MvPowerSeries.coeff_pderiv,map_mul,map_add,map_natCast,map_one]

variable {τ : Type*} [Fintype τ]

 
theorem map_formal_gradient (f : R →+* S)
    (H : τ → MvPowerSeries σ R) (hH : MvPowerSeries.HasSubst H)
    (F a : MvPowerSeries τ R)
    (ha : MvPowerSeries.subst H a∈Ideal.span
      (Set.range (fun i => MvPowerSeries.subst H (MvPowerSeries.pderiv i F)))) :
    MvPowerSeries.subst (fun i => MvPowerSeries.map f (H i)) (MvPowerSeries.map f a) ∈
      Ideal.span (Set.range (fun i =>
        MvPowerSeries.subst (fun i => MvPowerSeries.map f (H i))
          (MvPowerSeries.pderiv i (MvPowerSeries.map f F)))) := by
  obtain ⟨b,hb⟩ := Ideal.mem_span_range_iff_exists_fun.mp ha
  refine Ideal.mem_span_range_iff_exists_fun.mpr ⟨fun i => MvPowerSeries.map f (b i),?_⟩
  have hh := congrArg (MvPowerSeries.map f) hb
  simpa only [map_sum,map_mul,MvPowerSeries.map_subst hH,map_formal_pderiv] using hh

end
end PD4Tensor

namespace PD4Tensor
noncomputable section
open scoped BigOperators
variable {ι κ : Type*} [Fintype κ] [DecidableEq ι]
  {A : ι → Type*} [∀ i,AddCommMonoid (A i)]

 

def activeExtension (active : κ ↪ ι) (b : ∀ j,A (active j)) : ∀ i,A i :=
  ∑ j,Pi.single (active j) (b j)

@[simp] theorem activeExtension_selected (active : κ ↪ ι) (b : ∀ j,A (active j)) (j : κ) :
    activeExtension active b (active j)=b j := by
  classical
  simp only [activeExtension,Finset.sum_apply]
  rw [Finset.sum_eq_single j]
  · exact Pi.single_eq_same _ _
  · intro k _ hk
    exact Pi.single_eq_of_ne (fun h => hk (active.injective h).symm) _
  · simp

theorem activeExtension_other (active : κ ↪ ι) (b : ∀ j,A (active j))
    (i : ι) (hi : i∉Set.range active) : activeExtension active b i=0 := by
  classical
  simp only [activeExtension,Finset.sum_apply]
  apply Finset.sum_eq_zero
  intro j _
  exact Pi.single_eq_of_ne (fun h => hi ⟨j,h.symm⟩) _

 

theorem sum_activeExtension [Fintype ι] {B : Type*} [AddCommMonoid B]
    (active : κ ↪ ι) (b : ∀ j,A (active j)) (f : ∀ i,A i →+ B) :
    ∑ i,f i (activeExtension active b i)=∑ j,f (active j) (b j) := by
  classical
  simp only [activeExtension,Finset.sum_apply,map_sum]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro j _
  rw [Finset.sum_eq_single (active j)]
  · rw [Pi.single_eq_same]
  · intro i _ hi
    rw [Pi.single_eq_of_ne hi,map_zero]
  · simp

 

omit [Fintype κ] [DecidableEq ι] in
theorem embedding_preimage (active : κ ↪ ι) (q : Fin 3 ↪ ι)
    (hq : ∀ j,q j∈Set.range active) :
    ∃ r : Fin 3 ↪ κ,∀ j,active (r j)=q j := by
  classical
  choose r hr using hq
  refine ⟨⟨r,?_⟩,hr⟩
  intro i j hij
  apply q.injective
  rw [←hr i,←hr j,hij]

end
end PD4Tensor
end

end OAI