ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MvPolynomial.IsSymmetric.neg
theorem neg (hφ : IsSymmetric φ) : IsSymmetric (-φ) 
Arguments: {σ : Type u_1} {R : Type u_2} [CommRing R] {φ : MvPolynomial σ R} (hφ : φ.IsSymmetric)
Goal: (-φ).IsSymmetric
-- MvPolynomial.IsSymmetric.sub
theorem sub (hφ : IsSymmetric φ) (hψ : IsSymmetric ψ) : IsSymmetric (φ - ψ) 
Arguments: {σ : Type u_1} {R : Type u_2} [CommRing R] {φ ψ : MvPolynomial σ R} (hφ : φ.IsSymmetric) (hψ : ψ.IsSymmetric)
Goal: (φ - ψ).IsSymmetric
-- MvPolynomial.renameSymmetricSubalgebra_apply_coe
@[simps!]
def renameSymmetricSubalgebra [CommSemiring R] (e : σ ≃ τ) :
    symmetricSubalgebra σ R ≃ₐ[R] symmetricSubalgebra τ R 
Arguments: {σ : Type u_1} {R : Type u_2} {τ : Type u_3} [CommSemiring R] (e : σ ≃ τ) (a : ↥(MvPolynomial.symmetricSubalgebra σ R))
Goal: ↑((MvPolynomial.renameSymmetricSubalgebra e) a) = (MvPolynomial.rename ⇑e) ↑a
-- MvPolynomial.renameSymmetricSubalgebra_symm_apply_coe
@[simps!]
def renameSymmetricSubalgebra [CommSemiring R] (e : σ ≃ τ) :
    symmetricSubalgebra σ R ≃ₐ[R] symmetricSubalgebra τ R 
Arguments: {σ : Type u_1} {R : Type u_2} {τ : Type u_3} [CommSemiring R] (e : σ ≃ τ) (a : ↥(MvPolynomial.symmetricSubalgebra τ R))
Goal: ↑((MvPolynomial.renameSymmetricSubalgebra e).symm a) = (MvPolynomial.rename ⇑e.symm) ↑a
-- MvPolynomial.esymm_eq_multiset_esymm
theorem esymm_eq_multiset_esymm : esymm σ R = (univ.val.map X).esymm 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ]
Goal: MvPolynomial.esymm σ R = (Multiset.map MvPolynomial.X Finset.univ.val).esymm
-- MvPolynomial.aeval_esymm_eq_multiset_esymm
theorem aeval_esymm_eq_multiset_esymm [Algebra R S] (f : σ → S) (n : ℕ) :
    aeval f (esymm σ R n) = (univ.val.map f).esymm n 
Arguments: (σ : Type u_1) (R : Type u_2) {S : Type u_4} [CommSemiring R] [CommSemiring S] [Fintype σ] [Algebra R S] (f : σ → S) (n : ℕ)
Goal: (MvPolynomial.aeval f) (MvPolynomial.esymm σ R n) = (Multiset.map f Finset.univ.val).esymm n
-- MvPolynomial.esymm_eq_sum_subtype
theorem esymm_eq_sum_subtype (n : ℕ) :
    esymm σ R n = ∑ t : { s : Finset σ // s.card = n }, ∏ i ∈ (t : Finset σ), X i 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] (n : ℕ)
Goal: MvPolynomial.esymm σ R n = ∑ t : { s // s.card = n }, ∏ i ∈ ↑t, MvPolynomial.X i
-- MvPolynomial.esymm_eq_sum_monomial
theorem esymm_eq_sum_monomial (n : ℕ) :
    esymm σ R n = ∑ t ∈ powersetCard n univ, monomial (∑ i ∈ t, Finsupp.single i 1) 1 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] (n : ℕ)
Goal: MvPolynomial.esymm σ R n =
  ∑ t ∈ Finset.powersetCard n Finset.univ, (MvPolynomial.monomial (∑ i ∈ t, Finsupp.single i 1)) 1
-- MvPolynomial.esymm_zero
@[simp]
theorem esymm_zero : esymm σ R 0 = 1 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ]
Goal: MvPolynomial.esymm σ R 0 = 1
-- MvPolynomial.map_esymm
theorem map_esymm (n : ℕ) (f : R →+* S) : map f (esymm σ R n) = esymm σ S n 
Arguments: (σ : Type u_1) (R : Type u_2) {S : Type u_4} [CommSemiring R] [CommSemiring S] [Fintype σ] (n : ℕ) (f : R →+* S)
Goal: (MvPolynomial.map f) (MvPolynomial.esymm σ R n) = MvPolynomial.esymm σ S n
-- MvPolynomial.rename_esymm
theorem rename_esymm (n : ℕ) (e : σ ≃ τ) : rename e (esymm σ R n) = esymm τ R n 
Arguments: (σ : Type u_1) (R : Type u_2) {τ : Type u_3} [CommSemiring R] [Fintype σ] [Fintype τ] (n : ℕ) (e : σ ≃ τ)
Goal: (MvPolynomial.rename ⇑e) (MvPolynomial.esymm σ R n) = MvPolynomial.esymm τ R n
-- MvPolynomial.esymm_isSymmetric
theorem esymm_isSymmetric (n : ℕ) : IsSymmetric (esymm σ R n) 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] (n : ℕ)
Goal: (MvPolynomial.esymm σ R n).IsSymmetric
-- MvPolynomial.support_esymm''
theorem support_esymm'' (n : ℕ) [DecidableEq σ] [Nontrivial R] :
    (esymm σ R n).support =
      (powersetCard n (univ : Finset σ)).biUnion fun t =>
        (Finsupp.single (∑ i ∈ t, Finsupp.single i 1) (1 : R)).support 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] (n : ℕ) [DecidableEq σ] [Nontrivial R]
Goal: (MvPolynomial.esymm σ R n).support =
  (Finset.powersetCard n Finset.univ).biUnion fun t => (Finsupp.single (∑ i ∈ t, Finsupp.single i 1) 1).support
-- MvPolynomial.support_esymm'
theorem support_esymm' (n : ℕ) [DecidableEq σ] [Nontrivial R] :
    (esymm σ R n).support =
      (powersetCard n (univ : Finset σ)).biUnion fun t => {∑ i ∈ t, Finsupp.single i 1} 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] (n : ℕ) [DecidableEq σ] [Nontrivial R]
Goal: (MvPolynomial.esymm σ R n).support = (Finset.powersetCard n Finset.univ).biUnion fun t => {∑ i ∈ t, Finsupp.single i 1}
-- MvPolynomial.support_esymm
theorem support_esymm (n : ℕ) [DecidableEq σ] [Nontrivial R] :
    (esymm σ R n).support =
      (powersetCard n (univ : Finset σ)).image fun t => ∑ i ∈ t, Finsupp.single i 1 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] (n : ℕ) [DecidableEq σ] [Nontrivial R]
Goal: (MvPolynomial.esymm σ R n).support =
  Finset.image (fun t => ∑ i ∈ t, Finsupp.single i 1) (Finset.powersetCard n Finset.univ)
-- MvPolynomial.degrees_esymm
theorem degrees_esymm [Nontrivial R] (n : ℕ) (hpos : 0 < n) (hn : n ≤ Fintype.card σ) :
    (esymm σ R n).degrees = (univ : Finset σ).val 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] [Nontrivial R] (n : ℕ) (hpos : 0 < n) (hn : n ≤ Fintype.card σ)
Goal: (MvPolynomial.esymm σ R n).degrees = Finset.univ.val
-- MvPolynomial.psum_def
lemma psum_def (n : ℕ) : psum σ R n = ∑ i, X i ^ n 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] (n : ℕ)
Goal: MvPolynomial.psum σ R n = ∑ i : σ, MvPolynomial.X i ^ n
-- MvPolynomial.psum_zero
@[simp]
theorem psum_zero : psum σ R 0 = Fintype.card σ 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ]
Goal: MvPolynomial.psum σ R 0 = ↑(Fintype.card σ)
-- MvPolynomial.psum_one
@[simp]
theorem psum_one : psum σ R 1 = ∑ i, X i 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ]
Goal: MvPolynomial.psum σ R 1 = ∑ i : σ, MvPolynomial.X i
-- MvPolynomial.rename_psum
@[simp]
theorem rename_psum (n : ℕ) (e : σ ≃ τ) : rename e (psum σ R n) = psum τ R n 
Arguments: (σ : Type u_1) (R : Type u_2) {τ : Type u_3} [CommSemiring R] [Fintype σ] [Fintype τ] (n : ℕ) (e : σ ≃ τ)
Goal: (MvPolynomial.rename ⇑e) (MvPolynomial.psum σ R n) = MvPolynomial.psum τ R n
-- MvPolynomial.psum_isSymmetric
theorem psum_isSymmetric (n : ℕ) : IsSymmetric (psum σ R n) 
Arguments: (σ : Type u_1) (R : Type u_2) [CommSemiring R] [Fintype σ] (n : ℕ)
Goal: (MvPolynomial.psum σ R n).IsSymmetric
-- RingCon.rel_eq_coe
theorem rel_eq_coe : c.r = c 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R)
Goal: Setoid.r = ⇑c
-- RingCon.toCon_coe_eq_coe
@[simp]
theorem toCon_coe_eq_coe : (c.toCon : R → R → Prop) = c 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R)
Goal: ⇑c.toCon = ⇑c
-- RingCon.refl
protected theorem refl (x) : c x x 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) (x : R)
Goal: c x x
-- RingCon.symm
protected theorem symm {x y} : c x y → c y x 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) {x y : R}
Goal: c x y → c y x
-- RingCon.trans
protected theorem trans {x y z} : c x y → c y z → c x z 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) {x y z : R}
Goal: c x y → c y z → c x z
-- RingCon.add
protected theorem add {w x y z} : c w x → c y z → c (w + y) (x + z) 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) {w x y z : R}
Goal: c w x → c y z → c (w + y) (x + z)
-- RingCon.mul
protected theorem mul {w x y z} : c w x → c y z → c (w * y) (x * z) 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) {w x y z : R}
Goal: c w x → c y z → c (w * y) (x * z)
-- RingCon.sub
protected theorem sub {S : Type*} [AddGroup S] [Mul S] (t : RingCon S)
    {a b c d : S} (h : t a b) (h' : t c d) : t (a - c) (b - d) 
Arguments: {S : Type u_3} [AddGroup S] [Mul S] (t : RingCon S) {a b c d : S} (h : t a b) (h' : t c d)
Goal: t (a - c) (b - d)
-- RingCon.neg
protected theorem neg {S : Type*} [AddGroup S] [Mul S] (t : RingCon S)
    {a b} (h : t a b) : t (-a) (-b) 
Arguments: {S : Type u_3} [AddGroup S] [Mul S] (t : RingCon S) {a b : S} (h : t a b)
Goal: t (-a) (-b)
-- RingCon.nsmul
protected theorem nsmul {S : Type*} [AddGroup S] [Mul S] (t : RingCon S)
    (m : ℕ) {x y : S} (hx : t x y) : t (m • x) (m • y) 
Arguments: {S : Type u_3} [AddGroup S] [Mul S] (t : RingCon S) (m : ℕ) {x y : S} (hx : t x y)
Goal: t (m • x) (m • y)
-- RingCon.zsmul
protected theorem zsmul {S : Type*} [AddGroup S] [Mul S] (t : RingCon S)
    (z : ℤ) {x y : S} (hx : t x y) : t (z • x) (z • y) 
Arguments: {S : Type u_3} [AddGroup S] [Mul S] (t : RingCon S) (z : ℤ) {x y : S} (hx : t x y)
Goal: t (z • x) (z • y)
-- RingCon.rel_mk
@[simp]
theorem rel_mk {s : Con R} {h a b} : RingCon.mk s h a b ↔ s a b 
Arguments: {R : Type u_2} [Add R] [Mul R] {s : Con R} {h : ∀ {w x y z : R}, Setoid.r w x → Setoid.r y z → Setoid.r (w + y) (x + z)} {a b : R}
Goal: { toCon := s, add' := h } a b ↔ s a b
-- RingCon.ext'
theorem ext' {c d : RingCon R} (H : ⇑c = ⇑d) : c = d 
Arguments: {R : Type u_2} [Add R] [Mul R] {c d : RingCon R} (H : ⇑c = ⇑d)
Goal: c = d
-- RingCon.ext
theorem ext {c d : RingCon R} (H : ∀ x y, c x y ↔ d x y) : c = d 
Arguments: {R : Type u_2} [Add R] [Mul R] {c d : RingCon R} (H : ∀ (x y : R), c x y ↔ d x y)
Goal: c = d
-- RingCon.quot_mk_eq_coe
@[simp]
theorem quot_mk_eq_coe (x : R) : Quot.mk c x = (x : c.Quotient) 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) (x : R)
Goal: Quot.mk (⇑c) x = ↑x
-- RingCon.eq
@[simp]
protected theorem eq {a b : R} : (a : c.Quotient) = (b : c.Quotient) ↔ c a b 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) {a b : R}
Goal: ↑a = ↑b ↔ c a b
-- RingCon.coe_add
@[simp, norm_cast]
theorem coe_add (x y : R) : (↑(x + y) : c.Quotient) = ↑x + ↑y 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) (x y : R)
Goal: ↑(x + y) = ↑x + ↑y
-- RingCon.coe_mul
@[simp, norm_cast]
theorem coe_mul (x y : R) : (↑(x * y) : c.Quotient) = ↑x * ↑y 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R) (x y : R)
Goal: ↑(x * y) = ↑x * ↑y
-- RingCon.coe_zero
@[simp, norm_cast]
theorem coe_zero : (↑(0 : R) : c.Quotient) = 0 
Arguments: {R : Type u_2} [AddZeroClass R] [Mul R] (c : RingCon R)
Goal: ↑0 = 0
-- RingCon.coe_one
@[simp, norm_cast]
theorem coe_one : (↑(1 : R) : c.Quotient) = 1 
Arguments: {R : Type u_2} [Add R] [MulOneClass R] (c : RingCon R)
Goal: ↑1 = 1
-- RingCon.coe_smul
@[simp, norm_cast]
theorem coe_smul (a : α) (x : R) : (↑(a • x) : c.Quotient) = a • (x : c.Quotient) 
Arguments: {α : Type u_1} {R : Type u_2} [Add R] [MulOneClass R] [SMul α R] [IsScalarTower α R R] (c : RingCon R) (a : α) (x : R)
Goal: ↑(a • x) = a • ↑x
-- RingCon.coe_neg
@[simp, norm_cast]
theorem coe_neg (x : R) : (↑(-x) : c.Quotient) = -x 
Arguments: {R : Type u_2} [AddGroup R] [Mul R] (c : RingCon R) (x : R)
Goal: ↑(-x) = -↑x
-- RingCon.coe_sub
@[simp, norm_cast]
theorem coe_sub (x y : R) : (↑(x - y) : c.Quotient) = x - y 
Arguments: {R : Type u_2} [AddGroup R] [Mul R] (c : RingCon R) (x y : R)
Goal: ↑(x - y) = ↑x - ↑y
-- RingCon.coe_zsmul
@[simp, norm_cast]
theorem coe_zsmul (z : ℤ) (x : R) : (↑(z • x) : c.Quotient) = z • (x : c.Quotient) 
Arguments: {R : Type u_2} [AddGroup R] [Mul R] (c : RingCon R) (z : ℤ) (x : R)
Goal: ↑(z • x) = z • ↑x
-- RingCon.coe_nsmul
@[simp, norm_cast]
theorem coe_nsmul (n : ℕ) (x : R) : (↑(n • x) : c.Quotient) = n • (x : c.Quotient) 
Arguments: {R : Type u_2} [AddMonoid R] [Mul R] (c : RingCon R) (n : ℕ) (x : R)
Goal: ↑(n • x) = n • ↑x
-- RingCon.coe_pow
@[simp, norm_cast]
theorem coe_pow (x : R) (n : ℕ) : (↑(x ^ n) : c.Quotient) = (x : c.Quotient) ^ n 
Arguments: {R : Type u_2} [Add R] [Monoid R] (c : RingCon R) (x : R) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- RingCon.coe_natCast
@[simp, norm_cast]
theorem coe_natCast (n : ℕ) : (↑(n : R) : c.Quotient) = n 
Arguments: {R : Type u_2} [AddMonoidWithOne R] [Mul R] (c : RingCon R) (n : ℕ)
Goal: ↑↑n = ↑n
-- RingCon.coe_intCast
@[simp, norm_cast]
theorem coe_intCast (n : ℕ) : (↑(n : R) : c.Quotient) = n 
Arguments: {R : Type u_2} [AddGroupWithOne R] [Mul R] (c : RingCon R) (n : ℕ)
Goal: ↑↑n = ↑n
-- RingCon.le_def
theorem le_def {c d : RingCon R} : c ≤ d ↔ ∀ {x y}, c x y → d x y 
Arguments: {R : Type u_2} [Add R] [Mul R] {c d : RingCon R}
Goal: c ≤ d ↔ ∀ {x y : R}, c x y → d x y
-- RingCon.sInf_toSetoid
theorem sInf_toSetoid (S : Set (RingCon R)) : (sInf S).toSetoid = sInf ((·.toSetoid) '' S) 
Arguments: {R : Type u_2} [Add R] [Mul R] (S : Set (RingCon R))
Goal: (sInf S).toSetoid = sInf ((fun x => x.toSetoid) '' S)
-- RingCon.coe_sInf
@[simp, norm_cast]
theorem coe_sInf (S : Set (RingCon R)) : ⇑(sInf S) = sInf ((⇑) '' S) 
Arguments: {R : Type u_2} [Add R] [Mul R] (S : Set (RingCon R))
Goal: ⇑(sInf S) = sInf (DFunLike.coe '' S)
-- RingCon.coe_iInf
@[simp, norm_cast]
theorem coe_iInf {ι : Sort*} (f : ι → RingCon R) : ⇑(iInf f) = ⨅ i, ⇑(f i) 
Arguments: {R : Type u_2} [Add R] [Mul R] {ι : Sort u_3} (f : ι → RingCon R)
Goal: ⇑(iInf f) = ⨅ i, ⇑(f i)
-- RingCon.coe_top
@[simp, norm_cast]
theorem coe_top : ⇑(⊤ : RingCon R) = ⊤ 
Arguments: {R : Type u_2} [Add R] [Mul R]
Goal: ⇑⊤ = ⊤
-- RingCon.coe_bot
@[simp, norm_cast]
theorem coe_bot : ⇑(⊥ : RingCon R) = Eq 
Arguments: {R : Type u_2} [Add R] [Mul R]
Goal: ⇑⊥ = Eq
-- RingCon.coe_inf
@[simp, norm_cast]
theorem coe_inf {c d : RingCon R} : ⇑(c ⊓ d) = ⇑c ⊓ ⇑d 
Arguments: {R : Type u_2} [Add R] [Mul R] {c d : RingCon R}
Goal: ⇑(c ⊓ d) = ⇑c ⊓ ⇑d
-- RingCon.inf_iff_and
theorem inf_iff_and {c d : RingCon R} {x y} : (c ⊓ d) x y ↔ c x y ∧ d x y 
Arguments: {R : Type u_2} [Add R] [Mul R] {c d : RingCon R} {x y : R}
Goal: (c ⊓ d) x y ↔ c x y ∧ d x y
-- RingCon.ringConGen_eq
theorem ringConGen_eq (r : R → R → Prop) :
    ringConGen r = sInf {s : RingCon R | ∀ x y, r x y → s x y} 
Arguments: {R : Type u_2} [Add R] [Mul R] (r : R → R → Prop)
Goal: ringConGen r = sInf {s | ∀ (x y : R), r x y → s x y}
-- RingCon.ringConGen_le
theorem ringConGen_le {r : R → R → Prop} {c : RingCon R}
    (h : ∀ x y, r x y → c x y) : ringConGen r ≤ c 
Arguments: {R : Type u_2} [Add R] [Mul R] {r : R → R → Prop} {c : RingCon R} (h : ∀ (x y : R), r x y → c x y)
Goal: ringConGen r ≤ c
-- RingCon.ringConGen_mono
theorem ringConGen_mono {r s : R → R → Prop} (h : ∀ x y, r x y → s x y) :
    ringConGen r ≤ ringConGen s 
Arguments: {R : Type u_2} [Add R] [Mul R] {r s : R → R → Prop} (h : ∀ (x y : R), r x y → s x y)
Goal: ringConGen r ≤ ringConGen s
-- RingCon.ringConGen_of_ringCon
theorem ringConGen_of_ringCon (c : RingCon R) : ringConGen c = c 
Arguments: {R : Type u_2} [Add R] [Mul R] (c : RingCon R)
Goal: ringConGen ⇑c = c
-- RingCon.ringConGen_idem
theorem ringConGen_idem (r : R → R → Prop) : ringConGen (ringConGen r) = ringConGen r 
Arguments: {R : Type u_2} [Add R] [Mul R] (r : R → R → Prop)
Goal: ringConGen ⇑(ringConGen r) = ringConGen r
-- RingCon.sup_eq_ringConGen
theorem sup_eq_ringConGen (c d : RingCon R) : c ⊔ d = ringConGen fun x y => c x y ∨ d x y 
Arguments: {R : Type u_2} [Add R] [Mul R] (c d : RingCon R)
Goal: c ⊔ d = ringConGen fun x y => c x y ∨ d x y
-- RingCon.sup_def
theorem sup_def {c d : RingCon R} : c ⊔ d = ringConGen (⇑c ⊔ ⇑d) 
Arguments: {R : Type u_2} [Add R] [Mul R] {c d : RingCon R}
Goal: c ⊔ d = ringConGen (⇑c ⊔ ⇑d)
-- RingCon.sSup_eq_ringConGen
theorem sSup_eq_ringConGen (S : Set (RingCon R)) :
    sSup S = ringConGen fun x y => ∃ c : RingCon R, c ∈ S ∧ c x y 
Arguments: {R : Type u_2} [Add R] [Mul R] (S : Set (RingCon R))
Goal: sSup S = ringConGen fun x y => ∃ c ∈ S, c x y
-- RingCon.sSup_def
theorem sSup_def {S : Set (RingCon R)} :
    sSup S = ringConGen (sSup (@Set.image (RingCon R) (R → R → Prop) (⇑) S)) 
Arguments: {R : Type u_2} [Add R] [Mul R] {S : Set (RingCon R)}
Goal: sSup S = ringConGen (sSup (DFunLike.coe '' S))
-- Polynomial.EisensteinCriterionAux.map_eq_C_mul_X_pow_of_forall_coeff_mem
theorem map_eq_C_mul_X_pow_of_forall_coeff_mem {f : R[X]} {P : Ideal R}
    (hfP : ∀ n : ℕ, ↑n < f.degree → f.coeff n ∈ P) :
    map (mk P) f = C ((mk P) f.leadingCoeff) * X ^ f.natDegree 
Arguments: {R : Type u_1} [CommRing R] {f : R[X]} {P : Ideal R} (hfP : ∀ (n : ℕ), ↑n < f.degree → f.coeff n ∈ P)
Goal: Polynomial.map (Ideal.Quotient.mk P) f =
  Polynomial.C ((Ideal.Quotient.mk P) f.leadingCoeff) * Polynomial.X ^ f.natDegree
-- Polynomial.EisensteinCriterionAux.le_natDegree_of_map_eq_mul_X_pow
theorem le_natDegree_of_map_eq_mul_X_pow {n : ℕ} {P : Ideal R} (hP : P.IsPrime) {q : R[X]}
    {c : Polynomial (R ⧸ P)} (hq : map (mk P) q = c * X ^ n) (hc0 : c.degree = 0) :
    n ≤ q.natDegree 
Arguments: {R : Type u_1} [CommRing R] {n : ℕ} {P : Ideal R} (hP : P.IsPrime) {q : R[X]} {c : (R ⧸ P)[X]} (hq : Polynomial.map (Ideal.Quotient.mk P) q = c * Polynomial.X ^ n) (hc0 : c.degree = 0)
Goal: n ≤ q.natDegree
-- Polynomial.EisensteinCriterionAux.eval_zero_mem_ideal_of_eq_mul_X_pow
theorem eval_zero_mem_ideal_of_eq_mul_X_pow {n : ℕ} {P : Ideal R} {q : R[X]}
    {c : Polynomial (R ⧸ P)} (hq : map (mk P) q = c * X ^ n) (hn0 : n ≠ 0) : eval 0 q ∈ P 
Arguments: {R : Type u_1} [CommRing R] {n : ℕ} {P : Ideal R} {q : R[X]} {c : (R ⧸ P)[X]} (hq : Polynomial.map (Ideal.Quotient.mk P) q = c * Polynomial.X ^ n) (hn0 : n ≠ 0)
Goal: Polynomial.eval 0 q ∈ P
-- Polynomial.EisensteinCriterionAux.isUnit_of_natDegree_eq_zero_of_isPrimitive
theorem isUnit_of_natDegree_eq_zero_of_isPrimitive {p q : R[X]}
    -- Porting note: stated using `IsPrimitive` which is defeq to old statement.
    (hu : IsPrimitive (p * q)) (hpm : p.natDegree = 0) : IsUnit p 
Arguments: {R : Type u_1} [CommRing R] {p q : R[X]} (hu : (p * q).IsPrimitive) (hpm : p.natDegree = 0)
Goal: IsUnit p
-- Polynomial.irreducible_of_eisenstein_criterion
theorem irreducible_of_eisenstein_criterion {f : R[X]} {P : Ideal R} (hP : P.IsPrime)
    (hfl : f.leadingCoeff ∉ P) (hfP : ∀ n : ℕ, ↑n < degree f → f.coeff n ∈ P) (hfd0 : 0 < degree f)
    (h0 : f.coeff 0 ∉ P ^ 2) (hu : f.IsPrimitive) : Irreducible f 
Arguments: {R : Type u_1} [CommRing R] [IsDomain R] {f : R[X]} {P : Ideal R} (hP : P.IsPrime) (hfl : f.leadingCoeff ∉ P) (hfP : ∀ (n : ℕ), ↑n < f.degree → f.coeff n ∈ P) (hfd0 : 0 < f.degree) (h0 : f.coeff 0 ∉ P ^ 2) (hu : f.IsPrimitive)
Goal: Irreducible f
-- Algebra.norm_apply
theorem norm_apply (x : S) : norm R x = LinearMap.det (lmul R S x) 
Arguments: (R : Type u_1) {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] (x : S)
Goal: (Algebra.norm R) x = LinearMap.det ((Algebra.lmul R S) x)
-- Algebra.norm_eq_one_of_not_exists_basis
theorem norm_eq_one_of_not_exists_basis (h : ¬∃ s : Finset S, Nonempty (Basis s R S)) (x : S) :
    norm R x = 1 
Arguments: (R : Type u_1) {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] (h : ¬∃ s, Nonempty (Basis { x // x ∈ s } R S)) (x : S)
Goal: (Algebra.norm R) x = 1
-- Algebra.norm_eq_one_of_not_module_finite
theorem norm_eq_one_of_not_module_finite (h : ¬Module.Finite R S) (x : S) : norm R x = 1 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] (h : ¬Module.Finite R S) (x : S)
Goal: (Algebra.norm R) x = 1
-- Algebra.norm_eq_matrix_det
theorem norm_eq_matrix_det [Fintype ι] [DecidableEq ι] (b : Basis ι R S) (s : S) :
    norm R s = Matrix.det (Algebra.leftMulMatrix b s) 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] {ι : Type w} [Fintype ι] [DecidableEq ι] (b : Basis ι R S) (s : S)
Goal: (Algebra.norm R) s = ((Algebra.leftMulMatrix b) s).det
-- Algebra.norm_algebraMap_of_basis
theorem norm_algebraMap_of_basis [Fintype ι] (b : Basis ι R S) (x : R) :
    norm R (algebraMap R S x) = x ^ Fintype.card ι 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] {ι : Type w} [Fintype ι] (b : Basis ι R S) (x : R)
Goal: (Algebra.norm R) ((algebraMap R S) x) = x ^ Fintype.card ι
-- Algebra.norm_algebraMap
@[simp]
protected theorem norm_algebraMap {L : Type*} [Ring L] [Algebra K L] (x : K) :
    norm K (algebraMap K L x) = x ^ finrank K L 
Arguments: {K : Type u_4} [Field K] {L : Type u_7} [Ring L] [Algebra K L] (x : K)
Goal: (Algebra.norm K) ((algebraMap K L) x) = x ^ FiniteDimensional.finrank K L
-- MvPolynomial.isLocalization_C_mk'
lemma isLocalization_C_mk' (a : R) (m : M) :
    C (IsLocalization.mk' S a m) = IsLocalization.mk' (MvPolynomial σ S) (C (σ := σ) a)
      ⟨C m, Submonoid.mem_map_of_mem C m.property⟩ 
Arguments: {σ : Type u_1} {R : Type u_2} [CommRing R] (M : Submonoid R) (S : Type u_3) [CommRing S] [Algebra R S] [IsLocalization M S] (a : R) (m : ↥M)
Goal: MvPolynomial.C (IsLocalization.mk' S a m) =
  IsLocalization.mk' (MvPolynomial σ S) (MvPolynomial.C a) ⟨MvPolynomial.C ↑m, ⋯⟩
-- _private.Mathlib.RingTheory.MvPolynomial.Localization.0.IsLocalization.Away.auxHom_mk
@[simp]
private lemma auxHom_mk (p : MvPolynomial Unit R) :
    auxHom S r p = aeval (S₁ := S) (fun _ ↦ invSelf r) p 
Arguments: {R : Type u_2} [CommRing R] (S : Type u_3) [CommRing S] [Algebra R S] (r : R) [IsLocalization.Away r S] (p : MvPolynomial Unit R)
Goal: (IsLocalization.Away.auxHom S r) ((Ideal.Quotient.mk (Ideal.span {MvPolynomial.C r * MvPolynomial.X () - 1})) p) =
  (MvPolynomial.aeval fun x => IsLocalization.Away.invSelf r) p
-- _private.Mathlib.RingTheory.MvPolynomial.Localization.0.IsLocalization.Away.auxHom_auxInv
private lemma auxHom_auxInv : (auxHom S r).toRingHom.comp (auxInv S r) = RingHom.id S 
Arguments: {R : Type u_2} [CommRing R] (S : Type u_3) [CommRing S] [Algebra R S] (r : R) [IsLocalization.Away r S]
Goal: (IsLocalization.Away.auxHom S r).comp (IsLocalization.Away.auxInv S r) = RingHom.id S
-- _private.Mathlib.RingTheory.MvPolynomial.Localization.0.IsLocalization.Away.auxInv_auxHom
private lemma auxInv_auxHom : (auxInv S r).comp (auxHom (S := S) r).toRingHom = RingHom.id _ 
Arguments: {R : Type u_2} [CommRing R] (S : Type u_3) [CommRing S] [Algebra R S] (r : R) [IsLocalization.Away r S]
Goal: (IsLocalization.Away.auxInv S r).comp (IsLocalization.Away.auxHom S r).toRingHom =
  RingHom.id (MvPolynomial Unit R ⧸ Ideal.span {MvPolynomial.C r * MvPolynomial.X () - 1})
-- IsLocalization.Away.mvPolynomialQuotientEquiv_apply
@[simp]
lemma mvPolynomialQuotientEquiv_apply (p : MvPolynomial Unit R) :
    mvPolynomialQuotientEquiv S r (Ideal.Quotient.mk _ p) = aeval (S₁ := S) (fun _ ↦ invSelf r) p 
Arguments: {R : Type u_2} [CommRing R] (S : Type u_3) [CommRing S] [Algebra R S] (r : R) [IsLocalization.Away r S] (p : MvPolynomial Unit R)
Goal: (IsLocalization.Away.mvPolynomialQuotientEquiv S r)
    ((Ideal.Quotient.mk (Ideal.span {MvPolynomial.C r * MvPolynomial.X () - 1})) p) =
  (MvPolynomial.aeval fun x => IsLocalization.Away.invSelf r) p
-- IsAdjoinRoot.map_surjective
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure IsAdjoinRoot {R : Type u} (S : Type v) [CommSemiring R] [Semiring S] [Algebra R S]
    (f : R[X]) : Type max u v where
  map : R[X] →+* S
  map_surjective : Function.Surjective map
  ker_map : RingHom.ker map = Ideal.span {f}
  algebraMap_eq : algebraMap R S = map.comp Polynomial.C
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {f : R[X]} (self : IsAdjoinRoot S f)
Goal: Function.Surjective ⇑self.map
-- IsAdjoinRoot.algebraMap_eq
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure IsAdjoinRoot {R : Type u} (S : Type v) [CommSemiring R] [Semiring S] [Algebra R S]
    (f : R[X]) : Type max u v where
  map : R[X] →+* S
  map_surjective : Function.Surjective map
  ker_map : RingHom.ker map = Ideal.span {f}
  algebraMap_eq : algebraMap R S = map.comp Polynomial.C
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {f : R[X]} (self : IsAdjoinRoot S f)
Goal: algebraMap R S = self.map.comp Polynomial.C
-- IsAdjoinRoot.ker_map
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure IsAdjoinRoot {R : Type u} (S : Type v) [CommSemiring R] [Semiring S] [Algebra R S]
    (f : R[X]) : Type max u v where
  map : R[X] →+* S
  map_surjective : Function.Surjective map
  ker_map : RingHom.ker map = Ideal.span {f}
  algebraMap_eq : algebraMap R S = map.comp Polynomial.C
Arguments: {R : Type u} {S : Type v} [CommSemiring R] [Semiring S] [Algebra R S] {f : R[X]} (self : IsAdjoinRoot S f)
Goal: RingHom.ker self.map = Ideal.span {f}