ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- OrderMonoidWithZeroHom.coe_mul
@[simp]
theorem coe_mul (f g : α →*₀o β) : ⇑(f * g) = f * g 
Arguments: {α : Type u_2} {β : Type u_3} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] (f g : α →*₀o β)
Goal: ⇑(f * g) = ⇑f * ⇑g
-- OrderMonoidWithZeroHom.mul_apply
@[simp]
theorem mul_apply (f g : α →*₀o β) (a : α) : (f * g) a = f a * g a 
Arguments: {α : Type u_2} {β : Type u_3} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] (f g : α →*₀o β) (a : α)
Goal: (f * g) a = f a * g a
-- OrderMonoidWithZeroHom.mul_comp
theorem mul_comp (g₁ g₂ : β →*₀o γ) (f : α →*₀o β) : (g₁ * g₂).comp f = g₁.comp f * g₂.comp f 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] [LinearOrderedCommMonoidWithZero γ] (g₁ g₂ : β →*₀o γ) (f : α →*₀o β)
Goal: (g₁ * g₂).comp f = g₁.comp f * g₂.comp f
-- OrderMonoidWithZeroHom.comp_mul
theorem comp_mul (g : β →*₀o γ) (f₁ f₂ : α →*₀o β) : g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] [LinearOrderedCommMonoidWithZero γ] (g : β →*₀o γ) (f₁ f₂ : α →*₀o β)
Goal: g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂
-- OrderMonoidWithZeroHom.toMonoidWithZeroHom_eq_coe
@[simp]
theorem toMonoidWithZeroHom_eq_coe (f : α →*₀o β) : f.toMonoidWithZeroHom = f 
Arguments: {α : Type u_2} {β : Type u_3} {hα : Preorder α} {hα' : MulZeroOneClass α} {hβ : Preorder β} {hβ' : MulZeroOneClass β} (f : α →*₀o β)
Goal: f.toMonoidWithZeroHom = ↑f
-- OrderMonoidWithZeroHom.toOrderMonoidHom_eq_coe
@[simp]
theorem toOrderMonoidHom_eq_coe (f : α →*₀o β) : f.toOrderMonoidHom = f 
Arguments: {α : Type u_2} {β : Type u_3} {hα : Preorder α} {hα' : MulZeroOneClass α} {hβ : Preorder β} {hβ' : MulZeroOneClass β} (f : α →*₀o β)
Goal: f.toOrderMonoidHom = ↑f
-- LaurentPolynomial.ext
@[ext]
theorem LaurentPolynomial.ext [Semiring R] {p q : R[T;T⁻¹]} (h : ∀ a, p a = q a) : p = q 
Arguments: {R : Type u_1} [Semiring R] {p q : R[T;T⁻¹]} (h : ∀ (a : ℤ), p a = q a)
Goal: p = q
-- Polynomial.toLaurent_apply
theorem Polynomial.toLaurent_apply [Semiring R] (p : R[X]) :
    toLaurent p = p.toFinsupp.mapDomain (↑) 
Arguments: {R : Type u_1} [Semiring R] (p : R[X])
Goal: Polynomial.toLaurent p = AddMonoidAlgebra.mapDomain Nat.cast p.toFinsupp
-- Polynomial.coe_toLaurentAlg
@[simp] lemma Polynomial.coe_toLaurentAlg [CommSemiring R] :
    (toLaurentAlg : R[X] → R[T;T⁻¹]) = toLaurent 
Arguments: {R : Type u_1} [CommSemiring R]
Goal: ⇑Polynomial.toLaurentAlg = ⇑Polynomial.toLaurent
-- Polynomial.toLaurentAlg_apply
theorem Polynomial.toLaurentAlg_apply [CommSemiring R] (f : R[X]) : toLaurentAlg f = toLaurent f 
Arguments: {R : Type u_1} [CommSemiring R] (f : R[X])
Goal: Polynomial.toLaurentAlg f = Polynomial.toLaurent f
-- LaurentPolynomial.single_zero_one_eq_one
theorem single_zero_one_eq_one : (Finsupp.single 0 1 : R[T;T⁻¹]) = (1 : R[T;T⁻¹]) 
Arguments: {R : Type u_1} [Semiring R]
Goal: Finsupp.single 0 1 = 1
-- LaurentPolynomial.algebraMap_apply
theorem algebraMap_apply {R A : Type*} [CommSemiring R] [Semiring A] [Algebra R A] (r : R) :
    algebraMap R (LaurentPolynomial A) r = C (algebraMap R A r) 
Arguments: {R : Type u_2} {A : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] (r : R)
Goal: (algebraMap R A[T;T⁻¹]) r = LaurentPolynomial.C ((algebraMap R A) r)
-- LaurentPolynomial.C_eq_algebraMap
theorem C_eq_algebraMap {R : Type*} [CommSemiring R] (r : R) : C r = algebraMap R R[T;T⁻¹] r 
Arguments: {R : Type u_2} [CommSemiring R] (r : R)
Goal: LaurentPolynomial.C r = (algebraMap R R[T;T⁻¹]) r
-- LaurentPolynomial.single_eq_C
theorem single_eq_C (r : R) : Finsupp.single 0 r = C r 
Arguments: {R : Type u_1} [Semiring R] (r : R)
Goal: Finsupp.single 0 r = LaurentPolynomial.C r
-- LaurentPolynomial.C_apply
@[simp] lemma C_apply (t : R) (n : ℤ) : C t n = if n = 0 then t else 0 
Arguments: {R : Type u_1} [Semiring R] (t : R) (n : ℤ)
Goal: (LaurentPolynomial.C t) n = if n = 0 then t else 0
-- LaurentPolynomial.T_apply
@[simp] lemma T_apply (m n : ℤ) : (T n : R[T;T⁻¹]) m = if n = m then 1 else 0 
Arguments: {R : Type u_1} [Semiring R] (m n : ℤ)
Goal: (LaurentPolynomial.T n) m = if n = m then 1 else 0
-- LaurentPolynomial.T_zero
@[simp]
theorem T_zero : (T 0 : R[T;T⁻¹]) = 1 
Arguments: {R : Type u_1} [Semiring R]
Goal: LaurentPolynomial.T 0 = 1
-- LaurentPolynomial.T_add
theorem T_add (m n : ℤ) : (T (m + n) : R[T;T⁻¹]) = T m * T n 
Arguments: {R : Type u_1} [Semiring R] (m n : ℤ)
Goal: LaurentPolynomial.T (m + n) = LaurentPolynomial.T m * LaurentPolynomial.T n
-- LaurentPolynomial.T_sub
theorem T_sub (m n : ℤ) : (T (m - n) : R[T;T⁻¹]) = T m * T (-n) 
Arguments: {R : Type u_1} [Semiring R] (m n : ℤ)
Goal: LaurentPolynomial.T (m - n) = LaurentPolynomial.T m * LaurentPolynomial.T (-n)
-- LaurentPolynomial.T_pow
@[simp]
theorem T_pow (m : ℤ) (n : ℕ) : (T m ^ n : R[T;T⁻¹]) = T (n * m) 
Arguments: {R : Type u_1} [Semiring R] (m : ℤ) (n : ℕ)
Goal: LaurentPolynomial.T m ^ n = LaurentPolynomial.T (↑n * m)
-- LaurentPolynomial.mul_T_assoc
@[simp]
theorem mul_T_assoc (f : R[T;T⁻¹]) (m n : ℤ) : f * T m * T n = f * T (m + n) 
Arguments: {R : Type u_1} [Semiring R] (f : R[T;T⁻¹]) (m n : ℤ)
Goal: f * LaurentPolynomial.T m * LaurentPolynomial.T n = f * LaurentPolynomial.T (m + n)
-- LaurentPolynomial.single_eq_C_mul_T
@[simp]
theorem single_eq_C_mul_T (r : R) (n : ℤ) :
    (Finsupp.single n r : R[T;T⁻¹]) = (C r * T n : R[T;T⁻¹]) 
Arguments: {R : Type u_1} [Semiring R] (r : R) (n : ℤ)
Goal: Finsupp.single n r = LaurentPolynomial.C r * LaurentPolynomial.T n
-- Polynomial.toLaurent_C_mul_T
@[simp]
theorem _root_.Polynomial.toLaurent_C_mul_T (n : ℕ) (r : R) :
    (toLaurent (Polynomial.monomial n r) : R[T;T⁻¹]) = C r * T n 
Arguments: {R : Type u_1} [Semiring R] (n : ℕ) (r : R)
Goal: Polynomial.toLaurent ((Polynomial.monomial n) r) = LaurentPolynomial.C r * LaurentPolynomial.T ↑n
-- Polynomial.toLaurent_C
@[simp]
theorem _root_.Polynomial.toLaurent_C (r : R) : toLaurent (Polynomial.C r) = C r 
Arguments: {R : Type u_1} [Semiring R] (r : R)
Goal: Polynomial.toLaurent (Polynomial.C r) = LaurentPolynomial.C r
-- Polynomial.toLaurent_comp_C
@[simp]
theorem _root_.Polynomial.toLaurent_comp_C : toLaurent (R := R) ∘ Polynomial.C = C 
Arguments: {R : Type u_1} [Semiring R]
Goal: ⇑Polynomial.toLaurent ∘ ⇑Polynomial.C = ⇑LaurentPolynomial.C
-- Polynomial.toLaurent_X
@[simp]
theorem _root_.Polynomial.toLaurent_X : (toLaurent Polynomial.X : R[T;T⁻¹]) = T 1 
Arguments: {R : Type u_1} [Semiring R]
Goal: Polynomial.toLaurent Polynomial.X = LaurentPolynomial.T 1
-- Polynomial.toLaurent_one
theorem _root_.Polynomial.toLaurent_one : (Polynomial.toLaurent : R[X] → R[T;T⁻¹]) 1 = 1 
Arguments: {R : Type u_1} [Semiring R]
Goal: Polynomial.toLaurent 1 = 1
-- Polynomial.toLaurent_C_mul_eq
theorem _root_.Polynomial.toLaurent_C_mul_eq (r : R) (f : R[X]) :
    toLaurent (Polynomial.C r * f) = C r * toLaurent f 
Arguments: {R : Type u_1} [Semiring R] (r : R) (f : R[X])
Goal: Polynomial.toLaurent (Polynomial.C r * f) = LaurentPolynomial.C r * Polynomial.toLaurent f
-- Polynomial.toLaurent_X_pow
theorem _root_.Polynomial.toLaurent_X_pow (n : ℕ) : toLaurent (X ^ n : R[X]) = T n 
Arguments: {R : Type u_1} [Semiring R] (n : ℕ)
Goal: Polynomial.toLaurent (Polynomial.X ^ n) = LaurentPolynomial.T ↑n
-- Polynomial.toLaurent_C_mul_X_pow
theorem _root_.Polynomial.toLaurent_C_mul_X_pow (n : ℕ) (r : R) :
    toLaurent (Polynomial.C r * X ^ n) = C r * T n 
Arguments: {R : Type u_1} [Semiring R] (n : ℕ) (r : R)
Goal: Polynomial.toLaurent (Polynomial.C r * Polynomial.X ^ n) = LaurentPolynomial.C r * LaurentPolynomial.T ↑n
-- LaurentPolynomial.invOf_T
@[simp]
theorem invOf_T (n : ℤ) : ⅟ (T n : R[T;T⁻¹]) = T (-n) 
Arguments: {R : Type u_1} [Semiring R] (n : ℤ)
Goal: ⅟(LaurentPolynomial.T n) = LaurentPolynomial.T (-n)
-- LaurentPolynomial.isUnit_T
theorem isUnit_T (n : ℤ) : IsUnit (T n : R[T;T⁻¹]) 
Arguments: {R : Type u_1} [Semiring R] (n : ℤ)
Goal: IsUnit (LaurentPolynomial.T n)
-- LaurentPolynomial.induction_on
@[elab_as_elim]
protected theorem induction_on {M : R[T;T⁻¹] → Prop} (p : R[T;T⁻¹]) (h_C : ∀ a, M (C a))
    (h_add : ∀ {p q}, M p → M q → M (p + q))
    (h_C_mul_T : ∀ (n : ℕ) (a : R), M (C a * T n) → M (C a * T (n + 1)))
    (h_C_mul_T_Z : ∀ (n : ℕ) (a : R), M (C a * T (-n)) → M (C a * T (-n - 1))) : M p 
Arguments: {R : Type u_1} [Semiring R] {M : R[T;T⁻¹] → Prop} (p : R[T;T⁻¹]) (h_C : ∀ (a : R), M (LaurentPolynomial.C a)) (h_add : ∀ {p q : R[T;T⁻¹]}, M p → M q → M (p + q)) (h_C_mul_T :
  ∀ (n : ℕ) (a : R),
    M (LaurentPolynomial.C a * LaurentPolynomial.T ↑n) → M (LaurentPolynomial.C a * LaurentPolynomial.T (↑n + 1))) (h_C_mul_T_Z :
  ∀ (n : ℕ) (a : R),
    M (LaurentPolynomial.C a * LaurentPolynomial.T (-↑n)) → M (LaurentPolynomial.C a * LaurentPolynomial.T (-↑n - 1)))
Goal: M p
-- LaurentPolynomial.induction_on'
@[elab_as_elim]
protected theorem induction_on' {M : R[T;T⁻¹] → Prop} (p : R[T;T⁻¹])
    (h_add : ∀ p q, M p → M q → M (p + q)) (h_C_mul_T : ∀ (n : ℤ) (a : R), M (C a * T n)) :
    M p 
Arguments: {R : Type u_1} [Semiring R] {M : R[T;T⁻¹] → Prop} (p : R[T;T⁻¹]) (h_add : ∀ (p q : R[T;T⁻¹]), M p → M q → M (p + q)) (h_C_mul_T : ∀ (n : ℤ) (a : R), M (LaurentPolynomial.C a * LaurentPolynomial.T n))
Goal: M p
-- LaurentPolynomial.commute_T
theorem commute_T (n : ℤ) (f : R[T;T⁻¹]) : Commute (T n) f 
Arguments: {R : Type u_1} [Semiring R] (n : ℤ) (f : R[T;T⁻¹])
Goal: Commute (LaurentPolynomial.T n) f
-- LaurentPolynomial.T_mul
@[simp]
theorem T_mul (n : ℤ) (f : R[T;T⁻¹]) : T n * f = f * T n 
Arguments: {R : Type u_1} [Semiring R] (n : ℤ) (f : R[T;T⁻¹])
Goal: LaurentPolynomial.T n * f = f * LaurentPolynomial.T n
-- LaurentPolynomial.trunc_C_mul_T
@[simp]
theorem trunc_C_mul_T (n : ℤ) (r : R) : trunc (C r * T n) = ite (0 ≤ n) (monomial n.toNat r) 0 
Arguments: {R : Type u_1} [Semiring R] (n : ℤ) (r : R)
Goal: LaurentPolynomial.trunc (LaurentPolynomial.C r * LaurentPolynomial.T n) =
  if 0 ≤ n then (Polynomial.monomial n.toNat) r else 0
-- LaurentPolynomial.leftInverse_trunc_toLaurent
@[simp]
theorem leftInverse_trunc_toLaurent :
    Function.LeftInverse (trunc : R[T;T⁻¹] → R[X]) Polynomial.toLaurent 
Arguments: {R : Type u_1} [Semiring R]
Goal: Function.LeftInverse ⇑LaurentPolynomial.trunc ⇑Polynomial.toLaurent
-- Polynomial.trunc_toLaurent
@[simp]
theorem _root_.Polynomial.trunc_toLaurent (f : R[X]) : trunc (toLaurent f) = f 
Arguments: {R : Type u_1} [Semiring R] (f : R[X])
Goal: LaurentPolynomial.trunc (Polynomial.toLaurent f) = f
-- Polynomial.toLaurent_injective
theorem _root_.Polynomial.toLaurent_injective :
    Function.Injective (Polynomial.toLaurent : R[X] → R[T;T⁻¹]) 
Arguments: {R : Type u_1} [Semiring R]
Goal: Function.Injective ⇑Polynomial.toLaurent
-- Polynomial.toLaurent_inj
@[simp]
theorem _root_.Polynomial.toLaurent_inj (f g : R[X]) : toLaurent f = toLaurent g ↔ f = g 
Arguments: {R : Type u_1} [Semiring R] (f g : R[X])
Goal: Polynomial.toLaurent f = Polynomial.toLaurent g ↔ f = g
-- Polynomial.toLaurent_ne_zero
theorem _root_.Polynomial.toLaurent_ne_zero {f : R[X]} : f ≠ 0 ↔ toLaurent f ≠ 0 
Arguments: {R : Type u_1} [Semiring R] {f : R[X]}
Goal: f ≠ 0 ↔ Polynomial.toLaurent f ≠ 0
-- LaurentPolynomial.exists_T_pow
theorem exists_T_pow (f : R[T;T⁻¹]) : ∃ (n : ℕ) (f' : R[X]), toLaurent f' = f * T n 
Arguments: {R : Type u_1} [Semiring R] (f : R[T;T⁻¹])
Goal: ∃ n f', Polynomial.toLaurent f' = f * LaurentPolynomial.T ↑n
-- LaurentPolynomial.induction_on_mul_T
@[elab_as_elim]
theorem induction_on_mul_T {Q : R[T;T⁻¹] → Prop} (f : R[T;T⁻¹])
    (Qf : ∀ {f : R[X]} {n : ℕ}, Q (toLaurent f * T (-n))) : Q f 
Arguments: {R : Type u_1} [Semiring R] {Q : R[T;T⁻¹] → Prop} (f : R[T;T⁻¹]) (Qf : ∀ {f : R[X]} {n : ℕ}, Q (Polynomial.toLaurent f * LaurentPolynomial.T (-↑n)))
Goal: Q f
-- LaurentPolynomial.reduce_to_polynomial_of_mul_T
theorem reduce_to_polynomial_of_mul_T (f : R[T;T⁻¹]) {Q : R[T;T⁻¹] → Prop}
    (Qf : ∀ f : R[X], Q (toLaurent f)) (QT : ∀ f, Q (f * T 1) → Q f) : Q f 
Arguments: {R : Type u_1} [Semiring R] (f : R[T;T⁻¹]) {Q : R[T;T⁻¹] → Prop} (Qf : ∀ (f : R[X]), Q (Polynomial.toLaurent f)) (QT : ∀ (f : R[T;T⁻¹]), Q (f * LaurentPolynomial.T 1) → Q f)
Goal: Q f
-- LaurentPolynomial.support_C_mul_T
theorem support_C_mul_T (a : R) (n : ℤ) : Finsupp.support (C a * T n) ⊆ {n} 
Arguments: {R : Type u_1} [Semiring R] (a : R) (n : ℤ)
Goal: (LaurentPolynomial.C a * LaurentPolynomial.T n).support ⊆ {n}
-- LaurentPolynomial.support_C_mul_T_of_ne_zero
theorem support_C_mul_T_of_ne_zero {a : R} (a0 : a ≠ 0) (n : ℤ) :
    Finsupp.support (C a * T n) = {n} 
Arguments: {R : Type u_1} [Semiring R] {a : R} (a0 : a ≠ 0) (n : ℤ)
Goal: (LaurentPolynomial.C a * LaurentPolynomial.T n).support = {n}
-- LaurentPolynomial.toLaurent_support
theorem toLaurent_support (f : R[X]) : f.toLaurent.support = f.support.map Nat.castEmbedding 
Arguments: {R : Type u_1} [Semiring R] (f : R[X])
Goal: (Polynomial.toLaurent f).support = Finset.map Nat.castEmbedding f.support
-- LaurentPolynomial.degree_zero
@[simp]
theorem degree_zero : degree (0 : R[T;T⁻¹]) = ⊥ 
Arguments: {R : Type u_1} [Semiring R]
Goal: LaurentPolynomial.degree 0 = ⊥
-- LaurentPolynomial.degree_eq_bot_iff
@[simp]
theorem degree_eq_bot_iff {f : R[T;T⁻¹]} : f.degree = ⊥ ↔ f = 0 
Arguments: {R : Type u_1} [Semiring R] {f : R[T;T⁻¹]}
Goal: f.degree = ⊥ ↔ f = 0
-- LaurentPolynomial.degree_C_mul_T
@[simp]
theorem degree_C_mul_T (n : ℤ) (a : R) (a0 : a ≠ 0) : degree (C a * T n) = n 
Arguments: {R : Type u_1} [Semiring R] (n : ℤ) (a : R) (a0 : a ≠ 0)
Goal: (LaurentPolynomial.C a * LaurentPolynomial.T n).degree = ↑n
-- LaurentPolynomial.degree_C_mul_T_ite
theorem degree_C_mul_T_ite [DecidableEq R] (n : ℤ) (a : R) :
    degree (C a * T n) = if a = 0 then ⊥ else ↑n 
Arguments: {R : Type u_1} [Semiring R] [DecidableEq R] (n : ℤ) (a : R)
Goal: (LaurentPolynomial.C a * LaurentPolynomial.T n).degree = if a = 0 then ⊥ else ↑n
-- LaurentPolynomial.degree_T
@[simp]
theorem degree_T [Nontrivial R] (n : ℤ) : (T n : R[T;T⁻¹]).degree = n 
Arguments: {R : Type u_1} [Semiring R] [Nontrivial R] (n : ℤ)
Goal: (LaurentPolynomial.T n).degree = ↑n
-- LaurentPolynomial.degree_C
theorem degree_C {a : R} (a0 : a ≠ 0) : (C a).degree = 0 
Arguments: {R : Type u_1} [Semiring R] {a : R} (a0 : a ≠ 0)
Goal: (LaurentPolynomial.C a).degree = 0
-- LaurentPolynomial.degree_C_ite
theorem degree_C_ite [DecidableEq R] (a : R) : (C a).degree = if a = 0 then ⊥ else 0 
Arguments: {R : Type u_1} [Semiring R] [DecidableEq R] (a : R)
Goal: (LaurentPolynomial.C a).degree = if a = 0 then ⊥ else 0
-- LaurentPolynomial.degree_C_mul_T_le
theorem degree_C_mul_T_le (n : ℤ) (a : R) : degree (C a * T n) ≤ n 
Arguments: {R : Type u_1} [Semiring R] (n : ℤ) (a : R)
Goal: (LaurentPolynomial.C a * LaurentPolynomial.T n).degree ≤ ↑n
-- LaurentPolynomial.degree_T_le
theorem degree_T_le (n : ℤ) : (T n : R[T;T⁻¹]).degree ≤ n 
Arguments: {R : Type u_1} [Semiring R] (n : ℤ)
Goal: (LaurentPolynomial.T n).degree ≤ ↑n
-- LaurentPolynomial.degree_C_le
theorem degree_C_le (a : R) : (C a).degree ≤ 0 
Arguments: {R : Type u_1} [Semiring R] (a : R)
Goal: (LaurentPolynomial.C a).degree ≤ 0
-- LaurentPolynomial.algebraMap_X_pow
theorem algebraMap_X_pow (n : ℕ) : algebraMap R[X] R[T;T⁻¹] (X ^ n) = T n 
Arguments: {R : Type u_1} [CommSemiring R] (n : ℕ)
Goal: (algebraMap R[X] R[T;T⁻¹]) (Polynomial.X ^ n) = LaurentPolynomial.T ↑n
-- LaurentPolynomial.algebraMap_eq_toLaurent
@[simp]
theorem algebraMap_eq_toLaurent (f : R[X]) : algebraMap R[X] R[T;T⁻¹] f = toLaurent f 
Arguments: {R : Type u_1} [CommSemiring R] (f : R[X])
Goal: (algebraMap R[X] R[T;T⁻¹]) f = Polynomial.toLaurent f
-- LaurentPolynomial.isLocalization
theorem isLocalization : IsLocalization (Submonoid.closure ({X} : Set R[X])) R[T;T⁻¹] 
Arguments: {R : Type u_1} [CommSemiring R]
Goal: IsLocalization (Submonoid.closure {Polynomial.X}) R[T;T⁻¹]
-- LaurentPolynomial.invert_T
@[simp] lemma invert_T (n : ℤ) : invert (T n : R[T;T⁻¹]) = T (-n) 
Arguments: {R : Type u_2} [CommSemiring R] (n : ℤ)
Goal: LaurentPolynomial.invert (LaurentPolynomial.T n) = LaurentPolynomial.T (-n)
-- LaurentPolynomial.invert_apply
@[simp] lemma invert_apply (f : R[T;T⁻¹]) (n : ℤ) : invert f n = f (-n) 
Arguments: {R : Type u_2} [CommSemiring R] (f : R[T;T⁻¹]) (n : ℤ)
Goal: (LaurentPolynomial.invert f) n = f (-n)
-- LaurentPolynomial.invert_comp_C
@[simp] lemma invert_comp_C : invert ∘ (@C R _) = C 
Arguments: {R : Type u_2} [CommSemiring R]
Goal: ⇑LaurentPolynomial.invert ∘ ⇑LaurentPolynomial.C = ⇑LaurentPolynomial.C
-- LaurentPolynomial.invert_C
@[simp] lemma invert_C (t : R) : invert (C t) = C t 
Arguments: {R : Type u_2} [CommSemiring R] (t : R)
Goal: LaurentPolynomial.invert (LaurentPolynomial.C t) = LaurentPolynomial.C t
-- LaurentPolynomial.involutive_invert
lemma involutive_invert : Involutive (invert (R := R)) 
Arguments: {R : Type u_2} [CommSemiring R]
Goal: Function.Involutive ⇑LaurentPolynomial.invert
-- LaurentPolynomial.invert_symm
@[simp] lemma invert_symm : (invert (R := R)).symm = invert 
Arguments: {R : Type u_2} [CommSemiring R]
Goal: LaurentPolynomial.invert.symm = LaurentPolynomial.invert
-- LaurentPolynomial.toLaurent_reverse
lemma toLaurent_reverse (p : R[X]) :
    toLaurent p.reverse = invert (toLaurent p) * (T p.natDegree) 
Arguments: {R : Type u_2} [CommSemiring R] (p : R[X])
Goal: Polynomial.toLaurent p.reverse = LaurentPolynomial.invert (Polynomial.toLaurent p) * LaurentPolynomial.T ↑p.natDegree
-- PolynomialModule.zero_apply
theorem zero_apply (i : ℕ) : (0 : PolynomialModule R M) i = 0 
Arguments: (R : Type u_1) {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (i : ℕ)
Goal: 0 i = 0
-- PolynomialModule.add_apply
theorem add_apply (g₁ g₂ : PolynomialModule R M) (a : ℕ) : (g₁ + g₂) a = g₁ a + g₂ a 
Arguments: (R : Type u_1) {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (g₁ g₂ : PolynomialModule R M) (a : ℕ)
Goal: (g₁ + g₂) a = g₁ a + g₂ a
-- PolynomialModule.single_apply
theorem single_apply (i : ℕ) (m : M) (n : ℕ) : single R i m n = ite (i = n) m 0 
Arguments: (R : Type u_1) {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (i : ℕ) (m : M) (n : ℕ)
Goal: ((PolynomialModule.single R i) m) n = if i = n then m else 0
-- PolynomialModule.lsingle_apply
theorem lsingle_apply (i : ℕ) (m : M) (n : ℕ) : lsingle R i m n = ite (i = n) m 0 
Arguments: (R : Type u_1) {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (i : ℕ) (m : M) (n : ℕ)
Goal: ((PolynomialModule.lsingle R i) m) n = if i = n then m else 0
-- PolynomialModule.single_smul
theorem single_smul (i : ℕ) (r : R) (m : M) : single R i (r • m) = r • single R i m 
Arguments: (R : Type u_1) {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (i : ℕ) (r : R) (m : M)
Goal: (PolynomialModule.single R i) (r • m) = r • (PolynomialModule.single R i) m
-- PolynomialModule.induction_linear
theorem induction_linear {P : PolynomialModule R M → Prop} (f : PolynomialModule R M) (h0 : P 0)
    (hadd : ∀ f g, P f → P g → P (f + g)) (hsingle : ∀ a b, P (single R a b)) : P f 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] {P : PolynomialModule R M → Prop} (f : PolynomialModule R M) (h0 : P 0) (hadd : ∀ (f g : PolynomialModule R M), P f → P g → P (f + g)) (hsingle : ∀ (a : ℕ) (b : M), P ((PolynomialModule.single R a) b))
Goal: P f
-- PolynomialModule.smul_def
lemma smul_def (f : R[X]) (m : PolynomialModule R M) :
    f • m = aeval (Finsupp.lmapDomain M R Nat.succ) f m 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (f : R[X]) (m : PolynomialModule R M)
Goal: f • m = ((Polynomial.aeval (Finsupp.lmapDomain M R Nat.succ)) f) m
-- PolynomialModule.monomial_smul_single
@[simp]
theorem monomial_smul_single (i : ℕ) (r : R) (j : ℕ) (m : M) :
    monomial i r • single R j m = single R (i + j) (r • m) 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (i : ℕ) (r : R) (j : ℕ) (m : M)
Goal: (Polynomial.monomial i) r • (PolynomialModule.single R j) m = (PolynomialModule.single R (i + j)) (r • m)
-- PolynomialModule.monomial_smul_apply
@[simp]
theorem monomial_smul_apply (i : ℕ) (r : R) (g : PolynomialModule R M) (n : ℕ) :
    (monomial i r • g) n = ite (i ≤ n) (r • g (n - i)) 0 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (i : ℕ) (r : R) (g : PolynomialModule R M) (n : ℕ)
Goal: ((Polynomial.monomial i) r • g) n = if i ≤ n then r • g (n - i) else 0
-- PolynomialModule.smul_single_apply
@[simp]
theorem smul_single_apply (i : ℕ) (f : R[X]) (m : M) (n : ℕ) :
    (f • single R i m) n = ite (i ≤ n) (f.coeff (n - i) • m) 0 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (i : ℕ) (f : R[X]) (m : M) (n : ℕ)
Goal: (f • (PolynomialModule.single R i) m) n = if i ≤ n then f.coeff (n - i) • m else 0
-- PolynomialModule.smul_apply
theorem smul_apply (f : R[X]) (g : PolynomialModule R M) (n : ℕ) :
    (f • g) n = ∑ x ∈ Finset.antidiagonal n, f.coeff x.1 • g x.2 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (f : R[X]) (g : PolynomialModule R M) (n : ℕ)
Goal: (f • g) n = ∑ x ∈ Finset.antidiagonal n, f.coeff x.1 • g x.2
-- PolynomialModule.equivPolynomialSelf_apply_eq
@[simp]
lemma equivPolynomialSelf_apply_eq (p : PolynomialModule R R) :
    equivPolynomialSelf p = equivPolynomial p 
Arguments: {R : Type u_1} [CommRing R] (p : PolynomialModule R R)
Goal: PolynomialModule.equivPolynomialSelf p = PolynomialModule.equivPolynomial p
-- PolynomialModule.equivPolynomial_single
@[simp]
lemma equivPolynomial_single {S : Type*} [CommRing S] [Algebra R S] (n : ℕ) (x : S) :
    equivPolynomial (single R n x) = monomial n x 
Arguments: {R : Type u_1} [CommRing R] {S : Type u_4} [CommRing S] [Algebra R S] (n : ℕ) (x : S)
Goal: PolynomialModule.equivPolynomial ((PolynomialModule.single R n) x) = (Polynomial.monomial n) x
-- PolynomialModule.map_single
@[simp]
theorem map_single (f : M →ₗ[R] M') (i : ℕ) (m : M) : map R' f (single R i m) = single R' i (f m) 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (R' : Type u_4) {M' : Type u_5} [CommRing R'] [AddCommGroup M'] [Module R' M'] [Module R M'] (f : M →ₗ[R] M') (i : ℕ) (m : M)
Goal: (PolynomialModule.map R' f) ((PolynomialModule.single R i) m) = (PolynomialModule.single R' i) (f m)
-- PolynomialModule.map_smul
theorem map_smul (f : M →ₗ[R] M') (p : R[X]) (q : PolynomialModule R M) :
    map R' f (p • q) = p.map (algebraMap R R') • map R' f q 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (R' : Type u_4) {M' : Type u_5} [CommRing R'] [AddCommGroup M'] [Module R' M'] [Algebra R R'] [Module R M'] [IsScalarTower R R' M'] (f : M →ₗ[R] M') (p : R[X]) (q : PolynomialModule R M)
Goal: (PolynomialModule.map R' f) (p • q) = Polynomial.map (algebraMap R R') p • (PolynomialModule.map R' f) q
-- PolynomialModule.eval_apply
@[simps! (config := .lemmasOnly)]
def eval (r : R) : PolynomialModule R M →ₗ[R] M 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (r : R) (p : PolynomialModule R M)
Goal: (PolynomialModule.eval r) p = Finsupp.sum p fun i m => r ^ i • m
-- PolynomialModule.eval_single
@[simp]
theorem eval_single (r : R) (i : ℕ) (m : M) : eval r (single R i m) = r ^ i • m 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (r : R) (i : ℕ) (m : M)
Goal: (PolynomialModule.eval r) ((PolynomialModule.single R i) m) = r ^ i • m
-- PolynomialModule.eval_lsingle
@[simp]
theorem eval_lsingle (r : R) (i : ℕ) (m : M) : eval r (lsingle R i m) = r ^ i • m 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (r : R) (i : ℕ) (m : M)
Goal: (PolynomialModule.eval r) ((PolynomialModule.lsingle R i) m) = r ^ i • m
-- PolynomialModule.eval_smul
theorem eval_smul (p : R[X]) (q : PolynomialModule R M) (r : R) :
    eval r (p • q) = p.eval r • eval r q 
Arguments: {R : Type u_1} {M : Type u_2} [CommRing R] [AddCommGroup M] [Module R M] (p : R[X]) (q : PolynomialModule R M) (r : R)
Goal: (PolynomialModule.eval r) (p • q) = Polynomial.eval r p • (PolynomialModule.eval r) q