ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Derivation.compAlgebraMap_apply
@[simps!]
def compAlgebraMap [Algebra A B] [IsScalarTower R A B] [IsScalarTower A B M]
    (d : Derivation R B M) : Derivation R A M 
Arguments: {R : Type u_1} (A : Type u_2) {B : Type u_3} {M : Type u_4} [CommSemiring R] [CommSemiring A] [CommSemiring B] [AddCommMonoid M] [Algebra R A] [Algebra R B] [Module A M] [Module B M] [Module R M] [Algebra A B] [IsScalarTower R A B] [IsScalarTower A B M] (d : Derivation R B M)
Goal: ∀ (a : A), (Derivation.compAlgebraMap A d) a = d ((algebraMap A B) a)
-- Derivation.coe_restrictScalars
lemma coe_restrictScalars (d : Derivation S A M) : ⇑(d.restrictScalars R) = ⇑d 
Arguments: (R : Type u_1) {A : Type u_2} {M : Type u_4} [CommSemiring R] [CommSemiring A] [AddCommMonoid M] [Algebra R A] [Module A M] [Module R M] {S : Type u_5} [CommSemiring S] [Algebra S A] [Module S M] [LinearMap.CompatibleSMul A M R S] (d : Derivation S A M)
Goal: ⇑(Derivation.restrictScalars R d) = ⇑d
-- Derivation.restrictScalars_apply
@[simp]
lemma restrictScalars_apply (d : Derivation S A M) (x : A) : d.restrictScalars R x = d x 
Arguments: (R : Type u_1) {A : Type u_2} {M : Type u_4} [CommSemiring R] [CommSemiring A] [AddCommMonoid M] [Algebra R A] [Module A M] [Module R M] {S : Type u_5} [CommSemiring S] [Algebra S A] [Module S M] [LinearMap.CompatibleSMul A M R S] (d : Derivation S A M) (x : A)
Goal: (Derivation.restrictScalars R d) x = d x
-- Derivation.coe_mk'
@[simp]
theorem coe_mk' (D : A →ₗ[R] M) (h) : ⇑(mk' D h) = D 
Arguments: {R : Type u_1} [CommSemiring R] {A : Type u_2} [CommSemiring A] [Algebra R A] {M : Type u_3} [AddCancelCommMonoid M] [Module R M] [Module A M] (D : A →ₗ[R] M) (h : ∀ (a b : A), D (a * b) = a • D b + b • D a)
Goal: ⇑(Derivation.mk' D h) = ⇑D
-- Derivation.coe_mk'_linearMap
@[simp]
theorem coe_mk'_linearMap (D : A →ₗ[R] M) (h) : (mk' D h : A →ₗ[R] M) = D 
Arguments: {R : Type u_1} [CommSemiring R] {A : Type u_2} [CommSemiring A] [Algebra R A] {M : Type u_3} [AddCancelCommMonoid M] [Module R M] [Module A M] (D : A →ₗ[R] M) (h : ∀ (a b : A), D (a * b) = a • D b + b • D a)
Goal: ↑(Derivation.mk' D h) = D
-- Derivation.map_neg
protected theorem map_neg : D (-a) = -D a 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D : Derivation R A M) (a : A)
Goal: D (-a) = -D a
-- Derivation.map_sub
protected theorem map_sub : D (a - b) = D a - D b 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D : Derivation R A M) (a b : A)
Goal: D (a - b) = D a - D b
-- Derivation.map_intCast
@[simp]
theorem map_intCast (n : ℤ) : D (n : A) = 0 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D : Derivation R A M) (n : ℤ)
Goal: D ↑n = 0
-- Derivation.leibniz_of_mul_eq_one
theorem leibniz_of_mul_eq_one {a b : A} (h : a * b = 1) : D a = -a ^ 2 • D b 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D : Derivation R A M) {a b : A} (h : a * b = 1)
Goal: D a = -a ^ 2 • D b
-- Derivation.leibniz_invOf
theorem leibniz_invOf [Invertible a] : D (⅟ a) = -⅟ a ^ 2 • D a 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D : Derivation R A M) (a : A) [Invertible a]
Goal: D ⅟a = -⅟a ^ 2 • D a
-- Derivation.leibniz_inv
theorem leibniz_inv (a : K) : D a⁻¹ = -a⁻¹ ^ 2 • D a 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_3} [AddCommGroup M] [Module R M] {K : Type u_4} [Field K] [Module K M] [Algebra R K] (D : Derivation R K M) (a : K)
Goal: D a⁻¹ = -a⁻¹ ^ 2 • D a
-- Derivation.leibniz_div
theorem leibniz_div (a b : K) : D (a / b) = b⁻¹ ^ 2 • (b • D a - a • D b) 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_3} [AddCommGroup M] [Module R M] {K : Type u_4} [Field K] [Module K M] [Algebra R K] (D : Derivation R K M) (a b : K)
Goal: D (a / b) = b⁻¹ ^ 2 • (b • D a - a • D b)
-- Derivation.leibniz_div_const
theorem leibniz_div_const (a b : K) (h : D b = 0) : D (a / b) = b⁻¹ • D a 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_3} [AddCommGroup M] [Module R M] {K : Type u_4} [Field K] [Module K M] [Algebra R K] (D : Derivation R K M) (a b : K) (h : D b = 0)
Goal: D (a / b) = b⁻¹ • D a
-- Derivation.leibniz_zpow
lemma leibniz_zpow (a : K) (n : ℤ) : D (a ^ n) = n • a ^ (n - 1) • D a 
Arguments: {R : Type u_1} [CommRing R] {M : Type u_3} [AddCommGroup M] [Module R M] {K : Type u_4} [Field K] [Module K M] [Algebra R K] (D : Derivation R K M) (a : K) (n : ℤ)
Goal: D (a ^ n) = n • a ^ (n - 1) • D a
-- Derivation.coe_neg
@[simp]
theorem coe_neg (D : Derivation R A M) : ⇑(-D) = -D 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D : Derivation R A M)
Goal: ⇑(-D) = -⇑D
-- Derivation.coe_neg_linearMap
@[simp]
theorem coe_neg_linearMap (D : Derivation R A M) : ↑(-D) = (-D : A →ₗ[R] M) 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D : Derivation R A M)
Goal: ↑(-D) = -↑D
-- Derivation.neg_apply
theorem neg_apply : (-D) a = -D a 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D : Derivation R A M) (a : A)
Goal: (-D) a = -D a
-- Derivation.coe_sub
@[simp]
theorem coe_sub (D1 D2 : Derivation R A M) : ⇑(D1 - D2) = D1 - D2 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D1 D2 : Derivation R A M)
Goal: ⇑(D1 - D2) = ⇑D1 - ⇑D2
-- Derivation.coe_sub_linearMap
@[simp]
theorem coe_sub_linearMap (D1 D2 : Derivation R A M) : ↑(D1 - D2) = (D1 - D2 : A →ₗ[R] M) 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] (D1 D2 : Derivation R A M)
Goal: ↑(D1 - D2) = ↑D1 - ↑D2
-- Derivation.sub_apply
theorem sub_apply : (D1 - D2) a = D1 a - D2 a 
Arguments: {R : Type u_1} [CommRing R] {A : Type u_2} [CommRing A] [Algebra R A] {M : Type u_3} [AddCommGroup M] [Module A M] [Module R M] {D1 D2 : Derivation R A M} (a : A)
Goal: (D1 - D2) a = D1 a - D2 a
-- isLocalRingHom_of_le_jacobson_bot
theorem isLocalRingHom_of_le_jacobson_bot {R : Type*} [CommRing R] (I : Ideal R)
    (h : I ≤ Ideal.jacobson ⊥) : IsLocalRingHom (Ideal.Quotient.mk I) 
Arguments: {R : Type u_1} [CommRing R] (I : Ideal R) (h : I ≤ ⊥.jacobson)
Goal: IsLocalRingHom (Ideal.Quotient.mk I)
-- HenselianRing.jac
class HenselianRing (R : Type*) [CommRing R] (I : Ideal R) : Prop where
  jac : I ≤ Ideal.jacobson ⊥
  is_henselian :
    ∀ (f : R[X]) (_ : f.Monic) (a₀ : R) (_ : f.eval a₀ ∈ I)
      (_ : IsUnit (Ideal.Quotient.mk I (f.derivative.eval a₀))), ∃ a : R, f.IsRoot a ∧ a - a₀ ∈ I
Arguments: {R : Type u_1} [CommRing R] {I : Ideal R} [self : HenselianRing R I]
Goal: I ≤ ⊥.jacobson
-- HenselianRing.is_henselian
class HenselianRing (R : Type*) [CommRing R] (I : Ideal R) : Prop where
  jac : I ≤ Ideal.jacobson ⊥
  is_henselian :
    ∀ (f : R[X]) (_ : f.Monic) (a₀ : R) (_ : f.eval a₀ ∈ I)
      (_ : IsUnit (Ideal.Quotient.mk I (f.derivative.eval a₀))), ∃ a : R, f.IsRoot a ∧ a - a₀ ∈ I
Arguments: {R : Type u_1} [CommRing R] {I : Ideal R} [self : HenselianRing R I] (f : R[X])
Goal: f.Monic →
  ∀ (a₀ : R),
    Polynomial.eval a₀ f ∈ I →
      IsUnit ((Ideal.Quotient.mk I) (Polynomial.eval a₀ (Polynomial.derivative f))) → ∃ a, f.IsRoot a ∧ a - a₀ ∈ I
-- HenselianLocalRing.is_henselian
class HenselianLocalRing (R : Type*) [CommRing R] extends LocalRing R : Prop where
  is_henselian :
    ∀ (f : R[X]) (_ : f.Monic) (a₀ : R) (_ : f.eval a₀ ∈ maximalIdeal R)
      (_ : IsUnit (f.derivative.eval a₀)), ∃ a : R, f.IsRoot a ∧ a - a₀ ∈ maximalIdeal R
Arguments: {R : Type u_1} [CommRing R] [self : HenselianLocalRing R] (f : R[X])
Goal: f.Monic →
  ∀ (a₀ : R),
    Polynomial.eval a₀ f ∈ LocalRing.maximalIdeal R →
      IsUnit (Polynomial.eval a₀ (Polynomial.derivative f)) → ∃ a, f.IsRoot a ∧ a - a₀ ∈ LocalRing.maximalIdeal R
-- HenselianLocalRing.TFAE
theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
    TFAE
      [HenselianLocalRing R,
        ∀ f : R[X], f.Monic → ∀ a₀ : ResidueField R, aeval a₀ f = 0 →
          aeval a₀ (derivative f) ≠ 0 → ∃ a : R, f.IsRoot a ∧ residue R a = a₀,
        ∀ {K : Type u} [Field K],
          ∀ (φ : R →+* K), Surjective φ → ∀ f : R[X], f.Monic → ∀ a₀ : K,
            f.eval₂ φ a₀ = 0 → f.derivative.eval₂ φ a₀ ≠ 0 → ∃ a : R, f.IsRoot a ∧ φ a = a₀] 
Arguments: (R : Type u) [CommRing R] [LocalRing R]
Goal: [HenselianLocalRing R,
    ∀ (f : R[X]),
      f.Monic →
        ∀ (a₀ : LocalRing.ResidueField R),
          (Polynomial.aeval a₀) f = 0 →
            (Polynomial.aeval a₀) (Polynomial.derivative f) ≠ 0 → ∃ a, f.IsRoot a ∧ (LocalRing.residue R) a = a₀,
    ∀ {K : Type u} [inst : Field K] (φ : R →+* K),
      Function.Surjective ⇑φ →
        ∀ (f : R[X]),
          f.Monic →
            ∀ (a₀ : K),
              Polynomial.eval₂ φ a₀ f = 0 →
                Polynomial.eval₂ φ a₀ (Polynomial.derivative f) ≠ 0 → ∃ a, f.IsRoot a ∧ φ a = a₀].TFAE
-- mul_eq_mul_prime_prod
theorem mul_eq_mul_prime_prod {α : Type*} [DecidableEq α] {x y a : R} {s : Finset α} {p : α → R}
    (hp : ∀ i ∈ s, Prime (p i)) (hx : x * y = a * ∏ i ∈ s, p i) :
    ∃ (t u : Finset α) (b c : R),
      t ∪ u = s ∧ Disjoint t u ∧ a = b * c ∧ (x = b * ∏ i ∈ t, p i) ∧ y = c * ∏ i ∈ u, p i 
Arguments: {R : Type u_1} [CancelCommMonoidWithZero R] {α : Type u_2} [DecidableEq α] {x y a : R} {s : Finset α} {p : α → R} (hp : ∀ i ∈ s, Prime (p i)) (hx : x * y = a * ∏ i ∈ s, p i)
Goal: ∃ t u b c, t ∪ u = s ∧ Disjoint t u ∧ a = b * c ∧ x = b * ∏ i ∈ t, p i ∧ y = c * ∏ i ∈ u, p i
-- mul_eq_mul_prime_pow
theorem mul_eq_mul_prime_pow {x y a p : R} {n : ℕ} (hp : Prime p) (hx : x * y = a * p ^ n) :
    ∃ (i j : ℕ) (b c : R), i + j = n ∧ a = b * c ∧ x = b * p ^ i ∧ y = c * p ^ j 
Arguments: {R : Type u_1} [CancelCommMonoidWithZero R] {x y a p : R} {n : ℕ} (hp : Prime p) (hx : x * y = a * p ^ n)
Goal: ∃ i j b c, i + j = n ∧ a = b * c ∧ x = b * p ^ i ∧ y = c * p ^ j
-- Prime.neg
theorem Prime.neg {p : α} (hp : Prime p) : Prime (-p) 
Arguments: {α : Type u_1} [CommRing α] {p : α} (hp : Prime p)
Goal: Prime (-p)
-- Prime.abs
theorem Prime.abs [LinearOrder α] {p : α} (hp : Prime p) : Prime (abs p) 
Arguments: {α : Type u_1} [CommRing α] [LinearOrder α] {p : α} (hp : Prime p)
Goal: Prime |p|
-- AddOreLocalization.AddOreSet.ore_eq
class AddOreSet {R : Type*} [AddMonoid R] (S : AddSubmonoid R) where
    ore_right_cancel : ∀ (r₁ r₂ : R) (s : S), r₁ + s = r₂ + s → ∃ s' : S, s' + r₁ = s' + r₂
    oreMin : R → S → R
    oreSubtra : R → S → S
    ore_eq : ∀ (r : R) (s : S), oreSubtra r s + r = oreMin r s + s
Arguments: {R : Type u_1} [AddMonoid R] {S : AddSubmonoid R} [self : AddOreLocalization.AddOreSet S] (r : R) (s : ↥S)
Goal: ↑(AddOreLocalization.AddOreSet.oreSubtra r s) + r = AddOreLocalization.AddOreSet.oreMin r s + ↑s
-- AddOreLocalization.AddOreSet.ore_right_cancel
class AddOreSet {R : Type*} [AddMonoid R] (S : AddSubmonoid R) where
    ore_right_cancel : ∀ (r₁ r₂ : R) (s : S), r₁ + s = r₂ + s → ∃ s' : S, s' + r₁ = s' + r₂
    oreMin : R → S → R
    oreSubtra : R → S → S
    ore_eq : ∀ (r : R) (s : S), oreSubtra r s + r = oreMin r s + s
Arguments: {R : Type u_1} [AddMonoid R] {S : AddSubmonoid R} [self : AddOreLocalization.AddOreSet S] (r₁ r₂ : R) (s : ↥S)
Goal: r₁ + ↑s = r₂ + ↑s → ∃ s', ↑s' + r₁ = ↑s' + r₂
-- OreLocalization.OreSet.ore_eq
@[to_additive AddOreLocalization.AddOreSet]
class OreSet {R : Type*} [Monoid R] (S : Submonoid R) where
    ore_right_cancel : ∀ (r₁ r₂ : R) (s : S), r₁ * s = r₂ * s → ∃ s' : S, s' * r₁ = s' * r₂
    oreNum : R → S → R
    oreDenom : R → S → S
    ore_eq : ∀ (r : R) (s : S), oreDenom r s * r = oreNum r s * s
Arguments: {R : Type u_1} [Monoid R] {S : Submonoid R} [self : OreLocalization.OreSet S] (r : R) (s : ↥S)
Goal: ↑(OreLocalization.OreSet.oreDenom r s) * r = OreLocalization.OreSet.oreNum r s * ↑s
-- OreLocalization.OreSet.ore_right_cancel
@[to_additive AddOreLocalization.AddOreSet]
class OreSet {R : Type*} [Monoid R] (S : Submonoid R) where
    ore_right_cancel : ∀ (r₁ r₂ : R) (s : S), r₁ * s = r₂ * s → ∃ s' : S, s' * r₁ = s' * r₂
    oreNum : R → S → R
    oreDenom : R → S → S
    ore_eq : ∀ (r : R) (s : S), oreDenom r s * r = oreNum r s * s
Arguments: {R : Type u_1} [Monoid R] {S : Submonoid R} [self : OreLocalization.OreSet S] (r₁ r₂ : R) (s : ↥S)
Goal: r₁ * ↑s = r₂ * ↑s → ∃ s', ↑s' * r₁ = ↑s' * r₂
-- AddOreLocalization.ore_right_cancel
@[to_additive AddOreLocalization.ore_right_cancel]
theorem ore_right_cancel (r₁ r₂ : R) (s : S) (h : r₁ * s = r₂ * s) : ∃ s' : S, s' * r₁ = s' * r₂ 
Arguments: {R : Type u_1} [AddMonoid R] {S : AddSubmonoid R} [AddOreLocalization.AddOreSet S] (r₁ r₂ : R) (s : ↥S) (h : r₁ + ↑s = r₂ + ↑s)
Goal: ∃ s', ↑s' + r₁ = ↑s' + r₂
-- OreLocalization.ore_right_cancel
@[to_additive AddOreLocalization.ore_right_cancel]
theorem ore_right_cancel (r₁ r₂ : R) (s : S) (h : r₁ * s = r₂ * s) : ∃ s' : S, s' * r₁ = s' * r₂ 
Arguments: {R : Type u_1} [Monoid R] {S : Submonoid R} [OreLocalization.OreSet S] (r₁ r₂ : R) (s : ↥S) (h : r₁ * ↑s = r₂ * ↑s)
Goal: ∃ s', ↑s' * r₁ = ↑s' * r₂
-- AddOreLocalization.add_ore_eq
@[to_additive AddOreLocalization.add_ore_eq
  "The Ore condition of a difference, expressed in terms of `oreMin` and `oreSubtra`."]
theorem ore_eq (r : R) (s : S) : oreDenom r s * r = oreNum r s * s 
Arguments: {R : Type u_1} [AddMonoid R] {S : AddSubmonoid R} [AddOreLocalization.AddOreSet S] (r : R) (s : ↥S)
Goal: ↑(AddOreLocalization.oreSubtra r s) + r = AddOreLocalization.oreMin r s + ↑s
-- OreLocalization.ore_eq
@[to_additive AddOreLocalization.add_ore_eq
  "The Ore condition of a difference, expressed in terms of `oreMin` and `oreSubtra`."]
theorem ore_eq (r : R) (s : S) : oreDenom r s * r = oreNum r s * s 
Arguments: {R : Type u_1} [Monoid R] {S : Submonoid R} [OreLocalization.OreSet S] (r : R) (s : ↥S)
Goal: ↑(OreLocalization.oreDenom r s) * r = OreLocalization.oreNum r s * ↑s
-- OreLocalization.nonempty_oreSet_iff
lemma nonempty_oreSet_iff {R : Type*} [Ring R] {S : Submonoid R} :
    Nonempty (OreSet S) ↔ (∀ (r₁ r₂ : R) (s : S), r₁ * s = r₂ * s → ∃ s' : S, s' * r₁ = s' * r₂) ∧
      (∀ (r : R) (s : S), ∃ (r' : R) (s' : S), s' * r = r' * s) 
Arguments: {R : Type u_1} [Ring R] {S : Submonoid R}
Goal: Nonempty (OreLocalization.OreSet S) ↔
  (∀ (r₁ r₂ : R) (s : ↥S), r₁ * ↑s = r₂ * ↑s → ∃ s', ↑s' * r₁ = ↑s' * r₂) ∧
    ∀ (r : R) (s : ↥S), ∃ r' s', ↑s' * r = r' * ↑s
-- OreLocalization.nonempty_oreSet_iff_of_noZeroDivisors
lemma nonempty_oreSet_iff_of_noZeroDivisors {R : Type*} [Ring R] [NoZeroDivisors R]
    {S : Submonoid R} :
    Nonempty (OreSet S) ↔ ∀ (r : R) (s : S), ∃ (r' : R) (s' : S), s' * r = r' * s 
Arguments: {R : Type u_1} [Ring R] [NoZeroDivisors R] {S : Submonoid R}
Goal: Nonempty (OreLocalization.OreSet S) ↔ ∀ (r : R) (s : ↥S), ∃ r' s', ↑s' * r = r' * ↑s
-- PowerBasis.basis_eq_pow
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure PowerBasis (R S : Type*) [CommRing R] [Ring S] [Algebra R S] where
  gen : S
  dim : ℕ
  basis : Basis (Fin dim) R S
  basis_eq_pow : ∀ (i), basis i = gen ^ (i : ℕ)
Arguments: {R : Type u_7} {S : Type u_8} [CommRing R] [Ring S] [Algebra R S] (self : PowerBasis R S) (i : Fin self.dim)
Goal: self.basis i = self.gen ^ ↑i
-- PowerBasis.coe_basis
@[simp]
theorem coe_basis (pb : PowerBasis R S) : ⇑pb.basis = fun i : Fin pb.dim => pb.gen ^ (i : ℕ) 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] (pb : PowerBasis R S)
Goal: ⇑pb.basis = fun i => pb.gen ^ ↑i
-- PowerBasis.finite
theorem finite (pb : PowerBasis R S) : Module.Finite R S 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] (pb : PowerBasis R S)
Goal: Module.Finite R S
-- PowerBasis.finrank
theorem finrank [StrongRankCondition R] (pb : PowerBasis R S) :
    FiniteDimensional.finrank R S = pb.dim 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] [StrongRankCondition R] (pb : PowerBasis R S)
Goal: FiniteDimensional.finrank R S = pb.dim
-- PowerBasis.mem_span_pow'
theorem mem_span_pow' {x y : S} {d : ℕ} :
    y ∈ Submodule.span R (Set.range fun i : Fin d => x ^ (i : ℕ)) ↔
      ∃ f : R[X], f.degree < d ∧ y = aeval x f 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] {x y : S} {d : ℕ}
Goal: y ∈ Submodule.span R (Set.range fun i => x ^ ↑i) ↔ ∃ f, f.degree < ↑d ∧ y = (Polynomial.aeval x) f
-- PowerBasis.mem_span_pow
theorem mem_span_pow {x y : S} {d : ℕ} (hd : d ≠ 0) :
    y ∈ Submodule.span R (Set.range fun i : Fin d => x ^ (i : ℕ)) ↔
      ∃ f : R[X], f.natDegree < d ∧ y = aeval x f 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] {x y : S} {d : ℕ} (hd : d ≠ 0)
Goal: y ∈ Submodule.span R (Set.range fun i => x ^ ↑i) ↔ ∃ f, f.natDegree < d ∧ y = (Polynomial.aeval x) f
-- PowerBasis.dim_ne_zero
theorem dim_ne_zero [Nontrivial S] (pb : PowerBasis R S) : pb.dim ≠ 0 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] [Nontrivial S] (pb : PowerBasis R S)
Goal: pb.dim ≠ 0
-- PowerBasis.dim_pos
theorem dim_pos [Nontrivial S] (pb : PowerBasis R S) : 0 < pb.dim 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] [Nontrivial S] (pb : PowerBasis R S)
Goal: 0 < pb.dim
-- PowerBasis.exists_eq_aeval
theorem exists_eq_aeval [Nontrivial S] (pb : PowerBasis R S) (y : S) :
    ∃ f : R[X], f.natDegree < pb.dim ∧ y = aeval pb.gen f 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] [Nontrivial S] (pb : PowerBasis R S) (y : S)
Goal: ∃ f, f.natDegree < pb.dim ∧ y = (Polynomial.aeval pb.gen) f
-- PowerBasis.exists_eq_aeval'
theorem exists_eq_aeval' (pb : PowerBasis R S) (y : S) : ∃ f : R[X], y = aeval pb.gen f 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] (pb : PowerBasis R S) (y : S)
Goal: ∃ f, y = (Polynomial.aeval pb.gen) f
-- PowerBasis.algHom_ext
theorem algHom_ext {S' : Type*} [Semiring S'] [Algebra R S'] (pb : PowerBasis R S)
    ⦃f g : S →ₐ[R] S'⦄ (h : f pb.gen = g pb.gen) : f = g 
Arguments: {R : Type u_1} {S : Type u_2} [CommRing R] [Ring S] [Algebra R S] {S' : Type u_7} [Semiring S'] [Algebra R S'] (pb : PowerBasis R S) ⦃f g : S →ₐ[R] S'⦄ (h : f pb.gen = g pb.gen)
Goal: f = g
-- PowerBasis.exists_smodEq
theorem exists_smodEq (pb : PowerBasis A B) (b : B) :
    ∃ a, SModEq (Ideal.span ({pb.gen})) b (algebraMap A B a) 
Arguments: {A : Type u_4} {B : Type u_5} [CommRing A] [CommRing B] [Algebra A B] (pb : PowerBasis A B) (b : B)
Goal: ∃ a, b ≡ (algebraMap A B) a [SMOD Ideal.span {pb.gen}]
-- PowerBasis.exists_gen_dvd_sub
theorem exists_gen_dvd_sub (pb : PowerBasis A B) (b : B) : ∃ a, pb.gen ∣ b - algebraMap A B a 
Arguments: {A : Type u_4} {B : Type u_5} [CommRing A] [CommRing B] [Algebra A B] (pb : PowerBasis A B) (b : B)
Goal: ∃ a, pb.gen ∣ b - (algebraMap A B) a
-- PowerBasis.aeval_minpolyGen
theorem aeval_minpolyGen (pb : PowerBasis A S) : aeval pb.gen (minpolyGen pb) = 0 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] (pb : PowerBasis A S)
Goal: (Polynomial.aeval pb.gen) pb.minpolyGen = 0
-- PowerBasis.minpolyGen_monic
theorem minpolyGen_monic (pb : PowerBasis A S) : Monic (minpolyGen pb) 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] (pb : PowerBasis A S)
Goal: pb.minpolyGen.Monic
-- PowerBasis.dim_le_natDegree_of_root
theorem dim_le_natDegree_of_root (pb : PowerBasis A S) {p : A[X]} (ne_zero : p ≠ 0)
    (root : aeval pb.gen p = 0) : pb.dim ≤ p.natDegree 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] (pb : PowerBasis A S) {p : A[X]} (ne_zero : p ≠ 0) (root : (Polynomial.aeval pb.gen) p = 0)
Goal: pb.dim ≤ p.natDegree
-- PowerBasis.dim_le_degree_of_root
theorem dim_le_degree_of_root (h : PowerBasis A S) {p : A[X]} (ne_zero : p ≠ 0)
    (root : aeval h.gen p = 0) : ↑h.dim ≤ p.degree 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] (h : PowerBasis A S) {p : A[X]} (ne_zero : p ≠ 0) (root : (Polynomial.aeval h.gen) p = 0)
Goal: ↑h.dim ≤ p.degree
-- PowerBasis.degree_minpolyGen
theorem degree_minpolyGen [Nontrivial A] (pb : PowerBasis A S) :
    degree (minpolyGen pb) = pb.dim 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] [Nontrivial A] (pb : PowerBasis A S)
Goal: pb.minpolyGen.degree = ↑pb.dim
-- PowerBasis.natDegree_minpolyGen
theorem natDegree_minpolyGen [Nontrivial A] (pb : PowerBasis A S) :
    natDegree (minpolyGen pb) = pb.dim 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] [Nontrivial A] (pb : PowerBasis A S)
Goal: pb.minpolyGen.natDegree = pb.dim
-- PowerBasis.minpolyGen_eq
@[simp]
theorem minpolyGen_eq (pb : PowerBasis A S) : pb.minpolyGen = minpoly A pb.gen 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] (pb : PowerBasis A S)
Goal: pb.minpolyGen = minpoly A pb.gen
-- PowerBasis.isIntegral_gen
theorem isIntegral_gen (pb : PowerBasis A S) : IsIntegral A pb.gen 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] (pb : PowerBasis A S)
Goal: IsIntegral A pb.gen
-- PowerBasis.degree_minpoly
@[simp]
theorem degree_minpoly [Nontrivial A] (pb : PowerBasis A S) :
    degree (minpoly A pb.gen) = pb.dim 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] [Nontrivial A] (pb : PowerBasis A S)
Goal: (minpoly A pb.gen).degree = ↑pb.dim
-- PowerBasis.natDegree_minpoly
@[simp]
theorem natDegree_minpoly [Nontrivial A] (pb : PowerBasis A S) :
    (minpoly A pb.gen).natDegree = pb.dim 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] [Nontrivial A] (pb : PowerBasis A S)
Goal: (minpoly A pb.gen).natDegree = pb.dim
-- PowerBasis.leftMulMatrix
protected theorem leftMulMatrix (pb : PowerBasis A S) : Algebra.leftMulMatrix pb.basis pb.gen =
    @Matrix.of (Fin pb.dim) (Fin pb.dim) _ fun i j =>
      if ↑j + 1 = pb.dim then -pb.minpolyGen.coeff ↑i else if (i : ℕ) = j + 1 then 1 else 0 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] (pb : PowerBasis A S)
Goal: (Algebra.leftMulMatrix pb.basis) pb.gen =
  Matrix.of fun i j => if ↑j + 1 = pb.dim then -pb.minpolyGen.coeff ↑i else if ↑i = ↑j + 1 then 1 else 0
-- PowerBasis.constr_pow_aeval
theorem constr_pow_aeval (pb : PowerBasis A S) {y : S'} (hy : aeval y (minpoly A pb.gen) = 0)
    (f : A[X]) : pb.basis.constr A (fun i => y ^ (i : ℕ)) (aeval pb.gen f) = aeval y f 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] {S' : Type u_7} [Ring S'] [Algebra A S'] (pb : PowerBasis A S) {y : S'} (hy : (Polynomial.aeval y) (minpoly A pb.gen) = 0) (f : A[X])
Goal: ((pb.basis.constr A) fun i => y ^ ↑i) ((Polynomial.aeval pb.gen) f) = (Polynomial.aeval y) f
-- PowerBasis.constr_pow_gen
theorem constr_pow_gen (pb : PowerBasis A S) {y : S'} (hy : aeval y (minpoly A pb.gen) = 0) :
    pb.basis.constr A (fun i => y ^ (i : ℕ)) pb.gen = y 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] {S' : Type u_7} [Ring S'] [Algebra A S'] (pb : PowerBasis A S) {y : S'} (hy : (Polynomial.aeval y) (minpoly A pb.gen) = 0)
Goal: ((pb.basis.constr A) fun i => y ^ ↑i) pb.gen = y
-- PowerBasis.constr_pow_algebraMap
theorem constr_pow_algebraMap (pb : PowerBasis A S) {y : S'} (hy : aeval y (minpoly A pb.gen) = 0)
    (x : A) : pb.basis.constr A (fun i => y ^ (i : ℕ)) (algebraMap A S x) = algebraMap A S' x 
Arguments: {S : Type u_2} [Ring S] {A : Type u_4} [CommRing A] [Algebra A S] {S' : Type u_7} [Ring S'] [Algebra A S'] (pb : PowerBasis A S) {y : S'} (hy : (Polynomial.aeval y) (minpoly A pb.gen) = 0) (x : A)
Goal: ((pb.basis.constr A) fun i => y ^ ↑i) ((algebraMap A S) x) = (algebraMap A S') x