ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AdicCompletion.map_exact
theorem map_exact : Function.Exact (map I f) (map I g) 
Arguments: {R : Type u} [CommRing R] {I : Ideal R} {M : Type u} [AddCommGroup M] [Module R M] {N : Type u} [AddCommGroup N] [Module R N] {P : Type u} [AddCommGroup P] [Module R P] [IsNoetherianRing R] [Module.Finite R N] {f : M →ₗ[R] N} {g : N →ₗ[R] P} (hf : Function.Injective ⇑f) (hfg : Function.Exact ⇑f ⇑g) (hg : Function.Surjective ⇑g)
Goal: Function.Exact ⇑(AdicCompletion.map I f) ⇑(AdicCompletion.map I g)
-- Int.isCoprime_iff_gcd_eq_one
theorem Int.isCoprime_iff_gcd_eq_one {m n : ℤ} : IsCoprime m n ↔ Int.gcd m n = 1 
Arguments: {m n : ℤ}
Goal: IsCoprime m n ↔ m.gcd n = 1
-- Nat.isCoprime_iff_coprime
theorem Nat.isCoprime_iff_coprime {m n : ℕ} : IsCoprime (m : ℤ) n ↔ Nat.Coprime m n 
Arguments: {m n : ℕ}
Goal: IsCoprime ↑m ↑n ↔ m.Coprime n
-- Nat.Coprime.cast
theorem Nat.Coprime.cast {R : Type*} [CommRing R] {a b : ℕ} (h : Nat.Coprime a b) :
    IsCoprime (a : R) (b : R) 
Arguments: {R : Type u_1} [CommRing R] {a b : ℕ} (h : a.Coprime b)
Goal: IsCoprime ↑a ↑b
-- ne_zero_or_ne_zero_of_nat_coprime
theorem ne_zero_or_ne_zero_of_nat_coprime {A : Type u} [CommRing A] [Nontrivial A] {a b : ℕ}
    (h : Nat.Coprime a b) : (a : A) ≠ 0 ∨ (b : A) ≠ 0 
Arguments: {A : Type u} [CommRing A] [Nontrivial A] {a b : ℕ} (h : a.Coprime b)
Goal: ↑a ≠ 0 ∨ ↑b ≠ 0
-- IsCoprime.prod_left
theorem IsCoprime.prod_left : (∀ i ∈ t, IsCoprime (s i) x) → IsCoprime (∏ i ∈ t, s i) x 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {x : R} {s : I → R} {t : Finset I}
Goal: (∀ i ∈ t, IsCoprime (s i) x) → IsCoprime (∏ i ∈ t, s i) x
-- IsCoprime.prod_right
theorem IsCoprime.prod_right : (∀ i ∈ t, IsCoprime x (s i)) → IsCoprime x (∏ i ∈ t, s i) 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {x : R} {s : I → R} {t : Finset I}
Goal: (∀ i ∈ t, IsCoprime x (s i)) → IsCoprime x (∏ i ∈ t, s i)
-- IsCoprime.prod_left_iff
theorem IsCoprime.prod_left_iff : IsCoprime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsCoprime (s i) x 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {x : R} {s : I → R} {t : Finset I}
Goal: IsCoprime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsCoprime (s i) x
-- IsCoprime.prod_right_iff
theorem IsCoprime.prod_right_iff : IsCoprime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, IsCoprime x (s i) 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {x : R} {s : I → R} {t : Finset I}
Goal: IsCoprime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, IsCoprime x (s i)
-- IsCoprime.of_prod_left
theorem IsCoprime.of_prod_left (H1 : IsCoprime (∏ i ∈ t, s i) x) (i : I) (hit : i ∈ t) :
    IsCoprime (s i) x 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {x : R} {s : I → R} {t : Finset I} (H1 : IsCoprime (∏ i ∈ t, s i) x) (i : I) (hit : i ∈ t)
Goal: IsCoprime (s i) x
-- IsCoprime.of_prod_right
theorem IsCoprime.of_prod_right (H1 : IsCoprime x (∏ i ∈ t, s i)) (i : I) (hit : i ∈ t) :
    IsCoprime x (s i) 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {x : R} {s : I → R} {t : Finset I} (H1 : IsCoprime x (∏ i ∈ t, s i)) (i : I) (hit : i ∈ t)
Goal: IsCoprime x (s i)
-- Finset.prod_dvd_of_coprime
theorem Finset.prod_dvd_of_coprime :
    (t : Set I).Pairwise (IsCoprime on s) → (∀ i ∈ t, s i ∣ z) → (∏ x ∈ t, s x) ∣ z 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {z : R} {s : I → R} {t : Finset I}
Goal: (↑t).Pairwise (IsCoprime on s) → (∀ i ∈ t, s i ∣ z) → ∏ x ∈ t, s x ∣ z
-- Fintype.prod_dvd_of_coprime
theorem Fintype.prod_dvd_of_coprime [Fintype I] (Hs : Pairwise (IsCoprime on s))
    (Hs1 : ∀ i, s i ∣ z) : (∏ x, s x) ∣ z 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {z : R} {s : I → R} [Fintype I] (Hs : Pairwise (IsCoprime on s)) (Hs1 : ∀ (i : I), s i ∣ z)
Goal: ∏ x : I, s x ∣ z
-- exists_sum_eq_one_iff_pairwise_coprime
theorem exists_sum_eq_one_iff_pairwise_coprime [DecidableEq I] (h : t.Nonempty) :
    (∃ μ : I → R, (∑ i ∈ t, μ i * ∏ j ∈ t \ {i}, s j) = 1) ↔
      Pairwise (IsCoprime on fun i : t ↦ s i) 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {s : I → R} {t : Finset I} [DecidableEq I] (h : t.Nonempty)
Goal: (∃ μ, ∑ i ∈ t, μ i * ∏ j ∈ t \ {i}, s j = 1) ↔ Pairwise (IsCoprime on fun i => s ↑i)
-- exists_sum_eq_one_iff_pairwise_coprime'
theorem exists_sum_eq_one_iff_pairwise_coprime' [Fintype I] [Nonempty I] [DecidableEq I] :
    (∃ μ : I → R, (∑ i : I, μ i * ∏ j ∈ {i}ᶜ, s j) = 1) ↔ Pairwise (IsCoprime on s) 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {s : I → R} [Fintype I] [Nonempty I] [DecidableEq I]
Goal: (∃ μ, ∑ i : I, μ i * ∏ j ∈ {i}ᶜ, s j = 1) ↔ Pairwise (IsCoprime on s)
-- pairwise_coprime_iff_coprime_prod
theorem pairwise_coprime_iff_coprime_prod [DecidableEq I] :
    Pairwise (IsCoprime on fun i : t ↦ s i) ↔ ∀ i ∈ t, IsCoprime (s i) (∏ j ∈ t \ {i}, s j) 
Arguments: {R : Type u} {I : Type v} [CommSemiring R] {s : I → R} {t : Finset I} [DecidableEq I]
Goal: Pairwise (IsCoprime on fun i => s ↑i) ↔ ∀ i ∈ t, IsCoprime (s i) (∏ j ∈ t \ {i}, s j)
-- IsCoprime.pow_left
theorem IsCoprime.pow_left (H : IsCoprime x y) : IsCoprime (x ^ m) y 
Arguments: {R : Type u} [CommSemiring R] {x y : R} {m : ℕ} (H : IsCoprime x y)
Goal: IsCoprime (x ^ m) y
-- IsCoprime.pow_right
theorem IsCoprime.pow_right (H : IsCoprime x y) : IsCoprime x (y ^ n) 
Arguments: {R : Type u} [CommSemiring R] {x y : R} {n : ℕ} (H : IsCoprime x y)
Goal: IsCoprime x (y ^ n)
-- IsCoprime.pow
theorem IsCoprime.pow (H : IsCoprime x y) : IsCoprime (x ^ m) (y ^ n) 
Arguments: {R : Type u} [CommSemiring R] {x y : R} {m n : ℕ} (H : IsCoprime x y)
Goal: IsCoprime (x ^ m) (y ^ n)
-- IsCoprime.pow_left_iff
theorem IsCoprime.pow_left_iff (hm : 0 < m) : IsCoprime (x ^ m) y ↔ IsCoprime x y 
Arguments: {R : Type u} [CommSemiring R] {x y : R} {m : ℕ} (hm : 0 < m)
Goal: IsCoprime (x ^ m) y ↔ IsCoprime x y
-- IsCoprime.pow_right_iff
theorem IsCoprime.pow_right_iff (hm : 0 < m) : IsCoprime x (y ^ m) ↔ IsCoprime x y 
Arguments: {R : Type u} [CommSemiring R] {x y : R} {m : ℕ} (hm : 0 < m)
Goal: IsCoprime x (y ^ m) ↔ IsCoprime x y
-- IsCoprime.pow_iff
theorem IsCoprime.pow_iff (hm : 0 < m) (hn : 0 < n) : IsCoprime (x ^ m) (y ^ n) ↔ IsCoprime x y 
Arguments: {R : Type u} [CommSemiring R] {x y : R} {m n : ℕ} (hm : 0 < m) (hn : 0 < n)
Goal: IsCoprime (x ^ m) (y ^ n) ↔ IsCoprime x y
-- IsRelPrime.prod_left
theorem IsRelPrime.prod_left : (∀ i ∈ t, IsRelPrime (s i) x) → IsRelPrime (∏ i ∈ t, s i) x 
Arguments: {α : Type u_2} {I : Type u_1} [CommMonoid α] [DecompositionMonoid α] {x : α} {s : I → α} {t : Finset I}
Goal: (∀ i ∈ t, IsRelPrime (s i) x) → IsRelPrime (∏ i ∈ t, s i) x
-- IsRelPrime.prod_right
theorem IsRelPrime.prod_right : (∀ i ∈ t, IsRelPrime x (s i)) → IsRelPrime x (∏ i ∈ t, s i) 
Arguments: {α : Type u_2} {I : Type u_1} [CommMonoid α] [DecompositionMonoid α] {x : α} {s : I → α} {t : Finset I}
Goal: (∀ i ∈ t, IsRelPrime x (s i)) → IsRelPrime x (∏ i ∈ t, s i)
-- IsRelPrime.prod_left_iff
theorem IsRelPrime.prod_left_iff : IsRelPrime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsRelPrime (s i) x 
Arguments: {α : Type u_1} {I : Type u_2} [CommMonoid α] [DecompositionMonoid α] {x : α} {s : I → α} {t : Finset I}
Goal: IsRelPrime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsRelPrime (s i) x
-- IsRelPrime.prod_right_iff
theorem IsRelPrime.prod_right_iff : IsRelPrime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, IsRelPrime x (s i) 
Arguments: {α : Type u_1} {I : Type u_2} [CommMonoid α] [DecompositionMonoid α] {x : α} {s : I → α} {t : Finset I}
Goal: IsRelPrime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, IsRelPrime x (s i)
-- IsRelPrime.of_prod_left
theorem IsRelPrime.of_prod_left (H1 : IsRelPrime (∏ i ∈ t, s i) x) (i : I) (hit : i ∈ t) :
    IsRelPrime (s i) x 
Arguments: {α : Type u_1} {I : Type u_2} [CommMonoid α] [DecompositionMonoid α] {x : α} {s : I → α} {t : Finset I} (H1 : IsRelPrime (∏ i ∈ t, s i) x) (i : I) (hit : i ∈ t)
Goal: IsRelPrime (s i) x
-- IsRelPrime.of_prod_right
theorem IsRelPrime.of_prod_right (H1 : IsRelPrime x (∏ i ∈ t, s i)) (i : I) (hit : i ∈ t) :
    IsRelPrime x (s i) 
Arguments: {α : Type u_1} {I : Type u_2} [CommMonoid α] [DecompositionMonoid α] {x : α} {s : I → α} {t : Finset I} (H1 : IsRelPrime x (∏ i ∈ t, s i)) (i : I) (hit : i ∈ t)
Goal: IsRelPrime x (s i)
-- Finset.prod_dvd_of_isRelPrime
theorem Finset.prod_dvd_of_isRelPrime :
    (t : Set I).Pairwise (IsRelPrime on s) → (∀ i ∈ t, s i ∣ z) → (∏ x ∈ t, s x) ∣ z 
Arguments: {α : Type u_2} {I : Type u_1} [CommMonoid α] [DecompositionMonoid α] {z : α} {s : I → α} {t : Finset I}
Goal: (↑t).Pairwise (IsRelPrime on s) → (∀ i ∈ t, s i ∣ z) → ∏ x ∈ t, s x ∣ z
-- Fintype.prod_dvd_of_isRelPrime
theorem Fintype.prod_dvd_of_isRelPrime [Fintype I] (Hs : Pairwise (IsRelPrime on s))
    (Hs1 : ∀ i, s i ∣ z) : (∏ x, s x) ∣ z 
Arguments: {α : Type u_2} {I : Type u_1} [CommMonoid α] [DecompositionMonoid α] {z : α} {s : I → α} [Fintype I] (Hs : Pairwise (IsRelPrime on s)) (Hs1 : ∀ (i : I), s i ∣ z)
Goal: ∏ x : I, s x ∣ z
-- pairwise_isRelPrime_iff_isRelPrime_prod
theorem pairwise_isRelPrime_iff_isRelPrime_prod [DecidableEq I] :
    Pairwise (IsRelPrime on fun i : t ↦ s i) ↔ ∀ i ∈ t, IsRelPrime (s i) (∏ j ∈ t \ {i}, s j) 
Arguments: {α : Type u_2} {I : Type u_1} [CommMonoid α] [DecompositionMonoid α] {s : I → α} {t : Finset I} [DecidableEq I]
Goal: Pairwise (IsRelPrime on fun i => s ↑i) ↔ ∀ i ∈ t, IsRelPrime (s i) (∏ j ∈ t \ {i}, s j)
-- IsRelPrime.pow_left
theorem pow_left (H : IsRelPrime x y) : IsRelPrime (x ^ m) y 
Arguments: {α : Type u_1} [CommMonoid α] [DecompositionMonoid α] {x y : α} {m : ℕ} (H : IsRelPrime x y)
Goal: IsRelPrime (x ^ m) y
-- IsRelPrime.pow_right
theorem pow_right (H : IsRelPrime x y) : IsRelPrime x (y ^ n) 
Arguments: {α : Type u_1} [CommMonoid α] [DecompositionMonoid α] {x y : α} {n : ℕ} (H : IsRelPrime x y)
Goal: IsRelPrime x (y ^ n)
-- IsRelPrime.pow
theorem pow (H : IsRelPrime x y) : IsRelPrime (x ^ m) (y ^ n) 
Arguments: {α : Type u_1} [CommMonoid α] [DecompositionMonoid α] {x y : α} {m n : ℕ} (H : IsRelPrime x y)
Goal: IsRelPrime (x ^ m) (y ^ n)
-- IsRelPrime.pow_left_iff
theorem pow_left_iff (hm : 0 < m) : IsRelPrime (x ^ m) y ↔ IsRelPrime x y 
Arguments: {α : Type u_1} [CommMonoid α] [DecompositionMonoid α] {x y : α} {m : ℕ} (hm : 0 < m)
Goal: IsRelPrime (x ^ m) y ↔ IsRelPrime x y
-- IsRelPrime.pow_right_iff
theorem pow_right_iff (hm : 0 < m) : IsRelPrime x (y ^ m) ↔ IsRelPrime x y 
Arguments: {α : Type u_1} [CommMonoid α] [DecompositionMonoid α] {x y : α} {m : ℕ} (hm : 0 < m)
Goal: IsRelPrime x (y ^ m) ↔ IsRelPrime x y
-- IsRelPrime.pow_iff
theorem pow_iff (hm : 0 < m) (hn : 0 < n) :
    IsRelPrime (x ^ m) (y ^ n) ↔ IsRelPrime x y 
Arguments: {α : Type u_1} [CommMonoid α] [DecompositionMonoid α] {x y : α} {m n : ℕ} (hm : 0 < m) (hn : 0 < n)
Goal: IsRelPrime (x ^ m) (y ^ n) ↔ IsRelPrime x y
-- ascPochhammer_zero
@[simp]
theorem ascPochhammer_zero : ascPochhammer S 0 = 1 
Arguments: (S : Type u) [Semiring S]
Goal: ascPochhammer S 0 = 1
-- ascPochhammer_one
@[simp]
theorem ascPochhammer_one : ascPochhammer S 1 = X 
Arguments: (S : Type u) [Semiring S]
Goal: ascPochhammer S 1 = Polynomial.X
-- ascPochhammer_succ_left
theorem ascPochhammer_succ_left (n : ℕ) :
    ascPochhammer S (n + 1) = X * (ascPochhammer S n).comp (X + 1) 
Arguments: (S : Type u) [Semiring S] (n : ℕ)
Goal: ascPochhammer S (n + 1) = Polynomial.X * (ascPochhammer S n).comp (Polynomial.X + 1)
-- monic_ascPochhammer
theorem monic_ascPochhammer (n : ℕ) [Nontrivial S] [NoZeroDivisors S] :
    Monic <| ascPochhammer S n 
Arguments: (S : Type u) [Semiring S] (n : ℕ) [Nontrivial S] [NoZeroDivisors S]
Goal: (ascPochhammer S n).Monic
-- ascPochhammer_map
@[simp]
theorem ascPochhammer_map (f : S →+* T) (n : ℕ) :
    (ascPochhammer S n).map f = ascPochhammer T n 
Arguments: {S : Type u} [Semiring S] {T : Type v} [Semiring T] (f : S →+* T) (n : ℕ)
Goal: Polynomial.map f (ascPochhammer S n) = ascPochhammer T n
-- ascPochhammer_eval₂
theorem ascPochhammer_eval₂ (f : S →+* T) (n : ℕ) (t : T) :
    (ascPochhammer T n).eval t = (ascPochhammer S n).eval₂ f t 
Arguments: {S : Type u} [Semiring S] {T : Type v} [Semiring T] (f : S →+* T) (n : ℕ) (t : T)
Goal: Polynomial.eval t (ascPochhammer T n) = Polynomial.eval₂ f t (ascPochhammer S n)
-- ascPochhammer_eval_comp
theorem ascPochhammer_eval_comp {R : Type*} [CommSemiring R] (n : ℕ) (p : R[X]) [Algebra R S]
    (x : S) : ((ascPochhammer S n).comp (p.map (algebraMap R S))).eval x =
    (ascPochhammer S n).eval (p.eval₂ (algebraMap R S) x) 
Arguments: {S : Type u} [Semiring S] {R : Type u_1} [CommSemiring R] (n : ℕ) (p : R[X]) [Algebra R S] (x : S)
Goal: Polynomial.eval x ((ascPochhammer S n).comp (Polynomial.map (algebraMap R S) p)) =
  Polynomial.eval (Polynomial.eval₂ (algebraMap R S) x p) (ascPochhammer S n)
-- ascPochhammer_eval_cast
@[simp, norm_cast]
theorem ascPochhammer_eval_cast (n k : ℕ) :
    (((ascPochhammer ℕ n).eval k : ℕ) : S) = ((ascPochhammer S n).eval k : S) 
Arguments: (S : Type u) [Semiring S] (n k : ℕ)
Goal: ↑(Polynomial.eval k (ascPochhammer ℕ n)) = Polynomial.eval (↑k) (ascPochhammer S n)
-- ascPochhammer_eval_zero
theorem ascPochhammer_eval_zero {n : ℕ} : (ascPochhammer S n).eval 0 = if n = 0 then 1 else 0 
Arguments: (S : Type u) [Semiring S] {n : ℕ}
Goal: Polynomial.eval 0 (ascPochhammer S n) = if n = 0 then 1 else 0
-- ascPochhammer_zero_eval_zero
theorem ascPochhammer_zero_eval_zero : (ascPochhammer S 0).eval 0 = 1 
Arguments: (S : Type u) [Semiring S]
Goal: Polynomial.eval 0 (ascPochhammer S 0) = 1
-- ascPochhammer_ne_zero_eval_zero
@[simp]
theorem ascPochhammer_ne_zero_eval_zero {n : ℕ} (h : n ≠ 0) : (ascPochhammer S n).eval 0 = 0 
Arguments: (S : Type u) [Semiring S] {n : ℕ} (h : n ≠ 0)
Goal: Polynomial.eval 0 (ascPochhammer S n) = 0
-- ascPochhammer_succ_right
theorem ascPochhammer_succ_right (n : ℕ) :
    ascPochhammer S (n + 1) = ascPochhammer S n * (X + (n : S[X])) 
Arguments: (S : Type u) [Semiring S] (n : ℕ)
Goal: ascPochhammer S (n + 1) = ascPochhammer S n * (Polynomial.X + ↑n)
-- ascPochhammer_succ_eval
theorem ascPochhammer_succ_eval {S : Type*} [Semiring S] (n : ℕ) (k : S) :
    (ascPochhammer S (n + 1)).eval k = (ascPochhammer S n).eval k * (k + n) 
Arguments: {S : Type u_1} [Semiring S] (n : ℕ) (k : S)
Goal: Polynomial.eval k (ascPochhammer S (n + 1)) = Polynomial.eval k (ascPochhammer S n) * (k + ↑n)
-- ascPochhammer_succ_comp_X_add_one
theorem ascPochhammer_succ_comp_X_add_one (n : ℕ) :
    (ascPochhammer S (n + 1)).comp (X + 1) =
      ascPochhammer S (n + 1) + (n + 1) • (ascPochhammer S n).comp (X + 1) 
Arguments: (S : Type u) [Semiring S] (n : ℕ)
Goal: (ascPochhammer S (n + 1)).comp (Polynomial.X + 1) =
  ascPochhammer S (n + 1) + (n + 1) • (ascPochhammer S n).comp (Polynomial.X + 1)
-- ascPochhammer_mul
theorem ascPochhammer_mul (n m : ℕ) :
    ascPochhammer S n * (ascPochhammer S m).comp (X + (n : S[X])) = ascPochhammer S (n + m) 
Arguments: (S : Type u) [Semiring S] (n m : ℕ)
Goal: ascPochhammer S n * (ascPochhammer S m).comp (Polynomial.X + ↑n) = ascPochhammer S (n + m)
-- ascPochhammer_nat_eq_ascFactorial
theorem ascPochhammer_nat_eq_ascFactorial (n : ℕ) :
    ∀ k, (ascPochhammer ℕ k).eval n = n.ascFactorial k
  
Arguments: (n k : ℕ)
Goal: Polynomial.eval n (ascPochhammer ℕ k) = n.ascFactorial k
-- ascPochhammer_nat_eq_descFactorial
theorem ascPochhammer_nat_eq_descFactorial (a b : ℕ) :
    (ascPochhammer ℕ b).eval a = (a + b - 1).descFactorial b 
Arguments: (a b : ℕ)
Goal: Polynomial.eval a (ascPochhammer ℕ b) = (a + b - 1).descFactorial b
-- ascPochhammer_natDegree
@[simp]
theorem ascPochhammer_natDegree (n : ℕ) [NoZeroDivisors S] [Nontrivial S] :
    (ascPochhammer S n).natDegree = n 
Arguments: (S : Type u) [Semiring S] (n : ℕ) [NoZeroDivisors S] [Nontrivial S]
Goal: (ascPochhammer S n).natDegree = n
-- ascPochhammer_pos
theorem ascPochhammer_pos (n : ℕ) (s : S) (h : 0 < s) : 0 < (ascPochhammer S n).eval s 
Arguments: {S : Type u_1} [StrictOrderedSemiring S] (n : ℕ) (s : S) (h : 0 < s)
Goal: 0 < Polynomial.eval s (ascPochhammer S n)
-- ascPochhammer_eval_one
@[simp]
theorem ascPochhammer_eval_one (S : Type*) [Semiring S] (n : ℕ) :
    (ascPochhammer S n).eval (1 : S) = (n ! : S) 
Arguments: (S : Type u_2) [Semiring S] (n : ℕ)
Goal: Polynomial.eval 1 (ascPochhammer S n) = ↑n.factorial
-- factorial_mul_ascPochhammer
theorem factorial_mul_ascPochhammer (S : Type*) [Semiring S] (r n : ℕ) :
    (r ! : S) * (ascPochhammer S n).eval (r + 1 : S) = (r + n)! 
Arguments: (S : Type u_2) [Semiring S] (r n : ℕ)
Goal: ↑r.factorial * Polynomial.eval (↑r + 1) (ascPochhammer S n) = ↑(r + n).factorial
-- ascPochhammer_nat_eval_succ
theorem ascPochhammer_nat_eval_succ (r : ℕ) :
    ∀ n : ℕ, n * (ascPochhammer ℕ r).eval (n + 1) = (n + r) * (ascPochhammer ℕ r).eval n
  
Arguments: (r n : ℕ)
Goal: n * Polynomial.eval (n + 1) (ascPochhammer ℕ r) = (n + r) * Polynomial.eval n (ascPochhammer ℕ r)
-- ascPochhammer_eval_succ
theorem ascPochhammer_eval_succ (r n : ℕ) :
    (n : S) * (ascPochhammer S r).eval (n + 1 : S) =
    (n + r) * (ascPochhammer S r).eval (n : S) 
Arguments: (S : Type u_1) [Semiring S] (r n : ℕ)
Goal: ↑n * Polynomial.eval (↑n + 1) (ascPochhammer S r) = (↑n + ↑r) * Polynomial.eval (↑n) (ascPochhammer S r)
-- descPochhammer_zero
@[simp]
theorem descPochhammer_zero : descPochhammer R 0 = 1 
Arguments: (R : Type u) [Ring R]
Goal: descPochhammer R 0 = 1
-- descPochhammer_one
@[simp]
theorem descPochhammer_one : descPochhammer R 1 = X 
Arguments: (R : Type u) [Ring R]
Goal: descPochhammer R 1 = Polynomial.X
-- descPochhammer_succ_left
theorem descPochhammer_succ_left (n : ℕ) :
    descPochhammer R (n + 1) = X * (descPochhammer R n).comp (X - 1) 
Arguments: (R : Type u) [Ring R] (n : ℕ)
Goal: descPochhammer R (n + 1) = Polynomial.X * (descPochhammer R n).comp (Polynomial.X - 1)
-- monic_descPochhammer
theorem monic_descPochhammer (n : ℕ) [Nontrivial R] [NoZeroDivisors R] :
    Monic <| descPochhammer R n 
Arguments: (R : Type u) [Ring R] (n : ℕ) [Nontrivial R] [NoZeroDivisors R]
Goal: (descPochhammer R n).Monic
-- descPochhammer_map
@[simp]
theorem descPochhammer_map (f : R →+* T) (n : ℕ) :
    (descPochhammer R n).map f = descPochhammer T n 
Arguments: {R : Type u} [Ring R] {T : Type v} [Ring T] (f : R →+* T) (n : ℕ)
Goal: Polynomial.map f (descPochhammer R n) = descPochhammer T n
-- descPochhammer_eval_cast
@[simp, norm_cast]
theorem descPochhammer_eval_cast (n : ℕ) (k : ℤ) :
    (((descPochhammer ℤ n).eval k : ℤ) : R) = ((descPochhammer R n).eval k : R) 
Arguments: (R : Type u) [Ring R] (n : ℕ) (k : ℤ)
Goal: ↑(Polynomial.eval k (descPochhammer ℤ n)) = Polynomial.eval (↑k) (descPochhammer R n)
-- descPochhammer_eval_zero
theorem descPochhammer_eval_zero {n : ℕ} :
    (descPochhammer R n).eval 0 = if n = 0 then 1 else 0 
Arguments: (R : Type u) [Ring R] {n : ℕ}
Goal: Polynomial.eval 0 (descPochhammer R n) = if n = 0 then 1 else 0
-- descPochhammer_zero_eval_zero
theorem descPochhammer_zero_eval_zero : (descPochhammer R 0).eval 0 = 1 
Arguments: (R : Type u) [Ring R]
Goal: Polynomial.eval 0 (descPochhammer R 0) = 1
-- descPochhammer_ne_zero_eval_zero
@[simp]
theorem descPochhammer_ne_zero_eval_zero {n : ℕ} (h : n ≠ 0) : (descPochhammer R n).eval 0 = 0 
Arguments: (R : Type u) [Ring R] {n : ℕ} (h : n ≠ 0)
Goal: Polynomial.eval 0 (descPochhammer R n) = 0
-- descPochhammer_succ_right
theorem descPochhammer_succ_right (n : ℕ) :
    descPochhammer R (n + 1) = descPochhammer R n * (X - (n : R[X])) 
Arguments: (R : Type u) [Ring R] (n : ℕ)
Goal: descPochhammer R (n + 1) = descPochhammer R n * (Polynomial.X - ↑n)
-- descPochhammer_natDegree
@[simp]
theorem descPochhammer_natDegree (n : ℕ) [NoZeroDivisors R] [Nontrivial R] :
    (descPochhammer R n).natDegree = n 
Arguments: (R : Type u) [Ring R] (n : ℕ) [NoZeroDivisors R] [Nontrivial R]
Goal: (descPochhammer R n).natDegree = n
-- descPochhammer_succ_eval
theorem descPochhammer_succ_eval {S : Type*} [Ring S] (n : ℕ) (k : S) :
    (descPochhammer S (n + 1)).eval k = (descPochhammer S n).eval k * (k - n) 
Arguments: {S : Type u_1} [Ring S] (n : ℕ) (k : S)
Goal: Polynomial.eval k (descPochhammer S (n + 1)) = Polynomial.eval k (descPochhammer S n) * (k - ↑n)
-- descPochhammer_succ_comp_X_sub_one
theorem descPochhammer_succ_comp_X_sub_one (n : ℕ) :
    (descPochhammer R (n + 1)).comp (X - 1) =
      descPochhammer R (n + 1) - (n + (1 : R[X])) • (descPochhammer R n).comp (X - 1) 
Arguments: (R : Type u) [Ring R] (n : ℕ)
Goal: (descPochhammer R (n + 1)).comp (Polynomial.X - 1) =
  descPochhammer R (n + 1) - (↑n + 1) • (descPochhammer R n).comp (Polynomial.X - 1)
-- descPochhammer_eq_ascPochhammer
theorem descPochhammer_eq_ascPochhammer (n : ℕ) :
    descPochhammer ℤ n = (ascPochhammer ℤ n).comp ((X : ℤ[X]) - n + 1) 
Arguments: (n : ℕ)
Goal: descPochhammer ℤ n = (ascPochhammer ℤ n).comp (Polynomial.X - ↑n + 1)
-- descPochhammer_eval_eq_ascPochhammer
theorem descPochhammer_eval_eq_ascPochhammer (r : R) (n : ℕ) :
    (descPochhammer R n).eval r = (ascPochhammer R n).eval (r - n + 1) 
Arguments: (R : Type u) [Ring R] (r : R) (n : ℕ)
Goal: Polynomial.eval r (descPochhammer R n) = Polynomial.eval (r - ↑n + 1) (ascPochhammer R n)
-- descPochhammer_mul
theorem descPochhammer_mul (n m : ℕ) :
    descPochhammer R n * (descPochhammer R m).comp (X - (n : R[X])) = descPochhammer R (n + m) 
Arguments: (R : Type u) [Ring R] (n m : ℕ)
Goal: descPochhammer R n * (descPochhammer R m).comp (Polynomial.X - ↑n) = descPochhammer R (n + m)
-- ascPochhammer_eval_neg_eq_descPochhammer
theorem ascPochhammer_eval_neg_eq_descPochhammer (r : R) : ∀ (k : ℕ),
    (ascPochhammer R k).eval (-r) = (-1)^k * (descPochhammer R k).eval r
  
Arguments: (R : Type u) [Ring R] (r : R) (k : ℕ)
Goal: Polynomial.eval (-r) (ascPochhammer R k) = (-1) ^ k * Polynomial.eval r (descPochhammer R k)
-- descPochhammer_eval_eq_descFactorial
theorem descPochhammer_eval_eq_descFactorial (n k : ℕ) :
    (descPochhammer R k).eval (n : R) = n.descFactorial k 
Arguments: (R : Type u) [Ring R] (n k : ℕ)
Goal: Polynomial.eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k)
-- descPochhammer_int_eq_ascFactorial
theorem descPochhammer_int_eq_ascFactorial (a b : ℕ) :
    (descPochhammer ℤ b).eval (a + b : ℤ) = (a + 1).ascFactorial b 
Arguments: (a b : ℕ)
Goal: Polynomial.eval (↑a + ↑b) (descPochhammer ℤ b) = ↑((a + 1).ascFactorial b)
-- Multiset.prod_X_add_C_eq_sum_esymm
theorem prod_X_add_C_eq_sum_esymm (s : Multiset R) :
    (s.map fun r => X + C r).prod =
      ∑ j ∈ Finset.range (Multiset.card s + 1), (C (s.esymm j) * X ^ (Multiset.card s - j)) 
Arguments: {R : Type u_1} [CommSemiring R] (s : Multiset R)
Goal: (Multiset.map (fun r => Polynomial.X + Polynomial.C r) s).prod =
  ∑ j ∈ Finset.range (Multiset.card s + 1), Polynomial.C (s.esymm j) * Polynomial.X ^ (Multiset.card s - j)
-- Multiset.prod_X_add_C_coeff
theorem prod_X_add_C_coeff (s : Multiset R) {k : ℕ} (h : k ≤ Multiset.card s) :
    (s.map fun r => X + C r).prod.coeff k = s.esymm (Multiset.card s - k) 
Arguments: {R : Type u_1} [CommSemiring R] (s : Multiset R) {k : ℕ} (h : k ≤ Multiset.card s)
Goal: (Multiset.map (fun r => Polynomial.X + Polynomial.C r) s).prod.coeff k = s.esymm (Multiset.card s - k)
-- Multiset.prod_X_add_C_coeff'
theorem prod_X_add_C_coeff' {σ} (s : Multiset σ) (r : σ → R) {k : ℕ} (h : k ≤ Multiset.card s) :
    (s.map fun i => X + C (r i)).prod.coeff k = (s.map r).esymm (Multiset.card s - k) 
Arguments: {R : Type u_1} [CommSemiring R] {σ : Type u_2} (s : Multiset σ) (r : σ → R) {k : ℕ} (h : k ≤ Multiset.card s)
Goal: (Multiset.map (fun i => Polynomial.X + Polynomial.C (r i)) s).prod.coeff k =
  (Multiset.map r s).esymm (Multiset.card s - k)
-- Finset.prod_X_add_C_coeff
theorem _root_.Finset.prod_X_add_C_coeff {σ} (s : Finset σ) (r : σ → R) {k : ℕ} (h : k ≤ s.card) :
    (∏ i ∈ s, (X + C (r i))).coeff k = ∑ t ∈ s.powersetCard (s.card - k), ∏ i ∈ t, r i 
Arguments: {R : Type u_1} [CommSemiring R] {σ : Type u_2} (s : Finset σ) (r : σ → R) {k : ℕ} (h : k ≤ s.card)
Goal: (∏ i ∈ s, (Polynomial.X + Polynomial.C (r i))).coeff k = ∑ t ∈ Finset.powersetCard (s.card - k) s, ∏ i ∈ t, r i
-- Multiset.esymm_neg
theorem esymm_neg (s : Multiset R) (k : ℕ) : (map Neg.neg s).esymm k = (-1) ^ k * esymm s k 
Arguments: {R : Type u_1} [CommRing R] (s : Multiset R) (k : ℕ)
Goal: (Multiset.map Neg.neg s).esymm k = (-1) ^ k * s.esymm k