ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- list_sum_pow_char
theorem list_sum_pow_char (l : List R) : l.sum ^ p = (l.map (· ^ p : R → R)).sum 
Arguments: {R : Type u} [CommSemiring R] (p : ℕ) [ExpChar R p] (l : List R)
Goal: l.sum ^ p = (List.map (fun x => x ^ p) l).sum
-- multiset_sum_pow_char
theorem multiset_sum_pow_char (s : Multiset R) : s.sum ^ p = (s.map (· ^ p : R → R)).sum 
Arguments: {R : Type u} [CommSemiring R] (p : ℕ) [ExpChar R p] (s : Multiset R)
Goal: s.sum ^ p = (Multiset.map (fun x => x ^ p) s).sum
-- sum_pow_char
theorem sum_pow_char {ι : Type*} (s : Finset ι) (f : ι → R) :
    (∑ i ∈ s, f i) ^ p = ∑ i ∈ s, f i ^ p 
Arguments: {R : Type u} [CommSemiring R] (p : ℕ) [ExpChar R p] {ι : Type u_2} (s : Finset ι) (f : ι → R)
Goal: (∑ i ∈ s, f i) ^ p = ∑ i ∈ s, f i ^ p
-- list_sum_pow_char_pow
theorem list_sum_pow_char_pow (l : List R) : l.sum ^ p ^ n = (l.map (· ^ p ^ n : R → R)).sum 
Arguments: {R : Type u} [CommSemiring R] (p : ℕ) [ExpChar R p] (n : ℕ) (l : List R)
Goal: l.sum ^ p ^ n = (List.map (fun x => x ^ p ^ n) l).sum
-- multiset_sum_pow_char_pow
theorem multiset_sum_pow_char_pow (s : Multiset R) :
    s.sum ^ p ^ n = (s.map (· ^ p ^ n : R → R)).sum 
Arguments: {R : Type u} [CommSemiring R] (p : ℕ) [ExpChar R p] (n : ℕ) (s : Multiset R)
Goal: s.sum ^ p ^ n = (Multiset.map (fun x => x ^ p ^ n) s).sum
-- sum_pow_char_pow
theorem sum_pow_char_pow {ι : Type*} (s : Finset ι) (f : ι → R) :
    (∑ i ∈ s, f i) ^ p ^ n = ∑ i ∈ s, f i ^ p ^ n 
Arguments: {R : Type u} [CommSemiring R] (p : ℕ) [ExpChar R p] (n : ℕ) {ι : Type u_2} (s : Finset ι) (f : ι → R)
Goal: (∑ i ∈ s, f i) ^ p ^ n = ∑ i ∈ s, f i ^ p ^ n
-- frobenius_neg
theorem frobenius_neg : frobenius R p (-x) = -frobenius R p x 
Arguments: (R : Type u) [CommRing R] (p : ℕ) [ExpChar R p] (x : R)
Goal: (frobenius R p) (-x) = -(frobenius R p) x
-- frobenius_sub
theorem frobenius_sub : frobenius R p (x - y) = frobenius R p x - frobenius R p y 
Arguments: (R : Type u) [CommRing R] (p : ℕ) [ExpChar R p] (x y : R)
Goal: (frobenius R p) (x - y) = (frobenius R p) x - (frobenius R p) y
-- List.sum_nil
@[to_additive (attr := simp)]
theorem prod_nil : ([] : List M).prod = 1 
Arguments: {M : Type u_4} [AddZeroClass M]
Goal: [].sum = 0
-- List.prod_nil
@[to_additive (attr := simp)]
theorem prod_nil : ([] : List M).prod = 1 
Arguments: {M : Type u_4} [MulOneClass M]
Goal: [].prod = 1
-- List.sum_singleton
@[to_additive]
theorem prod_singleton : [a].prod = a 
Arguments: {M : Type u_4} [AddZeroClass M] {a : M}
Goal: [a].sum = a
-- List.prod_singleton
@[to_additive]
theorem prod_singleton : [a].prod = a 
Arguments: {M : Type u_4} [MulOneClass M] {a : M}
Goal: [a].prod = a
-- List.prod_one_cons
@[to_additive (attr := simp)]
theorem prod_one_cons : (1 :: l).prod = l.prod 
Arguments: {M : Type u_4} [MulOneClass M] {l : List M}
Goal: (1 :: l).prod = l.prod
-- List.sum_zero_cons
@[to_additive (attr := simp)]
theorem prod_one_cons : (1 :: l).prod = l.prod 
Arguments: {M : Type u_4} [AddZeroClass M] {l : List M}
Goal: (0 :: l).sum = l.sum
-- List.prod_map_one
@[to_additive]
theorem prod_map_one {l : List ι} :
    (l.map fun _ => (1 : M)).prod = 1 
Arguments: {ι : Type u_1} {M : Type u_4} [MulOneClass M] {l : List ι}
Goal: (List.map (fun x => 1) l).prod = 1
-- List.sum_map_zero
@[to_additive]
theorem prod_map_one {l : List ι} :
    (l.map fun _ => (1 : M)).prod = 1 
Arguments: {ι : Type u_1} {M : Type u_4} [AddZeroClass M] {l : List ι}
Goal: (List.map (fun x => 0) l).sum = 0
-- List.prod_cons
@[to_additive (attr := simp)]
theorem prod_cons : (a :: l).prod = a * l.prod 
Arguments: {M : Type u_4} [Monoid M] {l : List M} {a : M}
Goal: (a :: l).prod = a * l.prod
-- List.sum_cons
@[to_additive (attr := simp)]
theorem prod_cons : (a :: l).prod = a * l.prod 
Arguments: {M : Type u_4} [AddMonoid M] {l : List M} {a : M}
Goal: (a :: l).sum = a + l.sum
-- List.sum_induction
@[to_additive]
lemma prod_induction
    (p : M → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ l, p x) :
    p l.prod 
Arguments: {M : Type u_4} [AddMonoid M] {l : List M} (p : M → Prop) (hom : ∀ (a b : M), p a → p b → p (a + b)) (unit : p 0) (base : ∀ x ∈ l, p x)
Goal: p l.sum
-- List.prod_induction
@[to_additive]
lemma prod_induction
    (p : M → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ l, p x) :
    p l.prod 
Arguments: {M : Type u_4} [Monoid M] {l : List M} (p : M → Prop) (hom : ∀ (a b : M), p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ l, p x)
Goal: p l.prod
-- List.prod_append
@[to_additive (attr := simp)]
theorem prod_append : (l₁ ++ l₂).prod = l₁.prod * l₂.prod 
Arguments: {M : Type u_4} [Monoid M] {l₁ l₂ : List M}
Goal: (l₁ ++ l₂).prod = l₁.prod * l₂.prod
-- List.sum_append
@[to_additive (attr := simp)]
theorem prod_append : (l₁ ++ l₂).prod = l₁.prod * l₂.prod 
Arguments: {M : Type u_4} [AddMonoid M] {l₁ l₂ : List M}
Goal: (l₁ ++ l₂).sum = l₁.sum + l₂.sum
-- List.sum_concat
@[to_additive]
theorem prod_concat : (l.concat a).prod = l.prod * a 
Arguments: {M : Type u_4} [AddMonoid M] {l : List M} {a : M}
Goal: (l.concat a).sum = l.sum + a
-- List.prod_concat
@[to_additive]
theorem prod_concat : (l.concat a).prod = l.prod * a 
Arguments: {M : Type u_4} [Monoid M] {l : List M} {a : M}
Goal: (l.concat a).prod = l.prod * a
-- List.sum_join
@[to_additive (attr := simp)]
theorem prod_join {l : List (List M)} : l.join.prod = (l.map List.prod).prod 
Arguments: {M : Type u_4} [AddMonoid M] {l : List (List M)}
Goal: l.join.sum = (List.map List.sum l).sum
-- List.prod_join
@[to_additive (attr := simp)]
theorem prod_join {l : List (List M)} : l.join.prod = (l.map List.prod).prod 
Arguments: {M : Type u_4} [Monoid M] {l : List (List M)}
Goal: l.join.prod = (List.map List.prod l).prod
-- List.sum_eq_foldr
@[to_additive]
theorem prod_eq_foldr : ∀ {l : List M}, l.prod = foldr (· * ·) 1 l
  
Arguments: {M : Type u_4} [AddMonoid M] {l : List M}
Goal: l.sum = List.foldr (fun x x_1 => x + x_1) 0 l
-- List.prod_eq_foldr
@[to_additive]
theorem prod_eq_foldr : ∀ {l : List M}, l.prod = foldr (· * ·) 1 l
  
Arguments: {M : Type u_4} [Monoid M] {l : List M}
Goal: l.prod = List.foldr (fun x x_1 => x * x_1) 1 l
-- List.sum_replicate
@[to_additive (attr := simp)]
theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).prod = a ^ n 
Arguments: {M : Type u_4} [AddMonoid M] (n : ℕ) (a : M)
Goal: (List.replicate n a).sum = n • a
-- List.prod_replicate
@[to_additive (attr := simp)]
theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).prod = a ^ n 
Arguments: {M : Type u_4} [Monoid M] (n : ℕ) (a : M)
Goal: (List.replicate n a).prod = a ^ n
-- List.prod_eq_pow_card
@[to_additive sum_eq_card_nsmul]
theorem prod_eq_pow_card (l : List M) (m : M) (h : ∀ x ∈ l, x = m) : l.prod = m ^ l.length 
Arguments: {M : Type u_4} [Monoid M] (l : List M) (m : M) (h : ∀ x ∈ l, x = m)
Goal: l.prod = m ^ l.length
-- List.sum_eq_card_nsmul
@[to_additive sum_eq_card_nsmul]
theorem prod_eq_pow_card (l : List M) (m : M) (h : ∀ x ∈ l, x = m) : l.prod = m ^ l.length 
Arguments: {M : Type u_4} [AddMonoid M] (l : List M) (m : M) (h : ∀ x ∈ l, x = m)
Goal: l.sum = l.length • m
-- List.prod_hom_rel
@[to_additive]
theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι → N} (h₁ : r 1 1)
    (h₂ : ∀ ⦃i a b⦄, r a b → r (f i * a) (g i * b)) : r (l.map f).prod (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι → N} (h₁ : r 1 1) (h₂ : ∀ ⦃i : ι⦄ ⦃a : M⦄ ⦃b : N⦄, r a b → r (f i * a) (g i * b))
Goal: r (List.map f l).prod (List.map g l).prod
-- List.sum_hom_rel
@[to_additive]
theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι → N} (h₁ : r 1 1)
    (h₂ : ∀ ⦃i a b⦄, r a b → r (f i * a) (g i * b)) : r (l.map f).prod (l.map g).prod 
Arguments: {ι : Type u_1} {M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N] (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι → N} (h₁ : r 0 0) (h₂ : ∀ ⦃i : ι⦄ ⦃a : M⦄ ⦃b : N⦄, r a b → r (f i + a) (g i + b))
Goal: r (List.map f l).sum (List.map g l).sum
-- List.rel_sum
@[to_additive]
theorem rel_prod {R : M → N → Prop} (h : R 1 1) (hf : (R ⇒ R ⇒ R) (· * ·) (· * ·)) :
    (Forall₂ R ⇒ R) prod prod 
Arguments: {M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N] {R : M → N → Prop} (h : R 0 0) (hf : (R ⇒ R ⇒ R) (fun x x_1 => x + x_1) fun x x_1 => x + x_1)
Goal: (List.Forall₂ R ⇒ R) List.sum List.sum
-- List.rel_prod
@[to_additive]
theorem rel_prod {R : M → N → Prop} (h : R 1 1) (hf : (R ⇒ R ⇒ R) (· * ·) (· * ·)) :
    (Forall₂ R ⇒ R) prod prod 
Arguments: {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] {R : M → N → Prop} (h : R 1 1) (hf : (R ⇒ R ⇒ R) (fun x x_1 => x * x_1) fun x x_1 => x * x_1)
Goal: (List.Forall₂ R ⇒ R) List.prod List.prod
-- List.sum_hom
@[to_additive]
theorem prod_hom (l : List M) {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) :
    (l.map f).prod = f l.prod 
Arguments: {M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N] (l : List M) {F : Type u_8} [FunLike F M N] [AddMonoidHomClass F M N] (f : F)
Goal: (List.map (⇑f) l).sum = f l.sum
-- List.prod_hom
@[to_additive]
theorem prod_hom (l : List M) {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) :
    (l.map f).prod = f l.prod 
Arguments: {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] (l : List M) {F : Type u_8} [FunLike F M N] [MonoidHomClass F M N] (f : F)
Goal: (List.map (⇑f) l).prod = f l.prod
-- List.sum_hom₂
@[to_additive]
theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d)
    (hf' : f 1 1 = 1) (f₁ : ι → M) (f₂ : ι → N) :
    (l.map fun i => f (f₁ i) (f₂ i)).prod = f (l.map f₁).prod (l.map f₂).prod 
Arguments: {ι : Type u_1} {M : Type u_4} {N : Type u_5} {P : Type u_6} [AddMonoid M] [AddMonoid N] [AddMonoid P] (l : List ι) (f : M → N → P) (hf : ∀ (a b : M) (c d : N), f (a + b) (c + d) = f a c + f b d) (hf' : f 0 0 = 0) (f₁ : ι → M) (f₂ : ι → N)
Goal: (List.map (fun i => f (f₁ i) (f₂ i)) l).sum = f (List.map f₁ l).sum (List.map f₂ l).sum
-- List.prod_hom₂
@[to_additive]
theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d)
    (hf' : f 1 1 = 1) (f₁ : ι → M) (f₂ : ι → N) :
    (l.map fun i => f (f₁ i) (f₂ i)).prod = f (l.map f₁).prod (l.map f₂).prod 
Arguments: {ι : Type u_1} {M : Type u_4} {N : Type u_5} {P : Type u_6} [Monoid M] [Monoid N] [Monoid P] (l : List ι) (f : M → N → P) (hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d) (hf' : f 1 1 = 1) (f₁ : ι → M) (f₂ : ι → N)
Goal: (List.map (fun i => f (f₁ i) (f₂ i)) l).prod = f (List.map f₁ l).prod (List.map f₂ l).prod
-- List.prod_map_mul
@[to_additive (attr := simp)]
theorem prod_map_mul {α : Type*} [CommMonoid α] {l : List ι} {f g : ι → α} :
    (l.map fun i => f i * g i).prod = (l.map f).prod * (l.map g).prod 
Arguments: {ι : Type u_1} {α : Type u_8} [CommMonoid α] {l : List ι} {f g : ι → α}
Goal: (List.map (fun i => f i * g i) l).prod = (List.map f l).prod * (List.map g l).prod
-- List.sum_map_add
@[to_additive (attr := simp)]
theorem prod_map_mul {α : Type*} [CommMonoid α] {l : List ι} {f g : ι → α} :
    (l.map fun i => f i * g i).prod = (l.map f).prod * (l.map g).prod 
Arguments: {ι : Type u_1} {α : Type u_8} [AddCommMonoid α] {l : List ι} {f g : ι → α}
Goal: (List.map (fun i => f i + g i) l).sum = (List.map f l).sum + (List.map g l).sum
-- List.prod_map_hom
@[to_additive]
theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type*} [FunLike G M N] [MonoidHomClass G M N]
    (g : G) :
    (L.map (g ∘ f)).prod = g (L.map f).prod 
Arguments: {ι : Type u_1} {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] (L : List ι) (f : ι → M) {G : Type u_8} [FunLike G M N] [MonoidHomClass G M N] (g : G)
Goal: (List.map (⇑g ∘ f) L).prod = g (List.map f L).prod
-- List.sum_map_hom
@[to_additive]
theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type*} [FunLike G M N] [MonoidHomClass G M N]
    (g : G) :
    (L.map (g ∘ f)).prod = g (L.map f).prod 
Arguments: {ι : Type u_1} {M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N] (L : List ι) (f : ι → M) {G : Type u_8} [FunLike G M N] [AddMonoidHomClass G M N] (g : G)
Goal: (List.map (⇑g ∘ f) L).sum = g (List.map f L).sum
-- List.prod_isUnit
@[to_additive]
theorem prod_isUnit : ∀ {L : List M}, (∀ m ∈ L, IsUnit m) → IsUnit L.prod
  
Arguments: {M : Type u_4} [Monoid M] {L : List M}
Goal: (∀ m ∈ L, IsUnit m) → IsUnit L.prod
-- List.sum_isAddUnit
@[to_additive]
theorem prod_isUnit : ∀ {L : List M}, (∀ m ∈ L, IsUnit m) → IsUnit L.prod
  
Arguments: {M : Type u_4} [AddMonoid M] {L : List M}
Goal: (∀ m ∈ L, IsAddUnit m) → IsAddUnit L.sum
-- List.sum_isAddUnit_iff
@[to_additive]
theorem prod_isUnit_iff {α : Type*} [CommMonoid α] {L : List α} :
    IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m 
Arguments: {α : Type u_8} [AddCommMonoid α] {L : List α}
Goal: IsAddUnit L.sum ↔ ∀ m ∈ L, IsAddUnit m
-- List.prod_isUnit_iff
@[to_additive]
theorem prod_isUnit_iff {α : Type*} [CommMonoid α] {L : List α} :
    IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m 
Arguments: {α : Type u_8} [CommMonoid α] {L : List α}
Goal: IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m
-- List.prod_take_mul_prod_drop
@[to_additive (attr := simp)]
theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).prod * (L.drop i).prod = L.prod
  
Arguments: {M : Type u_4} [Monoid M] (L : List M) (i : ℕ)
Goal: (List.take i L).prod * (List.drop i L).prod = L.prod
-- List.sum_take_add_sum_drop
@[to_additive (attr := simp)]
theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).prod * (L.drop i).prod = L.prod
  
Arguments: {M : Type u_4} [AddMonoid M] (L : List M) (i : ℕ)
Goal: (List.take i L).sum + (List.drop i L).sum = L.sum
-- List.prod_take_succ
@[to_additive (attr := simp)]
theorem prod_take_succ :
    ∀ (L : List M) (i : ℕ) (p : i < L.length), (L.take (i + 1)).prod = (L.take i).prod * L[i]
  
Arguments: {M : Type u_4} [Monoid M] (L : List M) (i : ℕ) (p : i < L.length)
Goal: (List.take (i + 1) L).prod = (List.take i L).prod * L[i]
-- List.sum_take_succ
@[to_additive (attr := simp)]
theorem prod_take_succ :
    ∀ (L : List M) (i : ℕ) (p : i < L.length), (L.take (i + 1)).prod = (L.take i).prod * L[i]
  
Arguments: {M : Type u_4} [AddMonoid M] (L : List M) (i : ℕ) (p : i < L.length)
Goal: (List.take (i + 1) L).sum = (List.take i L).sum + L[i]
-- List.length_pos_of_sum_ne_zero
@[to_additive "A list with sum not zero must have positive length."]
theorem length_pos_of_prod_ne_one (L : List M) (h : L.prod ≠ 1) : 0 < L.length 
Arguments: {M : Type u_4} [AddMonoid M] (L : List M) (h : L.sum ≠ 0)
Goal: 0 < L.length
-- List.length_pos_of_prod_ne_one
@[to_additive "A list with sum not zero must have positive length."]
theorem length_pos_of_prod_ne_one (L : List M) (h : L.prod ≠ 1) : 0 < L.length 
Arguments: {M : Type u_4} [Monoid M] (L : List M) (h : L.prod ≠ 1)
Goal: 0 < L.length
-- List.length_pos_of_sum_pos
@[to_additive length_pos_of_sum_pos "A list with positive sum must have positive length."]
theorem length_pos_of_one_lt_prod [Preorder M] (L : List M) (h : 1 < L.prod) : 0 < L.length 
Arguments: {M : Type u_4} [AddMonoid M] [Preorder M] (L : List M) (h : 0 < L.sum)
Goal: 0 < L.length
-- List.length_pos_of_one_lt_prod
@[to_additive length_pos_of_sum_pos "A list with positive sum must have positive length."]
theorem length_pos_of_one_lt_prod [Preorder M] (L : List M) (h : 1 < L.prod) : 0 < L.length 
Arguments: {M : Type u_4} [Monoid M] [Preorder M] (L : List M) (h : 1 < L.prod)
Goal: 0 < L.length
-- List.length_pos_of_prod_lt_one
@[to_additive "A list with negative sum must have positive length."]
theorem length_pos_of_prod_lt_one [Preorder M] (L : List M) (h : L.prod < 1) : 0 < L.length 
Arguments: {M : Type u_4} [Monoid M] [Preorder M] (L : List M) (h : L.prod < 1)
Goal: 0 < L.length
-- List.length_pos_of_sum_neg
@[to_additive "A list with negative sum must have positive length."]
theorem length_pos_of_prod_lt_one [Preorder M] (L : List M) (h : L.prod < 1) : 0 < L.length 
Arguments: {M : Type u_4} [AddMonoid M] [Preorder M] (L : List M) (h : L.sum < 0)
Goal: 0 < L.length
-- List.prod_set
@[to_additive]
theorem prod_set :
    ∀ (L : List M) (n : ℕ) (a : M),
      (L.set n a).prod =
        ((L.take n).prod * if n < L.length then a else 1) * (L.drop (n + 1)).prod
  
Arguments: {M : Type u_4} [Monoid M] (L : List M) (n : ℕ) (a : M)
Goal: (L.set n a).prod = ((List.take n L).prod * if n < L.length then a else 1) * (List.drop (n + 1) L).prod
-- List.sum_set
@[to_additive]
theorem prod_set :
    ∀ (L : List M) (n : ℕ) (a : M),
      (L.set n a).prod =
        ((L.take n).prod * if n < L.length then a else 1) * (L.drop (n + 1)).prod
  
Arguments: {M : Type u_4} [AddMonoid M] (L : List M) (n : ℕ) (a : M)
Goal: (L.set n a).sum = ((List.take n L).sum + if n < L.length then a else 0) + (List.drop (n + 1) L).sum
-- List.get?_zero_mul_tail_prod
@[to_additive "We'd like to state this as `L.headI + L.tail.sum = L.sum`, but because `L.headI`
  relies on an inhabited instance to return a garbage value on the empty list, this is not possible.
  Instead, we write the statement in terms of `(L.get? 0).getD 0`."]
theorem get?_zero_mul_tail_prod (l : List M) : (l.get? 0).getD 1 * l.tail.prod = l.prod 
Arguments: {M : Type u_4} [Monoid M] (l : List M)
Goal: (l.get? 0).getD 1 * l.tail.prod = l.prod
-- List.get?_zero_add_tail_sum
@[to_additive "We'd like to state this as `L.headI + L.tail.sum = L.sum`, but because `L.headI`
  relies on an inhabited instance to return a garbage value on the empty list, this is not possible.
  Instead, we write the statement in terms of `(L.get? 0).getD 0`."]
theorem get?_zero_mul_tail_prod (l : List M) : (l.get? 0).getD 1 * l.tail.prod = l.prod 
Arguments: {M : Type u_4} [AddMonoid M] (l : List M)
Goal: (l.get? 0).getD 0 + l.tail.sum = l.sum
-- List.headI_add_tail_sum_of_ne_nil
@[to_additive "Same as `get?_zero_add_tail_sum`, but avoiding the `List.headI` garbage complication
  by requiring the list to be nonempty."]
theorem headI_mul_tail_prod_of_ne_nil [Inhabited M] (l : List M) (h : l ≠ []) :
    l.headI * l.tail.prod = l.prod 
Arguments: {M : Type u_4} [AddMonoid M] [Inhabited M] (l : List M) (h : l ≠ [])
Goal: l.headI + l.tail.sum = l.sum
-- List.headI_mul_tail_prod_of_ne_nil
@[to_additive "Same as `get?_zero_add_tail_sum`, but avoiding the `List.headI` garbage complication
  by requiring the list to be nonempty."]
theorem headI_mul_tail_prod_of_ne_nil [Inhabited M] (l : List M) (h : l ≠ []) :
    l.headI * l.tail.prod = l.prod 
Arguments: {M : Type u_4} [Monoid M] [Inhabited M] (l : List M) (h : l ≠ [])
Goal: l.headI * l.tail.prod = l.prod
-- Commute.list_prod_right
@[to_additive]
theorem _root_.Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y x) :
    Commute y l.prod 
Arguments: {M : Type u_4} [Monoid M] (l : List M) (y : M) (h : ∀ x ∈ l, Commute y x)
Goal: Commute y l.prod
-- AddCommute.list_sum_right
@[to_additive]
theorem _root_.Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y x) :
    Commute y l.prod 
Arguments: {M : Type u_4} [AddMonoid M] (l : List M) (y : M) (h : ∀ x ∈ l, AddCommute y x)
Goal: AddCommute y l.sum
-- Commute.list_prod_left
@[to_additive]
theorem _root_.Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Commute x y) :
    Commute l.prod y 
Arguments: {M : Type u_4} [Monoid M] (l : List M) (y : M) (h : ∀ x ∈ l, Commute x y)
Goal: Commute l.prod y
-- AddCommute.list_sum_left
@[to_additive]
theorem _root_.Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Commute x y) :
    Commute l.prod y 
Arguments: {M : Type u_4} [AddMonoid M] (l : List M) (y : M) (h : ∀ x ∈ l, AddCommute x y)
Goal: AddCommute l.sum y
-- List.sum_range_succ
@[to_additive] lemma prod_range_succ (f : ℕ → M) (n : ℕ) :
    ((range n.succ).map f).prod = ((range n).map f).prod * f n 
Arguments: {M : Type u_4} [AddMonoid M] (f : ℕ → M) (n : ℕ)
Goal: (List.map f (List.range n.succ)).sum = (List.map f (List.range n)).sum + f n
-- List.prod_range_succ
@[to_additive] lemma prod_range_succ (f : ℕ → M) (n : ℕ) :
    ((range n.succ).map f).prod = ((range n).map f).prod * f n 
Arguments: {M : Type u_4} [Monoid M] (f : ℕ → M) (n : ℕ)
Goal: (List.map f (List.range n.succ)).prod = (List.map f (List.range n)).prod * f n
-- List.sum_range_succ'
@[to_additive
"A variant of `sum_range_succ` which pulls off the first term in the sum rather than the last."]
lemma prod_range_succ' (f : ℕ → M) (n : ℕ) :
    ((range n.succ).map f).prod = f 0 * ((range n).map fun i ↦ f i.succ).prod 
Arguments: {M : Type u_4} [AddMonoid M] (f : ℕ → M) (n : ℕ)
Goal: (List.map f (List.range n.succ)).sum = f 0 + (List.map (fun i => f i.succ) (List.range n)).sum
-- List.prod_range_succ'
@[to_additive
"A variant of `sum_range_succ` which pulls off the first term in the sum rather than the last."]
lemma prod_range_succ' (f : ℕ → M) (n : ℕ) :
    ((range n.succ).map f).prod = f 0 * ((range n).map fun i ↦ f i.succ).prod 
Arguments: {M : Type u_4} [Monoid M] (f : ℕ → M) (n : ℕ)
Goal: (List.map f (List.range n.succ)).prod = f 0 * (List.map (fun i => f i.succ) (List.range n)).prod
-- List.sum_eq_zero
@[to_additive] lemma prod_eq_one (hl : ∀ x ∈ l, x = 1) : l.prod = 1 
Arguments: {M : Type u_4} [AddMonoid M] {l : List M} (hl : ∀ x ∈ l, x = 0)
Goal: l.sum = 0
-- List.prod_eq_one
@[to_additive] lemma prod_eq_one (hl : ∀ x ∈ l, x = 1) : l.prod = 1 
Arguments: {M : Type u_4} [Monoid M] {l : List M} (hl : ∀ x ∈ l, x = 1)
Goal: l.prod = 1
-- List.exists_mem_ne_zero_of_sum_ne_zero
@[to_additive] lemma exists_mem_ne_one_of_prod_ne_one (h : l.prod ≠ 1) :
    ∃ x ∈ l, x ≠ (1 : M) 
Arguments: {M : Type u_4} [AddMonoid M] {l : List M} (h : l.sum ≠ 0)
Goal: ∃ x ∈ l, x ≠ 0
-- List.exists_mem_ne_one_of_prod_ne_one
@[to_additive] lemma exists_mem_ne_one_of_prod_ne_one (h : l.prod ≠ 1) :
    ∃ x ∈ l, x ≠ (1 : M) 
Arguments: {M : Type u_4} [Monoid M] {l : List M} (h : l.prod ≠ 1)
Goal: ∃ x ∈ l, x ≠ 1
-- List.sum_erase_of_comm
@[to_additive]
lemma prod_erase_of_comm [DecidableEq M] (ha : a ∈ l) (comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x) :
    a * (l.erase a).prod = l.prod 
Arguments: {M : Type u_4} [AddMonoid M] {l : List M} {a : M} [DecidableEq M] (ha : a ∈ l) (comm : ∀ x ∈ l, ∀ y ∈ l, x + y = y + x)
Goal: a + (l.erase a).sum = l.sum
-- List.prod_erase_of_comm
@[to_additive]
lemma prod_erase_of_comm [DecidableEq M] (ha : a ∈ l) (comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x) :
    a * (l.erase a).prod = l.prod 
Arguments: {M : Type u_4} [Monoid M] {l : List M} {a : M} [DecidableEq M] (ha : a ∈ l) (comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x)
Goal: a * (l.erase a).prod = l.prod
-- List.prod_map_eq_pow_single
@[to_additive]
lemma prod_map_eq_pow_single [DecidableEq α] {l : List α} (a : α) (f : α → M)
    (hf : ∀ a', a' ≠ a → a' ∈ l → f a' = 1) : (l.map f).prod = f a ^ l.count a 
Arguments: {α : Type u_2} {M : Type u_4} [Monoid M] [DecidableEq α] {l : List α} (a : α) (f : α → M) (hf : ∀ (a' : α), a' ≠ a → a' ∈ l → f a' = 1)
Goal: (List.map f l).prod = f a ^ List.count a l
-- List.sum_map_eq_nsmul_single
@[to_additive]
lemma prod_map_eq_pow_single [DecidableEq α] {l : List α} (a : α) (f : α → M)
    (hf : ∀ a', a' ≠ a → a' ∈ l → f a' = 1) : (l.map f).prod = f a ^ l.count a 
Arguments: {α : Type u_2} {M : Type u_4} [AddMonoid M] [DecidableEq α] {l : List α} (a : α) (f : α → M) (hf : ∀ (a' : α), a' ≠ a → a' ∈ l → f a' = 0)
Goal: (List.map f l).sum = List.count a l • f a
-- List.sum_eq_nsmul_single
@[to_additive]
lemma prod_eq_pow_single [DecidableEq M] (a : M) (h : ∀ a', a' ≠ a → a' ∈ l → a' = 1) :
    l.prod = a ^ l.count a 
Arguments: {M : Type u_4} [AddMonoid M] {l : List M} [DecidableEq M] (a : M) (h : ∀ (a' : M), a' ≠ a → a' ∈ l → a' = 0)
Goal: l.sum = List.count a l • a
-- List.prod_eq_pow_single
@[to_additive]
lemma prod_eq_pow_single [DecidableEq M] (a : M) (h : ∀ a', a' ≠ a → a' ∈ l → a' = 1) :
    l.prod = a ^ l.count a 
Arguments: {M : Type u_4} [Monoid M] {l : List M} [DecidableEq M] (a : M) (h : ∀ (a' : M), a' ≠ a → a' ∈ l → a' = 1)
Goal: l.prod = a ^ List.count a l
-- List.Perm.sum_eq'
@[to_additive "If elements of a list additively commute with each other, then their sum does not
depend on the order of elements."]
lemma Perm.prod_eq' (h : l₁ ~ l₂) (hc : l₁.Pairwise Commute) : l₁.prod = l₂.prod 
Arguments: {M : Type u_4} [AddMonoid M] {l₁ l₂ : List M} (h : l₁ ~ l₂) (hc : List.Pairwise AddCommute l₁)
Goal: l₁.sum = l₂.sum