ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AdjoinRoot.powerBasis'_dim
@[simps]
def powerBasis' (hg : g.Monic) : PowerBasis R (AdjoinRoot g) 
Arguments: {R : Type u} [CommRing R] {g : R[X]} (hg : g.Monic)
Goal: (AdjoinRoot.powerBasis' hg).dim = g.natDegree
-- AdjoinRoot.powerBasis'_gen
@[simps]
def powerBasis' (hg : g.Monic) : PowerBasis R (AdjoinRoot g) 
Arguments: {R : Type u} [CommRing R] {g : R[X]} (hg : g.Monic)
Goal: (AdjoinRoot.powerBasis' hg).gen = AdjoinRoot.root g
-- AdjoinRoot.isIntegral_root
theorem isIntegral_root (hf : f ≠ 0) : IsIntegral K (root f) 
Arguments: {K : Type w} [Field K] {f : K[X]} (hf : f ≠ 0)
Goal: IsIntegral K (AdjoinRoot.root f)
-- AdjoinRoot.minpoly_root
theorem minpoly_root (hf : f ≠ 0) : minpoly K (root f) = f * C f.leadingCoeff⁻¹ 
Arguments: {K : Type w} [Field K] {f : K[X]} (hf : f ≠ 0)
Goal: minpoly K (AdjoinRoot.root f) = f * Polynomial.C f.leadingCoeff⁻¹
-- AdjoinRoot.powerBasis_dim
@[simps!]  -- Porting note: was `[simps]`
def powerBasis (hf : f ≠ 0) : PowerBasis K (AdjoinRoot f) 
Arguments: {K : Type w} [Field K] {f : K[X]} (hf : f ≠ 0)
Goal: (AdjoinRoot.powerBasis hf).dim = f.natDegree
-- AdjoinRoot.powerBasis_gen
@[simps!]  -- Porting note: was `[simps]`
def powerBasis (hf : f ≠ 0) : PowerBasis K (AdjoinRoot f) 
Arguments: {K : Type w} [Field K] {f : K[X]} (hf : f ≠ 0)
Goal: (AdjoinRoot.powerBasis hf).gen = AdjoinRoot.root f
-- AdjoinRoot.minpoly_powerBasis_gen
theorem minpoly_powerBasis_gen (hf : f ≠ 0) :
    minpoly K (powerBasis hf).gen = f * C f.leadingCoeff⁻¹ 
Arguments: {K : Type w} [Field K] {f : K[X]} (hf : f ≠ 0)
Goal: minpoly K (AdjoinRoot.powerBasis hf).gen = f * Polynomial.C f.leadingCoeff⁻¹
-- AdjoinRoot.minpoly_powerBasis_gen_of_monic
theorem minpoly_powerBasis_gen_of_monic (hf : f.Monic) (hf' : f ≠ 0 := hf.ne_zero) :
    minpoly K (powerBasis hf').gen = f 
Arguments: {K : Type w} [Field K] {f : K[X]} (hf : f.Monic) (hf' : f ≠ 0 := ⋯)
Goal: minpoly K (AdjoinRoot.powerBasis hf').gen = f
-- AdjoinRoot.Minpoly.toAdjoin_apply
@[simps!]
def Minpoly.toAdjoin : AdjoinRoot (minpoly R x) →ₐ[R] adjoin R ({x} : Set S) 
Arguments: (R : Type u) {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (x : S)
Goal: ∀ (a : R[X] ⧸ Submodule.toAddSubgroup (Ideal.span {minpoly R x})),
  (AdjoinRoot.Minpoly.toAdjoin R x) a =
    (QuotientAddGroup.lift (Submodule.toAddSubgroup (Ideal.span {minpoly R x}))
        ↑(Polynomial.eval₂RingHom (algebraMap R ↥(Algebra.adjoin R {x})) ⟨x, ⋯⟩) ⋯)
      a
-- AdjoinRoot.Minpoly.toAdjoin_apply'
theorem Minpoly.toAdjoin_apply' (a : AdjoinRoot (minpoly R x)) :
    Minpoly.toAdjoin R x a =
      liftHom (minpoly R x) (⟨x, self_mem_adjoin_singleton R x⟩ : adjoin R ({x} : Set S))
        (by simp [← Subalgebra.coe_eq_zero, aeval_subalgebra_coe]) a 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] {x : S} (a : AdjoinRoot (minpoly R x))
Goal: (AdjoinRoot.Minpoly.toAdjoin R x) a = (AdjoinRoot.liftHom (minpoly R x) ⟨x, ⋯⟩ ⋯) a
-- AdjoinRoot.Minpoly.toAdjoin.apply_X
theorem Minpoly.toAdjoin.apply_X :
    Minpoly.toAdjoin R x (mk (minpoly R x) X) = ⟨x, self_mem_adjoin_singleton R x⟩ 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] {x : S}
Goal: (AdjoinRoot.Minpoly.toAdjoin R x) ((AdjoinRoot.mk (minpoly R x)) Polynomial.X) = ⟨x, ⋯⟩
-- AdjoinRoot.Minpoly.toAdjoin.surjective
theorem Minpoly.toAdjoin.surjective : Function.Surjective (Minpoly.toAdjoin R x) 
Arguments: (R : Type u) {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (x : S)
Goal: Function.Surjective ⇑(AdjoinRoot.Minpoly.toAdjoin R x)
-- AdjoinRoot.equiv'_symm_apply
@[simps (config := .asFn)]
def equiv' (h₁ : aeval (root g) (minpoly R pb.gen) = 0) (h₂ : aeval pb.gen g = 0) :
    AdjoinRoot g ≃ₐ[R] S 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (g : R[X]) (pb : PowerBasis R S) (h₁ : (Polynomial.aeval (AdjoinRoot.root g)) (minpoly R pb.gen) = 0) (h₂ : (Polynomial.aeval pb.gen) g = 0)
Goal: ⇑(AdjoinRoot.equiv' g pb h₁ h₂).symm = ⇑(pb.lift (AdjoinRoot.root g) h₁)
-- AdjoinRoot.equiv'_apply
@[simps (config := .asFn)]
def equiv' (h₁ : aeval (root g) (minpoly R pb.gen) = 0) (h₂ : aeval pb.gen g = 0) :
    AdjoinRoot g ≃ₐ[R] S 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (g : R[X]) (pb : PowerBasis R S) (h₁ : (Polynomial.aeval (AdjoinRoot.root g)) (minpoly R pb.gen) = 0) (h₂ : (Polynomial.aeval pb.gen) g = 0)
Goal: ⇑(AdjoinRoot.equiv' g pb h₁ h₂) = ⇑(AdjoinRoot.liftHom g pb.gen h₂)
-- AdjoinRoot.equiv'_toAlgHom
theorem equiv'_toAlgHom (h₁ : aeval (root g) (minpoly R pb.gen) = 0) (h₂ : aeval pb.gen g = 0) :
    (equiv' g pb h₁ h₂).toAlgHom = AdjoinRoot.liftHom g pb.gen h₂ 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (g : R[X]) (pb : PowerBasis R S) (h₁ : (Polynomial.aeval (AdjoinRoot.root g)) (minpoly R pb.gen) = 0) (h₂ : (Polynomial.aeval pb.gen) g = 0)
Goal: ↑(AdjoinRoot.equiv' g pb h₁ h₂) = AdjoinRoot.liftHom g pb.gen h₂
-- AdjoinRoot.equiv'_symm_toAlgHom
theorem equiv'_symm_toAlgHom (h₁ : aeval (root g) (minpoly R pb.gen) = 0)
    (h₂ : aeval pb.gen g = 0) : (equiv' g pb h₁ h₂).symm.toAlgHom = pb.lift (root g) h₁ 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (g : R[X]) (pb : PowerBasis R S) (h₁ : (Polynomial.aeval (AdjoinRoot.root g)) (minpoly R pb.gen) = 0) (h₂ : (Polynomial.aeval pb.gen) g = 0)
Goal: ↑(AdjoinRoot.equiv' g pb h₁ h₂).symm = pb.lift (AdjoinRoot.root g) h₁
-- AdjoinRoot.quotMapOfEquivQuotMapCMapSpanMk_mk
@[simp]
theorem quotMapOfEquivQuotMapCMapSpanMk_mk (x : AdjoinRoot f) :
    quotMapOfEquivQuotMapCMapSpanMk I f (Ideal.Quotient.mk (I.map (of f)) x) =
      Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk (span {f})) (I.map (C : R →+* R[X]))) x 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (f : R[X]) (x : AdjoinRoot f)
Goal: (AdjoinRoot.quotMapOfEquivQuotMapCMapSpanMk I f) ((Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) I)) x) =
  (Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk (Ideal.span {f})) (Ideal.map Polynomial.C I))) x
-- AdjoinRoot.quotMapOfEquivQuotMapCMapSpanMk_symm_mk
theorem quotMapOfEquivQuotMapCMapSpanMk_symm_mk (x : AdjoinRoot f) :
    (quotMapOfEquivQuotMapCMapSpanMk I f).symm
        (Ideal.Quotient.mk ((I.map (C : R →+* R[X])).map (Ideal.Quotient.mk (span {f}))) x) =
      Ideal.Quotient.mk (I.map (of f)) x 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (f : R[X]) (x : AdjoinRoot f)
Goal: (AdjoinRoot.quotMapOfEquivQuotMapCMapSpanMk I f).symm
    ((Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk (Ideal.span {f})) (Ideal.map Polynomial.C I))) x) =
  (Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) I)) x
-- AdjoinRoot.quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk_mk
theorem quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk_mk (p : R[X]) :
    quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk I f (Ideal.Quotient.mk _ (mk f p)) =
      quotQuotMk (I.map C) (span {f}) p 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (f p : R[X])
Goal: (AdjoinRoot.quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk I f)
    ((Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk (Ideal.span {f})) (Ideal.map Polynomial.C I)))
      ((AdjoinRoot.mk f) p)) =
  (DoubleQuot.quotQuotMk (Ideal.map Polynomial.C I) (Ideal.span {f})) p
-- AdjoinRoot.quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk_symm_quotQuotMk
@[simp]
theorem quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk_symm_quotQuotMk (p : R[X]) :
    (quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk I f).symm (quotQuotMk (I.map C) (span {f}) p) =
      Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk (span {f})) (I.map (C : R →+* R[X])))
        (mk f p) 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (f p : R[X])
Goal: (AdjoinRoot.quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk I f).symm
    ((DoubleQuot.quotQuotMk (Ideal.map Polynomial.C I) (Ideal.span {f})) p) =
  (Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk (Ideal.span {f})) (Ideal.map Polynomial.C I))) ((AdjoinRoot.mk f) p)
-- AdjoinRoot.Polynomial.quotQuotEquivComm_mk
@[simp]
theorem Polynomial.quotQuotEquivComm_mk (p : R[X]) :
    (Polynomial.quotQuotEquivComm I f) (Ideal.Quotient.mk _ (p.map (Ideal.Quotient.mk I))) =
      Ideal.Quotient.mk (span ({(Ideal.Quotient.mk (I.map C)) f} : Set (R[X] ⧸ (I.map C))))
      (Ideal.Quotient.mk (I.map C) p) 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (f p : R[X])
Goal: (AdjoinRoot.Polynomial.quotQuotEquivComm I f)
    ((Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f}))
      (Polynomial.map (Ideal.Quotient.mk I) p)) =
  (Ideal.Quotient.mk (Ideal.span {(Ideal.Quotient.mk (Ideal.map Polynomial.C I)) f}))
    ((Ideal.Quotient.mk (Ideal.map Polynomial.C I)) p)
-- AdjoinRoot.Polynomial.quotQuotEquivComm_symm_mk_mk
@[simp]
theorem Polynomial.quotQuotEquivComm_symm_mk_mk (p : R[X]) :
    (Polynomial.quotQuotEquivComm I f).symm (Ideal.Quotient.mk (span
    ({(Ideal.Quotient.mk (I.map C)) f} : Set (R[X] ⧸ (I.map C)))) (Ideal.Quotient.mk (I.map C) p)) =
      Ideal.Quotient.mk (span {f.map (Ideal.Quotient.mk I)}) (p.map (Ideal.Quotient.mk I)) 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (f p : R[X])
Goal: (AdjoinRoot.Polynomial.quotQuotEquivComm I f).symm
    ((Ideal.Quotient.mk (Ideal.span {(Ideal.Quotient.mk (Ideal.map Polynomial.C I)) f}))
      ((Ideal.Quotient.mk (Ideal.map Polynomial.C I)) p)) =
  (Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) p)
-- AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot_mk_of
@[simp]
theorem quotAdjoinRootEquivQuotPolynomialQuot_mk_of (p : R[X]) :
    quotAdjoinRootEquivQuotPolynomialQuot I f (Ideal.Quotient.mk (I.map (of f)) (mk f p)) =
      Ideal.Quotient.mk (span ({f.map (Ideal.Quotient.mk I)} : Set (R ⧸ I)[X]))
      (p.map (Ideal.Quotient.mk I)) 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (f p : R[X])
Goal: (AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot I f)
    ((Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) I)) ((AdjoinRoot.mk f) p)) =
  (Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) p)
-- AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot_symm_mk_mk
@[simp]
theorem quotAdjoinRootEquivQuotPolynomialQuot_symm_mk_mk (p : R[X]) :
    (quotAdjoinRootEquivQuotPolynomialQuot I f).symm
        (Ideal.Quotient.mk (span ({f.map (Ideal.Quotient.mk I)} : Set (R ⧸ I)[X]))
        (p.map (Ideal.Quotient.mk I))) =
      Ideal.Quotient.mk (I.map (of f)) (mk f p) 
Arguments: {R : Type u} [CommRing R] (I : Ideal R) (f p : R[X])
Goal: (AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot I f).symm
    ((Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f}))
      (Polynomial.map (Ideal.Quotient.mk I) p)) =
  (Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) I)) ((AdjoinRoot.mk f) p)
-- AdjoinRoot.quotEquivQuotMap_apply
@[simps!]
noncomputable def quotEquivQuotMap (f : R[X]) (I : Ideal R) :
    (AdjoinRoot f ⧸ Ideal.map (of f) I) ≃ₐ[R]
      (R ⧸ I)[X] ⧸ Ideal.span ({Polynomial.map (Ideal.Quotient.mk I) f} : Set (R ⧸ I)[X]) 
Arguments: {R : Type u} [CommRing R] (f : R[X]) (I : Ideal R) (a : AdjoinRoot f ⧸ Ideal.map (AdjoinRoot.of f) I)
Goal: (AdjoinRoot.quotEquivQuotMap f I) a = (AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot I f) a
-- AdjoinRoot.quotEquivQuotMap_symm_apply
@[simps!]
noncomputable def quotEquivQuotMap (f : R[X]) (I : Ideal R) :
    (AdjoinRoot f ⧸ Ideal.map (of f) I) ≃ₐ[R]
      (R ⧸ I)[X] ⧸ Ideal.span ({Polynomial.map (Ideal.Quotient.mk I) f} : Set (R ⧸ I)[X]) 
Arguments: {R : Type u} [CommRing R] (f : R[X]) (I : Ideal R) (a : (R ⧸ I)[X] ⧸ Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f})
Goal: (AdjoinRoot.quotEquivQuotMap f I).symm a = (AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot I f).symm a
-- AdjoinRoot.quotEquivQuotMap_apply_mk
@[simp]
theorem quotEquivQuotMap_apply_mk (f g : R[X]) (I : Ideal R) :
    AdjoinRoot.quotEquivQuotMap f I (Ideal.Quotient.mk (Ideal.map (of f) I) (AdjoinRoot.mk f g)) =
      Ideal.Quotient.mk (Ideal.span ({Polynomial.map (Ideal.Quotient.mk I) f} : Set (R ⧸ I)[X]))
      (g.map (Ideal.Quotient.mk I)) 
Arguments: {R : Type u} [CommRing R] (f g : R[X]) (I : Ideal R)
Goal: (AdjoinRoot.quotEquivQuotMap f I) ((Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) I)) ((AdjoinRoot.mk f) g)) =
  (Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) g)
-- AdjoinRoot.quotEquivQuotMap_symm_apply_mk
theorem quotEquivQuotMap_symm_apply_mk (f g : R[X]) (I : Ideal R) :
    (AdjoinRoot.quotEquivQuotMap f I).symm (Ideal.Quotient.mk _
      (Polynomial.map (Ideal.Quotient.mk I) g)) =
        Ideal.Quotient.mk (Ideal.map (of f) I) (AdjoinRoot.mk f g) 
Arguments: {R : Type u} [CommRing R] (f g : R[X]) (I : Ideal R)
Goal: (AdjoinRoot.quotEquivQuotMap f I).symm
    ((Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) f}))
      (Polynomial.map (Ideal.Quotient.mk I) g)) =
  (Ideal.Quotient.mk (Ideal.map (AdjoinRoot.of f) I)) ((AdjoinRoot.mk f) g)
-- PowerBasis.quotientEquivQuotientMinpolyMap_symm_apply
@[simps!]
noncomputable def quotientEquivQuotientMinpolyMap (pb : PowerBasis R S) (I : Ideal R) :
    (S ⧸ I.map (algebraMap R S)) ≃ₐ[R]
      Polynomial (R ⧸ I) ⧸
        Ideal.span ({(minpoly R pb.gen).map (Ideal.Quotient.mk I)} : Set (Polynomial (R ⧸ I))) 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (pb : PowerBasis R S) (I : Ideal R)
Goal: ∀ (a : (R ⧸ I)[X] ⧸ Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R pb.gen)}),
  (pb.quotientEquivQuotientMinpolyMap I).symm a =
    (↑↑(AlgEquiv.ofRingEquiv ⋯)).symm ((↑↑(AdjoinRoot.quotEquivQuotMap (minpoly R pb.gen) I)).symm a)
-- PowerBasis.quotientEquivQuotientMinpolyMap_apply
@[simps!]
noncomputable def quotientEquivQuotientMinpolyMap (pb : PowerBasis R S) (I : Ideal R) :
    (S ⧸ I.map (algebraMap R S)) ≃ₐ[R]
      Polynomial (R ⧸ I) ⧸
        Ideal.span ({(minpoly R pb.gen).map (Ideal.Quotient.mk I)} : Set (Polynomial (R ⧸ I))) 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (pb : PowerBasis R S) (I : Ideal R)
Goal: ∀ (a : S ⧸ Ideal.map (algebraMap R S) I),
  (pb.quotientEquivQuotientMinpolyMap I) a =
    (AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot I (minpoly R pb.gen))
      ((Ideal.quotientMap (Ideal.map (AdjoinRoot.of (minpoly R pb.gen)) I)
          ↑(↑(AdjoinRoot.equiv' (minpoly R pb.gen) pb ⋯ ⋯)).symm ⋯)
        a)
-- PowerBasis.quotientEquivQuotientMinpolyMap_apply_mk
theorem quotientEquivQuotientMinpolyMap_apply_mk (pb : PowerBasis R S) (I : Ideal R) (g : R[X]) :
    pb.quotientEquivQuotientMinpolyMap I (Ideal.Quotient.mk (I.map (algebraMap R S))
      (aeval pb.gen g)) = Ideal.Quotient.mk
        (Ideal.span ({(minpoly R pb.gen).map (Ideal.Quotient.mk I)} : Set (Polynomial (R ⧸ I))))
          (g.map (Ideal.Quotient.mk I)) 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (pb : PowerBasis R S) (I : Ideal R) (g : R[X])
Goal: (pb.quotientEquivQuotientMinpolyMap I)
    ((Ideal.Quotient.mk (Ideal.map (algebraMap R S) I)) ((Polynomial.aeval pb.gen) g)) =
  (Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R pb.gen)}))
    (Polynomial.map (Ideal.Quotient.mk I) g)
-- PowerBasis.quotientEquivQuotientMinpolyMap_symm_apply_mk
theorem quotientEquivQuotientMinpolyMap_symm_apply_mk (pb : PowerBasis R S) (I : Ideal R)
    (g : R[X]) :
    (pb.quotientEquivQuotientMinpolyMap I).symm (Ideal.Quotient.mk (Ideal.span
      ({(minpoly R pb.gen).map (Ideal.Quotient.mk I)} : Set (Polynomial (R ⧸ I))))
        (g.map (Ideal.Quotient.mk I))) = Ideal.Quotient.mk (I.map (algebraMap R S))
          (aeval pb.gen g) 
Arguments: {R : Type u} {S : Type v} [CommRing R] [CommRing S] [Algebra R S] (pb : PowerBasis R S) (I : Ideal R) (g : R[X])
Goal: (pb.quotientEquivQuotientMinpolyMap I).symm
    ((Ideal.Quotient.mk (Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R pb.gen)}))
      (Polynomial.map (Ideal.Quotient.mk I) g)) =
  (Ideal.Quotient.mk (Ideal.map (algebraMap R S) I)) ((Polynomial.aeval pb.gen) g)
-- Irreducible.exists_dvd_monic_irreducible_of_isIntegral
theorem Irreducible.exists_dvd_monic_irreducible_of_isIntegral {K L : Type*}
    [CommRing K] [IsDomain K] [Field L] [Algebra K L] [Algebra.IsIntegral K L] {f : L[X]}
    (hf : Irreducible f) : ∃ g : K[X], g.Monic ∧ Irreducible g ∧ f ∣ g.map (algebraMap K L) 
Arguments: {K : Type u_1} {L : Type u_2} [CommRing K] [IsDomain K] [Field L] [Algebra K L] [Algebra.IsIntegral K L] {f : L[X]} (hf : Irreducible f)
Goal: ∃ g, g.Monic ∧ Irreducible g ∧ f ∣ Polynomial.map (algebraMap K L) g
-- minimalPrimes_eq_minimals
lemma minimalPrimes_eq_minimals : minimalPrimes R = minimals (· ≤ ·) (setOf Ideal.IsPrime) 
Arguments: {R : Type u_1} [CommSemiring R]
Goal: minimalPrimes R = minimals (fun x x_1 => x ≤ x_1) (setOf Ideal.IsPrime)
-- Ideal.exists_minimalPrimes_le
theorem Ideal.exists_minimalPrimes_le [J.IsPrime] (e : I ≤ J) : ∃ p ∈ I.minimalPrimes, p ≤ J 
Arguments: {R : Type u_1} [CommSemiring R] {I J : Ideal R} [J.IsPrime] (e : I ≤ J)
Goal: ∃ p ∈ I.minimalPrimes, p ≤ J
-- Ideal.radical_minimalPrimes
@[simp]
theorem Ideal.radical_minimalPrimes : I.radical.minimalPrimes = I.minimalPrimes 
Arguments: {R : Type u_1} [CommSemiring R] {I : Ideal R}
Goal: I.radical.minimalPrimes = I.minimalPrimes
-- Ideal.sInf_minimalPrimes
@[simp]
theorem Ideal.sInf_minimalPrimes : sInf I.minimalPrimes = I.radical 
Arguments: {R : Type u_1} [CommSemiring R] {I : Ideal R}
Goal: sInf I.minimalPrimes = I.radical
-- Ideal.exists_comap_eq_of_mem_minimalPrimes_of_injective
theorem Ideal.exists_comap_eq_of_mem_minimalPrimes_of_injective {f : R →+* S}
    (hf : Function.Injective f) (p) (H : p ∈ minimalPrimes R) :
    ∃ p' : Ideal S, p'.IsPrime ∧ p'.comap f = p 
Arguments: {R : Type u_1} {S : Type u_2} [CommSemiring R] [CommSemiring S] {f : R →+* S} (hf : Function.Injective ⇑f) (p : Ideal R) (H : p ∈ minimalPrimes R)
Goal: ∃ p', p'.IsPrime ∧ Ideal.comap f p' = p
-- Ideal.exists_comap_eq_of_mem_minimalPrimes
theorem Ideal.exists_comap_eq_of_mem_minimalPrimes {I : Ideal S} (f : R →+* S) (p)
    (H : p ∈ (I.comap f).minimalPrimes) : ∃ p' : Ideal S, p'.IsPrime ∧ I ≤ p' ∧ p'.comap f = p 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] {I : Ideal S} (f : R →+* S) (p : Ideal R) (H : p ∈ (Ideal.comap f I).minimalPrimes)
Goal: ∃ p', p'.IsPrime ∧ I ≤ p' ∧ Ideal.comap f p' = p
-- Ideal.exists_minimalPrimes_comap_eq
theorem Ideal.exists_minimalPrimes_comap_eq {I : Ideal S} (f : R →+* S) (p)
    (H : p ∈ (I.comap f).minimalPrimes) : ∃ p' ∈ I.minimalPrimes, Ideal.comap f p' = p 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] {I : Ideal S} (f : R →+* S) (p : Ideal R) (H : p ∈ (Ideal.comap f I).minimalPrimes)
Goal: ∃ p' ∈ I.minimalPrimes, Ideal.comap f p' = p
-- Ideal.minimal_primes_comap_of_surjective
theorem Ideal.minimal_primes_comap_of_surjective {f : R →+* S} (hf : Function.Surjective f)
    {I J : Ideal S} (h : J ∈ I.minimalPrimes) : J.comap f ∈ (I.comap f).minimalPrimes 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] {f : R →+* S} (hf : Function.Surjective ⇑f) {I J : Ideal S} (h : J ∈ I.minimalPrimes)
Goal: Ideal.comap f J ∈ (Ideal.comap f I).minimalPrimes
-- Ideal.comap_minimalPrimes_eq_of_surjective
theorem Ideal.comap_minimalPrimes_eq_of_surjective {f : R →+* S} (hf : Function.Surjective f)
    (I : Ideal S) : (I.comap f).minimalPrimes = Ideal.comap f '' I.minimalPrimes 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [CommRing S] {f : R →+* S} (hf : Function.Surjective ⇑f) (I : Ideal S)
Goal: (Ideal.comap f I).minimalPrimes = Ideal.comap f '' I.minimalPrimes
-- Ideal.minimalPrimes_eq_comap
theorem Ideal.minimalPrimes_eq_comap :
    I.minimalPrimes = Ideal.comap (Ideal.Quotient.mk I) '' minimalPrimes (R ⧸ I) 
Arguments: {R : Type u_1} [CommRing R] {I : Ideal R}
Goal: I.minimalPrimes = Ideal.comap (Ideal.Quotient.mk I) '' minimalPrimes (R ⧸ I)
-- Ideal.minimalPrimes_eq_subsingleton
theorem Ideal.minimalPrimes_eq_subsingleton (hI : I.IsPrimary) : I.minimalPrimes = {I.radical} 
Arguments: {R : Type u_1} [CommRing R] {I : Ideal R} (hI : I.IsPrimary)
Goal: I.minimalPrimes = {I.radical}
-- Ideal.minimalPrimes_eq_subsingleton_self
theorem Ideal.minimalPrimes_eq_subsingleton_self [I.IsPrime] : I.minimalPrimes = {I} 
Arguments: {R : Type u_1} [CommRing R] {I : Ideal R} [I.IsPrime]
Goal: I.minimalPrimes = {I}
-- IsLocalization.AtPrime.prime_unique_of_minimal
theorem _root_.IsLocalization.AtPrime.prime_unique_of_minimal {S} [CommSemiring S] [Algebra R S]
    [IsLocalization.AtPrime S I] {J K : Ideal S} [J.IsPrime] [K.IsPrime] : J = K 
Arguments: {R : Type u_1} [CommSemiring R] {I : Ideal R} [hI : I.IsPrime] (hMin : I ∈ minimalPrimes R) {S : Type u_2} [CommSemiring S] [Algebra R S] [IsLocalization.AtPrime S I] {J K : Ideal S} [J.IsPrime] [K.IsPrime]
Goal: J = K
-- Localization.AtPrime.prime_unique_of_minimal
theorem prime_unique_of_minimal (J : Ideal (Localization I.primeCompl)) [J.IsPrime] :
    J = LocalRing.maximalIdeal (Localization I.primeCompl) 
Arguments: {R : Type u_1} [CommSemiring R] {I : Ideal R} [hI : I.IsPrime] (hMin : I ∈ minimalPrimes R) (J : Ideal (Localization I.primeCompl)) [J.IsPrime]
Goal: J = LocalRing.maximalIdeal (Localization I.primeCompl)
-- Localization.AtPrime.nilpotent_iff_mem_maximal_of_minimal
theorem nilpotent_iff_mem_maximal_of_minimal {x : _} :
    IsNilpotent x ↔ x ∈ LocalRing.maximalIdeal (Localization I.primeCompl) 
Arguments: {R : Type u_1} [CommSemiring R] {I : Ideal R} [hI : I.IsPrime] (hMin : I ∈ minimalPrimes R) {x : Localization I.primeCompl}
Goal: IsNilpotent x ↔ x ∈ LocalRing.maximalIdeal (Localization I.primeCompl)
-- Localization.AtPrime.nilpotent_iff_not_unit_of_minimal
theorem nilpotent_iff_not_unit_of_minimal {x : Localization I.primeCompl} :
    IsNilpotent x ↔ x ∈ nonunits _ 
Arguments: {R : Type u_1} [CommSemiring R] {I : Ideal R} [hI : I.IsPrime] (hMin : I ∈ minimalPrimes R) {x : Localization I.primeCompl}
Goal: IsNilpotent x ↔ x ∈ nonunits (Localization I.primeCompl)
-- BinomialRing.factorial_nsmul_multichoose
class BinomialRing (R : Type*) [AddCommMonoid R] [Pow R ℕ] where
    nsmul_right_injective (n : ℕ) (h : n ≠ 0) : Injective (n • · : R → R)
    multichoose : R → ℕ → R
    factorial_nsmul_multichoose (r : R) (n : ℕ) :
    n.factorial • multichoose r n = (ascPochhammer ℕ n).smeval r
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [self : BinomialRing R] (r : R) (n : ℕ)
Goal: n.factorial • BinomialRing.multichoose r n = (ascPochhammer ℕ n).smeval r
-- BinomialRing.nsmul_right_injective
class BinomialRing (R : Type*) [AddCommMonoid R] [Pow R ℕ] where
    nsmul_right_injective (n : ℕ) (h : n ≠ 0) : Injective (n • · : R → R)
    multichoose : R → ℕ → R
    factorial_nsmul_multichoose (r : R) (n : ℕ) :
    n.factorial • multichoose r n = (ascPochhammer ℕ n).smeval r
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [self : BinomialRing R] (n : ℕ) (h : n ≠ 0)
Goal: Function.Injective fun x => n • x
-- Ring.nsmul_right_injective
theorem nsmul_right_injective (n : ℕ) (h : n ≠ 0) :
    Injective (n • · : R → R) 
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [BinomialRing R] (n : ℕ) (h : n ≠ 0)
Goal: Function.Injective fun x => n • x
-- Ring.multichoose_eq_multichoose
@[simp]
theorem multichoose_eq_multichoose (r : R) (n : ℕ) :
    BinomialRing.multichoose r n = multichoose r n 
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [BinomialRing R] (r : R) (n : ℕ)
Goal: BinomialRing.multichoose r n = Ring.multichoose r n
-- Ring.factorial_nsmul_multichoose_eq_ascPochhammer
theorem factorial_nsmul_multichoose_eq_ascPochhammer (r : R) (n : ℕ) :
    n.factorial • multichoose r n = (ascPochhammer ℕ n).smeval r 
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [BinomialRing R] (r : R) (n : ℕ)
Goal: n.factorial • Ring.multichoose r n = (ascPochhammer ℕ n).smeval r
-- Ring.multichoose_zero_right'
@[simp]
theorem multichoose_zero_right' (r : R) : multichoose r 0 = r ^ 0 
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [BinomialRing R] (r : R)
Goal: Ring.multichoose r 0 = r ^ 0
-- Ring.multichoose_zero_right
theorem multichoose_zero_right [MulOneClass R] [NatPowAssoc R]
    (r : R) : multichoose r 0 = 1 
Arguments: {R : Type u_1} [AddCommMonoid R] [Pow R ℕ] [BinomialRing R] [MulOneClass R] [NatPowAssoc R] (r : R)
Goal: Ring.multichoose r 0 = 1