import OAI.NumberTheory.PowerFree.PairProjections

namespace OAI

namespace QuarticPowerFree

section
open MvPolynomial
open scoped BigOperators

theorem polynomial_projection_hilbert_le {n m : ℕ} {K : Type*} [Field K]
    (I : Ideal (MvPolynomial (Fin n) K))
    (J : Ideal (MvPolynomial (Fin m) K)) (z : Fin m → MvPolynomial (Fin n) K)
    (D : ℕ) (hz : ∀ i, (z i).totalDegree ≤ D)
    (hker : ∀ p, Ideal.Quotient.mk I (MvPolynomial.aeval z p) = 0 ↔ p ∈ J) (T : ℕ) :
    Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkₐ K J).toLinearMap) ≤
      Module.finrank K ((totalSpace (D*T)).map (Ideal.Quotient.mkₐ K I).toLinearMap) := by
  classical
  let := totalSpace_finite (n := n) (K := K) (D*T)
  let f₀ := (Ideal.Quotient.mkₐ K I).comp (MvPolynomial.aeval z)
  let f := Ideal.Quotient.liftₐ J f₀ (fun p hp => (hker p).mpr hp)
  have hf : Function.Injective f := by
    apply (injective_iff_map_eq_zero f).mpr
    intro y hy
    obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective y
    exact Ideal.Quotient.eq_zero_iff_mem.mpr ((hker p).mp hy)
  let g := (f.toLinearMap.domRestrict
    ((totalSpace T).map (Ideal.Quotient.mkₐ K J).toLinearMap)).codRestrict
      ((totalSpace (D*T)).map (Ideal.Quotient.mkₐ K I).toLinearMap) (by
        rintro ⟨y,p,hp,rfl⟩
        exact ⟨MvPolynomial.aeval z p,totalSpace_aeval z D hz p T hp,rfl⟩)
  apply LinearMap.finrank_le_finrank_of_injective (f := g)
  intro y z he
  exact Subtype.ext (hf (congrArg Subtype.val he))

theorem polynomial_projection_equation_degree_bound {n h : ℕ} {K : Type*} [Field K]
    (I : Ideal (MvPolynomial (Fin n) K)) (P : Polynomial ℚ)
    (hP : P.natDegree ≤ h)
    (hT : ∀ᶠ T : ℕ in Filter.atTop,
      (Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkₐ K I).toLinearMap) : ℚ) =
        P.eval (T : ℚ)) (z : Fin (h+1) → MvPolynomial (Fin n) K)
    (D : ℕ) (hD : 0 < D) (hz : ∀ i, (z i).totalDegree ≤ D)
    (q : MvPolynomial (Fin (h+1)) K) (hq : q ≠ 0)
    (hker : ∀ p, Ideal.Quotient.mk I (MvPolynomial.aeval z p) = 0 ↔ q ∣ p) :
    (q.totalDegree : ℚ) ≤ (h.factorial : ℚ) * P.coeff h * (D:ℚ)^h := by
  let Q := P.comp (Polynomial.C (D:ℚ)*Polynomial.X)
  have hQT : ∀ᶠ T : ℕ in Filter.atTop,
      (Module.finrank K ((totalSpace (D*T)).map (Ideal.Quotient.mkₐ K I).toLinearMap) : ℚ) =
        Q.eval (T:ℚ) := by
    obtain ⟨T₀,hT₀⟩ := Filter.eventually_atTop.mp hT
    apply Filter.eventually_atTop.mpr
    refine ⟨T₀,fun T hTT => ?_⟩
    have hT' : T₀ ≤ D*T := hTT.trans (by simpa using Nat.mul_le_mul_right T hD)
    simpa [Q,Polynomial.eval_comp] using hT₀ (D*T) hT'
  have hQ : Q.natDegree ≤ h := by
    have hh := Polynomial.natDegree_comp_le (p := P) (q := Polynomial.C (D:ℚ)*Polynomial.X)
    have hND : (Polynomial.C (D:ℚ)*Polynomial.X).natDegree ≤ 1 := by
      exact le_trans Polynomial.natDegree_mul_le (by simp)
    exact (hh.trans ((Nat.mul_le_mul_left _ hND).trans_eq (Nat.mul_one _))).trans hP
  have hh : ∀ᶠ T : ℕ in Filter.atTop,
      (hypersurfaceHilbertPolynomial h q.totalDegree).eval (T:ℚ) ≤ Q.eval (T:ℚ) := by
    filter_upwards [hQT,Filter.eventually_ge_atTop q.totalDegree] with T hT hqT
    rw [←hT,←hypersurface_hilbert_polynomial q hq T hqT]
    exact_mod_cast polynomial_projection_hilbert_le I (Ideal.span {q}) z D hz
      (fun p => (hker p).trans Ideal.mem_span_singleton.symm) T
  have hc := coeff_le_of_eventually_nat_eval_le
    (hypersurfaceHilbertPolynomial h q.totalDegree) Q h
    (hypersurfaceHilbertPolynomial_degree _ _) hQ hh
  rw [hypersurfaceHilbertPolynomial_coeff,Polynomial.comp_C_mul_X_coeff] at hc
  have hf : (0:ℚ) < h.factorial := by exact_mod_cast Nat.factorial_pos h
  exact (div_le_iff₀ hf).mp hc |>.trans_eq (by ring)

end
section
open MvPolynomial

theorem polynomial_projection_equation_degree_bound_equiv {n h : ℕ}
    {σ K : Type*} [Field K] (e : Fin (h+1) ≃ σ)
    (I : Ideal (MvPolynomial (Fin n) K)) (P : Polynomial ℚ)
    (hP : P.natDegree ≤ h)
    (hT : ∀ᶠ T : ℕ in Filter.atTop,
      (Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkₐ K I).toLinearMap) : ℚ) =
        P.eval (T : ℚ)) (z : σ → MvPolynomial (Fin n) K)
    (D : ℕ) (hD : 0 < D) (hz : ∀ i, (z i).totalDegree ≤ D)
    (q : MvPolynomial σ K) (hq : q ≠ 0)
    (hker : ∀ p, Ideal.Quotient.mk I (MvPolynomial.aeval z p) = 0 ↔ q ∣ p) :
    (q.totalDegree : ℚ) ≤ (h.factorial : ℚ) * P.coeff h * (D:ℚ)^h := by
  let E := MvPolynomial.renameEquiv K e
  let q₀ := E.symm q
  have hq₀ : q₀ ≠ 0 := by
    intro hz
    apply hq
    have hh := congrArg E hz
    simpa only [q₀,E.apply_symm_apply,map_zero] using hh
  have he (p : MvPolynomial (Fin (h+1)) K) :
      MvPolynomial.aeval (z ∘ e) p = MvPolynomial.aeval z (E p) := by
    simp only [E,MvPolynomial.renameEquiv_apply,MvPolynomial.aeval_rename,Function.comp_def]
  have hk₀ (p) : Ideal.Quotient.mk I (MvPolynomial.aeval (z ∘ e) p) = 0 ↔ q₀ ∣ p := by
    rw [he,hker]
    have hh := map_dvd_iff E (a := q₀) (b := p)
    rwa [show E q₀ = q from E.apply_symm_apply q] at hh
  have hh := polynomial_projection_equation_degree_bound I P hP hT (z ∘ e) D hD
    (fun i => hz (e i)) q₀ hq₀ hk₀
  have hdeg : q₀.totalDegree = q.totalDegree := MvPolynomial.totalDegree_renameEquiv e.symm q
  rwa [hdeg] at hh

theorem affine_polynomial_projection_degree_bound {n h : ℕ} {σ K : Type*}
    [Field K] (e : Fin (h+1) ≃ σ)
    (I : Ideal (MvPolynomial (Fin n) K)) (hdim : affineDimension I = h)
    (z : σ → MvPolynomial (Fin n) K) (D : ℕ) (hD : 0 < D)
    (hz : ∀ i, (z i).totalDegree ≤ D)
    (q : MvPolynomial σ K) (hq : q ≠ 0)
    (hker : ∀ p, Ideal.Quotient.mk I (MvPolynomial.aeval z p) = 0 ↔ q ∣ p) :
    (q.totalDegree:ℚ) ≤ affineDegree I * (D:ℚ)^h := by
  have hh := polynomial_projection_equation_degree_bound_equiv e I (coordinateHilbert I)
    hdim.le (coordinateHilbert_eventually I) z D hD hz q hq hker
  simpa only [affineDegree,hdim] using hh

end

theorem left_coordinates_transcendence_selection {d : ℕ} {K A : Type*}
    [Field K] [CommRing A] [IsDomain A] [Algebra K A]
    (a : Fin d → A) (x : A) (hx : Transcendental K x)
    [Algebra.IsAlgebraic (Algebra.adjoin K (insert x (Set.range a))) A] :
    ∃ m : ℕ, ∃ j : Fin m → Fin d,
      AlgebraicIndependent K (Fin.cases x (a ∘ j)) ∧ Function.Injective j ∧
      Algebra.trdeg K A = (m+1 : ℕ) := by
  classical
  have hx' : AlgebraicIndepOn K id {x} := by
    change AlgebraicIndependent K (fun z : ({x} : Set A) => z.val)
    rw [algebraicIndependent_singleton_iff (⟨x,rfl⟩ : ({x} : Set A))]
    exact hx
  obtain ⟨t,hxt,htt,htb⟩ := exists_isTranscendenceBasis_between
    (R := K) (A := A) {x} (insert x (Set.range a)) (by simp) hx'
  have htfin : t.Finite := ((Set.finite_range a).insert x).subset htt
  let : Fintype t := htfin.fintype
  let xt : t := ⟨x,hxt (Set.mem_singleton x)⟩
  have hcard : 0 < Fintype.card t := Fintype.card_pos_iff.mpr ⟨xt⟩
  let m := Fintype.card t - 1
  have hm : m+1 = Fintype.card t := by omega
  let e₀ : Fin (m+1) ≃ t := (finCongr hm).trans (Fintype.equivFin t).symm
  let e : Fin (m+1) ≃ t := (Equiv.swap 0 (e₀.symm xt)).trans e₀
  have he0 : e 0 = xt := by simp [e]
  have heA (i : Fin m) : (e i.succ).val ∈ Set.range a := by
    have hh := htt (e i.succ).property
    rcases hh with hh | hh
    · have heq : e i.succ = xt := Subtype.ext hh
      have : i.succ = 0 := e.injective (heq.trans he0.symm)
      exact (Fin.succ_ne_zero i this).elim
    · exact hh
  choose j hj using heA
  have heval : (fun i : Fin (m+1) => (e i).val) = Fin.cases x (a ∘ j) := by
    funext i
    refine Fin.cases ?_ (fun l => ?_) i
    · exact congrArg Subtype.val he0
    · exact (hj l).symm
  have hi : AlgebraicIndependent K (Fin.cases x (a ∘ j)) := by
    simpa only [Function.comp_def,heval] using htb.1.comp e e.injective
  refine ⟨m,j,hi,?_,?_⟩
  · intro i l hil
    apply Fin.succ_injective
    apply hi.injective
    simp only [Fin.cases_succ,Function.comp_def,hil]
  · rw [←htb.cardinalMk_eq_trdeg,Cardinal.mk_fintype,←hm]

theorem pair_right_isAlgebraic {d : ℕ} {K A : Type*}
    [Field K] [CommRing A] [IsDomain A] [Algebra K A]
    (k : ℕ) (a b : Fin d → A) (x : A) (θ : Fin d → K)
    (ha : ∀ i, a i ≠ 0) (hab : ∀ i, a i ^ k * b i = x - algebraMap K A (θ i))
    (i : Fin d) : IsAlgebraic (Algebra.adjoin K (insert x (Set.range a))) (b i) := by
  let S := Algebra.adjoin K (insert x (Set.range a))
  let ai : S := ⟨a i,Algebra.subset_adjoin (Set.mem_insert_of_mem _ ⟨i,rfl⟩)⟩
  let xi : S := ⟨x,Algebra.subset_adjoin (Set.mem_insert _ _)⟩
  let p : Polynomial S := Polynomial.C (ai^k) * Polynomial.X -
    Polynomial.C (xi - algebraMap K S (θ i))
  refine ⟨p,?_,?_⟩
  · intro hp
    have hh := congrArg (fun q : Polynomial S => q.coeff 1) hp
    have hh' : ai^k = 0 := by
      simpa only [p,Polynomial.coeff_sub,Polynomial.coeff_C_mul_X,
        Polynomial.coeff_C,ite_eq_right (by decide : (1:ℕ) ≠ 0),
        ite_eq_left rfl,ite_true,sub_zero,Polynomial.coeff_zero] using hh
    have hai : ai ≠ 0 := fun h => ha i (congrArg Subtype.val h)
    exact pow_ne_zero k hai hh'
  · change Polynomial.aeval (b i) p = 0
    simp only [p,map_sub,map_mul,Polynomial.aeval_C,Polynomial.aeval_X]
    change a i ^ k * b i - (x - algebraMap K A (θ i)) = 0
    exact sub_eq_zero.mpr (hab i)

theorem pair_projection_isAlgebraic {d : ℕ} {K A : Type*}
    [Field K] [CommRing A] [IsDomain A] [Algebra K A]
    (k : ℕ) (a b : Fin d → A) (x : A) (θ : Fin d → K)
    (ha : ∀ i, a i ≠ 0) (hab : ∀ i, a i ^ k * b i = x - algebraMap K A (θ i))
    (hgen : Algebra.adjoin K (Set.range a ∪ Set.range b) = ⊤) :
    Algebra.IsAlgebraic (Algebra.adjoin K (insert x (Set.range a))) A := by
  constructor
  intro z
  have hz : IsAlgebraic (Algebra.adjoin K (Set.range a ∪ Set.range b)) z := by
    rw [hgen]
    exact isAlgebraic_algebraMap (R := (⊤ : Subalgebra K A)) ⟨z,trivial⟩
  apply hz.adjoin_of_forall_isAlgebraic
  rintro y ⟨hy,hyn⟩
  rcases hy with ⟨i,rfl⟩ | ⟨i,rfl⟩
  · exact (hyn (Set.mem_insert_of_mem _ ⟨i,rfl⟩)).elim
  · exact pair_right_isAlgebraic k a b x θ ha hab i

open MvPolynomial

theorem principal_evaluation_kernel_reindex {σ τ K A : Type*}
    [Field K] [CommRing A] [Algebra K A] (e : σ ≃ τ)
    (x : σ → A) (y : τ → A) (hxy : ∀ i, y (e i) = x i)
    (q : MvPolynomial σ K)
    (hq : ∀ p, MvPolynomial.aeval x p = 0 ↔ q ∣ p) :
    ∀ p, MvPolynomial.aeval y p = 0 ↔ MvPolynomial.renameEquiv K e q ∣ p := by
  intro p
  let p₀ := (MvPolynomial.renameEquiv K e).symm p
  have he : MvPolynomial.aeval x p₀ = MvPolynomial.aeval y p := by
    have hh : (MvPolynomial.aeval y).comp (MvPolynomial.renameEquiv K e).toAlgHom =
        MvPolynomial.aeval x := by
      apply MvPolynomial.algHom_ext
      intro i
      simpa using hxy i
    have hv := AlgHom.congr_fun hh p₀
    simpa only [AlgHom.comp_apply,AlgEquiv.coe_toAlgHom,
      p₀,AlgEquiv.apply_symm_apply] using hv.symm
  rw [←he,hq]
  exact (map_dvd_iff (MvPolynomial.renameEquiv K e)).symm.trans (by
    rw [show MvPolynomial.renameEquiv K e p₀ = p from AlgEquiv.apply_symm_apply _ _])

def pairProjectionIndex (m : ℕ) : Fin (m+2) ≃ Option (Fin (m+1)) :=
  (Equiv.swap 0 1).trans (finSuccEquiv (m+1))

@[simp] theorem pairProjectionIndex_zero (m : ℕ) : pairProjectionIndex m 0 = some 0 := by
  simp [pairProjectionIndex]

@[simp] theorem pairProjectionIndex_one (m : ℕ) : pairProjectionIndex m 1 = none := by
  simp [pairProjectionIndex]

@[simp] theorem pairProjectionIndex_succ_succ (m : ℕ) (i : Fin m) :
    pairProjectionIndex m i.succ.succ = some i.succ := by
  have hi0 : i.succ.succ ≠ (0 : Fin (m+2)) := Fin.succ_ne_zero _
  have hi1 : i.succ.succ ≠ (1 : Fin (m+2)) := by
    intro h
    have := congrArg Fin.val h
    simp only [Fin.val_succ,Fin.val_one] at this
    omega
  simp [pairProjectionIndex,Equiv.swap_apply_of_ne_of_ne hi0 hi1]

theorem finite_basis_extra_dependent {h : ℕ} {K A : Type*}
    [Field K] [CommRing A] [IsDomain A] [Algebra K A]
    (x : A) (a : Fin (h+1) → A) (htr : Algebra.trdeg K A = (h+1 : ℕ)) :
    ¬ AlgebraicIndependent K (Fin.cases x a) := by
  intro hI
  have hh := hI.lift_cardinalMk_le_trdeg
  simp only [Cardinal.mk_fintype,Fintype.card_fin,Cardinal.lift_natCast,htr] at hh
  have : h+2 ≤ h+1 := by exact_mod_cast hh
  omega

theorem pairProjectionIndex_evaluation {d h : ℕ} {A : Type*}
    (a : Fin d → A) (x : A) (j : Fin h → Fin d) (i : Fin d) (r : Fin (h+2)) :
    (fun o => o.elim x (a ∘ Fin.cases i j)) (pairProjectionIndex h r) =
      Fin.cases (a i) (Fin.cases x (a ∘ j)) r := by
  refine Fin.cases ?_ (fun r' => ?_) r
  · simp only [pairProjectionIndex_zero,Option.elim_some,Function.comp_apply,Fin.cases_zero]
  · refine Fin.cases ?_ (fun r'' => ?_) r'
    · change (fun o => o.elim x (a ∘ Fin.cases i j)) (pairProjectionIndex h 1) = x
      simp only [pairProjectionIndex_one,Option.elim_none]
    · simp only [pairProjectionIndex_succ_succ,Option.elim_some,Function.comp_apply,Fin.cases_succ]

theorem pair_principal_projection_of_extra {d h : ℕ} {K A : Type*}
    [Field K] [CommRing A] [IsDomain A] [Algebra K A]
    (a : Fin d → A) (x : A) (j : Fin h → Fin d) (i : Fin d)
    (hj : AlgebraicIndependent K (Fin.cases x (a ∘ j)))
    (htr : Algebra.trdeg K A = (h+1 : ℕ)) :
    ∃ p : MvPolynomial (Option (Fin (h+1))) K, Irreducible p ∧
      (∀ q, MvPolynomial.aeval (fun o => o.elim x (a ∘ Fin.cases i j)) q = 0 ↔ p ∣ q) := by
  have hdep := finite_basis_extra_dependent (K := K) (h := h) (a i) (Fin.cases x (a ∘ j)) htr
  generalize hy : (Fin.cases x (a ∘ j) : Fin (h+1) → A) = y at hj hdep
  obtain ⟨q,hq,_,hkq⟩ := exists_principal_relation_of_dependent (K := K) (h := h+1) (a i) y hj hdep
  refine ⟨MvPolynomial.renameEquiv K (pairProjectionIndex h) q, ?_, ?_⟩
  · exact (MulEquiv.irreducible_iff (MvPolynomial.renameEquiv K (pairProjectionIndex h)).toMulEquiv).mpr hq
  · apply principal_evaluation_kernel_reindex (pairProjectionIndex h) _ _ _ q hkq
    intro r
    rw [←hy]
    exact pairProjectionIndex_evaluation a x j i r

theorem pair_principal_projection_of_basis {d h : ℕ} {K A : Type*}
    [Field K] [CommRing A] [IsDomain A] [Algebra K A]
    (a : Fin d → A) (x : A) (j : Fin h → Fin d)
    (hj : AlgebraicIndependent K (Fin.cases x (a ∘ j)))
    (hjinj : Function.Injective j) (htr : Algebra.trdeg K A = (h+1 : ℕ))
    (hhd : h+1 ≤ d) :
    ∃ j : Fin (h+1) → Fin d, Function.Injective j ∧
      ∃ p : MvPolynomial (Option (Fin (h+1))) K, Irreducible p ∧
        (∀ q, MvPolynomial.aeval (fun o => o.elim x (a ∘ j)) q = 0 ↔ p ∣ q) := by
  classical
  have hex : ∃ i : Fin d, i ∉ Set.range j := by
    by_contra hh
    push Not at hh
    have hsur : Function.Surjective j := hh
    have hc := Fintype.card_le_of_surjective _ hsur
    simp only [Fintype.card_fin] at hc
    omega
  obtain ⟨i,hi⟩ := hex
  let js : Fin (h+1) → Fin d := Fin.cases i j
  have hjs : Function.Injective js := by
    intro r s hrs
    induction r using Fin.cases with
    | zero =>
      induction s using Fin.cases with
      | zero => rfl
      | succ s => exact (hi ⟨s,hrs.symm⟩).elim
    | succ r =>
      induction s using Fin.cases with
      | zero => exact (hi ⟨r,hrs⟩).elim
      | succ s => exact congrArg Fin.succ (hjinj hrs)
  obtain ⟨p,hp,hkp⟩ := pair_principal_projection_of_extra a x j i hj htr
  exact ⟨js,hjs,p,hp,hkp⟩

theorem pair_principal_projection_selection {d : ℕ} {K A : Type*}
    [Field K] [CommRing A] [IsDomain A] [Algebra K A]
    (k : ℕ) (a b : Fin d → A) (x : A) (θ : Fin d → K)
    (ha : ∀ i, a i ≠ 0) (hab : ∀ i, a i ^ k * b i = x - algebraMap K A (θ i))
    (hgen : Algebra.adjoin K (Set.range a ∪ Set.range b) = ⊤)
    (hx : Transcendental K x) (hdim : Algebra.trdeg K A ≤ d) :
    ∃ h : ℕ, ∃ j : Fin (h+1) → Fin d, Function.Injective j ∧
      Algebra.trdeg K A = (h+1 : ℕ) ∧
      ∃ p : MvPolynomial (Option (Fin (h+1))) K, Irreducible p ∧
        (∀ q, MvPolynomial.aeval (fun o => o.elim x (a ∘ j)) q = 0 ↔ p ∣ q) := by
  classical
  let := pair_projection_isAlgebraic k a b x θ ha hab hgen
  obtain ⟨h,j,hj,hjinj,htr⟩ := left_coordinates_transcendence_selection a x hx
  have hhd : h+1 ≤ d := by exact_mod_cast (htr ▸ hdim)
  obtain ⟨js,hjs,p,hp,hkp⟩ := pair_principal_projection_of_basis a x j hj hjinj htr hhd
  exact ⟨h, js, hjs, htr, p, hp, hkp⟩

end QuarticPowerFree

end OAI