ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.Perm.prod_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} [Monoid M] {l₁ l₂ : List M} (h : l₁ ~ l₂) (hc : List.Pairwise Commute l₁)
Goal: l₁.prod = l₂.prod
-- List.prod_erase
@[to_additive (attr := simp)]
lemma prod_erase [DecidableEq M] (ha : a ∈ l) : a * (l.erase a).prod = l.prod 
Arguments: {M : Type u_4} [CommMonoid M] {a : M} {l : List M} [DecidableEq M] (ha : a ∈ l)
Goal: a * (l.erase a).prod = l.prod
-- List.sum_erase
@[to_additive (attr := simp)]
lemma prod_erase [DecidableEq M] (ha : a ∈ l) : a * (l.erase a).prod = l.prod 
Arguments: {M : Type u_4} [AddCommMonoid M] {a : M} {l : List M} [DecidableEq M] (ha : a ∈ l)
Goal: a + (l.erase a).sum = l.sum
-- List.sum_map_erase
@[to_additive (attr := simp)]
lemma prod_map_erase [DecidableEq α] (f : α → M) {a} :
    ∀ {l : List α}, a ∈ l → f a * ((l.erase a).map f).prod = (l.map f).prod
  
Arguments: {α : Type u_2} {M : Type u_4} [AddCommMonoid M] [DecidableEq α] (f : α → M) {a : α} {l : List α}
Goal: a ∈ l → f a + (List.map f (l.erase a)).sum = (List.map f l).sum
-- List.prod_map_erase
@[to_additive (attr := simp)]
lemma prod_map_erase [DecidableEq α] (f : α → M) {a} :
    ∀ {l : List α}, a ∈ l → f a * ((l.erase a).map f).prod = (l.map f).prod
  
Arguments: {α : Type u_2} {M : Type u_4} [CommMonoid M] [DecidableEq α] (f : α → M) {a : α} {l : List α}
Goal: a ∈ l → f a * (List.map f (l.erase a)).prod = (List.map f l).prod
-- List.Perm.sum_eq
@[to_additive] lemma Perm.prod_eq (h : Perm l₁ l₂) : prod l₁ = prod l₂ 
Arguments: {M : Type u_4} [AddCommMonoid M] {l₁ l₂ : List M} (h : l₁ ~ l₂)
Goal: l₁.sum = l₂.sum
-- List.Perm.prod_eq
@[to_additive] lemma Perm.prod_eq (h : Perm l₁ l₂) : prod l₁ = prod l₂ 
Arguments: {M : Type u_4} [CommMonoid M] {l₁ l₂ : List M} (h : l₁ ~ l₂)
Goal: l₁.prod = l₂.prod
-- List.sum_reverse
@[to_additive] lemma prod_reverse (l : List M) : prod l.reverse = prod l 
Arguments: {M : Type u_4} [AddCommMonoid M] (l : List M)
Goal: l.reverse.sum = l.sum
-- List.prod_reverse
@[to_additive] lemma prod_reverse (l : List M) : prod l.reverse = prod l 
Arguments: {M : Type u_4} [CommMonoid M] (l : List M)
Goal: l.reverse.prod = l.prod
-- List.sum_add_sum_eq_sum_zipWith_add_sum_drop
@[to_additive]
lemma prod_mul_prod_eq_prod_zipWith_mul_prod_drop :
    ∀ l l' : List M,
      l.prod * l'.prod =
        (zipWith (· * ·) l l').prod * (l.drop l'.length).prod * (l'.drop l.length).prod
  
Arguments: {M : Type u_4} [AddCommMonoid M] (l l' : List M)
Goal: l.sum + l'.sum =
  (List.zipWith (fun x x_1 => x + x_1) l l').sum + (List.drop l'.length l).sum + (List.drop l.length l').sum
-- List.prod_mul_prod_eq_prod_zipWith_mul_prod_drop
@[to_additive]
lemma prod_mul_prod_eq_prod_zipWith_mul_prod_drop :
    ∀ l l' : List M,
      l.prod * l'.prod =
        (zipWith (· * ·) l l').prod * (l.drop l'.length).prod * (l'.drop l.length).prod
  
Arguments: {M : Type u_4} [CommMonoid M] (l l' : List M)
Goal: l.prod * l'.prod =
  (List.zipWith (fun x x_1 => x * x_1) l l').prod * (List.drop l'.length l).prod * (List.drop l.length l').prod
-- List.prod_mul_prod_eq_prod_zipWith_of_length_eq
@[to_additive]
lemma prod_mul_prod_eq_prod_zipWith_of_length_eq (l l' : List M) (h : l.length = l'.length) :
    l.prod * l'.prod = (zipWith (· * ·) l l').prod 
Arguments: {M : Type u_4} [CommMonoid M] (l l' : List M) (h : l.length = l'.length)
Goal: l.prod * l'.prod = (List.zipWith (fun x x_1 => x * x_1) l l').prod
-- List.sum_add_sum_eq_sum_zipWith_of_length_eq
@[to_additive]
lemma prod_mul_prod_eq_prod_zipWith_of_length_eq (l l' : List M) (h : l.length = l'.length) :
    l.prod * l'.prod = (zipWith (· * ·) l l').prod 
Arguments: {M : Type u_4} [AddCommMonoid M] (l l' : List M) (h : l.length = l'.length)
Goal: l.sum + l'.sum = (List.zipWith (fun x x_1 => x + x_1) l l').sum
-- List.sum_map_ite
@[to_additive]
lemma prod_map_ite (p : α → Prop) [DecidablePred p] (f g : α → M) (l : List α) :
    (l.map fun a => if p a then f a else g a).prod =
      ((l.filter p).map f).prod * ((l.filter fun a ↦ ¬p a).map g).prod 
Arguments: {α : Type u_2} {M : Type u_4} [AddCommMonoid M] (p : α → Prop) [DecidablePred p] (f g : α → M) (l : List α)
Goal: (List.map (fun a => if p a then f a else g a) l).sum =
  (List.map f (List.filter (fun b => decide (p b)) l)).sum + (List.map g (List.filter (fun a => decide ¬p a) l)).sum
-- List.prod_map_ite
@[to_additive]
lemma prod_map_ite (p : α → Prop) [DecidablePred p] (f g : α → M) (l : List α) :
    (l.map fun a => if p a then f a else g a).prod =
      ((l.filter p).map f).prod * ((l.filter fun a ↦ ¬p a).map g).prod 
Arguments: {α : Type u_2} {M : Type u_4} [CommMonoid M] (p : α → Prop) [DecidablePred p] (f g : α → M) (l : List α)
Goal: (List.map (fun a => if p a then f a else g a) l).prod =
  (List.map f (List.filter (fun b => decide (p b)) l)).prod * (List.map g (List.filter (fun a => decide ¬p a) l)).prod
-- List.prod_map_filter_mul_prod_map_filter_not
@[to_additive]
lemma prod_map_filter_mul_prod_map_filter_not (p : α → Prop) [DecidablePred p] (f : α → M)
    (l : List α) :
    ((l.filter p).map f).prod * ((l.filter fun x => ¬p x).map f).prod = (l.map f).prod 
Arguments: {α : Type u_2} {M : Type u_4} [CommMonoid M] (p : α → Prop) [DecidablePred p] (f : α → M) (l : List α)
Goal: (List.map f (List.filter (fun b => decide (p b)) l)).prod * (List.map f (List.filter (fun x => decide ¬p x) l)).prod =
  (List.map f l).prod
-- List.sum_map_filter_add_sum_map_filter_not
@[to_additive]
lemma prod_map_filter_mul_prod_map_filter_not (p : α → Prop) [DecidablePred p] (f : α → M)
    (l : List α) :
    ((l.filter p).map f).prod * ((l.filter fun x => ¬p x).map f).prod = (l.map f).prod 
Arguments: {α : Type u_2} {M : Type u_4} [AddCommMonoid M] (p : α → Prop) [DecidablePred p] (f : α → M) (l : List α)
Goal: (List.map f (List.filter (fun b => decide (p b)) l)).sum + (List.map f (List.filter (fun x => decide ¬p x) l)).sum =
  (List.map f l).sum
-- List.eq_of_sum_take_eq
@[to_additive]
lemma eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length)
    (h' : ∀ i ≤ L.length, (L.take i).prod = (L'.take i).prod) : L = L' 
Arguments: {M : Type u_4} [AddLeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length) (h' : ∀ i ≤ L.length, (List.take i L).sum = (List.take i L').sum)
Goal: L = L'
-- List.eq_of_prod_take_eq
@[to_additive]
lemma eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length)
    (h' : ∀ i ≤ L.length, (L.take i).prod = (L'.take i).prod) : L = L' 
Arguments: {M : Type u_4} [LeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length) (h' : ∀ i ≤ L.length, (List.take i L).prod = (List.take i L').prod)
Goal: L = L'
-- List.prod_inv_reverse
@[to_additive "This is the `List.sum` version of `add_neg_rev`"]
theorem prod_inv_reverse : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).reverse.prod
  
Arguments: {G : Type u_7} [Group G] (L : List G)
Goal: L.prod⁻¹ = (List.map (fun x => x⁻¹) L).reverse.prod
-- List.sum_neg_reverse
@[to_additive "This is the `List.sum` version of `add_neg_rev`"]
theorem prod_inv_reverse : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).reverse.prod
  
Arguments: {G : Type u_7} [AddGroup G] (L : List G)
Goal: -L.sum = (List.map (fun x => -x) L).reverse.sum
-- List.prod_reverse_noncomm
@[to_additive "A non-commutative variant of `List.sum_reverse`"]
theorem prod_reverse_noncomm : ∀ L : List G, L.reverse.prod = (L.map fun x => x⁻¹).prod⁻¹ 
Arguments: {G : Type u_7} [Group G] (L : List G)
Goal: L.reverse.prod = (List.map (fun x => x⁻¹) L).prod⁻¹
-- List.sum_reverse_noncomm
@[to_additive "A non-commutative variant of `List.sum_reverse`"]
theorem prod_reverse_noncomm : ∀ L : List G, L.reverse.prod = (L.map fun x => x⁻¹).prod⁻¹ 
Arguments: {G : Type u_7} [AddGroup G] (L : List G)
Goal: L.reverse.sum = -(List.map (fun x => -x) L).sum
-- List.prod_drop_succ
@[to_additive (attr := simp)
  "Counterpart to `List.sum_take_succ` when we have a negation operation"]
theorem prod_drop_succ :
    ∀ (L : List G) (i : ℕ) (p), (L.drop (i + 1)).prod = (L.get ⟨i, p⟩)⁻¹ * (L.drop i).prod
  
Arguments: {G : Type u_7} [Group G] (L : List G) (i : ℕ) (p : i < L.length)
Goal: (List.drop (i + 1) L).prod = (L.get ⟨i, p⟩)⁻¹ * (List.drop i L).prod
-- List.sum_drop_succ
@[to_additive (attr := simp)
  "Counterpart to `List.sum_take_succ` when we have a negation operation"]
theorem prod_drop_succ :
    ∀ (L : List G) (i : ℕ) (p), (L.drop (i + 1)).prod = (L.get ⟨i, p⟩)⁻¹ * (L.drop i).prod
  
Arguments: {G : Type u_7} [AddGroup G] (L : List G) (i : ℕ) (p : i < L.length)
Goal: (List.drop (i + 1) L).sum = -L.get ⟨i, p⟩ + (List.drop i L).sum
-- List.prod_range_div'
@[to_additive "Cancellation of a telescoping sum."]
theorem prod_range_div' (n : ℕ) (f : ℕ → G) :
    ((range n).map fun k ↦ f k / f (k + 1)).prod = f 0 / f n 
Arguments: {G : Type u_7} [Group G] (n : ℕ) (f : ℕ → G)
Goal: (List.map (fun k => f k / f (k + 1)) (List.range n)).prod = f 0 / f n
-- List.sum_range_sub'
@[to_additive "Cancellation of a telescoping sum."]
theorem prod_range_div' (n : ℕ) (f : ℕ → G) :
    ((range n).map fun k ↦ f k / f (k + 1)).prod = f 0 / f n 
Arguments: {G : Type u_7} [AddGroup G] (n : ℕ) (f : ℕ → G)
Goal: (List.map (fun k => f k - f (k + 1)) (List.range n)).sum = f 0 - f n
-- List.prod_rotate_eq_one_of_prod_eq_one
lemma prod_rotate_eq_one_of_prod_eq_one :
    ∀ {l : List G} (_ : l.prod = 1) (n : ℕ), (l.rotate n).prod = 1
  
Arguments: {G : Type u_7} [Group G] {l : List G}
Goal: l.prod = 1 → ∀ (n : ℕ), (l.rotate n).prod = 1
-- List.sum_neg
@[to_additive "This is the `List.sum` version of `add_neg`"]
theorem prod_inv : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).prod
  
Arguments: {G : Type u_7} [AddCommGroup G] (L : List G)
Goal: -L.sum = (List.map (fun x => -x) L).sum
-- List.prod_inv
@[to_additive "This is the `List.sum` version of `add_neg`"]
theorem prod_inv : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).prod
  
Arguments: {G : Type u_7} [CommGroup G] (L : List G)
Goal: L.prod⁻¹ = (List.map (fun x => x⁻¹) L).prod
-- List.sum_range_sub
@[to_additive "Cancellation of a telescoping sum."]
theorem prod_range_div (n : ℕ) (f : ℕ → G) :
    ((range n).map fun k ↦ f (k + 1) / f k).prod = f n / f 0 
Arguments: {G : Type u_7} [AddCommGroup G] (n : ℕ) (f : ℕ → G)
Goal: (List.map (fun k => f (k + 1) - f k) (List.range n)).sum = f n - f 0
-- List.prod_range_div
@[to_additive "Cancellation of a telescoping sum."]
theorem prod_range_div (n : ℕ) (f : ℕ → G) :
    ((range n).map fun k ↦ f (k + 1) / f k).prod = f n / f 0 
Arguments: {G : Type u_7} [CommGroup G] (n : ℕ) (f : ℕ → G)
Goal: (List.map (fun k => f (k + 1) / f k) (List.range n)).prod = f n / f 0
-- List.sum_set'
@[to_additive "Alternative version of `List.sum_set` when the list is over a group"]
theorem prod_set' (L : List G) (n : ℕ) (a : G) :
    (L.set n a).prod = L.prod * if hn : n < L.length then (L.get ⟨n, hn⟩)⁻¹ * a else 1 
Arguments: {G : Type u_7} [AddCommGroup G] (L : List G) (n : ℕ) (a : G)
Goal: (L.set n a).sum = L.sum + if hn : n < L.length then -L.get ⟨n, hn⟩ + a else 0
-- List.prod_set'
@[to_additive "Alternative version of `List.sum_set` when the list is over a group"]
theorem prod_set' (L : List G) (n : ℕ) (a : G) :
    (L.set n a).prod = L.prod * if hn : n < L.length then (L.get ⟨n, hn⟩)⁻¹ * a else 1 
Arguments: {G : Type u_7} [CommGroup G] (L : List G) (n : ℕ) (a : G)
Goal: (L.set n a).prod = L.prod * if hn : n < L.length then (L.get ⟨n, hn⟩)⁻¹ * a else 1
-- List.prod_map_ite_eq
@[to_additive]
lemma prod_map_ite_eq {A : Type*} [DecidableEq A] (l : List A) (f g : A → G) (a : A) :
    (l.map fun x => if x = a then f x else g x).prod
      = (f a / g a) ^ (l.count a) * (l.map g).prod 
Arguments: {G : Type u_7} [CommGroup G] {A : Type u_8} [DecidableEq A] (l : List A) (f g : A → G) (a : A)
Goal: (List.map (fun x => if x = a then f x else g x) l).prod = (f a / g a) ^ List.count a l * (List.map g l).prod
-- List.sum_map_ite_eq
@[to_additive]
lemma prod_map_ite_eq {A : Type*} [DecidableEq A] (l : List A) (f g : A → G) (a : A) :
    (l.map fun x => if x = a then f x else g x).prod
      = (f a / g a) ^ (l.count a) * (l.map g).prod 
Arguments: {G : Type u_7} [AddCommGroup G] {A : Type u_8} [DecidableEq A] (l : List A) (f g : A → G) (a : A)
Goal: (List.map (fun x => if x = a then f x else g x) l).sum = List.count a l • (f a - g a) + (List.map g l).sum
-- List.sum_const_nat
theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n 
Arguments: (m n : ℕ)
Goal: (List.replicate m n).sum = m * n
-- List.headI_add_tail_sum
theorem headI_add_tail_sum (L : List ℕ) : L.headI + L.tail.sum = L.sum 
Arguments: (L : List ℕ)
Goal: L.headI + L.tail.sum = L.sum
-- List.headI_le_sum
theorem headI_le_sum (L : List ℕ) : L.headI ≤ L.sum 
Arguments: (L : List ℕ)
Goal: L.headI ≤ L.sum
-- List.tail_sum
theorem tail_sum (L : List ℕ) : L.tail.sum = L.sum - L.headI 
Arguments: (L : List ℕ)
Goal: L.tail.sum = L.sum - L.headI
-- List.alternatingProd_nil
@[to_additive (attr := simp)]
theorem alternatingProd_nil : alternatingProd ([] : List α) = 1 
Arguments: {α : Type u_2} [One α] [Mul α] [Inv α]
Goal: [].alternatingProd = 1
-- List.alternatingSum_nil
@[to_additive (attr := simp)]
theorem alternatingProd_nil : alternatingProd ([] : List α) = 1 
Arguments: {α : Type u_2} [Zero α] [Add α] [Neg α]
Goal: [].alternatingSum = 0
-- List.alternatingProd_singleton
@[to_additive (attr := simp)]
theorem alternatingProd_singleton (a : α) : alternatingProd [a] = a 
Arguments: {α : Type u_2} [One α] [Mul α] [Inv α] (a : α)
Goal: [a].alternatingProd = a
-- List.alternatingSum_singleton
@[to_additive (attr := simp)]
theorem alternatingProd_singleton (a : α) : alternatingProd [a] = a 
Arguments: {α : Type u_2} [Zero α] [Add α] [Neg α] (a : α)
Goal: [a].alternatingSum = a
-- List.alternatingProd_cons_cons'
@[to_additive]
theorem alternatingProd_cons_cons' (a b : α) (l : List α) :
    alternatingProd (a :: b :: l) = a * b⁻¹ * alternatingProd l 
Arguments: {α : Type u_2} [One α] [Mul α] [Inv α] (a b : α) (l : List α)
Goal: (a :: b :: l).alternatingProd = a * b⁻¹ * l.alternatingProd
-- List.alternatingSum_cons_cons'
@[to_additive]
theorem alternatingProd_cons_cons' (a b : α) (l : List α) :
    alternatingProd (a :: b :: l) = a * b⁻¹ * alternatingProd l 
Arguments: {α : Type u_2} [Zero α] [Add α] [Neg α] (a b : α) (l : List α)
Goal: (a :: b :: l).alternatingSum = a + -b + l.alternatingSum
-- List.alternatingSum_cons_cons
@[to_additive]
theorem alternatingProd_cons_cons [DivInvMonoid α] (a b : α) (l : List α) :
    alternatingProd (a :: b :: l) = a / b * alternatingProd l 
Arguments: {α : Type u_2} [SubNegMonoid α] (a b : α) (l : List α)
Goal: (a :: b :: l).alternatingSum = a - b + l.alternatingSum
-- List.alternatingProd_cons_cons
@[to_additive]
theorem alternatingProd_cons_cons [DivInvMonoid α] (a b : α) (l : List α) :
    alternatingProd (a :: b :: l) = a / b * alternatingProd l 
Arguments: {α : Type u_2} [DivInvMonoid α] (a b : α) (l : List α)
Goal: (a :: b :: l).alternatingProd = a / b * l.alternatingProd
-- List.alternatingSum_cons'
@[to_additive]
theorem alternatingProd_cons' :
    ∀ (a : α) (l : List α), alternatingProd (a :: l) = a * (alternatingProd l)⁻¹
  
Arguments: {α : Type u_2} [AddCommGroup α] (a : α) (l : List α)
Goal: (a :: l).alternatingSum = a + -l.alternatingSum
-- List.alternatingProd_cons'
@[to_additive]
theorem alternatingProd_cons' :
    ∀ (a : α) (l : List α), alternatingProd (a :: l) = a * (alternatingProd l)⁻¹
  
Arguments: {α : Type u_2} [CommGroup α] (a : α) (l : List α)
Goal: (a :: l).alternatingProd = a * l.alternatingProd⁻¹
-- List.alternatingSum_cons
@[to_additive (attr := simp)]
theorem alternatingProd_cons (a : α) (l : List α) :
    alternatingProd (a :: l) = a / alternatingProd l 
Arguments: {α : Type u_2} [AddCommGroup α] (a : α) (l : List α)
Goal: (a :: l).alternatingSum = a - l.alternatingSum
-- List.alternatingProd_cons
@[to_additive (attr := simp)]
theorem alternatingProd_cons (a : α) (l : List α) :
    alternatingProd (a :: l) = a / alternatingProd l 
Arguments: {α : Type u_2} [CommGroup α] (a : α) (l : List α)
Goal: (a :: l).alternatingProd = a / l.alternatingProd
-- List.sum_nat_mod
lemma sum_nat_mod (l : List ℕ) (n : ℕ) : l.sum % n = (l.map (· % n)).sum % n 
Arguments: (l : List ℕ) (n : ℕ)
Goal: l.sum % n = (List.map (fun x => x % n) l).sum % n
-- List.prod_nat_mod
lemma prod_nat_mod (l : List ℕ) (n : ℕ) : l.prod % n = (l.map (· % n)).prod % n 
Arguments: (l : List ℕ) (n : ℕ)
Goal: l.prod % n = (List.map (fun x => x % n) l).prod % n
-- List.sum_int_mod
lemma sum_int_mod (l : List ℤ) (n : ℤ) : l.sum % n = (l.map (· % n)).sum % n 
Arguments: (l : List ℤ) (n : ℤ)
Goal: l.sum % n = (List.map (fun x => x % n) l).sum % n
-- List.prod_int_mod
lemma prod_int_mod (l : List ℤ) (n : ℤ) : l.prod % n = (l.map (· % n)).prod % n 
Arguments: (l : List ℤ) (n : ℤ)
Goal: l.prod % n = (List.map (fun x => x % n) l).prod % n
-- List.sum_map_count_dedup_filter_eq_countP
theorem sum_map_count_dedup_filter_eq_countP (p : α → Bool) (l : List α) :
    ((l.dedup.filter p).map fun x => l.count x).sum = l.countP p 
Arguments: {α : Type u_2} [DecidableEq α] (p : α → Bool) (l : List α)
Goal: (List.map (fun x => List.count x l) (List.filter p l.dedup)).sum = List.countP p l
-- List.sum_map_count_dedup_eq_length
theorem sum_map_count_dedup_eq_length (l : List α) :
    (l.dedup.map fun x => l.count x).sum = l.length 
Arguments: {α : Type u_2} [DecidableEq α] (l : List α)
Goal: (List.map (fun x => List.count x l) l.dedup).sum = l.length
-- map_list_sum
@[to_additive]
theorem map_list_prod {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) (l : List M) :
    f l.prod = (l.map f).prod 
Arguments: {M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N] {F : Type u_8} [FunLike F M N] [AddMonoidHomClass F M N] (f : F) (l : List M)
Goal: f l.sum = (List.map (⇑f) l).sum
-- map_list_prod
@[to_additive]
theorem map_list_prod {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) (l : List M) :
    f l.prod = (l.map f).prod 
Arguments: {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] {F : Type u_8} [FunLike F M N] [MonoidHomClass F M N] (f : F) (l : List M)
Goal: f l.prod = (List.map (⇑f) l).prod
-- AddMonoidHom.map_list_sum
@[to_additive]
protected theorem map_list_prod (f : M →* N) (l : List M) : f l.prod = (l.map f).prod 
Arguments: {M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N] (f : M →+ N) (l : List M)
Goal: f l.sum = (List.map (⇑f) l).sum
-- MonoidHom.map_list_prod
@[to_additive]
protected theorem map_list_prod (f : M →* N) (l : List M) : f l.prod = (l.map f).prod 
Arguments: {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N] (f : M →* N) (l : List M)
Goal: f l.prod = (List.map (⇑f) l).prod
-- Nat.sum_eq_listSum
@[simp] lemma Nat.sum_eq_listSum (l : List ℕ) : Nat.sum l = l.sum 
Arguments: (l : List ℕ)
Goal: Nat.sum l = l.sum
-- List.length_sigma
lemma length_sigma {σ : α → Type*} (l₁ : List α) (l₂ : ∀ a, List (σ a)) :
    length (l₁.sigma l₂) = (l₁.map fun a ↦ length (l₂ a)).sum 
Arguments: {α : Type u_2} {σ : α → Type u_8} (l₁ : List α) (l₂ : (a : α) → List (σ a))
Goal: (l₁.sigma l₂).length = (List.map (fun a => (l₂ a).length) l₁).sum
-- List.ranges_join
lemma ranges_join (l : List ℕ) : l.ranges.join = range l.sum 
Arguments: (l : List ℕ)
Goal: l.ranges.join = List.range l.sum
-- List.mem_mem_ranges_iff_lt_sum
lemma mem_mem_ranges_iff_lt_sum (l : List ℕ) {n : ℕ} :
    (∃ s ∈ l.ranges, n ∈ s) ↔ n < l.sum 
Arguments: (l : List ℕ) {n : ℕ}
Goal: (∃ s ∈ l.ranges, n ∈ s) ↔ n < l.sum
-- List.length_join
@[simp]
theorem length_join (L : List (List α)) : length (join L) = sum (map length L) 
Arguments: {α : Type u_2} (L : List (List α))
Goal: L.join.length = (List.map List.length L).sum
-- List.countP_join
lemma countP_join (p : α → Bool) : ∀ L : List (List α), countP p L.join = (L.map (countP p)).sum
  
Arguments: {α : Type u_2} (p : α → Bool) (L : List (List α))
Goal: List.countP p L.join = (List.map (List.countP p) L).sum
-- List.count_join
lemma count_join [BEq α] (L : List (List α)) (a : α) : L.join.count a = (L.map (count a)).sum 
Arguments: {α : Type u_2} [BEq α] (L : List (List α)) (a : α)
Goal: List.count a L.join = (List.map (List.count a) L).sum
-- List.length_bind
@[simp]
theorem length_bind (l : List α) (f : α → List β) :
    length (List.bind l f) = sum (map (length ∘ f) l) 
Arguments: {α : Type u_2} {β : Type u_3} (l : List α) (f : α → List β)
Goal: (l.bind f).length = (List.map (List.length ∘ f) l).sum
-- List.countP_bind
lemma countP_bind (p : β → Bool) (l : List α) (f : α → List β) :
    countP p (l.bind f) = sum (map (countP p ∘ f) l) 
Arguments: {α : Type u_2} {β : Type u_3} (p : β → Bool) (l : List α) (f : α → List β)
Goal: List.countP p (l.bind f) = (List.map (List.countP p ∘ f) l).sum
-- List.count_bind
lemma count_bind [BEq β] (l : List α) (f : α → List β) (x : β) :
    count x (l.bind f) = sum (map (count x ∘ f) l) 
Arguments: {α : Type u_2} {β : Type u_3} [BEq β] (l : List α) (f : α → List β) (x : β)
Goal: List.count x (l.bind f) = (List.map (List.count x ∘ f) l).sum
-- List.take_sum_join
lemma take_sum_join (L : List (List α)) (i : ℕ) :
    L.join.take ((L.map length).take i).sum = (L.take i).join 
Arguments: {α : Type u_2} (L : List (List α)) (i : ℕ)
Goal: List.take (List.take i (List.map List.length L)).sum L.join = (List.take i L).join
-- List.drop_sum_join
lemma drop_sum_join (L : List (List α)) (i : ℕ) :
    L.join.drop ((L.map length).take i).sum = (L.drop i).join 
Arguments: {α : Type u_2} (L : List (List α)) (i : ℕ)
Goal: List.drop (List.take i (List.map List.length L)).sum L.join = (List.drop i L).join
-- List.drop_take_succ_join_eq_getElem
lemma drop_take_succ_join_eq_getElem (L : List (List α)) (i : Nat) (h : i < L.length) :
    (L.join.take ((L.map length).take (i + 1)).sum).drop ((L.map length).take i).sum = L[i] 
Arguments: {α : Type u_2} (L : List (List α)) (i : ℕ) (h : i < L.length)
Goal: List.drop (List.take i (List.map List.length L)).sum
    (List.take (List.take (i + 1) (List.map List.length L)).sum L.join) =
  L[i]
-- List.drop_take_succ_join_eq_get
@[deprecated drop_take_succ_join_eq_getElem (since := "2024-06-11")]
lemma drop_take_succ_join_eq_get (L : List (List α)) (i : Fin L.length) :
    (L.join.take ((L.map length).take (i + 1)).sum).drop ((L.map length).take i).sum = get L i 
Arguments: {α : Type u_2} (L : List (List α)) (i : Fin L.length)
Goal: List.drop (List.take (↑i) (List.map List.length L)).sum
    (List.take (List.take (↑i + 1) (List.map List.length L)).sum L.join) =
  L.get i
-- List.neg_one_mem_of_prod_eq_neg_one
theorem neg_one_mem_of_prod_eq_neg_one {l : List ℤ} (h : l.prod = -1) : (-1 : ℤ) ∈ l 
Arguments: {l : List ℤ} (h : l.prod = -1)
Goal: -1 ∈ l
-- List.length_le_sum_of_one_le
theorem length_le_sum_of_one_le (L : List ℕ) (h : ∀ i ∈ L, 1 ≤ i) : L.length ≤ L.sum 
Arguments: (L : List ℕ) (h : ∀ i ∈ L, 1 ≤ i)
Goal: L.length ≤ L.sum
-- List.dvd_prod
theorem dvd_prod [CommMonoid M] {a} {l : List M} (ha : a ∈ l) : a ∣ l.prod 
Arguments: {M : Type u_4} [CommMonoid M] {a : M} {l : List M} (ha : a ∈ l)
Goal: a ∣ l.prod
-- List.Sublist.prod_dvd_prod
theorem Sublist.prod_dvd_prod [CommMonoid M] {l₁ l₂ : List M} (h : l₁ <+ l₂) :
    l₁.prod ∣ l₂.prod 
Arguments: {M : Type u_4} [CommMonoid M] {l₁ l₂ : List M} (h : l₁ <+ l₂)
Goal: l₁.prod ∣ l₂.prod
-- List.alternatingProd_append
@[to_additive]
theorem alternatingProd_append :
    ∀ l₁ l₂ : List α,
      alternatingProd (l₁ ++ l₂) = alternatingProd l₁ * alternatingProd l₂ ^ (-1 : ℤ) ^ length l₁
  
Arguments: {α : Type u_2} [CommGroup α] (l₁ l₂ : List α)
Goal: (l₁ ++ l₂).alternatingProd = l₁.alternatingProd * l₂.alternatingProd ^ (-1) ^ l₁.length
-- List.alternatingSum_append
@[to_additive]
theorem alternatingProd_append :
    ∀ l₁ l₂ : List α,
      alternatingProd (l₁ ++ l₂) = alternatingProd l₁ * alternatingProd l₂ ^ (-1 : ℤ) ^ length l₁
  
Arguments: {α : Type u_2} [AddCommGroup α] (l₁ l₂ : List α)
Goal: (l₁ ++ l₂).alternatingSum = l₁.alternatingSum + (-1) ^ l₁.length • l₂.alternatingSum
-- List.alternatingSum_reverse
@[to_additive]
theorem alternatingProd_reverse :
    ∀ l : List α, alternatingProd (reverse l) = alternatingProd l ^ (-1 : ℤ) ^ (length l + 1)
  
Arguments: {α : Type u_2} [AddCommGroup α] (l : List α)
Goal: l.reverse.alternatingSum = (-1) ^ (l.length + 1) • l.alternatingSum