import OAI.NumberTheory.PowerFree.NormComponents

namespace OAI

namespace QuarticPowerFree

section
open MvPolynomial
open scoped BigOperators Classical

theorem norm_box_prime_count {n d D : ℕ} (hd : 5 ≤ d) (hd' : d ≤ 8) (hD : 0 < D)
    (ω : Fin n → ℝ) (hω : ∀ i, 0 < ω i) (hωW : ∀ i, ω i ≤ 2/5)
    (w : Fin n → ℕ) (hw : ∀ i, w i ≠ 0) (hscale : ∀ i, (w i:ℝ) = 15*ω i)
    (M : NormBoxSystem n d D ω w) (Cbox : ℝ) (hCbox : 1 ≤ Cbox) (F e₀ : ℕ) :
    ∃ C X₀ : ℝ, 0 < C ∧ ∀ X : ℝ, X₀ < X → ∀ S : Finset (Fin n → ℤ),
      (∀ z ∈ S, ∀ j, |(z j:ℝ)| ≤ Cbox*X^(ω j)) →
      (∀ t : ℂ, (S.filter (fun z => MvPolynomial.aeval (fun j => (z j:ℂ)) M.q = t)).card ≤ F) →
      (∀ c : Fin d → ℤ, (S.filter (fun z => ∀ i, z (M.x i) = c i)).card ≤ F) →
      (∀ z ∈ S, ∀ i, MvPolynomial.aeval (fun j => (z j:ℂ)) (M.a i) ≠ 0) →
      ∀ (I : Ideal (MvPolynomial (Fin n) ℂ)), I.IsPrime → M.ideal ≤ I →
        affineDimension I ≤ d+1 → affineDegree I ≤ e₀ → (∀ z ∈ S, PointOn I z) →
      (S.card:ℝ) ≤ C*X^(997/1000:ℝ) := by
  classical
  choose K H hK hH halt using fun (e : ℕ) (i : Fin (d+1)) =>
    norm_component_alternatives (h := d+1-i.val) hd hd' (by omega) (by omega) hD
      ω hω hωW w hw hscale M Cbox (by linarith) F e (1/4000) (by norm_num)
  let c := fun e => ∑ i : Fin (d+1), H e i
  let Ke := fun e => 1+∑ i : Fin (d+1), K e i
  have hc : ∀ e, 0 ≤ c e := fun e => Finset.sum_nonneg (fun i _ => hH e i)
  have hKe : ∀ e, 1 ≤ Ke e := by
    intro e
    dsimp [Ke]
    exact le_add_of_nonneg_right (Finset.sum_nonneg (fun i _ => zero_le_one.trans (hK e i)))
  have hci (e) (i : Fin (d+1)) : H e i ≤ c e := Finset.single_le_sum
    (fun j (_ : j ∈ Finset.univ) => hH e j) (Finset.mem_univ i)
  have hKi (e) (i : Fin (d+1)) : K e i ≤ Ke e := by
    have hh := Finset.single_le_sum (fun j (_ : j ∈ Finset.univ) => zero_le_one.trans (hK e j)) (Finset.mem_univ i)
    dsimp [Ke]
    linarith
  let W : ℝ := 1+∑ j, ω j
  have hsum : 0 ≤ ∑ j, ω j := Finset.sum_nonneg (fun j _ => (hω j).le)
  have hW : 0 ≤ W := by dsimp [W]; linarith
  obtain ⟨C,Xcut,hC,hcount⟩ := physical_affine_count n (d+1) 0 e₀ (by omega)
    ω hω Cbox W hCbox hW (normBoxIncrement d) (normBoxStage d)
    (normBox_increment_nonneg d hd hd') (fun i => normBoxEnvelope_pos _ _)
    (normBox_prefix d hd hd') (1/1000) (by norm_num) c Ke hc hKe
  refine ⟨C,max (max 2 Cbox) Xcut,hC,fun X hX S hbox hnF haF hnonzero I hI hMI hdim hdeg hon => ?_⟩
  have hX2 : 2 < X := lt_of_le_of_lt ((le_max_left _ _).trans (le_max_left _ _)) hX
  have hCX : Cbox ≤ X := le_of_lt (lt_of_le_of_lt ((le_max_right _ _).trans (le_max_left _ _)) hX)
  have hXcut : Xcut < X := lt_of_le_of_lt (le_max_right _ _) hX
  have hX1 : 1 ≤ X := by linarith
  have hXp : 0 < X := by linarith
  have hmax (j : Fin n) : ω j ≤ ∑ l, ω l := Finset.single_le_sum
    (fun l _ => (hω l).le) (Finset.mem_univ j)
  have hbound (z) (hz : z ∈ S) (j) : |(z j:ℝ)| ≤ X^W := by
    calc
      _ ≤ Cbox*X^(ω j) := hbox z hz j
      _ ≤ X*X^(∑ l, ω l) := mul_le_mul hCX
        (Real.rpow_le_rpow_of_exponent_le hX1 (hmax j)) (Real.rpow_nonneg hXp.le _) hXp.le
      _ = X^W := by dsimp [W]; rw [Real.rpow_add hXp,Real.rpow_one]
  let G : KernelGeometry n := ⟨S,X^W,Real.one_le_rpow hX1 hW,hbound⟩
  have hb := hcount X hXcut G le_rfl hbox I hI hdim hdeg hon
  have hcS := hb (by
    intro i e J hJ hIJ _ hJe hJdim hp
    let : J.IsPrime := hJ
    obtain ⟨z,hz,hzJ⟩ := hp
    have ha := M.quotient_left_nonzero J z hzJ (hnonzero z hz)
    have hh := halt e i X hX2.le S hbox hnF haF J hJ (hMI.trans hIJ) hJdim hJe ha
    rcases hh with hs | hHilb
    · left
      have hm := mul_le_mul_of_nonneg_right (hKi e i) (Real.rpow_nonneg hXp.le (1/4000))
      norm_num only [show (1/1000:ℝ)/4=1/4000 by norm_num]
      exact hs.trans hm
    · right
      intro T hT
      have hh := hHilb T hT
      have hm := mul_le_mul_of_nonneg_right (hci e i) (pow_nonneg (by linarith : 0 ≤ T) (d+1-i.val-1))
      change T^(d+1-i.val)/(((d+1-i.val).factorial:ℝ)*(normBoxEnvelope d (d+1-i.val))^(d+1-i.val))-
        c e*T^(d+1-i.val-1) ≤ _
      linarith only [hh,hm])
  exact hcS.trans (mul_le_mul_of_nonneg_left
    (Real.rpow_le_rpow_of_exponent_le hX1 (normBox_sum d hd hd')) hC.le)

theorem norm_box_prime_count_unrestricted {n d D : ℕ} (hd : 5 ≤ d) (hd' : d ≤ 8) (hD : 0 < D)
    (ω : Fin n → ℝ) (hω : ∀ i, 0 < ω i) (hωW : ∀ i, ω i ≤ 2/5)
    (w : Fin n → ℕ) (hw : ∀ i, w i ≠ 0) (hscale : ∀ i, (w i:ℝ) = 15*ω i)
    (M : NormBoxSystem n d D ω w) (Cbox : ℝ) (hCbox : 1 ≤ Cbox) (F e₀ : ℕ) :
    ∃ C X₀ : ℝ, 0 < C ∧ ∀ X : ℝ, X₀ < X → ∀ S : Finset (Fin n → ℤ),
      (∀ z ∈ S, ∀ j, |(z j:ℝ)| ≤ Cbox*X^(ω j)) →
      (∀ t : ℂ, (S.filter (fun z => MvPolynomial.aeval (fun j => (z j:ℂ)) M.q = t)).card ≤ F) →
      (∀ c : Fin d → ℤ, (S.filter (fun z => ∀ i, z (M.x i) = c i)).card ≤ F) →
      (∀ z ∈ S, ∀ i, MvPolynomial.aeval (fun j => (z j:ℂ)) (M.a i) ≠ 0) →
      ∀ (I : Ideal (MvPolynomial (Fin n) ℂ)), I.IsPrime → M.ideal ≤ I →
        affineDegree I ≤ e₀ → (∀ z ∈ S, PointOn I z) →
      (S.card:ℝ) ≤ C*X^(997/1000:ℝ) := by
  obtain ⟨C,X₀,hC,hb⟩ := norm_box_prime_count hd hd' hD ω hω hωW w hw hscale M Cbox hCbox F e₀
  refine ⟨C+F+1,max 2 X₀,by positivity,fun X hX S hbox hqF haF hn I hI hMI hdeg hon => ?_⟩
  let : I.IsPrime := hI
  have hX1 : 1 ≤ X := by have := (le_max_left 2 X₀).trans_lt hX; linarith
  have hp : 1 ≤ X^(997/1000:ℝ) := Real.one_le_rpow hX1 (by norm_num)
  have hfilter : S.filter (PointOn I) = S := Finset.filter_true_of_mem hon
  by_cases hq : IsAlgebraic ℂ (Ideal.Quotient.mk I M.q)
  · have hcard := algebraic_polynomial_fibre_count S F M.q hqF I hq
    rw [hfilter] at hcard
    calc
      (S.card:ℝ) ≤ F := by exact_mod_cast hcard
      _ ≤ (C+F+1)*X^(997/1000:ℝ) := by nlinarith [Nat.cast_nonneg (α := ℝ) F]
  · by_cases hs : S.Nonempty
    · obtain ⟨z,hz⟩ := hs
      have ha := M.quotient_left_nonzero I z (hon z hz) (hn z hz)
      have hdim := norm_dimension_le I (d-2) M.a M.b M.q M.θ ha (M.quotient_equations I hMI) M.generates hq
      have hh := hb X (lt_of_le_of_lt (le_max_right _ _) hX) S hbox hqF haF hn I hI hMI hdim hdeg hon
      exact hh.trans (mul_le_mul_of_nonneg_right (by have := Nat.cast_nonneg (α := ℝ) F; linarith : C ≤ C+F+1) (by positivity))
    · rw [Finset.not_nonempty_iff_eq_empty.mp hs,Finset.card_empty,Nat.cast_zero]
      positivity

theorem norm_box_count {n d D : ℕ} (hd : 5 ≤ d) (hd' : d ≤ 8) (hD : 0 < D)
    (ω : Fin n → ℝ) (hω : ∀ i, 0 < ω i) (hωW : ∀ i, ω i ≤ 2/5)
    (w : Fin n → ℕ) (hw : ∀ i, w i ≠ 0) (hscale : ∀ i, (w i:ℝ) = 15*ω i)
    (M : NormBoxSystem n d D ω w) (Cbox : ℝ) (hCbox : 1 ≤ Cbox) (F : ℕ) :
    ∃ C X₀ : ℝ, 0 < C ∧ ∀ X : ℝ, X₀ < X → ∀ S : Finset (Fin n → ℤ),
      (∀ z ∈ S, ∀ j, |(z j:ℝ)| ≤ Cbox*X^(ω j)) →
      (∀ t : ℂ, (S.filter (fun z => MvPolynomial.aeval (fun j => (z j:ℂ)) M.q = t)).card ≤ F) →
      (∀ c : Fin d → ℤ, (S.filter (fun z => ∀ i, z (M.x i) = c i)).card ≤ F) →
      (∀ z ∈ S, ∀ i, MvPolynomial.aeval (fun j => (z j:ℂ)) (M.a i) ≠ 0) →
      (∀ z ∈ S, PointOn M.ideal z) →
      (S.card:ℝ) ≤ C*X^(997/1000:ℝ) := by
  classical
  let Q := (Ideal.finite_minimalPrimes_of_isNoetherianRing (MvPolynomial (Fin n) ℂ) M.ideal).toFinset
  let E : ℕ := ∑ I ∈ Q, ⌈affineDegree I⌉₊
  have hQ (I) (hI : I ∈ Q) : I ∈ M.ideal.minimalPrimes := (Set.Finite.mem_toFinset _).mp hI
  have hE (I) (hI : I ∈ Q) : affineDegree I ≤ E := by
    have hsum : ⌈affineDegree I⌉₊ ≤ E := Finset.single_le_sum (f := fun J => ⌈affineDegree J⌉₊) (fun _ _ => Nat.zero_le _) hI
    exact (Nat.le_ceil _).trans (by exact_mod_cast hsum)
  obtain ⟨C,X₀,hC,hb⟩ := norm_box_prime_count_unrestricted hd hd' hD ω hω hωW w hw hscale M Cbox hCbox F E
  refine ⟨(Q.card+1)*C,max 2 X₀,by positivity,fun X hX S hbox hqF haF hn hon => ?_⟩
  have hXpos : 0 ≤ X := by have := (le_max_left 2 X₀).trans_lt hX; linarith
  have hX₀ : X₀ < X := (le_max_right _ _).trans_lt hX
  have cover : S ⊆ Q.biUnion (fun I => S.filter (PointOn I)) := by
    intro z hz
    obtain ⟨I,hI,hzI⟩ := point_on_minimal_component M.ideal (fun j => (z j:ℂ)) (hon z hz)
    exact Finset.mem_biUnion.mpr ⟨I,(Set.Finite.mem_toFinset _).mpr hI,Finset.mem_filter.mpr ⟨hz,hzI⟩⟩
  have hbound (I) (hI : I ∈ Q) : ((S.filter (PointOn I)).card:ℝ) ≤ C*X^(997/1000:ℝ) := by
    apply hb X hX₀ (S.filter (PointOn I))
    · intro z hz; exact hbox z (Finset.mem_filter.mp hz).1
    · intro t
      apply (Finset.card_le_card ?_).trans (hqF t)
      exact Finset.filter_subset_filter _ (Finset.filter_subset _ _)
    · intro c
      apply (Finset.card_le_card ?_).trans (haF c)
      exact Finset.filter_subset_filter _ (Finset.filter_subset _ _)
    · intro z hz; exact hn z (Finset.mem_filter.mp hz).1
    · exact (hQ I hI).isPrime
    · exact (hQ I hI).1.2
    · exact hE I hI
    · intro z hz; exact (Finset.mem_filter.mp hz).2
  calc
    (S.card:ℝ) ≤ (∑ I ∈ Q, (S.filter (PointOn I)).card : ℕ) := by
      exact_mod_cast (Finset.card_le_card cover).trans (Finset.card_biUnion_le)
    _ = ∑ I ∈ Q, ((S.filter (PointOn I)).card:ℝ) := by simp
    _ ≤ ∑ I ∈ Q, C*X^(997/1000:ℝ) := Finset.sum_le_sum hbound
    _ = Q.card*(C*X^(997/1000:ℝ)) := by simp
    _ ≤ ((Q.card+1)*C)*X^(997/1000:ℝ) := by nlinarith [Real.rpow_nonneg (x := X) hXpos (997/1000:ℝ)]

end

section
open Polynomial NumberField

theorem scaleRoots_irreducible {K : Type*} [Field K] (f : Polynomial K)
    (hf : Irreducible f) (r : K) (hr : r ≠ 0) :
    Irreducible (f.scaleRoots r) := by
  have hu (g : Polynomial K) : IsUnit (g.scaleRoots r) ↔ IsUnit g := by
    rw [Polynomial.isUnit_iff_degree_eq_zero,Polynomial.isUnit_iff_degree_eq_zero,
      Polynomial.degree_scaleRoots]
  refine ⟨fun h => hf.not_isUnit (hu f |>.mp h),?_⟩
  intro a b he
  have hback : f = a.scaleRoots r⁻¹ * b.scaleRoots r⁻¹ := by
    rw [← mul_scaleRoots_of_noZeroDivisors,← he,← scaleRoots_mul, mul_inv_cancel₀ hr,
      scaleRoots_one]
  rcases hf.isUnit_or_isUnit hback with ha | hb
  · left
    simpa only [Polynomial.isUnit_iff_degree_eq_zero,degree_scaleRoots] using ha
  · right
    simpa only [Polynomial.isUnit_iff_degree_eq_zero,degree_scaleRoots] using hb

theorem integralNormalization_irreducible (f : Polynomial ℤ)
    (hf : Irreducible (f.map (Int.castRingHom ℚ))) :
    Irreducible (f.integralNormalization.map (Int.castRingHom ℚ)) := by
  have hf0 : f ≠ 0 := fun h => hf.ne_zero (by simp [h])
  have hc : (f.leadingCoeff : ℚ) ≠ 0 := by exact_mod_cast leadingCoeff_ne_zero.mpr hf0
  have hs := scaleRoots_irreducible (f.map (Int.castRingHom ℚ)) hf (f.leadingCoeff : ℚ) hc
  have he := congrArg (Polynomial.map (Int.castRingHom ℚ))
    (integralNormalization_mul_C_leadingCoeff f)
  rw [Polynomial.map_mul,Polynomial.map_C,map_scaleRoots f f.leadingCoeff _ hc] at he
  change f.integralNormalization.map (Int.castRingHom ℚ) * C (f.leadingCoeff : ℚ) =
    (f.map (Int.castRingHom ℚ)).scaleRoots (f.leadingCoeff : ℚ) at he
  rw [← he] at hs
  exact (irreducible_mul_isUnit (isUnit_C.mpr (isUnit_iff_ne_zero.mpr hc))).mp hs

theorem minpoly_integral_normalization {K : Type*} [Field K] [NumberField K]
    (f : Polynomial ℤ) (hf : Irreducible (f.map (Int.castRingHom ℚ)))
    (hd : 1 ≤ f.natDegree) (θ : K) (hθ : f.aeval θ = 0)
    (t : 𝓞 K) (ht : (t : K) = (f.leadingCoeff : K) * θ) :
    minpoly ℤ t = f.integralNormalization := by
  have hf0 : f ≠ 0 := fun h => hf.ne_zero (by simp [h])
  have he : (f.integralNormalization.map (Int.castRingHom ℚ)).aeval (t : K) = 0 := by
    rw [show Int.castRingHom ℚ = algebraMap ℤ ℚ from rfl, aeval_map_algebraMap,
      aeval_def, ht]
    change f.integralNormalization.eval₂ (algebraMap ℤ K)
      ((algebraMap ℤ K) f.leadingCoeff * θ) = 0
    rw [integralNormalization_eval₂_leadingCoeff_mul hd]
    change (f.leadingCoeff : K) ^ (f.natDegree - 1) * f.aeval θ = 0
    rw [hθ, mul_zero]
  have hm := minpoly.eq_of_irreducible_of_monic (integralNormalization_irreducible f hf)
    he ((monic_integralNormalization hf0).map (Int.castRingHom ℚ))
  have htint : IsIntegral ℤ t := t.isIntegral
  have hm' := minpoly.isIntegrallyClosed_eq_field_fractions ℚ K htint
  apply map_injective (Int.castRingHom ℚ) (Int.cast_injective)
  change (minpoly ℤ t).map (algebraMap ℤ ℚ) = _
  rw [← hm']
  change minpoly ℚ (t : K) = _
  exact hm.symm

open Polynomial NumberField
open scoped nonZeroDivisors

theorem exponent_ne_zero_of_powerBasis {K : Type*} [Field K] [NumberField K]
    (θ : 𝓞 K) (pb : PowerBasis ℚ K) (hgen : pb.gen = (θ : K)) :
    RingOfIntegers.exponent θ ≠ 0 := by
  classical
  let b := RingOfIntegers.basis K
  let ι := Module.Free.ChooseBasisIndex ℤ (𝓞 K)
  let A := Algebra.adjoin ℤ {θ}
  obtain ⟨m, hm⟩ := IsLocalization.exist_integer_multiples_of_finite (nonZeroDivisors ℤ)
    (fun ij : ι × Fin pb.dim => pb.basis.repr ((b ij.1 : 𝓞 K) : K) ij.2)
  choose a ha using hm
  have hmb (i : ι) : (m : ℤ) • b i ∈ A := by
    have he : (m : ℤ) • ((b i : 𝓞 K) : K) =
        ∑ j : Fin pb.dim, (a (i,j) : ℚ) • pb.basis j := by
      conv_lhs => rw [← pb.basis.sum_repr ((b i : 𝓞 K) : K)]
      rw [Finset.smul_sum]
      apply Finset.sum_congr rfl
      intro j _
      rw [← smul_assoc, ← ha (i,j)]
      rfl
    have he' : (m : ℤ) • b i = ∑ j : Fin pb.dim, a (i,j) • θ ^ (j : ℕ) := by
      apply RingOfIntegers.ext
      simpa [pb.basis_eq_pow,hgen, Algebra.smul_def] using he
    rw [he']
    apply A.sum_mem
    intro j _
    exact A.smul_mem (A.pow_mem (Algebra.subset_adjoin (Set.mem_singleton θ)) _) _
  have hz (z : 𝓞 K) : (m : ℤ) • z ∈ A := by
    rw [← b.sum_repr z]
    rw [Finset.smul_sum]
    apply A.sum_mem
    intro i _
    rw [smul_comm]
    exact A.smul_mem (hmb i) _
  have hmc : (m : ℤ) ∈ Ideal.under ℤ (conductor ℤ θ) := by
    change ((m : ℤ) : 𝓞 K) ∈ conductor ℤ θ
    rw [mem_conductor_iff]
    intro z
    simpa [Algebra.smul_def] using hz z
  intro hzero
  have he := Int.ideal_span_absNorm_eq_self (Ideal.under ℤ (conductor ℤ θ))
  change Ideal.span {((RingOfIntegers.exponent θ : ℕ) : ℤ)} = _ at he
  rw [hzero, Nat.cast_zero, Ideal.span_singleton_zero] at he
  rw [← he, Ideal.mem_bot] at hmc
  exact nonZeroDivisors.coe_ne_zero m hmc

end

open Polynomial NumberField

theorem simple_root_ideal_power {R : Type*} [CommRing R] [IsDedekindDomain R]
    (P : Ideal R) [P.IsPrime] (hP : P ≠ ⊥) (f : Polynomial R)
    (a θ : R) (k : ℕ) (hθ : f.eval θ = 0) (haθ : a - θ ∈ P)
    (hd : f.derivative.eval a ∉ P) (hf : f.eval a ∈ P ^ k) : a - θ ∈ P ^ k := by
  let g := f /ₘ (X - C θ)
  have hfac : f.eval a = (a - θ) * g.eval a := by
    have h := congrArg (Polynomial.eval a)
      (Polynomial.X_sub_C_mul_divByMonic_eq_sub_modByMonic f θ)
    simpa only [eval_mul, eval_sub, eval_X, eval_C, modByMonic_X_sub_C_eq_C_eval,
      hθ, sub_zero] using h.symm
  have hdiag : g.eval θ = f.derivative.eval θ := by
    have h := congrArg (Polynomial.eval θ)
      (Polynomial.divByMonic_add_X_sub_C_mul_derivative_divByMonic_eq_derivative f θ)
    simpa only [eval_add, eval_mul, eval_sub, eval_X, eval_C,
      sub_self, zero_mul, add_zero] using h
  have hsub (q : Polynomial R) : q.eval a - q.eval θ ∈ P := by
    obtain ⟨t, ht⟩ := Polynomial.sub_dvd_eval_sub a θ q
    rw [ht]
    exact P.mul_mem_right t haθ
  have hg : g.eval a ∉ P := by
    intro hga
    have hgθ := P.sub_mem hga (hsub g)
    have hh : f.derivative.eval θ ∈ P := by simpa [hdiag] using hgθ
    apply hd
    convert P.add_mem (hsub f.derivative) hh using 1
    ring
  cases k with
  | zero => simp
  | succ k =>
    by_contra hx
    apply hg
    exact Ideal.mem_prime_of_mul_mem_pow hP hx (by rwa [← hfac])

theorem root_prime_ideal {K : Type*} [Field K] [NumberField K]
    (θ : 𝓞 K) (a : ℤ) (p k : ℕ) (hp : p.Prime) (hk : 0 < k)
    (hc : ¬ p ∣ RingOfIntegers.exponent θ)
    (hd : ¬ (p : ℤ) ∣ (minpoly ℤ θ).derivative.eval a)
    (hf : (p : ℤ) ^ k ∣ (minpoly ℤ θ).eval a) :
    ∃ P : Ideal (𝓞 K), P.IsPrime ∧ P ≠ ⊥ ∧ P.absNorm = p ∧
      (a : 𝓞 K) - θ ∈ P ^ k := by
  classical
  let : Fact p.Prime := ⟨hp⟩
  let Q : Polynomial ℤ := X - C a
  have hf1 : (p : ℤ) ∣ (minpoly ℤ θ).eval a :=
    dvd_trans (dvd_pow_self (p : ℤ) hk.ne') hf
  have hQ : Q.map (Int.castRingHom (ZMod p)) ∈ RingOfIntegers.monicFactorsMod θ p := by
    change Q.map _ ∈ (UniqueFactorizationMonoid.normalizedFactors _).toFinset
    rw [Multiset.mem_toFinset, Polynomial.mem_normalizedFactors_iff
      (Polynomial.map_monic_ne_zero (minpoly.monic θ.isIntegral))]
    simp only [Q, Polynomial.map_sub, Polynomial.map_X, Polynomial.map_C]
    refine ⟨irreducible_X_sub_C _, monic_X_sub_C _, ?_⟩
    rw [Polynomial.dvd_iff_isRoot, IsRoot.def, eval_map, eval₂_at_apply]
    exact (ZMod.intCast_zmod_eq_zero_iff_dvd _ _).mpr hf1
  let P' := (NumberField.Ideal.primesOverSpanEquivMonicFactorsMod hc).symm ⟨_, hQ⟩
  let P : Ideal (𝓞 K) := P'
  let : P.IsPrime := P'.property.1
  let : P.LiesOver (Ideal.span {(p : ℤ)}) := P'.property.2
  let : P.IsMaximal := Ideal.primesOver.isMaximal P'
  have hspan : P = Ideal.span {(p : 𝓞 K), θ - (a : 𝓞 K)} := by
    dsimp [P, P']
    rw [NumberField.Ideal.primesOverSpanEquivMonicFactorsMod_symm_apply_eq_span hc hQ]
    simp [Q]
  have hpP : (p : 𝓞 K) ∈ P := by rw [hspan]; exact Ideal.subset_span (Set.mem_insert _ _)
  have hP0 : P ≠ ⊥ := by
    intro h
    have : (p : 𝓞 K) = 0 := by simpa [h] using hpP
    exact (Nat.cast_ne_zero.mpr hp.ne_zero) this
  have hab : (a : 𝓞 K) - θ ∈ P := by
    have h : θ - (a : 𝓞 K) ∈ P := by rw [hspan]; exact Ideal.subset_span (Set.mem_insert_of_mem _ (Set.mem_singleton _))
    simpa only [neg_sub] using P.neg_mem h
  have hn : P.absNorm = p := by
    have hdeg := NumberField.Ideal.inertiaDeg_primesOverSpanEquivMonicFactorsMod_symm_apply hc hQ
    have hdeg' : P.inertiaDeg ℤ = 1 := by
      simpa only [P, P', Q, Polynomial.map_sub, Polynomial.map_X, Polynomial.map_C, natDegree_X_sub_C] using hdeg
    simpa only [hdeg', pow_one, Int.natAbs_natCast] using
      (Ideal.natAbs_pow_inertiaDeg (p : ℤ) P).symm
  refine ⟨P, inferInstance, hP0, hn, ?_⟩
  let f := (minpoly ℤ θ).map (Int.castRingHom (𝓞 K))
  apply simple_root_ideal_power P hP0 f (a : 𝓞 K) θ k
  · rw [show f = (minpoly ℤ θ).map (algebraMap ℤ (𝓞 K)) from rfl, eval_map]
    exact minpoly.aeval ℤ θ
  · exact hab
  · intro h
    have h' : (minpoly ℤ θ).derivative.eval a ∈ Ideal.span {(p : ℤ)} := by
      apply (Ideal.mem_of_liesOver P (Ideal.span {(p : ℤ)}) _).mpr
      simpa [f, derivative_map, eval_map, eval₂_at_apply] using h
    exact hd (Ideal.mem_span_singleton.mp h')
  · obtain ⟨t, ht⟩ := hf
    have he : f.eval (a : 𝓞 K) = (p : 𝓞 K) ^ k * (t : 𝓞 K) := by
      dsimp [f]
      rw [eval_map]
      change (minpoly ℤ θ).eval₂ (Int.castRingHom (𝓞 K)) ((Int.castRingHom (𝓞 K)) a) = _
      rw [eval₂_at_apply]
      change (((minpoly ℤ θ).eval a : ℤ) : 𝓞 K) = _
      rw [ht, Int.cast_mul, Int.cast_pow, Int.cast_natCast]
    rw [he]
    exact (P ^ k).mul_mem_right _ (Ideal.pow_mem_pow hpP k)

end QuarticPowerFree

end OAI