Big operators

In this file we define products and sums indexed by finite sets (specifically, Finset).

Notation

We introduce the following notation, localized in BigOperators. To enable the notation, use open BigOperators.

Let s be a Finset α, and f : α → β a function.

• ∏ x in s, f x is notation for Finset.prod s f (assuming β is a CommMonoid)
• ∑ x in s, f x is notation for Finset.sum s f (assuming β is an AddCommMonoid)
• ∏ x, f x is notation for Finset.prod Finset.univ f (assuming α is a Fintype and β is a CommMonoid)
• ∑ x, f x is notation for Finset.sum Finset.univ f (assuming α is a Fintype and β is an AddCommMonoid)

Implementation Notes

The first arguments in all definitions and lemmas is the codomain of the function of the big operator. This is necessary for the heuristic in @[to_additive]. See the documentation of to_additive.attr for more information.

def Finset.sum {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (f : α → β) : β

∑ x in s, f x is the sum of f x as x ranges over the elements of the finite set s.

Equations

• Finset.sum s f = Multiset.sum (Multiset.map f s.val)

def Finset.prod {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (f : α → β) : β

∏ x in s, f x is the product of f x as x ranges over the elements of the finite set s.

Equations

• Finset.prod s f = Multiset.prod (Multiset.map f s.val)

@[simp]

theorem Finset.sum_mk {β : Type u} {α : Type v} [AddCommMonoid β] (s : Multiset α) (hs : Multiset.Nodup s) (f : α → β) : Finset.sum { val := s, nodup := hs } f = Multiset.sum (Multiset.map f s)

@[simp]

theorem Finset.prod_mk {β : Type u} {α : Type v} [CommMonoid β] (s : Multiset α) (hs : Multiset.Nodup s) (f : α → β) : Finset.prod { val := s, nodup := hs } f = Multiset.prod (Multiset.map f s)

@[simp]

theorem Finset.sum_val {α : Type v} [AddCommMonoid α] (s : Finset α) : Multiset.sum s.val = Finset.sum s id

@[simp]

theorem Finset.prod_val {α : Type v} [CommMonoid α] (s : Finset α) : Multiset.prod s.val = Finset.prod s id

def BigOperators.bigsum : Lean.ParserDescr

∑ x, f x is notation for Finset.sum Finset.univ f. It is the sum of f x, where x ranges over the finite domain of f.

Equations

• One or more equations did not get rendered due to their size.

def BigOperators.bigprod : Lean.ParserDescr

∏ x, f x is notation for Finset.prod Finset.univ f. It is the product of f x, where x ranges over the finite domain of f.

Equations

• One or more equations did not get rendered due to their size.

def BigOperators.bigsumin : Lean.ParserDescr

∑ x in s, f x is notation for Finset.sum s f. It is the sum of f x, where x ranges over the finite set s.

Equations

• One or more equations did not get rendered due to their size.

def BigOperators.bigprodin : Lean.ParserDescr

∏ x in s, f x is notation for Finset.prod s f. It is the product of f x, where x ranges over the finite set s.

Equations

• One or more equations did not get rendered due to their size.

def BigOperators.delabFinsetProd : Lean.PrettyPrinter.Delaborator.Delab

Delaborator for Finset.prod. The pp.piBinderTypes option controls whether to show the domain type when the product is over Finset.univ.

Equations

• One or more equations did not get rendered due to their size.

def BigOperators.delabFinsetSum : Lean.PrettyPrinter.Delaborator.Delab

Delaborator for Finset.prod. The pp.piBinderTypes option controls whether to show the domain type when the sum is over Finset.univ.

Equations

• One or more equations did not get rendered due to their size.

theorem Finset.sum_eq_multiset_sum {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (f : α → β) : (Finset.sum s fun (x : α) => f x) = Multiset.sum (Multiset.map f s.val)

theorem Finset.prod_eq_multiset_prod {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (f : α → β) : (Finset.prod s fun (x : α) => f x) = Multiset.prod (Multiset.map f s.val)

@[simp]

theorem Finset.sum_map_val {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (f : α → β) : Multiset.sum (Multiset.map f s.val) = Finset.sum s fun (a : α) => f a

@[simp]

theorem Finset.prod_map_val {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (f : α → β) : Multiset.prod (Multiset.map f s.val) = Finset.prod s fun (a : α) => f a

theorem Finset.sum_eq_fold {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (f : α → β) : (Finset.sum s fun (x : α) => f x) = Finset.fold (fun (x x_1 : β) => x + x_1) 0 f s

theorem Finset.prod_eq_fold {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (f : α → β) : (Finset.prod s fun (x : α) => f x) = Finset.fold (fun (x x_1 : β) => x * x_1) 1 f s

@[simp]

theorem Finset.sum_multiset_singleton {α : Type v} (s : Finset α) : (Finset.sum s fun (x : α) => {x}) = s.val

@[simp]

theorem map_sum {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] [AddCommMonoid γ] {G : Type u_2} [FunLike G β γ] [AddMonoidHomClass G β γ] (g : G) (f : α → β) (s : Finset α) : g (Finset.sum s fun (x : α) => f x) = Finset.sum s fun (x : α) => g (f x)

@[simp]

theorem map_prod {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] [CommMonoid γ] {G : Type u_2} [FunLike G β γ] [MonoidHomClass G β γ] (g : G) (f : α → β) (s : Finset α) : g (Finset.prod s fun (x : α) => f x) = Finset.prod s fun (x : α) => g (f x)

@[deprecated map_list_prod]

theorem RingHom.map_list_prod {β : Type u} {γ : Type w} [Semiring β] [Semiring γ] (f : β →+* γ) (l : List β) : f (List.prod l) = List.prod (List.map (⇑f) l)

@[deprecated map_list_sum]

theorem RingHom.map_list_sum {β : Type u} {γ : Type w} [NonAssocSemiring β] [NonAssocSemiring γ] (f : β →+* γ) (l : List β) : f (List.sum l) = List.sum (List.map (⇑f) l)

@[deprecated unop_map_list_prod]

theorem RingHom.unop_map_list_prod {β : Type u} {γ : Type w} [Semiring β] [Semiring γ] (f : β →+* γᵐᵒᵖ) (l : List β) : MulOpposite.unop (f (List.prod l)) = List.prod (List.reverse (List.map (MulOpposite.unop ∘ ⇑f) l))

A morphism into the opposite ring acts on the product by acting on the reversed elements.

@[deprecated map_multiset_prod]

theorem RingHom.map_multiset_prod {β : Type u} {γ : Type w} [CommSemiring β] [CommSemiring γ] (f : β →+* γ) (s : Multiset β) : f (Multiset.prod s) = Multiset.prod (Multiset.map (⇑f) s)

@[deprecated map_multiset_sum]

theorem RingHom.map_multiset_sum {β : Type u} {γ : Type w} [NonAssocSemiring β] [NonAssocSemiring γ] (f : β →+* γ) (s : Multiset β) : f (Multiset.sum s) = Multiset.sum (Multiset.map (⇑f) s)

@[deprecated map_prod]

theorem RingHom.map_prod {β : Type u} {α : Type v} {γ : Type w} [CommSemiring β] [CommSemiring γ] (g : β →+* γ) (f : α → β) (s : Finset α) : g (Finset.prod s fun (x : α) => f x) = Finset.prod s fun (x : α) => g (f x)

@[deprecated map_sum]

theorem RingHom.map_sum {β : Type u} {α : Type v} {γ : Type w} [NonAssocSemiring β] [NonAssocSemiring γ] (g : β →+* γ) (f : α → β) (s : Finset α) : g (Finset.sum s fun (x : α) => f x) = Finset.sum s fun (x : α) => g (f x)

theorem AddMonoidHom.coe_finset_sum {β : Type u} {α : Type v} {γ : Type w} [AddZeroClass β] [AddCommMonoid γ] (f : α → β →+ γ) (s : Finset α) : ⇑(Finset.sum s fun (x : α) => f x) = Finset.sum s fun (x : α) => ⇑(f x)

theorem MonoidHom.coe_finset_prod {β : Type u} {α : Type v} {γ : Type w} [MulOneClass β] [CommMonoid γ] (f : α → β →* γ) (s : Finset α) : ⇑(Finset.prod s fun (x : α) => f x) = Finset.prod s fun (x : α) => ⇑(f x)

@[simp]

theorem AddMonoidHom.finset_sum_apply {β : Type u} {α : Type v} {γ : Type w} [AddZeroClass β] [AddCommMonoid γ] (f : α → β →+ γ) (s : Finset α) (b : β) : (Finset.sum s fun (x : α) => f x) b = Finset.sum s fun (x : α) => (f x) b

See also Finset.sum_apply, with the same conclusion but with the weaker hypothesis f : α → β → γ

@[simp]

theorem MonoidHom.finset_prod_apply {β : Type u} {α : Type v} {γ : Type w} [MulOneClass β] [CommMonoid γ] (f : α → β →* γ) (s : Finset α) (b : β) : (Finset.prod s fun (x : α) => f x) b = Finset.prod s fun (x : α) => (f x) b

See also Finset.prod_apply, with the same conclusion but with the weaker hypothesis f : α → β → γ

@[simp]

theorem Finset.sum_empty {β : Type u} {α : Type v} {f : α → β} [AddCommMonoid β] : (Finset.sum ∅ fun (x : α) => f x) = 0

@[simp]

theorem Finset.prod_empty {β : Type u} {α : Type v} {f : α → β} [CommMonoid β] : (Finset.prod ∅ fun (x : α) => f x) = 1

theorem Finset.sum_of_empty {β : Type u} {α : Type v} {f : α → β} [AddCommMonoid β] [IsEmpty α] (s : Finset α) : (Finset.sum s fun (i : α) => f i) = 0

theorem Finset.prod_of_empty {β : Type u} {α : Type v} {f : α → β} [CommMonoid β] [IsEmpty α] (s : Finset α) : (Finset.prod s fun (i : α) => f i) = 1

@[simp]

theorem Finset.sum_cons {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [AddCommMonoid β] (h : a ∉ s) : (Finset.sum (Finset.cons a s h) fun (x : α) => f x) = f a + Finset.sum s fun (x : α) => f x

@[simp]

theorem Finset.prod_cons {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [CommMonoid β] (h : a ∉ s) : (Finset.prod (Finset.cons a s h) fun (x : α) => f x) = f a * Finset.prod s fun (x : α) => f x

@[simp]

theorem Finset.sum_insert {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [AddCommMonoid β] [DecidableEq α] : a ∉ s → (Finset.sum (insert a s) fun (x : α) => f x) = f a + Finset.sum s fun (x : α) => f x

@[simp]

theorem Finset.prod_insert {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [CommMonoid β] [DecidableEq α] : a ∉ s → (Finset.prod (insert a s) fun (x : α) => f x) = f a * Finset.prod s fun (x : α) => f x

@[simp]

theorem Finset.sum_insert_of_eq_zero_if_not_mem {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [AddCommMonoid β] [DecidableEq α] (h : a ∉ s → f a = 0) : (Finset.sum (insert a s) fun (x : α) => f x) = Finset.sum s fun (x : α) => f x

The sum of f over insert a s is the same as the sum over s, as long as a is in s or f a = 0.

@[simp]

theorem Finset.prod_insert_of_eq_one_if_not_mem {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [CommMonoid β] [DecidableEq α] (h : a ∉ s → f a = 1) : (Finset.prod (insert a s) fun (x : α) => f x) = Finset.prod s fun (x : α) => f x

The product of f over insert a s is the same as the product over s, as long as a is in s or f a = 1.

@[simp]

theorem Finset.sum_insert_zero {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [AddCommMonoid β] [DecidableEq α] (h : f a = 0) : (Finset.sum (insert a s) fun (x : α) => f x) = Finset.sum s fun (x : α) => f x

The sum of f over insert a s is the same as the sum over s, as long as f a = 0.

@[simp]

theorem Finset.prod_insert_one {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [CommMonoid β] [DecidableEq α] (h : f a = 1) : (Finset.prod (insert a s) fun (x : α) => f x) = Finset.prod s fun (x : α) => f x

The product of f over insert a s is the same as the product over s, as long as f a = 1.

theorem Finset.sum_insert_sub {α : Type v} {s : Finset α} {a : α} {M : Type u_2} [AddCommGroup M] [DecidableEq α] (ha : a ∉ s) {f : α → M} : (Finset.sum (insert a s) fun (x : α) => f x) - f a = Finset.sum s fun (x : α) => f x

theorem Finset.prod_insert_div {α : Type v} {s : Finset α} {a : α} {M : Type u_2} [CommGroup M] [DecidableEq α] (ha : a ∉ s) {f : α → M} : (Finset.prod (insert a s) fun (x : α) => f x) / f a = Finset.prod s fun (x : α) => f x

@[simp]

theorem Finset.sum_singleton {β : Type u} {α : Type v} [AddCommMonoid β] (f : α → β) (a : α) : (Finset.sum {a} fun (x : α) => f x) = f a

@[simp]

theorem Finset.prod_singleton {β : Type u} {α : Type v} [CommMonoid β] (f : α → β) (a : α) : (Finset.prod {a} fun (x : α) => f x) = f a

theorem Finset.sum_pair {β : Type u} {α : Type v} {f : α → β} [AddCommMonoid β] [DecidableEq α] {a : α} {b : α} (h : a ≠ b) : (Finset.sum {a, b} fun (x : α) => f x) = f a + f b

theorem Finset.prod_pair {β : Type u} {α : Type v} {f : α → β} [CommMonoid β] [DecidableEq α] {a : α} {b : α} (h : a ≠ b) : (Finset.prod {a, b} fun (x : α) => f x) = f a * f b

@[simp]

theorem Finset.sum_const_zero {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] : (Finset.sum s fun (_x : α) => 0) = 0

@[simp]

theorem Finset.prod_const_one {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] : (Finset.prod s fun (_x : α) => 1) = 1

@[simp]

theorem Finset.sum_image {β : Type u} {α : Type v} {γ : Type w} {f : α → β} [AddCommMonoid β] [DecidableEq α] {s : Finset γ} {g : γ → α} : (∀ x ∈ s, ∀ y ∈ s, g x = g y → x = y) → (Finset.sum (Finset.image g s) fun (x : α) => f x) = Finset.sum s fun (x : γ) => f (g x)

@[simp]

theorem Finset.prod_image {β : Type u} {α : Type v} {γ : Type w} {f : α → β} [CommMonoid β] [DecidableEq α] {s : Finset γ} {g : γ → α} : (∀ x ∈ s, ∀ y ∈ s, g x = g y → x = y) → (Finset.prod (Finset.image g s) fun (x : α) => f x) = Finset.prod s fun (x : γ) => f (g x)

@[simp]

theorem Finset.sum_map {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] (s : Finset α) (e : α ↪ γ) (f : γ → β) : (Finset.sum (Finset.map e s) fun (x : γ) => f x) = Finset.sum s fun (x : α) => f (e x)

@[simp]

theorem Finset.prod_map {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] (s : Finset α) (e : α ↪ γ) (f : γ → β) : (Finset.prod (Finset.map e s) fun (x : γ) => f x) = Finset.prod s fun (x : α) => f (e x)

theorem Finset.sum_attach {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (f : α → β) : (Finset.sum (Finset.attach s) fun (x : { x : α // x ∈ s }) => f ↑x) = Finset.sum s fun (x : α) => f x

theorem Finset.prod_attach {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (f : α → β) : (Finset.prod (Finset.attach s) fun (x : { x : α // x ∈ s }) => f ↑x) = Finset.prod s fun (x : α) => f x

theorem Finset.sum_congr {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} {g : α → β} [AddCommMonoid β] (h : s₁ = s₂) : (∀ x ∈ s₂, f x = g x) → Finset.sum s₁ f = Finset.sum s₂ g

theorem Finset.prod_congr {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} {g : α → β} [CommMonoid β] (h : s₁ = s₂) : (∀ x ∈ s₂, f x = g x) → Finset.prod s₁ f = Finset.prod s₂ g

theorem Finset.sum_eq_zero {β : Type u} {α : Type v} [AddCommMonoid β] {f : α → β} {s : Finset α} (h : ∀ x ∈ s, f x = 0) : (Finset.sum s fun (x : α) => f x) = 0

theorem Finset.prod_eq_one {β : Type u} {α : Type v} [CommMonoid β] {f : α → β} {s : Finset α} (h : ∀ x ∈ s, f x = 1) : (Finset.prod s fun (x : α) => f x) = 1

theorem Finset.sum_disjUnion {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommMonoid β] (h : Disjoint s₁ s₂) : (Finset.sum (Finset.disjUnion s₁ s₂ h) fun (x : α) => f x) = (Finset.sum s₁ fun (x : α) => f x) + Finset.sum s₂ fun (x : α) => f x

theorem Finset.prod_disjUnion {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommMonoid β] (h : Disjoint s₁ s₂) : (Finset.prod (Finset.disjUnion s₁ s₂ h) fun (x : α) => f x) = (Finset.prod s₁ fun (x : α) => f x) * Finset.prod s₂ fun (x : α) => f x

theorem Finset.sum_disjiUnion {ι : Type u_1} {β : Type u} {α : Type v} {f : α → β} [AddCommMonoid β] (s : Finset ι) (t : ι → Finset α) (h : Set.PairwiseDisjoint (↑s) t) : (Finset.sum (Finset.disjiUnion s t h) fun (x : α) => f x) = Finset.sum s fun (i : ι) => Finset.sum (t i) fun (x : α) => f x

theorem Finset.prod_disjiUnion {ι : Type u_1} {β : Type u} {α : Type v} {f : α → β} [CommMonoid β] (s : Finset ι) (t : ι → Finset α) (h : Set.PairwiseDisjoint (↑s) t) : (Finset.prod (Finset.disjiUnion s t h) fun (x : α) => f x) = Finset.prod s fun (i : ι) => Finset.prod (t i) fun (x : α) => f x

theorem Finset.sum_union_inter {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommMonoid β] [DecidableEq α] : ((Finset.sum (s₁ ∪ s₂) fun (x : α) => f x) + Finset.sum (s₁ ∩ s₂) fun (x : α) => f x) = (Finset.sum s₁ fun (x : α) => f x) + Finset.sum s₂ fun (x : α) => f x

theorem Finset.prod_union_inter {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommMonoid β] [DecidableEq α] : ((Finset.prod (s₁ ∪ s₂) fun (x : α) => f x) * Finset.prod (s₁ ∩ s₂) fun (x : α) => f x) = (Finset.prod s₁ fun (x : α) => f x) * Finset.prod s₂ fun (x : α) => f x

theorem Finset.sum_union {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommMonoid β] [DecidableEq α] (h : Disjoint s₁ s₂) : (Finset.sum (s₁ ∪ s₂) fun (x : α) => f x) = (Finset.sum s₁ fun (x : α) => f x) + Finset.sum s₂ fun (x : α) => f x

theorem Finset.prod_union {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommMonoid β] [DecidableEq α] (h : Disjoint s₁ s₂) : (Finset.prod (s₁ ∪ s₂) fun (x : α) => f x) = (Finset.prod s₁ fun (x : α) => f x) * Finset.prod s₂ fun (x : α) => f x

theorem Finset.sum_filter_add_sum_filter_not {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (p : α → Prop) [DecidablePred p] [(x : α) → Decidable ¬p x] (f : α → β) : ((Finset.sum (Finset.filter p s) fun (x : α) => f x) + Finset.sum (Finset.filter (fun (x : α) => ¬p x) s) fun (x : α) => f x) = Finset.sum s fun (x : α) => f x

theorem Finset.prod_filter_mul_prod_filter_not {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (p : α → Prop) [DecidablePred p] [(x : α) → Decidable ¬p x] (f : α → β) : ((Finset.prod (Finset.filter p s) fun (x : α) => f x) * Finset.prod (Finset.filter (fun (x : α) => ¬p x) s) fun (x : α) => f x) = Finset.prod s fun (x : α) => f x

@[simp]

theorem Finset.sum_to_list {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (f : α → β) : List.sum (List.map f (Finset.toList s)) = Finset.sum s f

@[simp]

theorem Finset.prod_to_list {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (f : α → β) : List.prod (List.map f (Finset.toList s)) = Finset.prod s f

theorem Equiv.Perm.sum_comp {β : Type u} {α : Type v} [AddCommMonoid β] (σ : Equiv.Perm α) (s : Finset α) (f : α → β) (hs : {a : α | σ a ≠ a} ⊆ ↑s) : (Finset.sum s fun (x : α) => f (σ x)) = Finset.sum s fun (x : α) => f x

theorem Equiv.Perm.prod_comp {β : Type u} {α : Type v} [CommMonoid β] (σ : Equiv.Perm α) (s : Finset α) (f : α → β) (hs : {a : α | σ a ≠ a} ⊆ ↑s) : (Finset.prod s fun (x : α) => f (σ x)) = Finset.prod s fun (x : α) => f x

theorem Equiv.Perm.sum_comp' {β : Type u} {α : Type v} [AddCommMonoid β] (σ : Equiv.Perm α) (s : Finset α) (f : α → α → β) (hs : {a : α | σ a ≠ a} ⊆ ↑s) : (Finset.sum s fun (x : α) => f (σ x) x) = Finset.sum s fun (x : α) => f x (σ.symm x)

theorem Equiv.Perm.prod_comp' {β : Type u} {α : Type v} [CommMonoid β] (σ : Equiv.Perm α) (s : Finset α) (f : α → α → β) (hs : {a : α | σ a ≠ a} ⊆ ↑s) : (Finset.prod s fun (x : α) => f (σ x) x) = Finset.prod s fun (x : α) => f x (σ.symm x)

theorem Finset.sum_powerset_insert {β : Type u} {α : Type v} {s : Finset α} {a : α} [AddCommMonoid β] [DecidableEq α] (ha : a ∉ s) (f : Finset α → β) : (Finset.sum (Finset.powerset (insert a s)) fun (t : Finset α) => f t) = (Finset.sum (Finset.powerset s) fun (t : Finset α) => f t) + Finset.sum (Finset.powerset s) fun (t : Finset α) => f (insert a t)

A sum over all subsets of s ∪ {x} is obtained by summing the sum over all subsets of s, and over all subsets of s to which one adds x.

theorem Finset.prod_powerset_insert {β : Type u} {α : Type v} {s : Finset α} {a : α} [CommMonoid β] [DecidableEq α] (ha : a ∉ s) (f : Finset α → β) : (Finset.prod (Finset.powerset (insert a s)) fun (t : Finset α) => f t) = (Finset.prod (Finset.powerset s) fun (t : Finset α) => f t) * Finset.prod (Finset.powerset s) fun (t : Finset α) => f (insert a t)

A product over all subsets of s ∪ {x} is obtained by multiplying the product over all subsets of s, and over all subsets of s to which one adds x.

theorem Finset.sum_powerset_cons {β : Type u} {α : Type v} {s : Finset α} {a : α} [AddCommMonoid β] (ha : a ∉ s) (f : Finset α → β) : (Finset.sum (Finset.powerset (Finset.cons a s ha)) fun (t : Finset α) => f t) = (Finset.sum (Finset.powerset s) fun (t : Finset α) => f t) + Finset.sum (Finset.attach (Finset.powerset s)) fun (t : { x : Finset α // x ∈ Finset.powerset s }) => f (Finset.cons a ↑t ⋯)

A sum over all subsets of s ∪ {x} is obtained by summing the sum over all subsets of s, and over all subsets of s to which one adds x.

theorem Finset.prod_powerset_cons {β : Type u} {α : Type v} {s : Finset α} {a : α} [CommMonoid β] (ha : a ∉ s) (f : Finset α → β) : (Finset.prod (Finset.powerset (Finset.cons a s ha)) fun (t : Finset α) => f t) = (Finset.prod (Finset.powerset s) fun (t : Finset α) => f t) * Finset.prod (Finset.attach (Finset.powerset s)) fun (t : { x : Finset α // x ∈ Finset.powerset s }) => f (Finset.cons a ↑t ⋯)

A product over all subsets of s ∪ {x} is obtained by multiplying the product over all subsets of s, and over all subsets of s to which one adds x.

theorem Finset.sum_powerset {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (f : Finset α → β) : (Finset.sum (Finset.powerset s) fun (t : Finset α) => f t) = Finset.sum (Finset.range (s.card + 1)) fun (j : ℕ) => Finset.sum (Finset.powersetCard j s) fun (t : Finset α) => f t

A sum over powerset s is equal to the double sum over sets of subsets of s with card s = k, for k = 1, ..., card s

theorem Finset.prod_powerset {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (f : Finset α → β) : (Finset.prod (Finset.powerset s) fun (t : Finset α) => f t) = Finset.prod (Finset.range (s.card + 1)) fun (j : ℕ) => Finset.prod (Finset.powersetCard j s) fun (t : Finset α) => f t

A product over powerset s is equal to the double product over sets of subsets of s with card s = k, for k = 1, ..., card s.

theorem IsCompl.sum_add_sum {β : Type u} {α : Type v} [Fintype α] [AddCommMonoid β] {s : Finset α} {t : Finset α} (h : IsCompl s t) (f : α → β) : ((Finset.sum s fun (i : α) => f i) + Finset.sum t fun (i : α) => f i) = Finset.sum Finset.univ fun (i : α) => f i

theorem IsCompl.prod_mul_prod {β : Type u} {α : Type v} [Fintype α] [CommMonoid β] {s : Finset α} {t : Finset α} (h : IsCompl s t) (f : α → β) : ((Finset.prod s fun (i : α) => f i) * Finset.prod t fun (i : α) => f i) = Finset.prod Finset.univ fun (i : α) => f i

theorem Finset.sum_add_sum_compl {β : Type u} {α : Type v} [AddCommMonoid β] [Fintype α] [DecidableEq α] (s : Finset α) (f : α → β) : ((Finset.sum s fun (i : α) => f i) + Finset.sum sᶜ fun (i : α) => f i) = Finset.sum Finset.univ fun (i : α) => f i

Adding the sums of a function over s and over sᶜ gives the whole sum. For a version expressed with subtypes, see Fintype.sum_subtype_add_sum_subtype.

theorem Finset.prod_mul_prod_compl {β : Type u} {α : Type v} [CommMonoid β] [Fintype α] [DecidableEq α] (s : Finset α) (f : α → β) : ((Finset.prod s fun (i : α) => f i) * Finset.prod sᶜ fun (i : α) => f i) = Finset.prod Finset.univ fun (i : α) => f i

Multiplying the products of a function over s and over sᶜ gives the whole product. For a version expressed with subtypes, see Fintype.prod_subtype_mul_prod_subtype.

theorem Finset.sum_compl_add_sum {β : Type u} {α : Type v} [AddCommMonoid β] [Fintype α] [DecidableEq α] (s : Finset α) (f : α → β) : ((Finset.sum sᶜ fun (i : α) => f i) + Finset.sum s fun (i : α) => f i) = Finset.sum Finset.univ fun (i : α) => f i

theorem Finset.prod_compl_mul_prod {β : Type u} {α : Type v} [CommMonoid β] [Fintype α] [DecidableEq α] (s : Finset α) (f : α → β) : ((Finset.prod sᶜ fun (i : α) => f i) * Finset.prod s fun (i : α) => f i) = Finset.prod Finset.univ fun (i : α) => f i

theorem Finset.sum_sdiff {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommMonoid β] [DecidableEq α] (h : s₁ ⊆ s₂) : ((Finset.sum (s₂ \ s₁) fun (x : α) => f x) + Finset.sum s₁ fun (x : α) => f x) = Finset.sum s₂ fun (x : α) => f x

theorem Finset.prod_sdiff {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommMonoid β] [DecidableEq α] (h : s₁ ⊆ s₂) : ((Finset.prod (s₂ \ s₁) fun (x : α) => f x) * Finset.prod s₁ fun (x : α) => f x) = Finset.prod s₂ fun (x : α) => f x

theorem Finset.sum_subset_zero_on_sdiff {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} {g : α → β} [AddCommMonoid β] [DecidableEq α] (h : s₁ ⊆ s₂) (hg : ∀ x ∈ s₂ \ s₁, g x = 0) (hfg : ∀ x ∈ s₁, f x = g x) : (Finset.sum s₁ fun (i : α) => f i) = Finset.sum s₂ fun (i : α) => g i

theorem Finset.prod_subset_one_on_sdiff {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} {g : α → β} [CommMonoid β] [DecidableEq α] (h : s₁ ⊆ s₂) (hg : ∀ x ∈ s₂ \ s₁, g x = 1) (hfg : ∀ x ∈ s₁, f x = g x) : (Finset.prod s₁ fun (i : α) => f i) = Finset.prod s₂ fun (i : α) => g i

theorem Finset.sum_subset {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommMonoid β] (h : s₁ ⊆ s₂) (hf : ∀ x ∈ s₂, x ∉ s₁ → f x = 0) : (Finset.sum s₁ fun (x : α) => f x) = Finset.sum s₂ fun (x : α) => f x

theorem Finset.prod_subset {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommMonoid β] (h : s₁ ⊆ s₂) (hf : ∀ x ∈ s₂, x ∉ s₁ → f x = 1) : (Finset.prod s₁ fun (x : α) => f x) = Finset.prod s₂ fun (x : α) => f x

@[simp]

theorem Finset.sum_disj_sum {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] (s : Finset α) (t : Finset γ) (f : α ⊕ γ → β) : (Finset.sum (Finset.disjSum s t) fun (x : α ⊕ γ) => f x) = (Finset.sum s fun (x : α) => f (Sum.inl x)) + Finset.sum t fun (x : γ) => f (Sum.inr x)

@[simp]

theorem Finset.prod_disj_sum {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] (s : Finset α) (t : Finset γ) (f : α ⊕ γ → β) : (Finset.prod (Finset.disjSum s t) fun (x : α ⊕ γ) => f x) = (Finset.prod s fun (x : α) => f (Sum.inl x)) * Finset.prod t fun (x : γ) => f (Sum.inr x)

theorem Finset.sum_sum_elim {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] (s : Finset α) (t : Finset γ) (f : α → β) (g : γ → β) : (Finset.sum (Finset.disjSum s t) fun (x : α ⊕ γ) => Sum.elim f g x) = (Finset.sum s fun (x : α) => f x) + Finset.sum t fun (x : γ) => g x

theorem Finset.prod_sum_elim {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] (s : Finset α) (t : Finset γ) (f : α → β) (g : γ → β) : (Finset.prod (Finset.disjSum s t) fun (x : α ⊕ γ) => Sum.elim f g x) = (Finset.prod s fun (x : α) => f x) * Finset.prod t fun (x : γ) => g x

theorem Finset.sum_biUnion {β : Type u} {α : Type v} {γ : Type w} {f : α → β} [AddCommMonoid β] [DecidableEq α] {s : Finset γ} {t : γ → Finset α} (hs : Set.PairwiseDisjoint (↑s) t) : (Finset.sum (Finset.biUnion s t) fun (x : α) => f x) = Finset.sum s fun (x : γ) => Finset.sum (t x) fun (i : α) => f i

theorem Finset.prod_biUnion {β : Type u} {α : Type v} {γ : Type w} {f : α → β} [CommMonoid β] [DecidableEq α] {s : Finset γ} {t : γ → Finset α} (hs : Set.PairwiseDisjoint (↑s) t) : (Finset.prod (Finset.biUnion s t) fun (x : α) => f x) = Finset.prod s fun (x : γ) => Finset.prod (t x) fun (i : α) => f i

theorem Finset.sum_sigma {β : Type u} {α : Type v} [AddCommMonoid β] {σ : α → Type u_2} (s : Finset α) (t : (a : α) → Finset (σ a)) (f : Sigma σ → β) : (Finset.sum (Finset.sigma s t) fun (x : (i : α) × σ i) => f x) = Finset.sum s fun (a : α) => Finset.sum (t a) fun (s : σ a) => f { fst := a, snd := s }

Sum over a sigma type equals the sum of fiberwise sums. For rewriting in the reverse direction, use Finset.sum_sigma'

theorem Finset.prod_sigma {β : Type u} {α : Type v} [CommMonoid β] {σ : α → Type u_2} (s : Finset α) (t : (a : α) → Finset (σ a)) (f : Sigma σ → β) : (Finset.prod (Finset.sigma s t) fun (x : (i : α) × σ i) => f x) = Finset.prod s fun (a : α) => Finset.prod (t a) fun (s : σ a) => f { fst := a, snd := s }

Product over a sigma type equals the product of fiberwise products. For rewriting in the reverse direction, use Finset.prod_sigma'.

theorem Finset.sum_sigma' {β : Type u} {α : Type v} [AddCommMonoid β] {σ : α → Type u_2} (s : Finset α) (t : (a : α) → Finset (σ a)) (f : (a : α) → σ a → β) : (Finset.sum s fun (a : α) => Finset.sum (t a) fun (s : σ a) => f a s) = Finset.sum (Finset.sigma s t) fun (x : (i : α) × σ i) => f x.fst x.snd

theorem Finset.prod_sigma' {β : Type u} {α : Type v} [CommMonoid β] {σ : α → Type u_2} (s : Finset α) (t : (a : α) → Finset (σ a)) (f : (a : α) → σ a → β) : (Finset.prod s fun (a : α) => Finset.prod (t a) fun (s : σ a) => f a s) = Finset.prod (Finset.sigma s t) fun (x : (i : α) × σ i) => f x.fst x.snd

theorem Finset.sum_bij {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (i : (a : ι) → a ∈ s → κ) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t) (i_inj : ∀ (a₁ : ι) (ha₁ : a₁ ∈ s) (a₂ : ι) (ha₂ : a₂ ∈ s), i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂) (i_surj : ∀ b ∈ t, ∃ (a : ι) (ha : a ∈ s), i a ha = b) (h : ∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) : (Finset.sum s fun (x : ι) => f x) = Finset.sum t fun (x : κ) => g x

Reorder a sum.

The difference with Finset.sum_bij' is that the bijection is specified as a surjective injection, rather than by an inverse function.

The difference with Finset.sum_nbij is that the bijection is allowed to use membership of the domain of the sum, rather than being a non-dependent function.

theorem Finset.prod_bij {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (i : (a : ι) → a ∈ s → κ) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t) (i_inj : ∀ (a₁ : ι) (ha₁ : a₁ ∈ s) (a₂ : ι) (ha₂ : a₂ ∈ s), i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂) (i_surj : ∀ b ∈ t, ∃ (a : ι) (ha : a ∈ s), i a ha = b) (h : ∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) : (Finset.prod s fun (x : ι) => f x) = Finset.prod t fun (x : κ) => g x

Reorder a product.

The difference with Finset.prod_bij' is that the bijection is specified as a surjective injection, rather than by an inverse function.

The difference with Finset.prod_nbij is that the bijection is allowed to use membership of the domain of the product, rather than being a non-dependent function.

theorem Finset.sum_bij' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (i : (a : ι) → a ∈ s → κ) (j : (a : κ) → a ∈ t → ι) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t) (hj : ∀ (a : κ) (ha : a ∈ t), j a ha ∈ s) (left_inv : ∀ (a : ι) (ha : a ∈ s), j (i a ha) ⋯ = a) (right_inv : ∀ (a : κ) (ha : a ∈ t), i (j a ha) ⋯ = a) (h : ∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) : (Finset.sum s fun (x : ι) => f x) = Finset.sum t fun (x : κ) => g x

Reorder a sum.

The difference with Finset.sum_bij is that the bijection is specified with an inverse, rather than as a surjective injection.

The difference with Finset.sum_nbij' is that the bijection and its inverse are allowed to use membership of the domains of the sums, rather than being non-dependent functions.

theorem Finset.prod_bij' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (i : (a : ι) → a ∈ s → κ) (j : (a : κ) → a ∈ t → ι) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t) (hj : ∀ (a : κ) (ha : a ∈ t), j a ha ∈ s) (left_inv : ∀ (a : ι) (ha : a ∈ s), j (i a ha) ⋯ = a) (right_inv : ∀ (a : κ) (ha : a ∈ t), i (j a ha) ⋯ = a) (h : ∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) : (Finset.prod s fun (x : ι) => f x) = Finset.prod t fun (x : κ) => g x

Reorder a product.

The difference with Finset.prod_bij is that the bijection is specified with an inverse, rather than as a surjective injection.

The difference with Finset.prod_nbij' is that the bijection and its inverse are allowed to use membership of the domains of the products, rather than being non-dependent functions.

theorem Finset.sum_nbij {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (i : ι → κ) (hi : ∀ a ∈ s, i a ∈ t) (i_inj : Set.InjOn i ↑s) (i_surj : Set.SurjOn i ↑s ↑t) (h : ∀ a ∈ s, f a = g (i a)) : (Finset.sum s fun (x : ι) => f x) = Finset.sum t fun (x : κ) => g x

Reorder a sum.

The difference with Finset.sum_nbij' is that the bijection is specified as a surjective injection, rather than by an inverse function.

The difference with Finset.sum_bij is that the bijection is a non-dependent function, rather than being allowed to use membership of the domain of the sum.

theorem Finset.prod_nbij {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (i : ι → κ) (hi : ∀ a ∈ s, i a ∈ t) (i_inj : Set.InjOn i ↑s) (i_surj : Set.SurjOn i ↑s ↑t) (h : ∀ a ∈ s, f a = g (i a)) : (Finset.prod s fun (x : ι) => f x) = Finset.prod t fun (x : κ) => g x

Reorder a product.

The difference with Finset.prod_nbij' is that the bijection is specified as a surjective injection, rather than by an inverse function.

The difference with Finset.prod_bij is that the bijection is a non-dependent function, rather than being allowed to use membership of the domain of the product.

theorem Finset.sum_nbij' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (i : ι → κ) (j : κ → ι) (hi : ∀ a ∈ s, i a ∈ t) (hj : ∀ a ∈ t, j a ∈ s) (left_inv : ∀ a ∈ s, j (i a) = a) (right_inv : ∀ a ∈ t, i (j a) = a) (h : ∀ a ∈ s, f a = g (i a)) : (Finset.sum s fun (x : ι) => f x) = Finset.sum t fun (x : κ) => g x

Reorder a sum.

The difference with Finset.sum_nbij is that the bijection is specified with an inverse, rather than as a surjective injection.

The difference with Finset.sum_bij' is that the bijection and its inverse are non-dependent functions, rather than being allowed to use membership of the domains of the sums.

The difference with Finset.sum_equiv is that bijectivity is only required to hold on the domains of the sums, rather than on the entire types.

theorem Finset.prod_nbij' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (i : ι → κ) (j : κ → ι) (hi : ∀ a ∈ s, i a ∈ t) (hj : ∀ a ∈ t, j a ∈ s) (left_inv : ∀ a ∈ s, j (i a) = a) (right_inv : ∀ a ∈ t, i (j a) = a) (h : ∀ a ∈ s, f a = g (i a)) : (Finset.prod s fun (x : ι) => f x) = Finset.prod t fun (x : κ) => g x

Reorder a product.

The difference with Finset.prod_nbij is that the bijection is specified with an inverse, rather than as a surjective injection.

The difference with Finset.prod_bij' is that the bijection and its inverse are non-dependent functions, rather than being allowed to use membership of the domains of the products.

The difference with Finset.prod_equiv is that bijectivity is only required to hold on the domains of the products, rather than on the entire types.

theorem Finset.sum_equiv {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (e : ι ≃ κ) (hst : ∀ (i : ι), i ∈ s ↔ e i ∈ t) (hfg : ∀ i ∈ s, f i = g (e i)) : (Finset.sum s fun (i : ι) => f i) = Finset.sum t fun (i : κ) => g i

Specialization of Finset.sum_nbij'` that automatically fills in most arguments.

See Fintype.sum_equiv for the version where s and t are univ.

theorem Finset.prod_equiv {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (e : ι ≃ κ) (hst : ∀ (i : ι), i ∈ s ↔ e i ∈ t) (hfg : ∀ i ∈ s, f i = g (e i)) : (Finset.prod s fun (i : ι) => f i) = Finset.prod t fun (i : κ) => g i

Specialization of Finset.prod_nbij' that automatically fills in most arguments.

See Fintype.prod_equiv for the version where s and t are univ.

theorem Finset.sum_bijective {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (e : ι → κ) (he : Function.Bijective e) (hst : ∀ (i : ι), i ∈ s ↔ e i ∈ t) (hfg : ∀ i ∈ s, f i = g (e i)) : (Finset.sum s fun (i : ι) => f i) = Finset.sum t fun (i : κ) => g i

Specialization of Finset.sum_bij` that automatically fills in most arguments.

See Fintype.sum_bijective for the version where s and t are univ.

theorem Finset.prod_bijective {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (e : ι → κ) (he : Function.Bijective e) (hst : ∀ (i : ι), i ∈ s ↔ e i ∈ t) (hfg : ∀ i ∈ s, f i = g (e i)) : (Finset.prod s fun (i : ι) => f i) = Finset.prod t fun (i : κ) => g i

Specialization of Finset.prod_bij that automatically fills in most arguments.

See Fintype.prod_bijective for the version where s and t are univ.

theorem Finset.sum_of_injOn {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (e : ι → κ) (he : Set.InjOn e ↑s) (hest : Set.MapsTo e ↑s ↑t) (h' : ∀ i ∈ t, i ∉ e '' ↑s → g i = 0) (h : ∀ i ∈ s, f i = g (e i)) : (Finset.sum s fun (i : ι) => f i) = Finset.sum t fun (j : κ) => g j

theorem Finset.prod_of_injOn {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} {f : ι → α} {g : κ → α} (e : ι → κ) (he : Set.InjOn e ↑s) (hest : Set.MapsTo e ↑s ↑t) (h' : ∀ i ∈ t, i ∉ e '' ↑s → g i = 1) (h : ∀ i ∈ s, f i = g (e i)) : (Finset.prod s fun (i : ι) => f i) = Finset.prod t fun (j : κ) => g j

theorem Finset.sum_fiberwise_of_maps_to {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} [DecidableEq κ] {g : ι → κ} (h : ∀ i ∈ s, g i ∈ t) (f : ι → α) : (Finset.sum t fun (j : κ) => Finset.sum (Finset.filter (fun (i : ι) => g i = j) s) fun (i : ι) => f i) = Finset.sum s fun (i : ι) => f i

theorem Finset.prod_fiberwise_of_maps_to {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} [DecidableEq κ] {g : ι → κ} (h : ∀ i ∈ s, g i ∈ t) (f : ι → α) : (Finset.prod t fun (j : κ) => Finset.prod (Finset.filter (fun (i : ι) => g i = j) s) fun (i : ι) => f i) = Finset.prod s fun (i : ι) => f i

theorem Finset.sum_fiberwise_of_maps_to' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] {s : Finset ι} {t : Finset κ} [DecidableEq κ] {g : ι → κ} (h : ∀ i ∈ s, g i ∈ t) (f : κ → α) : (Finset.sum t fun (j : κ) => Finset.sum (Finset.filter (fun (i : ι) => g i = j) s) fun (_i : ι) => f j) = Finset.sum s fun (i : ι) => f (g i)

theorem Finset.prod_fiberwise_of_maps_to' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] {s : Finset ι} {t : Finset κ} [DecidableEq κ] {g : ι → κ} (h : ∀ i ∈ s, g i ∈ t) (f : κ → α) : (Finset.prod t fun (j : κ) => Finset.prod (Finset.filter (fun (i : ι) => g i = j) s) fun (_i : ι) => f j) = Finset.prod s fun (i : ι) => f (g i)

theorem Finset.sum_fiberwise {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] [DecidableEq κ] [Fintype κ] (s : Finset ι) (g : ι → κ) (f : ι → α) : (Finset.sum Finset.univ fun (j : κ) => Finset.sum (Finset.filter (fun (i : ι) => g i = j) s) fun (i : ι) => f i) = Finset.sum s fun (i : ι) => f i

theorem Finset.prod_fiberwise {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] [DecidableEq κ] [Fintype κ] (s : Finset ι) (g : ι → κ) (f : ι → α) : (Finset.prod Finset.univ fun (j : κ) => Finset.prod (Finset.filter (fun (i : ι) => g i = j) s) fun (i : ι) => f i) = Finset.prod s fun (i : ι) => f i

theorem Finset.sum_fiberwise' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [AddCommMonoid α] [DecidableEq κ] [Fintype κ] (s : Finset ι) (g : ι → κ) (f : κ → α) : (Finset.sum Finset.univ fun (j : κ) => Finset.sum (Finset.filter (fun (i : ι) => g i = j) s) fun (_i : ι) => f j) = Finset.sum s fun (i : ι) => f (g i)

theorem Finset.prod_fiberwise' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [CommMonoid α] [DecidableEq κ] [Fintype κ] (s : Finset ι) (g : ι → κ) (f : κ → α) : (Finset.prod Finset.univ fun (j : κ) => Finset.prod (Finset.filter (fun (i : ι) => g i = j) s) fun (_i : ι) => f j) = Finset.prod s fun (i : ι) => f (g i)

theorem Finset.sum_univ_pi {ι : Type u_1} {β : Type u} [AddCommMonoid β] [DecidableEq ι] [Fintype ι] {κ : ι → Type u_2} (t : (i : ι) → Finset (κ i)) (f : ((i : ι) → i ∈ Finset.univ → κ i) → β) : (Finset.sum (Finset.pi Finset.univ t) fun (x : (a : ι) → a ∈ Finset.univ → κ a) => f x) = Finset.sum (Fintype.piFinset t) fun (x : (a : ι) → κ a) => f fun (a : ι) (x_1 : a ∈ Finset.univ) => x a

Taking a sum over univ.pi t is the same as taking the sum over Fintype.piFinset t. univ.pi t and Fintype.piFinset t are essentially the same Finset, but differ in the type of their element, univ.pi t is a Finset (Π a ∈ univ, t a) and Fintype.piFinset t is a Finset (Π a, t a).

theorem Finset.prod_univ_pi {ι : Type u_1} {β : Type u} [CommMonoid β] [DecidableEq ι] [Fintype ι] {κ : ι → Type u_2} (t : (i : ι) → Finset (κ i)) (f : ((i : ι) → i ∈ Finset.univ → κ i) → β) : (Finset.prod (Finset.pi Finset.univ t) fun (x : (a : ι) → a ∈ Finset.univ → κ a) => f x) = Finset.prod (Fintype.piFinset t) fun (x : (a : ι) → κ a) => f fun (a : ι) (x_1 : a ∈ Finset.univ) => x a

Taking a product over univ.pi t is the same as taking the product over Fintype.piFinset t. univ.pi t and Fintype.piFinset t are essentially the same Finset, but differ in the type of their element, univ.pi t is a Finset (Π a ∈ univ, t a) and Fintype.piFinset t is a Finset (Π a, t a).

@[simp]

theorem Finset.sum_diag {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (f : α × α → β) : (Finset.sum (Finset.diag s) fun (i : α × α) => f i) = Finset.sum s fun (i : α) => f (i, i)

@[simp]

theorem Finset.prod_diag {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (f : α × α → β) : (Finset.prod (Finset.diag s) fun (i : α × α) => f i) = Finset.prod s fun (i : α) => f (i, i)

theorem Finset.sum_finset_product {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] (r : Finset (γ × α)) (s : Finset γ) (t : γ → Finset α) (h : ∀ (p : γ × α), p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1) {f : γ × α → β} : (Finset.sum r fun (p : γ × α) => f p) = Finset.sum s fun (c : γ) => Finset.sum (t c) fun (a : α) => f (c, a)

theorem Finset.prod_finset_product {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] (r : Finset (γ × α)) (s : Finset γ) (t : γ → Finset α) (h : ∀ (p : γ × α), p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1) {f : γ × α → β} : (Finset.prod r fun (p : γ × α) => f p) = Finset.prod s fun (c : γ) => Finset.prod (t c) fun (a : α) => f (c, a)

theorem Finset.sum_finset_product' {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] (r : Finset (γ × α)) (s : Finset γ) (t : γ → Finset α) (h : ∀ (p : γ × α), p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1) {f : γ → α → β} : (Finset.sum r fun (p : γ × α) => f p.1 p.2) = Finset.sum s fun (c : γ) => Finset.sum (t c) fun (a : α) => f c a

theorem Finset.prod_finset_product' {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] (r : Finset (γ × α)) (s : Finset γ) (t : γ → Finset α) (h : ∀ (p : γ × α), p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1) {f : γ → α → β} : (Finset.prod r fun (p : γ × α) => f p.1 p.2) = Finset.prod s fun (c : γ) => Finset.prod (t c) fun (a : α) => f c a

theorem Finset.sum_finset_product_right {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] (r : Finset (α × γ)) (s : Finset γ) (t : γ → Finset α) (h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) {f : α × γ → β} : (Finset.sum r fun (p : α × γ) => f p) = Finset.sum s fun (c : γ) => Finset.sum (t c) fun (a : α) => f (a, c)

theorem Finset.prod_finset_product_right {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] (r : Finset (α × γ)) (s : Finset γ) (t : γ → Finset α) (h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) {f : α × γ → β} : (Finset.prod r fun (p : α × γ) => f p) = Finset.prod s fun (c : γ) => Finset.prod (t c) fun (a : α) => f (a, c)

theorem Finset.sum_finset_product_right' {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] (r : Finset (α × γ)) (s : Finset γ) (t : γ → Finset α) (h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) {f : α → γ → β} : (Finset.sum r fun (p : α × γ) => f p.1 p.2) = Finset.sum s fun (c : γ) => Finset.sum (t c) fun (a : α) => f a c

theorem Finset.prod_finset_product_right' {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] (r : Finset (α × γ)) (s : Finset γ) (t : γ → Finset α) (h : ∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) {f : α → γ → β} : (Finset.prod r fun (p : α × γ) => f p.1 p.2) = Finset.prod s fun (c : γ) => Finset.prod (t c) fun (a : α) => f a c

abbrev Finset.sum_image'.match_1 {α : Type u_2} {γ : Type u_1} {s : Finset γ} {g : γ → α} (_x : α) (motive : (∃ a ∈ s, g a = _x) → Prop) : ∀ (x : ∃ a ∈ s, g a = _x), (∀ (c : γ) (hcs : c ∈ s) (hc : g c = _x), motive ⋯) → motive x

Equations

• ⋯ = ⋯

theorem Finset.sum_image' {β : Type u} {α : Type v} {γ : Type w} {f : α → β} [AddCommMonoid β] [DecidableEq α] {s : Finset γ} {g : γ → α} (h : γ → β) (eq : ∀ c ∈ s, f (g c) = Finset.sum (Finset.filter (fun (c' : γ) => g c' = g c) s) fun (x : γ) => h x) : (Finset.sum (Finset.image g s) fun (x : α) => f x) = Finset.sum s fun (x : γ) => h x

theorem Finset.prod_image' {β : Type u} {α : Type v} {γ : Type w} {f : α → β} [CommMonoid β] [DecidableEq α] {s : Finset γ} {g : γ → α} (h : γ → β) (eq : ∀ c ∈ s, f (g c) = Finset.prod (Finset.filter (fun (c' : γ) => g c' = g c) s) fun (x : γ) => h x) : (Finset.prod (Finset.image g s) fun (x : α) => f x) = Finset.prod s fun (x : γ) => h x

theorem Finset.sum_add_distrib {β : Type u} {α : Type v} {s : Finset α} {f : α → β} {g : α → β} [AddCommMonoid β] : (Finset.sum s fun (x : α) => f x + g x) = (Finset.sum s fun (x : α) => f x) + Finset.sum s fun (x : α) => g x

theorem Finset.prod_mul_distrib {β : Type u} {α : Type v} {s : Finset α} {f : α → β} {g : α → β} [CommMonoid β] : (Finset.prod s fun (x : α) => f x * g x) = (Finset.prod s fun (x : α) => f x) * Finset.prod s fun (x : α) => g x

theorem Finset.sum_add_sum_comm {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] (f : α → β) (g : α → β) (h : α → β) (i : α → β) : ((Finset.sum s fun (a : α) => f a + g a) + Finset.sum s fun (a : α) => h a + i a) = (Finset.sum s fun (a : α) => f a + h a) + Finset.sum s fun (a : α) => g a + i a

theorem Finset.prod_mul_prod_comm {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] (f : α → β) (g : α → β) (h : α → β) (i : α → β) : ((Finset.prod s fun (a : α) => f a * g a) * Finset.prod s fun (a : α) => h a * i a) = (Finset.prod s fun (a : α) => f a * h a) * Finset.prod s fun (a : α) => g a * i a

theorem Finset.sum_product {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset γ} {t : Finset α} {f : γ × α → β} : (Finset.sum (s ×ˢ t) fun (x : γ × α) => f x) = Finset.sum s fun (x : γ) => Finset.sum t fun (y : α) => f (x, y)

theorem Finset.prod_product {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset γ} {t : Finset α} {f : γ × α → β} : (Finset.prod (s ×ˢ t) fun (x : γ × α) => f x) = Finset.prod s fun (x : γ) => Finset.prod t fun (y : α) => f (x, y)

theorem Finset.sum_product' {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset γ} {t : Finset α} {f : γ → α → β} : (Finset.sum (s ×ˢ t) fun (x : γ × α) => f x.1 x.2) = Finset.sum s fun (x : γ) => Finset.sum t fun (y : α) => f x y

An uncurried version of Finset.sum_product

theorem Finset.prod_product' {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset γ} {t : Finset α} {f : γ → α → β} : (Finset.prod (s ×ˢ t) fun (x : γ × α) => f x.1 x.2) = Finset.prod s fun (x : γ) => Finset.prod t fun (y : α) => f x y

An uncurried version of Finset.prod_product.

theorem Finset.sum_product_right {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset γ} {t : Finset α} {f : γ × α → β} : (Finset.sum (s ×ˢ t) fun (x : γ × α) => f x) = Finset.sum t fun (y : α) => Finset.sum s fun (x : γ) => f (x, y)

theorem Finset.prod_product_right {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset γ} {t : Finset α} {f : γ × α → β} : (Finset.prod (s ×ˢ t) fun (x : γ × α) => f x) = Finset.prod t fun (y : α) => Finset.prod s fun (x : γ) => f (x, y)

theorem Finset.sum_product_right' {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset γ} {t : Finset α} {f : γ → α → β} : (Finset.sum (s ×ˢ t) fun (x : γ × α) => f x.1 x.2) = Finset.sum t fun (y : α) => Finset.sum s fun (x : γ) => f x y

An uncurried version of Finset.sum_product_right

theorem Finset.prod_product_right' {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset γ} {t : Finset α} {f : γ → α → β} : (Finset.prod (s ×ˢ t) fun (x : γ × α) => f x.1 x.2) = Finset.prod t fun (y : α) => Finset.prod s fun (x : γ) => f x y

An uncurried version of Finset.prod_product_right.

abbrev Finset.sum_comm'.match_1 {α : Type u_2} {γ : Type u_1} (motive : γ × α → Prop) : ∀ (x : γ × α), (∀ (x : γ) (y : α), motive (x, y)) → motive x

Equations

• ⋯ = ⋯

theorem Finset.sum_comm' {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset γ} {t : γ → Finset α} {t' : Finset α} {s' : α → Finset γ} (h : ∀ (x : γ) (y : α), x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t') {f : γ → α → β} : (Finset.sum s fun (x : γ) => Finset.sum (t x) fun (y : α) => f x y) = Finset.sum t' fun (y : α) => Finset.sum (s' y) fun (x : γ) => f x y

Generalization of Finset.sum_comm to the case when the inner Finsets depend on the outer variable.

theorem Finset.prod_comm' {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset γ} {t : γ → Finset α} {t' : Finset α} {s' : α → Finset γ} (h : ∀ (x : γ) (y : α), x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t') {f : γ → α → β} : (Finset.prod s fun (x : γ) => Finset.prod (t x) fun (y : α) => f x y) = Finset.prod t' fun (y : α) => Finset.prod (s' y) fun (x : γ) => f x y

Generalization of Finset.prod_comm to the case when the inner Finsets depend on the outer variable.

theorem Finset.sum_comm {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset γ} {t : Finset α} {f : γ → α → β} : (Finset.sum s fun (x : γ) => Finset.sum t fun (y : α) => f x y) = Finset.sum t fun (y : α) => Finset.sum s fun (x : γ) => f x y

theorem Finset.prod_comm {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset γ} {t : Finset α} {f : γ → α → β} : (Finset.prod s fun (x : γ) => Finset.prod t fun (y : α) => f x y) = Finset.prod t fun (y : α) => Finset.prod s fun (x : γ) => f x y

theorem Finset.sum_hom_rel {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] [AddCommMonoid γ] {r : β → γ → Prop} {f : α → β} {g : α → γ} {s : Finset α} (h₁ : r 0 0) (h₂ : ∀ (a : α) (b : β) (c : γ), r b c → r (f a + b) (g a + c)) : r (Finset.sum s fun (x : α) => f x) (Finset.sum s fun (x : α) => g x)

theorem Finset.prod_hom_rel {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] [CommMonoid γ] {r : β → γ → Prop} {f : α → β} {g : α → γ} {s : Finset α} (h₁ : r 1 1) (h₂ : ∀ (a : α) (b : β) (c : γ), r b c → r (f a * b) (g a * c)) : r (Finset.prod s fun (x : α) => f x) (Finset.prod s fun (x : α) => g x)

theorem Finset.sum_filter_of_ne {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommMonoid β] {p : α → Prop} [DecidablePred p] (hp : ∀ x ∈ s, f x ≠ 0 → p x) : (Finset.sum (Finset.filter p s) fun (x : α) => f x) = Finset.sum s fun (x : α) => f x

theorem Finset.prod_filter_of_ne {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoid β] {p : α → Prop} [DecidablePred p] (hp : ∀ x ∈ s, f x ≠ 1 → p x) : (Finset.prod (Finset.filter p s) fun (x : α) => f x) = Finset.prod s fun (x : α) => f x

theorem Finset.sum_filter_ne_zero {β : Type u} {α : Type v} {f : α → β} [AddCommMonoid β] (s : Finset α) [(x : α) → Decidable (f x ≠ 0)] : (Finset.sum (Finset.filter (fun (x : α) => f x ≠ 0) s) fun (x : α) => f x) = Finset.sum s fun (x : α) => f x

theorem Finset.prod_filter_ne_one {β : Type u} {α : Type v} {f : α → β} [CommMonoid β] (s : Finset α) [(x : α) → Decidable (f x ≠ 1)] : (Finset.prod (Finset.filter (fun (x : α) => f x ≠ 1) s) fun (x : α) => f x) = Finset.prod s fun (x : α) => f x

theorem Finset.sum_filter {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] (p : α → Prop) [DecidablePred p] (f : α → β) : (Finset.sum (Finset.filter p s) fun (a : α) => f a) = Finset.sum s fun (a : α) => if p a then f a else 0

theorem Finset.prod_filter {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] (p : α → Prop) [DecidablePred p] (f : α → β) : (Finset.prod (Finset.filter p s) fun (a : α) => f a) = Finset.prod s fun (a : α) => if p a then f a else 1

theorem Finset.sum_eq_single_of_mem {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} {f : α → β} (a : α) (h : a ∈ s) (h₀ : ∀ b ∈ s, b ≠ a → f b = 0) : (Finset.sum s fun (x : α) => f x) = f a

theorem Finset.prod_eq_single_of_mem {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} {f : α → β} (a : α) (h : a ∈ s) (h₀ : ∀ b ∈ s, b ≠ a → f b = 1) : (Finset.prod s fun (x : α) => f x) = f a

theorem Finset.sum_eq_single {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} {f : α → β} (a : α) (h₀ : ∀ b ∈ s, b ≠ a → f b = 0) (h₁ : a ∉ s → f a = 0) : (Finset.sum s fun (x : α) => f x) = f a

theorem Finset.prod_eq_single {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} {f : α → β} (a : α) (h₀ : ∀ b ∈ s, b ≠ a → f b = 1) (h₁ : a ∉ s → f a = 1) : (Finset.prod s fun (x : α) => f x) = f a

theorem Finset.sum_union_eq_left {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommMonoid β] [DecidableEq α] (hs : ∀ a ∈ s₂, a ∉ s₁ → f a = 0) : (Finset.sum (s₁ ∪ s₂) fun (a : α) => f a) = Finset.sum s₁ fun (a : α) => f a

theorem Finset.prod_union_eq_left {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommMonoid β] [DecidableEq α] (hs : ∀ a ∈ s₂, a ∉ s₁ → f a = 1) : (Finset.prod (s₁ ∪ s₂) fun (a : α) => f a) = Finset.prod s₁ fun (a : α) => f a

theorem Finset.sum_union_eq_right {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommMonoid β] [DecidableEq α] (hs : ∀ a ∈ s₁, a ∉ s₂ → f a = 0) : (Finset.sum (s₁ ∪ s₂) fun (a : α) => f a) = Finset.sum s₂ fun (a : α) => f a

theorem Finset.prod_union_eq_right {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommMonoid β] [DecidableEq α] (hs : ∀ a ∈ s₁, a ∉ s₂ → f a = 1) : (Finset.prod (s₁ ∪ s₂) fun (a : α) => f a) = Finset.prod s₂ fun (a : α) => f a

theorem Finset.sum_eq_add_of_mem {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} {f : α → β} (a : α) (b : α) (ha : a ∈ s) (hb : b ∈ s) (hn : a ≠ b) (h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 0) : (Finset.sum s fun (x : α) => f x) = f a + f b

theorem Finset.prod_eq_mul_of_mem {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} {f : α → β} (a : α) (b : α) (ha : a ∈ s) (hb : b ∈ s) (hn : a ≠ b) (h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1) : (Finset.prod s fun (x : α) => f x) = f a * f b

theorem Finset.sum_eq_add {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} {f : α → β} (a : α) (b : α) (hn : a ≠ b) (h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 0) (ha : a ∉ s → f a = 0) (hb : b ∉ s → f b = 0) : (Finset.sum s fun (x : α) => f x) = f a + f b

theorem Finset.prod_eq_mul {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} {f : α → β} (a : α) (b : α) (hn : a ≠ b) (h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1) (ha : a ∉ s → f a = 1) (hb : b ∉ s → f b = 1) : (Finset.prod s fun (x : α) => f x) = f a * f b

@[simp]

theorem Finset.sum_subtype_eq_sum_filter {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] (f : α → β) {p : α → Prop} [DecidablePred p] : (Finset.sum (Finset.subtype p s) fun (x : Subtype p) => f ↑x) = Finset.sum (Finset.filter p s) fun (x : α) => f x

A sum over s.subtype p equals one over s.filter p.

@[simp]

theorem Finset.prod_subtype_eq_prod_filter {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] (f : α → β) {p : α → Prop} [DecidablePred p] : (Finset.prod (Finset.subtype p s) fun (x : Subtype p) => f ↑x) = Finset.prod (Finset.filter p s) fun (x : α) => f x

A product over s.subtype p equals one over s.filter p.

theorem Finset.sum_subtype_of_mem {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] (f : α → β) {p : α → Prop} [DecidablePred p] (h : ∀ x ∈ s, p x) : (Finset.sum (Finset.subtype p s) fun (x : Subtype p) => f ↑x) = Finset.sum s fun (x : α) => f x

If all elements of a Finset satisfy the predicate p, a sum over s.subtype p equals that sum over s.

theorem Finset.prod_subtype_of_mem {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] (f : α → β) {p : α → Prop} [DecidablePred p] (h : ∀ x ∈ s, p x) : (Finset.prod (Finset.subtype p s) fun (x : Subtype p) => f ↑x) = Finset.prod s fun (x : α) => f x

If all elements of a Finset satisfy the predicate p, a product over s.subtype p equals that product over s.

theorem Finset.sum_subtype_map_embedding {β : Type u} {α : Type v} [AddCommMonoid β] {p : α → Prop} {s : Finset { x : α // p x }} {f : { x : α // p x } → β} {g : α → β} (h : ∀ x ∈ s, g ↑x = f x) : (Finset.sum (Finset.map (Function.Embedding.subtype fun (x : α) => p x) s) fun (x : α) => g x) = Finset.sum s fun (x : { x : α // p x }) => f x

A sum of a function over a Finset in a subtype equals a sum in the main type of a function that agrees with the first function on that Finset.

theorem Finset.prod_subtype_map_embedding {β : Type u} {α : Type v} [CommMonoid β] {p : α → Prop} {s : Finset { x : α // p x }} {f : { x : α // p x } → β} {g : α → β} (h : ∀ x ∈ s, g ↑x = f x) : (Finset.prod (Finset.map (Function.Embedding.subtype fun (x : α) => p x) s) fun (x : α) => g x) = Finset.prod s fun (x : { x : α // p x }) => f x

A product of a function over a Finset in a subtype equals a product in the main type of a function that agrees with the first function on that Finset.

theorem Finset.sum_coe_sort_eq_attach {β : Type u} {α : Type v} (s : Finset α) [AddCommMonoid β] (f : { x : α // x ∈ s } → β) : (Finset.sum Finset.univ fun (i : { x : α // x ∈ s }) => f i) = Finset.sum (Finset.attach s) fun (i : { x : α // x ∈ s }) => f i

theorem Finset.prod_coe_sort_eq_attach {β : Type u} {α : Type v} (s : Finset α) [CommMonoid β] (f : { x : α // x ∈ s } → β) : (Finset.prod Finset.univ fun (i : { x : α // x ∈ s }) => f i) = Finset.prod (Finset.attach s) fun (i : { x : α // x ∈ s }) => f i

theorem Finset.sum_coe_sort {β : Type u} {α : Type v} (s : Finset α) (f : α → β) [AddCommMonoid β] : (Finset.sum Finset.univ fun (i : { x : α // x ∈ s }) => f ↑i) = Finset.sum s fun (i : α) => f i

theorem Finset.prod_coe_sort {β : Type u} {α : Type v} (s : Finset α) (f : α → β) [CommMonoid β] : (Finset.prod Finset.univ fun (i : { x : α // x ∈ s }) => f ↑i) = Finset.prod s fun (i : α) => f i

theorem Finset.sum_finset_coe {β : Type u} {α : Type v} [AddCommMonoid β] (f : α → β) (s : Finset α) : (Finset.sum Finset.univ fun (i : ↑↑s) => f ↑i) = Finset.sum s fun (i : α) => f i

theorem Finset.prod_finset_coe {β : Type u} {α : Type v} [CommMonoid β] (f : α → β) (s : Finset α) : (Finset.prod Finset.univ fun (i : ↑↑s) => f ↑i) = Finset.prod s fun (i : α) => f i

theorem Finset.sum_subtype {β : Type u} {α : Type v} [AddCommMonoid β] {p : α → Prop} {F : Fintype (Subtype p)} (s : Finset α) (h : ∀ (x : α), x ∈ s ↔ p x) (f : α → β) : (Finset.sum s fun (a : α) => f a) = Finset.sum Finset.univ fun (a : Subtype p) => f ↑a

theorem Finset.prod_subtype {β : Type u} {α : Type v} [CommMonoid β] {p : α → Prop} {F : Fintype (Subtype p)} (s : Finset α) (h : ∀ (x : α), x ∈ s ↔ p x) (f : α → β) : (Finset.prod s fun (a : α) => f a) = Finset.prod Finset.univ fun (a : Subtype p) => f ↑a

theorem Finset.sum_set_coe {β : Type u} {α : Type v} {f : α → β} [AddCommMonoid β] (s : Set α) [Fintype ↑s] : (Finset.sum Finset.univ fun (i : ↑s) => f ↑i) = Finset.sum (Set.toFinset s) fun (i : α) => f i

theorem Finset.prod_set_coe {β : Type u} {α : Type v} {f : α → β} [CommMonoid β] (s : Set α) [Fintype ↑s] : (Finset.prod Finset.univ fun (i : ↑s) => f ↑i) = Finset.prod (Set.toFinset s) fun (i : α) => f i

abbrev Finset.sum_congr_set.match_1 {β : Type u_1} [Fintype β] (s : Set β) [DecidablePred fun (x : β) => x ∈ s] (motive : (x : { x : β // x ∈ s }) → x ∈ Finset.univ → Prop) : ∀ (x : { x : β // x ∈ s }) (x_1 : x ∈ Finset.univ), (∀ (x : β) (h : x ∈ s) (x_2 : { val := x, property := h } ∈ Finset.univ), motive { val := x, property := h } x_2) → motive x x_1

Equations

• ⋯ = ⋯

theorem Finset.sum_congr_set {α : Type u_2} [AddCommMonoid α] {β : Type u_3} [Fintype β] (s : Set β) [DecidablePred fun (x : β) => x ∈ s] (f : β → α) (g : ↑s → α) (w : ∀ (x : β) (h : x ∈ s), f x = g { val := x, property := h }) (w' : ∀ x ∉ s, f x = 0) : Finset.sum Finset.univ f = Finset.sum Finset.univ g

The sum of a function g defined only on a set s is equal to the sum of a function f defined everywhere, as long as f and g agree on s, and f = 0 off s.

theorem Finset.prod_congr_set {α : Type u_2} [CommMonoid α] {β : Type u_3} [Fintype β] (s : Set β) [DecidablePred fun (x : β) => x ∈ s] (f : β → α) (g : ↑s → α) (w : ∀ (x : β) (h : x ∈ s), f x = g { val := x, property := h }) (w' : ∀ x ∉ s, f x = 1) : Finset.prod Finset.univ f = Finset.prod Finset.univ g

The product of a function g defined only on a set s is equal to the product of a function f defined everywhere, as long as f and g agree on s, and f = 1 off s.

theorem Finset.sum_apply_dite {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset α} {p : α → Prop} {hp : DecidablePred p} [DecidablePred fun (x : α) => ¬p x] (f : (x : α) → p x → γ) (g : (x : α) → ¬p x → γ) (h : γ → β) : (Finset.sum s fun (x : α) => h (if hx : p x then f x hx else g x hx)) = (Finset.sum (Finset.attach (Finset.filter p s)) fun (x : { x : α // x ∈ Finset.filter p s }) => h (f ↑x ⋯)) + Finset.sum (Finset.attach (Finset.filter (fun (x : α) => ¬p x) s)) fun (x : { x : α // x ∈ Finset.filter (fun (x : α) => ¬p x) s }) => h (g ↑x ⋯)

theorem Finset.prod_apply_dite {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset α} {p : α → Prop} {hp : DecidablePred p} [DecidablePred fun (x : α) => ¬p x] (f : (x : α) → p x → γ) (g : (x : α) → ¬p x → γ) (h : γ → β) : (Finset.prod s fun (x : α) => h (if hx : p x then f x hx else g x hx)) = (Finset.prod (Finset.attach (Finset.filter p s)) fun (x : { x : α // x ∈ Finset.filter p s }) => h (f ↑x ⋯)) * Finset.prod (Finset.attach (Finset.filter (fun (x : α) => ¬p x) s)) fun (x : { x : α // x ∈ Finset.filter (fun (x : α) => ¬p x) s }) => h (g ↑x ⋯)

theorem Finset.sum_apply_ite {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset α} {p : α → Prop} {_hp : DecidablePred p} (f : α → γ) (g : α → γ) (h : γ → β) : (Finset.sum s fun (x : α) => h (if p x then f x else g x)) = (Finset.sum (Finset.filter p s) fun (x : α) => h (f x)) + Finset.sum (Finset.filter (fun (x : α) => ¬p x) s) fun (x : α) => h (g x)

theorem Finset.prod_apply_ite {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset α} {p : α → Prop} {_hp : DecidablePred p} (f : α → γ) (g : α → γ) (h : γ → β) : (Finset.prod s fun (x : α) => h (if p x then f x else g x)) = (Finset.prod (Finset.filter p s) fun (x : α) => h (f x)) * Finset.prod (Finset.filter (fun (x : α) => ¬p x) s) fun (x : α) => h (g x)

theorem Finset.sum_dite {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} {p : α → Prop} {hp : DecidablePred p} (f : (x : α) → p x → β) (g : (x : α) → ¬p x → β) : (Finset.sum s fun (x : α) => if hx : p x then f x hx else g x hx) = (Finset.sum (Finset.attach (Finset.filter p s)) fun (x : { x : α // x ∈ Finset.filter p s }) => f ↑x ⋯) + Finset.sum (Finset.attach (Finset.filter (fun (x : α) => ¬p x) s)) fun (x : { x : α // x ∈ Finset.filter (fun (x : α) => ¬p x) s }) => g ↑x ⋯

theorem Finset.prod_dite {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} {p : α → Prop} {hp : DecidablePred p} (f : (x : α) → p x → β) (g : (x : α) → ¬p x → β) : (Finset.prod s fun (x : α) => if hx : p x then f x hx else g x hx) = (Finset.prod (Finset.attach (Finset.filter p s)) fun (x : { x : α // x ∈ Finset.filter p s }) => f ↑x ⋯) * Finset.prod (Finset.attach (Finset.filter (fun (x : α) => ¬p x) s)) fun (x : { x : α // x ∈ Finset.filter (fun (x : α) => ¬p x) s }) => g ↑x ⋯

theorem Finset.sum_ite {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} {p : α → Prop} {hp : DecidablePred p} (f : α → β) (g : α → β) : (Finset.sum s fun (x : α) => if p x then f x else g x) = (Finset.sum (Finset.filter p s) fun (x : α) => f x) + Finset.sum (Finset.filter (fun (x : α) => ¬p x) s) fun (x : α) => g x

theorem Finset.prod_ite {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} {p : α → Prop} {hp : DecidablePred p} (f : α → β) (g : α → β) : (Finset.prod s fun (x : α) => if p x then f x else g x) = (Finset.prod (Finset.filter p s) fun (x : α) => f x) * Finset.prod (Finset.filter (fun (x : α) => ¬p x) s) fun (x : α) => g x

theorem Finset.sum_ite_of_false {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] {p : α → Prop} {hp : DecidablePred p} (f : α → β) (g : α → β) (h : ∀ x ∈ s, ¬p x) : (Finset.sum s fun (x : α) => if p x then f x else g x) = Finset.sum s fun (x : α) => g x

theorem Finset.prod_ite_of_false {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] {p : α → Prop} {hp : DecidablePred p} (f : α → β) (g : α → β) (h : ∀ x ∈ s, ¬p x) : (Finset.prod s fun (x : α) => if p x then f x else g x) = Finset.prod s fun (x : α) => g x

theorem Finset.sum_ite_of_true {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] {p : α → Prop} {hp : DecidablePred p} (f : α → β) (g : α → β) (h : ∀ x ∈ s, p x) : (Finset.sum s fun (x : α) => if p x then f x else g x) = Finset.sum s fun (x : α) => f x

theorem Finset.prod_ite_of_true {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] {p : α → Prop} {hp : DecidablePred p} (f : α → β) (g : α → β) (h : ∀ x ∈ s, p x) : (Finset.prod s fun (x : α) => if p x then f x else g x) = Finset.prod s fun (x : α) => f x

theorem Finset.sum_apply_ite_of_false {β : Type u} {α : Type v} {γ : Type w} {s : Finset α} [AddCommMonoid β] {p : α → Prop} {hp : DecidablePred p} (f : α → γ) (g : α → γ) (k : γ → β) (h : ∀ x ∈ s, ¬p x) : (Finset.sum s fun (x : α) => k (if p x then f x else g x)) = Finset.sum s fun (x : α) => k (g x)

theorem Finset.prod_apply_ite_of_false {β : Type u} {α : Type v} {γ : Type w} {s : Finset α} [CommMonoid β] {p : α → Prop} {hp : DecidablePred p} (f : α → γ) (g : α → γ) (k : γ → β) (h : ∀ x ∈ s, ¬p x) : (Finset.prod s fun (x : α) => k (if p x then f x else g x)) = Finset.prod s fun (x : α) => k (g x)

theorem Finset.sum_apply_ite_of_true {β : Type u} {α : Type v} {γ : Type w} {s : Finset α} [AddCommMonoid β] {p : α → Prop} {hp : DecidablePred p} (f : α → γ) (g : α → γ) (k : γ → β) (h : ∀ x ∈ s, p x) : (Finset.sum s fun (x : α) => k (if p x then f x else g x)) = Finset.sum s fun (x : α) => k (f x)

theorem Finset.prod_apply_ite_of_true {β : Type u} {α : Type v} {γ : Type w} {s : Finset α} [CommMonoid β] {p : α → Prop} {hp : DecidablePred p} (f : α → γ) (g : α → γ) (k : γ → β) (h : ∀ x ∈ s, p x) : (Finset.prod s fun (x : α) => k (if p x then f x else g x)) = Finset.prod s fun (x : α) => k (f x)

theorem Finset.sum_extend_by_zero {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (f : α → β) : (Finset.sum s fun (i : α) => if i ∈ s then f i else 0) = Finset.sum s fun (i : α) => f i

theorem Finset.prod_extend_by_one {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (f : α → β) : (Finset.prod s fun (i : α) => if i ∈ s then f i else 1) = Finset.prod s fun (i : α) => f i

@[simp]

theorem Finset.sum_ite_mem {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (t : Finset α) (f : α → β) : (Finset.sum s fun (i : α) => if i ∈ t then f i else 0) = Finset.sum (s ∩ t) fun (i : α) => f i

@[simp]

theorem Finset.prod_ite_mem {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (t : Finset α) (f : α → β) : (Finset.prod s fun (i : α) => if i ∈ t then f i else 1) = Finset.prod (s ∩ t) fun (i : α) => f i

@[simp]

theorem Finset.sum_dite_eq {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (a : α) (b : (x : α) → a = x → β) : (Finset.sum s fun (x : α) => if h : a = x then b x h else 0) = if a ∈ s then b a ⋯ else 0

@[simp]

theorem Finset.prod_dite_eq {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (a : α) (b : (x : α) → a = x → β) : (Finset.prod s fun (x : α) => if h : a = x then b x h else 1) = if a ∈ s then b a ⋯ else 1

@[simp]

theorem Finset.sum_dite_eq' {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (a : α) (b : (x : α) → x = a → β) : (Finset.sum s fun (x : α) => if h : x = a then b x h else 0) = if a ∈ s then b a ⋯ else 0

@[simp]

theorem Finset.prod_dite_eq' {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (a : α) (b : (x : α) → x = a → β) : (Finset.prod s fun (x : α) => if h : x = a then b x h else 1) = if a ∈ s then b a ⋯ else 1

@[simp]

theorem Finset.sum_ite_eq {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (a : α) (b : α → β) : (Finset.sum s fun (x : α) => if a = x then b x else 0) = if a ∈ s then b a else 0

@[simp]

theorem Finset.prod_ite_eq {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (a : α) (b : α → β) : (Finset.prod s fun (x : α) => if a = x then b x else 1) = if a ∈ s then b a else 1

@[simp]

theorem Finset.sum_ite_eq' {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (a : α) (b : α → β) : (Finset.sum s fun (x : α) => if x = a then b x else 0) = if a ∈ s then b a else 0

A sum taken over a conditional whose condition is an equality test on the index and whose alternative is 0 has value either the term at that index or 0.

The difference with Finset.sum_ite_eq is that the arguments to eq are swapped.

@[simp]

theorem Finset.prod_ite_eq' {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (a : α) (b : α → β) : (Finset.prod s fun (x : α) => if x = a then b x else 1) = if a ∈ s then b a else 1

A product taken over a conditional whose condition is an equality test on the index and whose alternative is 1 has value either the term at that index or 1.

The difference with Finset.prod_ite_eq is that the arguments to Eq are swapped.

theorem Finset.sum_ite_index {β : Type u} {α : Type v} [AddCommMonoid β] (p : Prop) [Decidable p] (s : Finset α) (t : Finset α) (f : α → β) : (Finset.sum (if p then s else t) fun (x : α) => f x) = if p then Finset.sum s fun (x : α) => f x else Finset.sum t fun (x : α) => f x

theorem Finset.prod_ite_index {β : Type u} {α : Type v} [CommMonoid β] (p : Prop) [Decidable p] (s : Finset α) (t : Finset α) (f : α → β) : (Finset.prod (if p then s else t) fun (x : α) => f x) = if p then Finset.prod s fun (x : α) => f x else Finset.prod t fun (x : α) => f x

@[simp]

theorem Finset.sum_ite_irrel {β : Type u} {α : Type v} [AddCommMonoid β] (p : Prop) [Decidable p] (s : Finset α) (f : α → β) (g : α → β) : (Finset.sum s fun (x : α) => if p then f x else g x) = if p then Finset.sum s fun (x : α) => f x else Finset.sum s fun (x : α) => g x

@[simp]

theorem Finset.prod_ite_irrel {β : Type u} {α : Type v} [CommMonoid β] (p : Prop) [Decidable p] (s : Finset α) (f : α → β) (g : α → β) : (Finset.prod s fun (x : α) => if p then f x else g x) = if p then Finset.prod s fun (x : α) => f x else Finset.prod s fun (x : α) => g x

@[simp]

theorem Finset.sum_dite_irrel {β : Type u} {α : Type v} [AddCommMonoid β] (p : Prop) [Decidable p] (s : Finset α) (f : p → α → β) (g : ¬p → α → β) : (Finset.sum s fun (x : α) => if h : p then f h x else g h x) = if h : p then Finset.sum s fun (x : α) => f h x else Finset.sum s fun (x : α) => g h x

@[simp]

theorem Finset.prod_dite_irrel {β : Type u} {α : Type v} [CommMonoid β] (p : Prop) [Decidable p] (s : Finset α) (f : p → α → β) (g : ¬p → α → β) : (Finset.prod s fun (x : α) => if h : p then f h x else g h x) = if h : p then Finset.prod s fun (x : α) => f h x else Finset.prod s fun (x : α) => g h x

@[simp]

theorem Finset.sum_pi_single' {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (a : α) (x : β) (s : Finset α) : (Finset.sum s fun (a' : α) => Pi.single a x a') = if a ∈ s then x else 0

@[simp]

theorem Finset.prod_pi_mulSingle' {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (a : α) (x : β) (s : Finset α) : (Finset.prod s fun (a' : α) => Pi.mulSingle a x a') = if a ∈ s then x else 1

@[simp]

theorem Finset.sum_pi_single {α : Type v} {β : α → Type u_2} [DecidableEq α] [(a : α) → AddCommMonoid (β a)] (a : α) (f : (a : α) → β a) (s : Finset α) : (Finset.sum s fun (a' : α) => Pi.single a' (f a') a) = if a ∈ s then f a else 0

@[simp]

theorem Finset.prod_pi_mulSingle {α : Type v} {β : α → Type u_2} [DecidableEq α] [(a : α) → CommMonoid (β a)] (a : α) (f : (a : α) → β a) (s : Finset α) : (Finset.prod s fun (a' : α) => Pi.mulSingle a' (f a') a) = if a ∈ s then f a else 1

theorem Finset.support_sum {ι : Type u_1} {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset ι) (f : ι → α → β) : (Function.support fun (x : α) => Finset.sum s fun (i : ι) => f i x) ⊆ ⋃ i ∈ s, Function.support (f i)

theorem Finset.mulSupport_prod {ι : Type u_1} {β : Type u} {α : Type v} [CommMonoid β] (s : Finset ι) (f : ι → α → β) : (Function.mulSupport fun (x : α) => Finset.prod s fun (i : ι) => f i x) ⊆ ⋃ i ∈ s, Function.mulSupport (f i)

theorem Finset.sum_indicator_subset_of_eq_zero {ι : Type u_1} {β : Type u} {α : Type v} [AddCommMonoid β] [Zero α] (f : ι → α) (g : ι → α → β) {s : Finset ι} {t : Finset ι} (h : s ⊆ t) (hg : ∀ (a : ι), g a 0 = 0) : (Finset.sum t fun (i : ι) => g i (Set.indicator (↑s) f i)) = Finset.sum s fun (i : ι) => g i (f i)

Consider a sum of g i (f i) over a finset. Suppose g is a function such as n ↦ (n • ·), which maps a second argument of 0 to 0 (or a weighted sum of f i * h i or f i • h i, where f gives the weights that are multiplied by some other function h). Then if f is replaced by the corresponding indicator function, the finset may be replaced by a possibly larger finset without changing the value of the sum.

theorem Finset.prod_mulIndicator_subset_of_eq_one {ι : Type u_1} {β : Type u} {α : Type v} [CommMonoid β] [One α] (f : ι → α) (g : ι → α → β) {s : Finset ι} {t : Finset ι} (h : s ⊆ t) (hg : ∀ (a : ι), g a 1 = 1) : (Finset.prod t fun (i : ι) => g i (Set.mulIndicator (↑s) f i)) = Finset.prod s fun (i : ι) => g i (f i)

Consider a product of g i (f i) over a finset. Suppose g is a function such as n ↦ (· ^ n), which maps a second argument of 1 to 1. Then if f is replaced by the corresponding multiplicative indicator function, the finset may be replaced by a possibly larger finset without changing the value of the product.

theorem Finset.sum_indicator_subset {ι : Type u_1} {β : Type u} [AddCommMonoid β] (f : ι → β) {s : Finset ι} {t : Finset ι} (h : s ⊆ t) : (Finset.sum t fun (i : ι) => Set.indicator (↑s) f i) = Finset.sum s fun (i : ι) => f i

Summing an indicator function over a possibly larger Finset is the same as summing the original function over the original finset.

theorem Finset.prod_mulIndicator_subset {ι : Type u_1} {β : Type u} [CommMonoid β] (f : ι → β) {s : Finset ι} {t : Finset ι} (h : s ⊆ t) : (Finset.prod t fun (i : ι) => Set.mulIndicator (↑s) f i) = Finset.prod s fun (i : ι) => f i

Taking the product of an indicator function over a possibly larger finset is the same as taking the original function over the original finset.

theorem Finset.sum_indicator_eq_sum_filter {ι : Type u_1} {β : Type u} [AddCommMonoid β] {κ : Type u_2} (s : Finset ι) (f : ι → κ → β) (t : ι → Set κ) (g : ι → κ) [DecidablePred fun (i : ι) => g i ∈ t i] : (Finset.sum s fun (i : ι) => Set.indicator (t i) (f i) (g i)) = Finset.sum (Finset.filter (fun (i : ι) => g i ∈ t i) s) fun (i : ι) => f i (g i)

theorem Finset.prod_mulIndicator_eq_prod_filter {ι : Type u_1} {β : Type u} [CommMonoid β] {κ : Type u_2} (s : Finset ι) (f : ι → κ → β) (t : ι → Set κ) (g : ι → κ) [DecidablePred fun (i : ι) => g i ∈ t i] : (Finset.prod s fun (i : ι) => Set.mulIndicator (t i) (f i) (g i)) = Finset.prod (Finset.filter (fun (i : ι) => g i ∈ t i) s) fun (i : ι) => f i (g i)

theorem Finset.sum_indicator_eq_sum_inter {ι : Type u_1} {β : Type u} [AddCommMonoid β] [DecidableEq ι] (s : Finset ι) (t : Finset ι) (f : ι → β) : (Finset.sum s fun (i : ι) => Set.indicator (↑t) f i) = Finset.sum (s ∩ t) fun (i : ι) => f i

theorem Finset.prod_mulIndicator_eq_prod_inter {ι : Type u_1} {β : Type u} [CommMonoid β] [DecidableEq ι] (s : Finset ι) (t : Finset ι) (f : ι → β) : (Finset.prod s fun (i : ι) => Set.mulIndicator (↑t) f i) = Finset.prod (s ∩ t) fun (i : ι) => f i

theorem Finset.indicator_sum {ι : Type u_1} {β : Type u} [AddCommMonoid β] {κ : Type u_2} (s : Finset ι) (t : Set κ) (f : ι → κ → β) : Set.indicator t (Finset.sum s fun (i : ι) => f i) = Finset.sum s fun (i : ι) => Set.indicator t (f i)

theorem Finset.mulIndicator_prod {ι : Type u_1} {β : Type u} [CommMonoid β] {κ : Type u_2} (s : Finset ι) (t : Set κ) (f : ι → κ → β) : Set.mulIndicator t (Finset.prod s fun (i : ι) => f i) = Finset.prod s fun (i : ι) => Set.mulIndicator t (f i)

theorem Finset.indicator_biUnion {ι : Type u_1} {β : Type u} [AddCommMonoid β] {κ : Type u_3} (s : Finset ι) (t : ι → Set κ) {f : κ → β} : Set.PairwiseDisjoint (↑s) t → Set.indicator (⋃ i ∈ s, t i) f = fun (a : κ) => Finset.sum s fun (i : ι) => Set.indicator (t i) f a

theorem Finset.mulIndicator_biUnion {ι : Type u_1} {β : Type u} [CommMonoid β] {κ : Type u_3} (s : Finset ι) (t : ι → Set κ) {f : κ → β} : Set.PairwiseDisjoint (↑s) t → Set.mulIndicator (⋃ i ∈ s, t i) f = fun (a : κ) => Finset.prod s fun (i : ι) => Set.mulIndicator (t i) f a

theorem Finset.indicator_biUnion_apply {ι : Type u_1} {β : Type u} [AddCommMonoid β] {κ : Type u_3} (s : Finset ι) (t : ι → Set κ) {f : κ → β} (h : Set.PairwiseDisjoint (↑s) t) (x : κ) : Set.indicator (⋃ i ∈ s, t i) f x = Finset.sum s fun (i : ι) => Set.indicator (t i) f x

theorem Finset.mulIndicator_biUnion_apply {ι : Type u_1} {β : Type u} [CommMonoid β] {κ : Type u_3} (s : Finset ι) (t : ι → Set κ) {f : κ → β} (h : Set.PairwiseDisjoint (↑s) t) (x : κ) : Set.mulIndicator (⋃ i ∈ s, t i) f x = Finset.prod s fun (i : ι) => Set.mulIndicator (t i) f x

theorem Finset.sum_bij_ne_zero {β : Type u} {α : Type v} {γ : Type w} [AddCommMonoid β] {s : Finset α} {t : Finset γ} {f : α → β} {g : γ → β} (i : (a : α) → a ∈ s → f a ≠ 0 → γ) (hi : ∀ (a : α) (h₁ : a ∈ s) (h₂ : f a ≠ 0), i a h₁ h₂ ∈ t) (i_inj : ∀ (a₁ : α) (h₁₁ : a₁ ∈ s) (h₁₂ : f a₁ ≠ 0) (a₂ : α) (h₂₁ : a₂ ∈ s) (h₂₂ : f a₂ ≠ 0), i a₁ h₁₁ h₁₂ = i a₂ h₂₁ h₂₂ → a₁ = a₂) (i_surj : ∀ b ∈ t, g b ≠ 0 → ∃ (a : α) (h₁ : a ∈ s) (h₂ : f a ≠ 0), i a h₁ h₂ = b) (h : ∀ (a : α) (h₁ : a ∈ s) (h₂ : f a ≠ 0), f a = g (i a h₁ h₂)) : (Finset.sum s fun (x : α) => f x) = Finset.sum t fun (x : γ) => g x

theorem Finset.prod_bij_ne_one {β : Type u} {α : Type v} {γ : Type w} [CommMonoid β] {s : Finset α} {t : Finset γ} {f : α → β} {g : γ → β} (i : (a : α) → a ∈ s → f a ≠ 1 → γ) (hi : ∀ (a : α) (h₁ : a ∈ s) (h₂ : f a ≠ 1), i a h₁ h₂ ∈ t) (i_inj : ∀ (a₁ : α) (h₁₁ : a₁ ∈ s) (h₁₂ : f a₁ ≠ 1) (a₂ : α) (h₂₁ : a₂ ∈ s) (h₂₂ : f a₂ ≠ 1), i a₁ h₁₁ h₁₂ = i a₂ h₂₁ h₂₂ → a₁ = a₂) (i_surj : ∀ b ∈ t, g b ≠ 1 → ∃ (a : α) (h₁ : a ∈ s) (h₂ : f a ≠ 1), i a h₁ h₂ = b) (h : ∀ (a : α) (h₁ : a ∈ s) (h₂ : f a ≠ 1), f a = g (i a h₁ h₂)) : (Finset.prod s fun (x : α) => f x) = Finset.prod t fun (x : γ) => g x

theorem Finset.sum_dite_of_false {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] {p : α → Prop} {hp : DecidablePred p} (h : ∀ x ∈ s, ¬p x) (f : (x : α) → p x → β) (g : (x : α) → ¬p x → β) : (Finset.sum s fun (x : α) => if hx : p x then f x hx else g x hx) = Finset.sum Finset.univ fun (x : { x : α // x ∈ s }) => g ↑x ⋯

theorem Finset.prod_dite_of_false {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] {p : α → Prop} {hp : DecidablePred p} (h : ∀ x ∈ s, ¬p x) (f : (x : α) → p x → β) (g : (x : α) → ¬p x → β) : (Finset.prod s fun (x : α) => if hx : p x then f x hx else g x hx) = Finset.prod Finset.univ fun (x : { x : α // x ∈ s }) => g ↑x ⋯

theorem Finset.sum_dite_of_true {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] {p : α → Prop} {hp : DecidablePred p} (h : ∀ x ∈ s, p x) (f : (x : α) → p x → β) (g : (x : α) → ¬p x → β) : (Finset.sum s fun (x : α) => if hx : p x then f x hx else g x hx) = Finset.sum Finset.univ fun (x : { x : α // x ∈ s }) => f ↑x ⋯

theorem Finset.prod_dite_of_true {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] {p : α → Prop} {hp : DecidablePred p} (h : ∀ x ∈ s, p x) (f : (x : α) → p x → β) (g : (x : α) → ¬p x → β) : (Finset.prod s fun (x : α) => if hx : p x then f x hx else g x hx) = Finset.prod Finset.univ fun (x : { x : α // x ∈ s }) => f ↑x ⋯

theorem Finset.nonempty_of_sum_ne_zero {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommMonoid β] (h : (Finset.sum s fun (x : α) => f x) ≠ 0) : s.Nonempty

theorem Finset.nonempty_of_prod_ne_one {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoid β] (h : (Finset.prod s fun (x : α) => f x) ≠ 1) : s.Nonempty

theorem Finset.exists_ne_zero_of_sum_ne_zero {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommMonoid β] (h : (Finset.sum s fun (x : α) => f x) ≠ 0) : ∃ a ∈ s, f a ≠ 0

theorem Finset.exists_ne_one_of_prod_ne_one {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoid β] (h : (Finset.prod s fun (x : α) => f x) ≠ 1) : ∃ a ∈ s, f a ≠ 1

theorem Finset.sum_range_succ_comm {β : Type u} [AddCommMonoid β] (f : ℕ → β) (n : ℕ) : (Finset.sum (Finset.range (n + 1)) fun (x : ℕ) => f x) = f n + Finset.sum (Finset.range n) fun (x : ℕ) => f x

theorem Finset.prod_range_succ_comm {β : Type u} [CommMonoid β] (f : ℕ → β) (n : ℕ) : (Finset.prod (Finset.range (n + 1)) fun (x : ℕ) => f x) = f n * Finset.prod (Finset.range n) fun (x : ℕ) => f x

theorem Finset.sum_range_succ {β : Type u} [AddCommMonoid β] (f : ℕ → β) (n : ℕ) : (Finset.sum (Finset.range (n + 1)) fun (x : ℕ) => f x) = (Finset.sum (Finset.range n) fun (x : ℕ) => f x) + f n

theorem Finset.prod_range_succ {β : Type u} [CommMonoid β] (f : ℕ → β) (n : ℕ) : (Finset.prod (Finset.range (n + 1)) fun (x : ℕ) => f x) = (Finset.prod (Finset.range n) fun (x : ℕ) => f x) * f n

abbrev Finset.sum_range_succ'.match_1 (motive : ℕ → Prop) : ∀ (x : ℕ), (Unit → motive 0) → (∀ (n : ℕ), motive (Nat.succ n)) → motive x

Equations

• ⋯ = ⋯

theorem Finset.sum_range_succ' {β : Type u} [AddCommMonoid β] (f : ℕ → β) (n : ℕ) : (Finset.sum (Finset.range (n + 1)) fun (k : ℕ) => f k) = (Finset.sum (Finset.range n) fun (k : ℕ) => f (k + 1)) + f 0

theorem Finset.prod_range_succ' {β : Type u} [CommMonoid β] (f : ℕ → β) (n : ℕ) : (Finset.prod (Finset.range (n + 1)) fun (k : ℕ) => f k) = (Finset.prod (Finset.range n) fun (k : ℕ) => f (k + 1)) * f 0

theorem Finset.eventually_constant_sum {β : Type u} [AddCommMonoid β] {u : ℕ → β} {N : ℕ} (hu : ∀ n ≥ N, u n = 0) {n : ℕ} (hn : N ≤ n) : (Finset.sum (Finset.range n) fun (k : ℕ) => u k) = Finset.sum (Finset.range N) fun (k : ℕ) => u k

theorem Finset.eventually_constant_prod {β : Type u} [CommMonoid β] {u : ℕ → β} {N : ℕ} (hu : ∀ n ≥ N, u n = 1) {n : ℕ} (hn : N ≤ n) : (Finset.prod (Finset.range n) fun (k : ℕ) => u k) = Finset.prod (Finset.range N) fun (k : ℕ) => u k

theorem Finset.sum_range_add {β : Type u} [AddCommMonoid β] (f : ℕ → β) (n : ℕ) (m : ℕ) : (Finset.sum (Finset.range (n + m)) fun (x : ℕ) => f x) = (Finset.sum (Finset.range n) fun (x : ℕ) => f x) + Finset.sum (Finset.range m) fun (x : ℕ) => f (n + x)

theorem Finset.prod_range_add {β : Type u} [CommMonoid β] (f : ℕ → β) (n : ℕ) (m : ℕ) : (Finset.prod (Finset.range (n + m)) fun (x : ℕ) => f x) = (Finset.prod (Finset.range n) fun (x : ℕ) => f x) * Finset.prod (Finset.range m) fun (x : ℕ) => f (n + x)

theorem Finset.sum_range_add_sub_sum_range {α : Type u_2} [AddCommGroup α] (f : ℕ → α) (n : ℕ) (m : ℕ) : ((Finset.sum (Finset.range (n + m)) fun (k : ℕ) => f k) - Finset.sum (Finset.range n) fun (k : ℕ) => f k) = Finset.sum (Finset.range m) fun (k : ℕ) => f (n + k)

theorem Finset.prod_range_add_div_prod_range {α : Type u_2} [CommGroup α] (f : ℕ → α) (n : ℕ) (m : ℕ) : ((Finset.prod (Finset.range (n + m)) fun (k : ℕ) => f k) / Finset.prod (Finset.range n) fun (k : ℕ) => f k) = Finset.prod (Finset.range m) fun (k : ℕ) => f (n + k)

theorem Finset.sum_range_zero {β : Type u} [AddCommMonoid β] (f : ℕ → β) : (Finset.sum (Finset.range 0) fun (k : ℕ) => f k) = 0

theorem Finset.prod_range_zero {β : Type u} [CommMonoid β] (f : ℕ → β) : (Finset.prod (Finset.range 0) fun (k : ℕ) => f k) = 1

theorem Finset.sum_range_one {β : Type u} [AddCommMonoid β] (f : ℕ → β) : (Finset.sum (Finset.range 1) fun (k : ℕ) => f k) = f 0

theorem Finset.prod_range_one {β : Type u} [CommMonoid β] (f : ℕ → β) : (Finset.prod (Finset.range 1) fun (k : ℕ) => f k) = f 0

theorem Finset.sum_list_map_count {α : Type v} [DecidableEq α] (l : List α) {M : Type u_2} [AddCommMonoid M] (f : α → M) : List.sum (List.map f l) = Finset.sum (List.toFinset l) fun (m : α) => List.count m l • f m

theorem Finset.prod_list_map_count {α : Type v} [DecidableEq α] (l : List α) {M : Type u_2} [CommMonoid M] (f : α → M) : List.prod (List.map f l) = Finset.prod (List.toFinset l) fun (m : α) => f m ^ List.count m l

theorem Finset.sum_list_count {α : Type v} [DecidableEq α] [AddCommMonoid α] (s : List α) : List.sum s = Finset.sum (List.toFinset s) fun (m : α) => List.count m s • m

theorem Finset.prod_list_count {α : Type v} [DecidableEq α] [CommMonoid α] (s : List α) : List.prod s = Finset.prod (List.toFinset s) fun (m : α) => m ^ List.count m s

theorem Finset.sum_list_count_of_subset {α : Type v} [DecidableEq α] [AddCommMonoid α] (m : List α) (s : Finset α) (hs : List.toFinset m ⊆ s) : List.sum m = Finset.sum s fun (i : α) => List.count i m • i

theorem Finset.prod_list_count_of_subset {α : Type v} [DecidableEq α] [CommMonoid α] (m : List α) (s : Finset α) (hs : List.toFinset m ⊆ s) : List.prod m = Finset.prod s fun (i : α) => i ^ List.count i m

theorem Finset.sum_filter_count_eq_countP {α : Type v} [DecidableEq α] (p : α → Prop) [DecidablePred p] (l : List α) : (Finset.sum (Finset.filter p (List.toFinset l)) fun (x : α) => List.count x l) = List.countP (fun (b : α) => decide (p b)) l

theorem Finset.sum_multiset_map_count {α : Type v} [DecidableEq α] (s : Multiset α) {M : Type u_2} [AddCommMonoid M] (f : α → M) : Multiset.sum (Multiset.map f s) = Finset.sum (Multiset.toFinset s) fun (m : α) => Multiset.count m s • f m

theorem Finset.prod_multiset_map_count {α : Type v} [DecidableEq α] (s : Multiset α) {M : Type u_2} [CommMonoid M] (f : α → M) : Multiset.prod (Multiset.map f s) = Finset.prod (Multiset.toFinset s) fun (m : α) => f m ^ Multiset.count m s

theorem Finset.sum_multiset_count {α : Type v} [DecidableEq α] [AddCommMonoid α] (s : Multiset α) : Multiset.sum s = Finset.sum (Multiset.toFinset s) fun (m : α) => Multiset.count m s • m

theorem Finset.prod_multiset_count {α : Type v} [DecidableEq α] [CommMonoid α] (s : Multiset α) : Multiset.prod s = Finset.prod (Multiset.toFinset s) fun (m : α) => m ^ Multiset.count m s

theorem Finset.sum_multiset_count_of_subset {α : Type v} [DecidableEq α] [AddCommMonoid α] (m : Multiset α) (s : Finset α) (hs : Multiset.toFinset m ⊆ s) : Multiset.sum m = Finset.sum s fun (i : α) => Multiset.count i m • i

theorem Finset.prod_multiset_count_of_subset {α : Type v} [DecidableEq α] [CommMonoid α] (m : Multiset α) (s : Finset α) (hs : Multiset.toFinset m ⊆ s) : Multiset.prod m = Finset.prod s fun (i : α) => i ^ Multiset.count i m

theorem Finset.sum_mem_multiset {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (m : Multiset α) (f : { x : α // x ∈ m } → β) (g : α → β) (hfg : ∀ (x : { x : α // x ∈ m }), f x = g ↑x) : (Finset.sum Finset.univ fun (x : { x : α // x ∈ m }) => f x) = Finset.sum (Multiset.toFinset m) fun (x : α) => g x

theorem Finset.prod_mem_multiset {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (m : Multiset α) (f : { x : α // x ∈ m } → β) (g : α → β) (hfg : ∀ (x : { x : α // x ∈ m }), f x = g ↑x) : (Finset.prod Finset.univ fun (x : { x : α // x ∈ m }) => f x) = Finset.prod (Multiset.toFinset m) fun (x : α) => g x

theorem Finset.sum_induction {α : Type v} {s : Finset α} {M : Type u_2} [AddCommMonoid M] (f : α → M) (p : M → Prop) (hom : ∀ (a b : M), p a → p b → p (a + b)) (unit : p 0) (base : ∀ x ∈ s, p (f x)) : p (Finset.sum s fun (x : α) => f x)

To prove a property of a sum, it suffices to prove that the property is additive and holds on summands.

theorem Finset.prod_induction {α : Type v} {s : Finset α} {M : Type u_2} [CommMonoid M] (f : α → M) (p : M → Prop) (hom : ∀ (a b : M), p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ s, p (f x)) : p (Finset.prod s fun (x : α) => f x)

To prove a property of a product, it suffices to prove that the property is multiplicative and holds on factors.

theorem Finset.sum_induction_nonempty {α : Type v} {s : Finset α} {M : Type u_2} [AddCommMonoid M] (f : α → M) (p : M → Prop) (hom : ∀ (a b : M), p a → p b → p (a + b)) (nonempty : s.Nonempty) (base : ∀ x ∈ s, p (f x)) : p (Finset.sum s fun (x : α) => f x)

To prove a property of a sum, it suffices to prove that the property is additive and holds on summands.

theorem Finset.prod_induction_nonempty {α : Type v} {s : Finset α} {M : Type u_2} [CommMonoid M] (f : α → M) (p : M → Prop) (hom : ∀ (a b : M), p a → p b → p (a * b)) (nonempty : s.Nonempty) (base : ∀ x ∈ s, p (f x)) : p (Finset.prod s fun (x : α) => f x)

To prove a property of a product, it suffices to prove that the property is multiplicative and holds on factors.

theorem Finset.sum_range_induction {β : Type u} [AddCommMonoid β] (f : ℕ → β) (s : ℕ → β) (base : s 0 = 0) (step : ∀ (n : ℕ), s (n + 1) = s n + f n) (n : ℕ) : (Finset.sum (Finset.range n) fun (k : ℕ) => f k) = s n

For any sum along {0, ..., n - 1} of a commutative-monoid-valued function, we can verify that it's equal to a different function just by checking differences of adjacent terms.

This is a discrete analogue of the fundamental theorem of calculus.

theorem Finset.prod_range_induction {β : Type u} [CommMonoid β] (f : ℕ → β) (s : ℕ → β) (base : s 0 = 1) (step : ∀ (n : ℕ), s (n + 1) = s n * f n) (n : ℕ) : (Finset.prod (Finset.range n) fun (k : ℕ) => f k) = s n

For any product along {0, ..., n - 1} of a commutative-monoid-valued function, we can verify that it's equal to a different function just by checking ratios of adjacent terms.

This is a multiplicative discrete analogue of the fundamental theorem of calculus.

theorem Finset.sum_range_sub {M : Type u_2} [AddCommGroup M] (f : ℕ → M) (n : ℕ) : (Finset.sum (Finset.range n) fun (i : ℕ) => f (i + 1) - f i) = f n - f 0

A telescoping sum along {0, ..., n - 1} of an additive commutative group valued function reduces to the difference of the last and first terms.

theorem Finset.prod_range_div {M : Type u_2} [CommGroup M] (f : ℕ → M) (n : ℕ) : (Finset.prod (Finset.range n) fun (i : ℕ) => f (i + 1) / f i) = f n / f 0

A telescoping product along {0, ..., n - 1} of a commutative group valued function reduces to the ratio of the last and first factors.

theorem Finset.sum_range_sub' {M : Type u_2} [AddCommGroup M] (f : ℕ → M) (n : ℕ) : (Finset.sum (Finset.range n) fun (i : ℕ) => f i - f (i + 1)) = f 0 - f n

theorem Finset.prod_range_div' {M : Type u_2} [CommGroup M] (f : ℕ → M) (n : ℕ) : (Finset.prod (Finset.range n) fun (i : ℕ) => f i / f (i + 1)) = f 0 / f n

theorem Finset.eq_sum_range_sub {M : Type u_2} [AddCommGroup M] (f : ℕ → M) (n : ℕ) : f n = f 0 + Finset.sum (Finset.range n) fun (i : ℕ) => f (i + 1) - f i

theorem Finset.eq_prod_range_div {M : Type u_2} [CommGroup M] (f : ℕ → M) (n : ℕ) : f n = f 0 * Finset.prod (Finset.range n) fun (i : ℕ) => f (i + 1) / f i

theorem Finset.eq_sum_range_sub' {M : Type u_2} [AddCommGroup M] (f : ℕ → M) (n : ℕ) : f n = Finset.sum (Finset.range (n + 1)) fun (i : ℕ) => if i = 0 then f 0 else f i - f (i - 1)

theorem Finset.eq_prod_range_div' {M : Type u_2} [CommGroup M] (f : ℕ → M) (n : ℕ) : f n = Finset.prod (Finset.range (n + 1)) fun (i : ℕ) => if i = 0 then f 0 else f i / f (i - 1)

theorem Finset.sum_range_tsub {α : Type v} [CanonicallyOrderedAddCommMonoid α] [Sub α] [OrderedSub α] [ContravariantClass α α (fun (x x_1 : α) => x + x_1) fun (x x_1 : α) => x ≤ x_1] {f : ℕ → α} (h : Monotone f) (n : ℕ) : (Finset.sum (Finset.range n) fun (i : ℕ) => f (i + 1) - f i) = f n - f 0

A telescoping sum along {0, ..., n-1} of an ℕ-valued function reduces to the difference of the last and first terms when the function we are summing is monotone.

@[simp]

theorem Finset.sum_const {β : Type u} {α : Type v} {s : Finset α} [AddCommMonoid β] (b : β) : (Finset.sum s fun (_x : α) => b) = s.card • b

@[simp]

theorem Finset.prod_const {β : Type u} {α : Type v} {s : Finset α} [CommMonoid β] (b : β) : (Finset.prod s fun (_x : α) => b) = b ^ s.card

theorem Finset.sum_eq_card_nsmul {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommMonoid β] {b : β} (hf : ∀ a ∈ s, f a = b) : (Finset.sum s fun (a : α) => f a) = s.card • b

theorem Finset.prod_eq_pow_card {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoid β] {b : β} (hf : ∀ a ∈ s, f a = b) : (Finset.prod s fun (a : α) => f a) = b ^ s.card

theorem Finset.card_nsmul_add_sum {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommMonoid β] {b : β} : (s.card • b + Finset.sum s fun (a : α) => f a) = Finset.sum s fun (a : α) => b + f a

theorem Finset.pow_card_mul_prod {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoid β] {b : β} : (b ^ s.card * Finset.prod s fun (a : α) => f a) = Finset.prod s fun (a : α) => b * f a

theorem Finset.sum_add_card_nsmul {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommMonoid β] {b : β} : (Finset.sum s fun (a : α) => f a) + s.card • b = Finset.sum s fun (a : α) => f a + b

theorem Finset.prod_mul_pow_card {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoid β] {b : β} : (Finset.prod s fun (a : α) => f a) * b ^ s.card = Finset.prod s fun (a : α) => f a * b

theorem Finset.nsmul_eq_sum_const {β : Type u} [AddCommMonoid β] (b : β) (n : ℕ) : n • b = Finset.sum (Finset.range n) fun (_k : ℕ) => b

theorem Finset.pow_eq_prod_const {β : Type u} [CommMonoid β] (b : β) (n : ℕ) : b ^ n = Finset.prod (Finset.range n) fun (_k : ℕ) => b

theorem Finset.sum_nsmul {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (n : ℕ) (f : α → β) : (Finset.sum s fun (x : α) => n • f x) = n • Finset.sum s fun (x : α) => f x

theorem Finset.prod_pow {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (n : ℕ) (f : α → β) : (Finset.prod s fun (x : α) => f x ^ n) = (Finset.prod s fun (x : α) => f x) ^ n

theorem Finset.sum_nsmul_assoc {ι : Type u_1} {β : Type u} [AddCommMonoid β] (s : Finset ι) (f : ι → ℕ) (a : β) : (Finset.sum s fun (i : ι) => f i • a) = (Finset.sum s fun (i : ι) => f i) • a

theorem Finset.prod_pow_eq_pow_sum {ι : Type u_1} {β : Type u} [CommMonoid β] (s : Finset ι) (f : ι → ℕ) (a : β) : (Finset.prod s fun (i : ι) => a ^ f i) = a ^ Finset.sum s fun (i : ι) => f i

theorem Finset.sum_powersetCard {β : Type u} {α : Type v} [AddCommMonoid β] (n : ℕ) (s : Finset α) (f : ℕ → β) : (Finset.sum (Finset.powersetCard n s) fun (t : Finset α) => f t.card) = Nat.choose s.card n • f n

A sum over Finset.powersetCard which only depends on the size of the sets is constant.

theorem Finset.prod_powersetCard {β : Type u} {α : Type v} [CommMonoid β] (n : ℕ) (s : Finset α) (f : ℕ → β) : (Finset.prod (Finset.powersetCard n s) fun (t : Finset α) => f t.card) = f n ^ Nat.choose s.card n

A product over Finset.powersetCard which only depends on the size of the sets is constant.

theorem Finset.sum_flip {β : Type u} [AddCommMonoid β] {n : ℕ} (f : ℕ → β) : (Finset.sum (Finset.range (n + 1)) fun (r : ℕ) => f (n - r)) = Finset.sum (Finset.range (n + 1)) fun (k : ℕ) => f k

theorem Finset.prod_flip {β : Type u} [CommMonoid β] {n : ℕ} (f : ℕ → β) : (Finset.prod (Finset.range (n + 1)) fun (r : ℕ) => f (n - r)) = Finset.prod (Finset.range (n + 1)) fun (k : ℕ) => f k

theorem Finset.sum_involution {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} {f : α → β} (g : (a : α) → a ∈ s → α) : (∀ (a : α) (ha : a ∈ s), f a + f (g a ha) = 0) → (∀ (a : α) (ha : a ∈ s), f a ≠ 0 → g a ha ≠ a) → ∀ (g_mem : ∀ (a : α) (ha : a ∈ s), g a ha ∈ s), (∀ (a : α) (ha : a ∈ s), g (g a ha) ⋯ = a) → (Finset.sum s fun (x : α) => f x) = 0

abbrev Finset.sum_involution.match_1 {α : Type u_1} (s : Finset α) (motive : s.Nonempty → Prop) : ∀ (x : s.Nonempty), (∀ (x : α) (hx : x ∈ s), motive ⋯) → motive x

Equations

• ⋯ = ⋯

theorem Finset.prod_involution {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} {f : α → β} (g : (a : α) → a ∈ s → α) : (∀ (a : α) (ha : a ∈ s), f a * f (g a ha) = 1) → (∀ (a : α) (ha : a ∈ s), f a ≠ 1 → g a ha ≠ a) → ∀ (g_mem : ∀ (a : α) (ha : a ∈ s), g a ha ∈ s), (∀ (a : α) (ha : a ∈ s), g (g a ha) ⋯ = a) → (Finset.prod s fun (x : α) => f x) = 1

theorem Finset.sum_comp {β : Type u} {α : Type v} {γ : Type w} {s : Finset α} [AddCommMonoid β] [DecidableEq γ] (f : γ → β) (g : α → γ) : (Finset.sum s fun (a : α) => f (g a)) = Finset.sum (Finset.image g s) fun (b : γ) => (Finset.filter (fun (a : α) => g a = b) s).card • f b

The sum of the composition of functions f and g, is the sum over b ∈ s.image g of f b times of the cardinality of the fibre of b. See also Finset.sum_image.

theorem Finset.prod_comp {β : Type u} {α : Type v} {γ : Type w} {s : Finset α} [CommMonoid β] [DecidableEq γ] (f : γ → β) (g : α → γ) : (Finset.prod s fun (a : α) => f (g a)) = Finset.prod (Finset.image g s) fun (b : γ) => f b ^ (Finset.filter (fun (a : α) => g a = b) s).card

The product of the composition of functions f and g, is the product over b ∈ s.image g of f b to the power of the cardinality of the fibre of b. See also Finset.prod_image.

theorem Finset.sum_piecewise {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (t : Finset α) (f : α → β) (g : α → β) : (Finset.sum s fun (x : α) => Finset.piecewise t f g x) = (Finset.sum (s ∩ t) fun (x : α) => f x) + Finset.sum (s \ t) fun (x : α) => g x

theorem Finset.prod_piecewise {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (t : Finset α) (f : α → β) (g : α → β) : (Finset.prod s fun (x : α) => Finset.piecewise t f g x) = (Finset.prod (s ∩ t) fun (x : α) => f x) * Finset.prod (s \ t) fun (x : α) => g x

theorem Finset.sum_inter_add_sum_diff {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (t : Finset α) (f : α → β) : ((Finset.sum (s ∩ t) fun (x : α) => f x) + Finset.sum (s \ t) fun (x : α) => f x) = Finset.sum s fun (x : α) => f x

theorem Finset.prod_inter_mul_prod_diff {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (t : Finset α) (f : α → β) : ((Finset.prod (s ∩ t) fun (x : α) => f x) * Finset.prod (s \ t) fun (x : α) => f x) = Finset.prod s fun (x : α) => f x

theorem Finset.sum_eq_add_sum_diff_singleton {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] {s : Finset α} {i : α} (h : i ∈ s) (f : α → β) : (Finset.sum s fun (x : α) => f x) = f i + Finset.sum (s \ {i}) fun (x : α) => f x

theorem Finset.prod_eq_mul_prod_diff_singleton {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] {s : Finset α} {i : α} (h : i ∈ s) (f : α → β) : (Finset.prod s fun (x : α) => f x) = f i * Finset.prod (s \ {i}) fun (x : α) => f x

theorem Finset.sum_eq_sum_diff_singleton_add {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] {s : Finset α} {i : α} (h : i ∈ s) (f : α → β) : (Finset.sum s fun (x : α) => f x) = (Finset.sum (s \ {i}) fun (x : α) => f x) + f i

theorem Finset.prod_eq_prod_diff_singleton_mul {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] {s : Finset α} {i : α} (h : i ∈ s) (f : α → β) : (Finset.prod s fun (x : α) => f x) = (Finset.prod (s \ {i}) fun (x : α) => f x) * f i

theorem Fintype.sum_eq_add_sum_compl {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] [Fintype α] (a : α) (f : α → β) : (Finset.sum Finset.univ fun (i : α) => f i) = f a + Finset.sum {a}ᶜ fun (i : α) => f i

theorem Fintype.prod_eq_mul_prod_compl {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] [Fintype α] (a : α) (f : α → β) : (Finset.prod Finset.univ fun (i : α) => f i) = f a * Finset.prod {a}ᶜ fun (i : α) => f i

theorem Fintype.sum_eq_sum_compl_add {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] [Fintype α] (a : α) (f : α → β) : (Finset.sum Finset.univ fun (i : α) => f i) = (Finset.sum {a}ᶜ fun (i : α) => f i) + f a

theorem Fintype.prod_eq_prod_compl_mul {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] [Fintype α] (a : α) (f : α → β) : (Finset.prod Finset.univ fun (i : α) => f i) = (Finset.prod {a}ᶜ fun (i : α) => f i) * f a

theorem Finset.dvd_prod_of_mem {β : Type u} {α : Type v} [CommMonoid β] (f : α → β) {a : α} {s : Finset α} (ha : a ∈ s) : f a ∣ Finset.prod s fun (i : α) => f i

theorem Finset.sum_partition {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommMonoid β] (R : Setoid α) [DecidableRel Setoid.r] : (Finset.sum s fun (x : α) => f x) = Finset.sum (Finset.image Quotient.mk'' s) fun (xbar : Quotient R) => Finset.sum (Finset.filter (fun (x : α) => ⟦x⟧ = xbar) s) fun (y : α) => f y

A sum can be partitioned into a sum of sums, each equivalent under a setoid.

theorem Finset.prod_partition {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoid β] (R : Setoid α) [DecidableRel Setoid.r] : (Finset.prod s fun (x : α) => f x) = Finset.prod (Finset.image Quotient.mk'' s) fun (xbar : Quotient R) => Finset.prod (Finset.filter (fun (x : α) => ⟦x⟧ = xbar) s) fun (y : α) => f y

A product can be partitioned into a product of products, each equivalent under a setoid.

theorem Finset.sum_cancels_of_partition_cancels {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommMonoid β] (R : Setoid α) [DecidableRel Setoid.r] (h : ∀ x ∈ s, (Finset.sum (Finset.filter (fun (y : α) => y ≈ x) s) fun (a : α) => f a) = 0) : (Finset.sum s fun (x : α) => f x) = 0

If we can partition a sum into subsets that cancel out, then the whole sum cancels.

theorem Finset.prod_cancels_of_partition_cancels {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoid β] (R : Setoid α) [DecidableRel Setoid.r] (h : ∀ x ∈ s, (Finset.prod (Finset.filter (fun (y : α) => y ≈ x) s) fun (a : α) => f a) = 1) : (Finset.prod s fun (x : α) => f x) = 1

If we can partition a product into subsets that cancel out, then the whole product cancels.

theorem Finset.sum_update_of_not_mem {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] {s : Finset α} {i : α} (h : i ∉ s) (f : α → β) (b : β) : (Finset.sum s fun (x : α) => Function.update f i b x) = Finset.sum s fun (x : α) => f x

theorem Finset.prod_update_of_not_mem {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] {s : Finset α} {i : α} (h : i ∉ s) (f : α → β) (b : β) : (Finset.prod s fun (x : α) => Function.update f i b x) = Finset.prod s fun (x : α) => f x

theorem Finset.sum_update_of_mem {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] {s : Finset α} {i : α} (h : i ∈ s) (f : α → β) (b : β) : (Finset.sum s fun (x : α) => Function.update f i b x) = b + Finset.sum (s \ {i}) fun (x : α) => f x

theorem Finset.prod_update_of_mem {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] {s : Finset α} {i : α} (h : i ∈ s) (f : α → β) (b : β) : (Finset.prod s fun (x : α) => Function.update f i b x) = b * Finset.prod (s \ {i}) fun (x : α) => f x

theorem Finset.eq_of_card_le_one_of_sum_eq {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} (hc : s.card ≤ 1) {f : α → β} {b : β} (h : (Finset.sum s fun (x : α) => f x) = b) (x : α) : x ∈ s → f x = b

If a sum of a Finset of size at most 1 has a given value, so do the terms in that sum.

theorem Finset.eq_of_card_le_one_of_prod_eq {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} (hc : s.card ≤ 1) {f : α → β} {b : β} (h : (Finset.prod s fun (x : α) => f x) = b) (x : α) : x ∈ s → f x = b

If a product of a Finset of size at most 1 has a given value, so do the terms in that product.

theorem Finset.add_sum_erase {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (f : α → β) {a : α} (h : a ∈ s) : (f a + Finset.sum (Finset.erase s a) fun (x : α) => f x) = Finset.sum s fun (x : α) => f x

Taking a sum over s : Finset α is the same as adding the value on a single element f a to the sum over s.erase a.

See Multiset.sum_map_erase for the Multiset version.

theorem Finset.mul_prod_erase {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (f : α → β) {a : α} (h : a ∈ s) : (f a * Finset.prod (Finset.erase s a) fun (x : α) => f x) = Finset.prod s fun (x : α) => f x

Taking a product over s : Finset α is the same as multiplying the value on a single element f a by the product of s.erase a.

See Multiset.prod_map_erase for the Multiset version.

theorem Finset.sum_erase_add {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (f : α → β) {a : α} (h : a ∈ s) : (Finset.sum (Finset.erase s a) fun (x : α) => f x) + f a = Finset.sum s fun (x : α) => f x

A variant of Finset.add_sum_erase with the addition swapped.

theorem Finset.prod_erase_mul {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (f : α → β) {a : α} (h : a ∈ s) : (Finset.prod (Finset.erase s a) fun (x : α) => f x) * f a = Finset.prod s fun (x : α) => f x

A variant of Finset.mul_prod_erase with the multiplication swapped.

theorem Finset.sum_erase {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) {f : α → β} {a : α} (h : f a = 0) : (Finset.sum (Finset.erase s a) fun (x : α) => f x) = Finset.sum s fun (x : α) => f x

If a function applied at a point is 0, a sum is unchanged by removing that point, if present, from a Finset.

theorem Finset.prod_erase {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) {f : α → β} {a : α} (h : f a = 1) : (Finset.prod (Finset.erase s a) fun (x : α) => f x) = Finset.prod s fun (x : α) => f x

If a function applied at a point is 1, a product is unchanged by removing that point, if present, from a Finset.

theorem Finset.sum_ite_zero {β : Type u} {α : Type v} [AddCommMonoid β] (s : Finset α) (p : α → Prop) [DecidablePred p] (h : ∀ i ∈ s, ∀ j ∈ s, p i → p j → i = j) (a : β) : (Finset.sum s fun (i : α) => if p i then a else 0) = if ∃ i ∈ s, p i then a else 0

See also Finset.sum_boole.

theorem Finset.prod_ite_one {β : Type u} {α : Type v} [CommMonoid β] (s : Finset α) (p : α → Prop) [DecidablePred p] (h : ∀ i ∈ s, ∀ j ∈ s, p i → p j → i = j) (a : β) : (Finset.prod s fun (i : α) => if p i then a else 1) = if ∃ i ∈ s, p i then a else 1

See also Finset.prod_boole.

theorem Finset.sum_erase_lt_of_pos {α : Type v} {γ : Type u_2} [DecidableEq α] [OrderedAddCommMonoid γ] [CovariantClass γ γ (fun (x x_1 : γ) => x + x_1) fun (x x_1 : γ) => x < x_1] {s : Finset α} {d : α} (hd : d ∈ s) {f : α → γ} (hdf : 0 < f d) : (Finset.sum (Finset.erase s d) fun (m : α) => f m) < Finset.sum s fun (m : α) => f m

theorem Finset.prod_erase_lt_of_one_lt {α : Type v} {γ : Type u_2} [DecidableEq α] [OrderedCommMonoid γ] [CovariantClass γ γ (fun (x x_1 : γ) => x * x_1) fun (x x_1 : γ) => x < x_1] {s : Finset α} {d : α} (hd : d ∈ s) {f : α → γ} (hdf : 1 < f d) : (Finset.prod (Finset.erase s d) fun (m : α) => f m) < Finset.prod s fun (m : α) => f m

theorem Finset.eq_zero_of_sum_eq_zero {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} {f : α → β} {a : α} (hp : (Finset.sum s fun (x : α) => f x) = 0) (h1 : ∀ x ∈ s, x ≠ a → f x = 0) (x : α) : x ∈ s → f x = 0

If a sum is 0 and the function is 0 except possibly at one point, it is 0 everywhere on the Finset.

theorem Finset.eq_one_of_prod_eq_one {β : Type u} {α : Type v} [CommMonoid β] {s : Finset α} {f : α → β} {a : α} (hp : (Finset.prod s fun (x : α) => f x) = 1) (h1 : ∀ x ∈ s, x ≠ a → f x = 1) (x : α) : x ∈ s → f x = 1

If a product is 1 and the function is 1 except possibly at one point, it is 1 everywhere on the Finset.

theorem Finset.sum_boole_nsmul {β : Type u} {α : Type v} [AddCommMonoid β] [DecidableEq α] (s : Finset α) (f : α → β) (a : α) : (Finset.sum s fun (x : α) => (if a = x then 1 else 0) • f x) = if a ∈ s then f a else 0

theorem Finset.prod_pow_boole {β : Type u} {α : Type v} [CommMonoid β] [DecidableEq α] (s : Finset α) (f : α → β) (a : α) : (Finset.prod s fun (x : α) => f x ^ if a = x then 1 else 0) = if a ∈ s then f a else 1

theorem Finset.prod_dvd_prod_of_dvd {β : Type u} {α : Type v} [CommMonoid β] {S : Finset α} (g1 : α → β) (g2 : α → β) (h : ∀ a ∈ S, g1 a ∣ g2 a) : Finset.prod S g1 ∣ Finset.prod S g2

theorem Finset.prod_dvd_prod_of_subset {ι : Type u_2} {M : Type u_3} [CommMonoid M] (s : Finset ι) (t : Finset ι) (f : ι → M) (h : s ⊆ t) : (Finset.prod s fun (i : ι) => f i) ∣ Finset.prod t fun (i : ι) => f i

theorem Finset.prod_add_prod_eq {β : Type u} {α : Type v} [CommSemiring β] {s : Finset α} {i : α} {f : α → β} {g : α → β} {h : α → β} (hi : i ∈ s) (h1 : g i + h i = f i) (h2 : ∀ j ∈ s, j ≠ i → g j = f j) (h3 : ∀ j ∈ s, j ≠ i → h j = f j) : ((Finset.prod s fun (i : α) => g i) + Finset.prod s fun (i : α) => h i) = Finset.prod s fun (i : α) => f i

If f = g = h everywhere but at i, where f i = g i + h i, then the product of f over s is the sum of the products of g and h.

theorem Finset.card_eq_sum_ones {α : Type v} (s : Finset α) : s.card = Finset.sum s fun (x : α) => 1

theorem Finset.sum_const_nat {α : Type v} {s : Finset α} {m : ℕ} {f : α → ℕ} (h₁ : ∀ x ∈ s, f x = m) : (Finset.sum s fun (x : α) => f x) = s.card * m

theorem Finset.natCast_card_filter {β : Type u} {α : Type v} [AddCommMonoidWithOne β] (p : α → Prop) [DecidablePred p] (s : Finset α) : ↑(Finset.filter p s).card = Finset.sum s fun (a : α) => if p a then 1 else 0

theorem Finset.card_filter {α : Type v} (p : α → Prop) [DecidablePred p] (s : Finset α) : (Finset.filter p s).card = Finset.sum s fun (a : α) => if p a then 1 else 0

@[simp]

theorem Finset.sum_boole {β : Type u} {α : Type v} {s : Finset α} {p : α → Prop} [AddCommMonoidWithOne β] [DecidablePred p] : (Finset.sum s fun (x : α) => if p x then 1 else 0) = ↑(Finset.filter p s).card

theorem Commute.sum_right {β : Type u} {α : Type v} [NonUnitalNonAssocSemiring β] (s : Finset α) (f : α → β) (b : β) (h : ∀ i ∈ s, Commute b (f i)) : Commute b (Finset.sum s fun (i : α) => f i)

theorem Commute.sum_left {β : Type u} {α : Type v} [NonUnitalNonAssocSemiring β] (s : Finset α) (f : α → β) (b : β) (h : ∀ i ∈ s, Commute (f i) b) : Commute (Finset.sum s fun (i : α) => f i) b

@[simp]

theorem Finset.op_sum {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} (f : α → β) : MulOpposite.op (Finset.sum s fun (x : α) => f x) = Finset.sum s fun (x : α) => MulOpposite.op (f x)

Moving to the opposite additive commutative monoid commutes with summing.

@[simp]

theorem Finset.unop_sum {β : Type u} {α : Type v} [AddCommMonoid β] {s : Finset α} (f : α → βᵐᵒᵖ) : MulOpposite.unop (Finset.sum s fun (x : α) => f x) = Finset.sum s fun (x : α) => MulOpposite.unop (f x)

@[simp]

theorem Finset.sum_neg_distrib {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [SubtractionCommMonoid β] : (Finset.sum s fun (x : α) => -f x) = -Finset.sum s fun (x : α) => f x

@[simp]

theorem Finset.prod_inv_distrib {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [DivisionCommMonoid β] : (Finset.prod s fun (x : α) => (f x)⁻¹) = (Finset.prod s fun (x : α) => f x)⁻¹

@[simp]

theorem Finset.sum_sub_distrib {β : Type u} {α : Type v} {s : Finset α} {f : α → β} {g : α → β} [SubtractionCommMonoid β] : (Finset.sum s fun (x : α) => f x - g x) = (Finset.sum s fun (x : α) => f x) - Finset.sum s fun (x : α) => g x

@[simp]

theorem Finset.prod_div_distrib {β : Type u} {α : Type v} {s : Finset α} {f : α → β} {g : α → β} [DivisionCommMonoid β] : (Finset.prod s fun (x : α) => f x / g x) = (Finset.prod s fun (x : α) => f x) / Finset.prod s fun (x : α) => g x

theorem Finset.sum_zsmul {β : Type u} {α : Type v} [SubtractionCommMonoid β] (f : α → β) (s : Finset α) (n : ℤ) : (Finset.sum s fun (a : α) => n • f a) = n • Finset.sum s fun (a : α) => f a

theorem Finset.prod_zpow {β : Type u} {α : Type v} [DivisionCommMonoid β] (f : α → β) (s : Finset α) (n : ℤ) : (Finset.prod s fun (a : α) => f a ^ n) = (Finset.prod s fun (a : α) => f a) ^ n

@[simp]

theorem Finset.sum_sdiff_eq_sub {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommGroup β] [DecidableEq α] (h : s₁ ⊆ s₂) : (Finset.sum (s₂ \ s₁) fun (x : α) => f x) = (Finset.sum s₂ fun (x : α) => f x) - Finset.sum s₁ fun (x : α) => f x

@[simp]

theorem Finset.prod_sdiff_eq_div {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommGroup β] [DecidableEq α] (h : s₁ ⊆ s₂) : (Finset.prod (s₂ \ s₁) fun (x : α) => f x) = (Finset.prod s₂ fun (x : α) => f x) / Finset.prod s₁ fun (x : α) => f x

theorem Finset.sum_sdiff_sub_sum_sdiff {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [AddCommGroup β] [DecidableEq α] : ((Finset.sum (s₂ \ s₁) fun (x : α) => f x) - Finset.sum (s₁ \ s₂) fun (x : α) => f x) = (Finset.sum s₂ fun (x : α) => f x) - Finset.sum s₁ fun (x : α) => f x

theorem Finset.prod_sdiff_div_prod_sdiff {β : Type u} {α : Type v} {s₁ : Finset α} {s₂ : Finset α} {f : α → β} [CommGroup β] [DecidableEq α] : ((Finset.prod (s₂ \ s₁) fun (x : α) => f x) / Finset.prod (s₁ \ s₂) fun (x : α) => f x) = (Finset.prod s₂ fun (x : α) => f x) / Finset.prod s₁ fun (x : α) => f x

@[simp]

theorem Finset.sum_erase_eq_sub {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [AddCommGroup β] [DecidableEq α] {a : α} (h : a ∈ s) : (Finset.sum (Finset.erase s a) fun (x : α) => f x) = (Finset.sum s fun (x : α) => f x) - f a

@[simp]

theorem Finset.prod_erase_eq_div {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommGroup β] [DecidableEq α] {a : α} (h : a ∈ s) : (Finset.prod (Finset.erase s a) fun (x : α) => f x) = (Finset.prod s fun (x : α) => f x) / f a

@[simp]

theorem Finset.card_sigma {α : Type v} {σ : α → Type u_2} (s : Finset α) (t : (a : α) → Finset (σ a)) : (Finset.sigma s t).card = Finset.sum s fun (a : α) => (t a).card

@[simp]

theorem Finset.card_disjiUnion {β : Type u} {α : Type v} (s : Finset α) (t : α → Finset β) (h : Set.PairwiseDisjoint (↑s) t) : (Finset.disjiUnion s t h).card = Finset.sum s fun (i : α) => (t i).card

theorem Finset.card_biUnion {β : Type u} {α : Type v} [DecidableEq β] {s : Finset α} {t : α → Finset β} (h : ∀ x ∈ s, ∀ y ∈ s, x ≠ y → Disjoint (t x) (t y)) : (Finset.biUnion s t).card = Finset.sum s fun (u : α) => (t u).card

theorem Finset.card_biUnion_le {β : Type u} {α : Type v} [DecidableEq β] {s : Finset α} {t : α → Finset β} : (Finset.biUnion s t).card ≤ Finset.sum s fun (a : α) => (t a).card

theorem Finset.card_eq_sum_card_fiberwise {β : Type u} {α : Type v} [DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β} (H : ∀ x ∈ s, f x ∈ t) : s.card = Finset.sum t fun (a : β) => (Finset.filter (fun (x : α) => f x = a) s).card

theorem Finset.card_eq_sum_card_image {β : Type u} {α : Type v} [DecidableEq β] (f : α → β) (s : Finset α) : s.card = Finset.sum (Finset.image f s) fun (a : β) => (Finset.filter (fun (x : α) => f x = a) s).card

theorem Finset.mem_sum {β : Type u} {α : Type v} {f : α → Multiset β} (s : Finset α) (b : β) : (b ∈ Finset.sum s fun (x : α) => f x) ↔ ∃ a ∈ s, b ∈ f a

theorem Finset.prod_eq_zero {β : Type u} {α : Type v} {s : Finset α} {a : α} {f : α → β} [CommMonoidWithZero β] (ha : a ∈ s) (h : f a = 0) : (Finset.prod s fun (x : α) => f x) = 0

theorem Finset.prod_boole {β : Type u} {α : Type v} [CommMonoidWithZero β] {s : Finset α} {p : α → Prop} [DecidablePred p] : (Finset.prod s fun (i : α) => if p i then 1 else 0) = if ∀ i ∈ s, p i then 1 else 0

theorem Finset.support_prod_subset {ι : Type u_1} {β : Type u} {α : Type v} [CommMonoidWithZero β] (s : Finset ι) (f : ι → α → β) : (Function.support fun (x : α) => Finset.prod s fun (i : ι) => f i x) ⊆ ⋂ i ∈ s, Function.support (f i)

theorem Finset.prod_eq_zero_iff {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoidWithZero β] [Nontrivial β] [NoZeroDivisors β] : (Finset.prod s fun (x : α) => f x) = 0 ↔ ∃ a ∈ s, f a = 0

theorem Finset.prod_ne_zero_iff {β : Type u} {α : Type v} {s : Finset α} {f : α → β} [CommMonoidWithZero β] [Nontrivial β] [NoZeroDivisors β] : (Finset.prod s fun (x : α) => f x) ≠ 0 ↔ ∀ a ∈ s, f a ≠ 0

theorem Finset.support_prod {ι : Type u_1} {β : Type u} {α : Type v} [CommMonoidWithZero β] [Nontrivial β] [NoZeroDivisors β] (s : Finset ι) (f : ι → α → β) : (Function.support fun (x : α) => Finset.prod s fun (i : ι) => f i x) = ⋂ i ∈ s, Function.support (f i)

theorem Finset.sum_unique_nonempty {α : Type u_2} {β : Type u_3} [AddCommMonoid β] [Unique α] (s : Finset α) (f : α → β) (h : s.Nonempty) : (Finset.sum s fun (x : α) => f x) = f default

theorem Finset.prod_unique_nonempty {α : Type u_2} {β : Type u_3} [CommMonoid β] [Unique α] (s : Finset α) (f : α → β) (h : s.Nonempty) : (Finset.prod s fun (x : α) => f x) = f default

theorem Finset.sum_nat_mod {α : Type v} (s : Finset α) (n : ℕ) (f : α → ℕ) : (Finset.sum s fun (i : α) => f i) % n = (Finset.sum s fun (i : α) => f i % n) % n

theorem Finset.prod_nat_mod {α : Type v} (s : Finset α) (n : ℕ) (f : α → ℕ) : (Finset.prod s fun (i : α) => f i) % n = (Finset.prod s fun (i : α) => f i % n) % n

theorem Finset.sum_int_mod {α : Type v} (s : Finset α) (n : ℤ) (f : α → ℤ) : (Finset.sum s fun (i : α) => f i) % n = (Finset.sum s fun (i : α) => f i % n) % n

theorem Finset.prod_int_mod {α : Type v} (s : Finset α) (n : ℤ) (f : α → ℤ) : (Finset.prod s fun (i : α) => f i) % n = (Finset.prod s fun (i : α) => f i % n) % n

theorem Fintype.sum_bijective {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [AddCommMonoid α] (e : ι → κ) (he : Function.Bijective e) (f : ι → α) (g : κ → α) (h : ∀ (x : ι), f x = g (e x)) : (Finset.sum Finset.univ fun (x : ι) => f x) = Finset.sum Finset.univ fun (x : κ) => g x

Fintype.sum_bijective is a variant of Finset.sum_bij that accepts Function.Bijective.

See Function.Bijective.sum_comp for a version without h.

theorem Fintype.prod_bijective {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [CommMonoid α] (e : ι → κ) (he : Function.Bijective e) (f : ι → α) (g : κ → α) (h : ∀ (x : ι), f x = g (e x)) : (Finset.prod Finset.univ fun (x : ι) => f x) = Finset.prod Finset.univ fun (x : κ) => g x

Fintype.prod_bijective is a variant of Finset.prod_bij that accepts Function.Bijective.

See Function.Bijective.prod_comp for a version without h.

theorem Function.Bijective.finset_prod {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [CommMonoid α] (e : ι → κ) (he : Function.Bijective e) (f : ι → α) (g : κ → α) (h : ∀ (x : ι), f x = g (e x)) : (Finset.prod Finset.univ fun (x : ι) => f x) = Finset.prod Finset.univ fun (x : κ) => g x

Alias of Fintype.prod_bijective.

---

Fintype.prod_bijective is a variant of Finset.prod_bij that accepts Function.Bijective.

See Function.Bijective.prod_comp for a version without h.

theorem Function.Bijective.finset_sum {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [AddCommMonoid α] (e : ι → κ) (he : Function.Bijective e) (f : ι → α) (g : κ → α) (h : ∀ (x : ι), f x = g (e x)) : (Finset.sum Finset.univ fun (x : ι) => f x) = Finset.sum Finset.univ fun (x : κ) => g x

theorem Fintype.sum_equiv {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [AddCommMonoid α] (e : ι ≃ κ) (f : ι → α) (g : κ → α) (h : ∀ (x : ι), f x = g (e x)) : (Finset.sum Finset.univ fun (x : ι) => f x) = Finset.sum Finset.univ fun (x : κ) => g x

Fintype.sum_equiv is a specialization of Finset.sum_bij that automatically fills in most arguments.

See Equiv.sum_comp for a version without h.

theorem Fintype.prod_equiv {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [CommMonoid α] (e : ι ≃ κ) (f : ι → α) (g : κ → α) (h : ∀ (x : ι), f x = g (e x)) : (Finset.prod Finset.univ fun (x : ι) => f x) = Finset.prod Finset.univ fun (x : κ) => g x

Fintype.prod_equiv is a specialization of Finset.prod_bij that automatically fills in most arguments.

See Equiv.prod_comp for a version without h.

theorem Function.Bijective.sum_comp {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [AddCommMonoid α] {e : ι → κ} (he : Function.Bijective e) (g : κ → α) : (Finset.sum Finset.univ fun (i : ι) => g (e i)) = Finset.sum Finset.univ fun (i : κ) => g i

theorem Function.Bijective.prod_comp {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [CommMonoid α] {e : ι → κ} (he : Function.Bijective e) (g : κ → α) : (Finset.prod Finset.univ fun (i : ι) => g (e i)) = Finset.prod Finset.univ fun (i : κ) => g i

theorem Equiv.sum_comp {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [AddCommMonoid α] (e : ι ≃ κ) (g : κ → α) : (Finset.sum Finset.univ fun (i : ι) => g (e i)) = Finset.sum Finset.univ fun (i : κ) => g i

theorem Equiv.prod_comp {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [CommMonoid α] (e : ι ≃ κ) (g : κ → α) : (Finset.prod Finset.univ fun (i : ι) => g (e i)) = Finset.prod Finset.univ fun (i : κ) => g i

theorem Fintype.sum_of_injective {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [AddCommMonoid α] (e : ι → κ) (hf : Function.Injective e) (f : ι → α) (g : κ → α) (h' : ∀ i ∉ Set.range e, g i = 0) (h : ∀ (i : ι), f i = g (e i)) : (Finset.sum Finset.univ fun (i : ι) => f i) = Finset.sum Finset.univ fun (j : κ) => g j

theorem Fintype.prod_of_injective {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [CommMonoid α] (e : ι → κ) (hf : Function.Injective e) (f : ι → α) (g : κ → α) (h' : ∀ i ∉ Set.range e, g i = 1) (h : ∀ (i : ι), f i = g (e i)) : (Finset.prod Finset.univ fun (i : ι) => f i) = Finset.prod Finset.univ fun (j : κ) => g j

theorem Fintype.sum_fiberwise {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype κ] [AddCommMonoid α] [DecidableEq κ] [Fintype ι] (g : ι → κ) (f : ι → α) : (Finset.sum Finset.univ fun (j : κ) => Finset.sum Finset.univ fun (i : { i : ι // g i = j }) => f ↑i) = Finset.sum Finset.univ fun (i : ι) => f i

theorem Fintype.prod_fiberwise {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype κ] [CommMonoid α] [DecidableEq κ] [Fintype ι] (g : ι → κ) (f : ι → α) : (Finset.prod Finset.univ fun (j : κ) => Finset.prod Finset.univ fun (i : { i : ι // g i = j }) => f ↑i) = Finset.prod Finset.univ fun (i : ι) => f i

theorem Fintype.sum_fiberwise' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype κ] [AddCommMonoid α] [DecidableEq κ] [Fintype ι] (g : ι → κ) (f : κ → α) : (Finset.sum Finset.univ fun (j : κ) => Finset.sum Finset.univ fun (_i : { i : ι // g i = j }) => f j) = Finset.sum Finset.univ fun (i : ι) => f (g i)

theorem Fintype.prod_fiberwise' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype κ] [CommMonoid α] [DecidableEq κ] [Fintype ι] (g : ι → κ) (f : κ → α) : (Finset.prod Finset.univ fun (j : κ) => Finset.prod Finset.univ fun (_i : { i : ι // g i = j }) => f j) = Finset.prod Finset.univ fun (i : ι) => f (g i)

theorem Fintype.sum_unique {α : Type u_5} {β : Type u_6} [AddCommMonoid β] [Unique α] [Fintype α] (f : α → β) : (Finset.sum Finset.univ fun (x : α) => f x) = f default

theorem Fintype.prod_unique {α : Type u_5} {β : Type u_6} [CommMonoid β] [Unique α] [Fintype α] (f : α → β) : (Finset.prod Finset.univ fun (x : α) => f x) = f default

theorem Fintype.sum_empty {α : Type u_5} {β : Type u_6} [AddCommMonoid β] [IsEmpty α] [Fintype α] (f : α → β) : (Finset.sum Finset.univ fun (x : α) => f x) = 0

theorem Fintype.prod_empty {α : Type u_5} {β : Type u_6} [CommMonoid β] [IsEmpty α] [Fintype α] (f : α → β) : (Finset.prod Finset.univ fun (x : α) => f x) = 1

theorem Fintype.sum_subsingleton {α : Type u_5} {β : Type u_6} [AddCommMonoid β] [Subsingleton α] [Fintype α] (f : α → β) (a : α) : (Finset.sum Finset.univ fun (x : α) => f x) = f a

theorem Fintype.prod_subsingleton {α : Type u_5} {β : Type u_6} [CommMonoid β] [Subsingleton α] [Fintype α] (f : α → β) (a : α) : (Finset.prod Finset.univ fun (x : α) => f x) = f a

theorem Fintype.sum_subtype_add_sum_subtype {α : Type u_5} {β : Type u_6} [Fintype α] [AddCommMonoid β] (p : α → Prop) (f : α → β) [DecidablePred p] : ((Finset.sum Finset.univ fun (i : { x : α // p x }) => f ↑i) + Finset.sum Finset.univ fun (i : { x : α // ¬p x }) => f ↑i) = Finset.sum Finset.univ fun (i : α) => f i

theorem Fintype.prod_subtype_mul_prod_subtype {α : Type u_5} {β : Type u_6} [Fintype α] [CommMonoid β] (p : α → Prop) (f : α → β) [DecidablePred p] : ((Finset.prod Finset.univ fun (i : { x : α // p x }) => f ↑i) * Finset.prod Finset.univ fun (i : { x : α // ¬p x }) => f ↑i) = Finset.prod Finset.univ fun (i : α) => f i

@[simp]

theorem Finset.sum_attach_univ {ι : Type u_1} {α : Type v} [AddCommMonoid α] [Fintype ι] (f : { i : ι // i ∈ Finset.univ } → α) : (Finset.sum (Finset.attach Finset.univ) fun (i : { x : ι // x ∈ Finset.univ }) => f i) = Finset.sum Finset.univ fun (i : ι) => f { val := i, property := ⋯ }

@[simp]

theorem Finset.prod_attach_univ {ι : Type u_1} {α : Type v} [CommMonoid α] [Fintype ι] (f : { i : ι // i ∈ Finset.univ } → α) : (Finset.prod (Finset.attach Finset.univ) fun (i : { x : ι // x ∈ Finset.univ }) => f i) = Finset.prod Finset.univ fun (i : ι) => f { val := i, property := ⋯ }

theorem Finset.sum_erase_attach {ι : Type u_1} {α : Type v} [AddCommMonoid α] [DecidableEq ι] {s : Finset ι} (f : ι → α) (i : { x : ι // x ∈ s }) : (Finset.sum (Finset.erase (Finset.attach s) i) fun (j : { x : ι // x ∈ s }) => f ↑j) = Finset.sum (Finset.erase s ↑i) fun (j : ι) => f j

theorem Finset.prod_erase_attach {ι : Type u_1} {α : Type v} [CommMonoid α] [DecidableEq ι] {s : Finset ι} (f : ι → α) (i : { x : ι // x ∈ s }) : (Finset.prod (Finset.erase (Finset.attach s) i) fun (j : { x : ι // x ∈ s }) => f ↑j) = Finset.prod (Finset.erase s ↑i) fun (j : ι) => f j

abbrev List.sum_toFinset.match_1 {α : Type u_1} (motive : (x : List α) → List.Nodup x → Prop) : ∀ (x : List α) (x_1 : List.Nodup x), (∀ (x : List.Nodup []), motive [] x) → (∀ (a : α) (l : List α) (hl : List.Nodup (a :: l)), motive (a :: l) hl) → motive x x_1

Equations

• ⋯ = ⋯

theorem List.sum_toFinset {α : Type v} {M : Type u_2} [DecidableEq α] [AddCommMonoid M] (f : α → M) {l : List α} (_hl : List.Nodup l) : Finset.sum (List.toFinset l) f = List.sum (List.map f l)

abbrev List.sum_toFinset.match_2 {α : Type u_1} (a : α) (l : List α) (motive : a ∉ l ∧ List.Nodup l → Prop) : ∀ (x : a ∉ l ∧ List.Nodup l), (∀ (not_mem : a ∉ l) (hl : List.Nodup l), motive ⋯) → motive x

Equations

• ⋯ = ⋯

theorem List.prod_toFinset {α : Type v} {M : Type u_2} [DecidableEq α] [CommMonoid M] (f : α → M) {l : List α} (_hl : List.Nodup l) : Finset.prod (List.toFinset l) f = List.prod (List.map f l)

theorem Multiset.disjoint_list_sum_left {α : Type v} {a : Multiset α} {l : List (Multiset α)} : Multiset.Disjoint (List.sum l) a ↔ ∀ b ∈ l, Multiset.Disjoint b a

theorem Multiset.disjoint_list_sum_right {α : Type v} {a : Multiset α} {l : List (Multiset α)} : Multiset.Disjoint a (List.sum l) ↔ ∀ b ∈ l, Multiset.Disjoint a b

theorem Multiset.disjoint_sum_left {α : Type v} {a : Multiset α} {i : Multiset (Multiset α)} : Multiset.Disjoint (Multiset.sum i) a ↔ ∀ b ∈ i, Multiset.Disjoint b a

theorem Multiset.disjoint_sum_right {α : Type v} {a : Multiset α} {i : Multiset (Multiset α)} : Multiset.Disjoint a (Multiset.sum i) ↔ ∀ b ∈ i, Multiset.Disjoint a b

theorem Multiset.disjoint_finset_sum_left {α : Type v} {β : Type u_2} {i : Finset β} {f : β → Multiset α} {a : Multiset α} : Multiset.Disjoint (Finset.sum i f) a ↔ ∀ b ∈ i, Multiset.Disjoint (f b) a

theorem Multiset.disjoint_finset_sum_right {α : Type v} {β : Type u_2} {i : Finset β} {f : β → Multiset α} {a : Multiset α} : Multiset.Disjoint a (Finset.sum i f) ↔ ∀ b ∈ i, Multiset.Disjoint a (f b)

theorem Multiset.add_eq_union_left_of_le {α : Type v} [DecidableEq α] {x : Multiset α} {y : Multiset α} {z : Multiset α} (h : y ≤ x) : z + x = z ∪ y ↔ Multiset.Disjoint z x ∧ x = y

theorem Multiset.add_eq_union_right_of_le {α : Type v} [DecidableEq α] {x : Multiset α} {y : Multiset α} {z : Multiset α} (h : z ≤ y) : x + y = x ∪ z ↔ y = z ∧ Multiset.Disjoint x y

theorem Multiset.finset_sum_eq_sup_iff_disjoint {α : Type v} [DecidableEq α] {β : Type u_2} {i : Finset β} {f : β → Multiset α} : Finset.sum i f = Finset.sup i f ↔ ∀ x ∈ i, ∀ y ∈ i, x ≠ y → Multiset.Disjoint (f x) (f y)

theorem Multiset.sup_powerset_len {α : Type u_2} [DecidableEq α] (x : Multiset α) : (Finset.sup (Finset.range (Multiset.card x + 1)) fun (k : ℕ) => Multiset.powersetCard k x) = Multiset.powerset x

@[simp]

theorem Multiset.toFinset_sum_count_eq {α : Type v} [DecidableEq α] (s : Multiset α) : (Finset.sum (Multiset.toFinset s) fun (a : α) => Multiset.count a s) = Multiset.card s

theorem Multiset.count_sum' {β : Type u} {α : Type v} [DecidableEq α] {s : Finset β} {a : α} {f : β → Multiset α} : Multiset.count a (Finset.sum s fun (x : β) => f x) = Finset.sum s fun (x : β) => Multiset.count a (f x)

@[simp]

theorem Multiset.toFinset_sum_count_nsmul_eq {α : Type v} [DecidableEq α] (s : Multiset α) : (Finset.sum (Multiset.toFinset s) fun (a : α) => Multiset.count a s • {a}) = s

theorem Multiset.exists_smul_of_dvd_count {α : Type v} [DecidableEq α] (s : Multiset α) {k : ℕ} (h : ∀ a ∈ s, k ∣ Multiset.count a s) : ∃ (u : Multiset α), s = k • u

theorem Multiset.toFinset_prod_dvd_prod {α : Type v} [DecidableEq α] [CommMonoid α] (S : Multiset α) : Finset.prod (Multiset.toFinset S) id ∣ Multiset.prod S

theorem Multiset.sum_sum {α : Type u_2} {ι : Type u_3} [AddCommMonoid α] (f : ι → Multiset α) (s : Finset ι) : Multiset.sum (Finset.sum s fun (x : ι) => f x) = Finset.sum s fun (x : ι) => Multiset.sum (f x)

theorem Multiset.prod_sum {α : Type u_2} {ι : Type u_3} [CommMonoid α] (f : ι → Multiset α) (s : Finset ι) : Multiset.prod (Finset.sum s fun (x : ι) => f x) = Finset.prod s fun (x : ι) => Multiset.prod (f x)

@[simp]

theorem Nat.cast_list_sum {β : Type u} [AddMonoidWithOne β] (s : List ℕ) : ↑(List.sum s) = List.sum (List.map Nat.cast s)

@[simp]

theorem Nat.cast_list_prod {β : Type u} [Semiring β] (s : List ℕ) : ↑(List.prod s) = List.prod (List.map Nat.cast s)

@[simp]

theorem Nat.cast_multiset_sum {β : Type u} [AddCommMonoidWithOne β] (s : Multiset ℕ) : ↑(Multiset.sum s) = Multiset.sum (Multiset.map Nat.cast s)

@[simp]

theorem Nat.cast_multiset_prod {β : Type u} [CommSemiring β] (s : Multiset ℕ) : ↑(Multiset.prod s) = Multiset.prod (Multiset.map Nat.cast s)

@[simp]

theorem Nat.cast_sum {β : Type u} {α : Type v} [AddCommMonoidWithOne β] (s : Finset α) (f : α → ℕ) : ↑(Finset.sum s fun (x : α) => f x) = Finset.sum s fun (x : α) => ↑(f x)

@[simp]

theorem Nat.cast_prod {β : Type u} {α : Type v} [CommSemiring β] (f : α → ℕ) (s : Finset α) : ↑(Finset.prod s fun (i : α) => f i) = Finset.prod s fun (i : α) => ↑(f i)

@[simp]

theorem Int.cast_list_sum {β : Type u} [AddGroupWithOne β] (s : List ℤ) : ↑(List.sum s) = List.sum (List.map Int.cast s)

@[simp]

theorem Int.cast_list_prod {β : Type u} [Ring β] (s : List ℤ) : ↑(List.prod s) = List.prod (List.map Int.cast s)

@[simp]

theorem Int.cast_multiset_sum {β : Type u} [AddCommGroupWithOne β] (s : Multiset ℤ) : ↑(Multiset.sum s) = Multiset.sum (Multiset.map Int.cast s)

@[simp]

theorem Int.cast_multiset_prod {R : Type u_2} [CommRing R] (s : Multiset ℤ) : ↑(Multiset.prod s) = Multiset.prod (Multiset.map Int.cast s)

@[simp]

theorem Int.cast_sum {β : Type u} {α : Type v} [AddCommGroupWithOne β] (s : Finset α) (f : α → ℤ) : ↑(Finset.sum s fun (x : α) => f x) = Finset.sum s fun (x : α) => ↑(f x)

@[simp]

theorem Int.cast_prod {α : Type v} {R : Type u_2} [CommRing R] (f : α → ℤ) (s : Finset α) : ↑(Finset.prod s fun (i : α) => f i) = Finset.prod s fun (i : α) => ↑(f i)

@[simp]

theorem Units.coe_prod {α : Type v} {M : Type u_2} [CommMonoid M] (f : α → Mˣ) (s : Finset α) : ↑(Finset.prod s fun (i : α) => f i) = Finset.prod s fun (i : α) => ↑(f i)

theorem Units.mk0_prod {β : Type u} {α : Type v} [CommGroupWithZero β] (s : Finset α) (f : α → β) (h : (Finset.prod s fun (b : α) => f b) ≠ 0) : Units.mk0 (Finset.prod s fun (b : α) => f b) h = Finset.prod (Finset.attach s) fun (b : { x : α // x ∈ s }) => Units.mk0 (f ↑b) ⋯

theorem nat_abs_sum_le {ι : Type u_2} (s : Finset ι) (f : ι → ℤ) : Int.natAbs (Finset.sum s fun (i : ι) => f i) ≤ Finset.sum s fun (i : ι) => Int.natAbs (f i)

Additive, Multiplicative

@[simp]

theorem ofMul_list_prod {α : Type v} [Monoid α] (s : List α) : Additive.ofMul (List.prod s) = List.sum (List.map (⇑Additive.ofMul) s)

@[simp]

theorem toMul_list_sum {α : Type v} [Monoid α] (s : List (Additive α)) : Additive.toMul (List.sum s) = List.prod (List.map (⇑Additive.toMul) s)

@[simp]

theorem ofAdd_list_prod {α : Type v} [AddMonoid α] (s : List α) : Multiplicative.ofAdd (List.sum s) = List.prod (List.map (⇑Multiplicative.ofAdd) s)

@[simp]

theorem toAdd_list_sum {α : Type v} [AddMonoid α] (s : List (Multiplicative α)) : Multiplicative.toAdd (List.prod s) = List.sum (List.map (⇑Multiplicative.toAdd) s)

@[simp]

theorem ofMul_multiset_prod {α : Type v} [CommMonoid α] (s : Multiset α) : Additive.ofMul (Multiset.prod s) = Multiset.sum (Multiset.map (⇑Additive.ofMul) s)

@[simp]

theorem toMul_multiset_sum {α : Type v} [CommMonoid α] (s : Multiset (Additive α)) : Additive.toMul (Multiset.sum s) = Multiset.prod (Multiset.map (⇑Additive.toMul) s)

@[simp]

theorem ofMul_prod {ι : Type u_1} {α : Type v} [CommMonoid α] (s : Finset ι) (f : ι → α) : Additive.ofMul (Finset.prod s fun (i : ι) => f i) = Finset.sum s fun (i : ι) => Additive.ofMul (f i)

@[simp]

theorem toMul_sum {ι : Type u_1} {α : Type v} [CommMonoid α] (s : Finset ι) (f : ι → Additive α) : Additive.toMul (Finset.sum s fun (i : ι) => f i) = Finset.prod s fun (i : ι) => Additive.toMul (f i)

@[simp]

theorem ofAdd_multiset_prod {α : Type v} [AddCommMonoid α] (s : Multiset α) : Multiplicative.ofAdd (Multiset.sum s) = Multiset.prod (Multiset.map (⇑Multiplicative.ofAdd) s)

@[simp]

theorem toAdd_multiset_sum {α : Type v} [AddCommMonoid α] (s : Multiset (Multiplicative α)) : Multiplicative.toAdd (Multiset.prod s) = Multiset.sum (Multiset.map (⇑Multiplicative.toAdd) s)

@[simp]

theorem ofAdd_sum {ι : Type u_1} {α : Type v} [AddCommMonoid α] (s : Finset ι) (f : ι → α) : Multiplicative.ofAdd (Finset.sum s fun (i : ι) => f i) = Finset.prod s fun (i : ι) => Multiplicative.ofAdd (f i)

@[simp]

theorem toAdd_prod {ι : Type u_1} {α : Type v} [AddCommMonoid α] (s : Finset ι) (f : ι → Multiplicative α) : Multiplicative.toAdd (Finset.prod s fun (i : ι) => f i) = Finset.sum s fun (i : ι) => Multiplicative.toAdd (f i)

Deprecated lemmas

Those lemmas were deprecated on the 2023/12/23.

@[deprecated Fintype.prod_equiv]

theorem Equiv.prod_comp' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [CommMonoid α] (e : ι ≃ κ) (f : ι → α) (g : κ → α) (h : ∀ (x : ι), f x = g (e x)) : (Finset.prod Finset.univ fun (x : ι) => f x) = Finset.prod Finset.univ fun (x : κ) => g x

Alias of Fintype.prod_equiv.

---

Fintype.prod_equiv is a specialization of Finset.prod_bij that automatically fills in most arguments.

See Equiv.prod_comp for a version without h.

@[deprecated Fintype.sum_equiv]

theorem Equiv.sum_comp' {ι : Type u_2} {κ : Type u_3} {α : Type u_4} [Fintype ι] [Fintype κ] [AddCommMonoid α] (e : ι ≃ κ) (f : ι → α) (g : κ → α) (h : ∀ (x : ι), f x = g (e x)) : (Finset.sum Finset.univ fun (x : ι) => f x) = Finset.sum Finset.univ fun (x : κ) => g x

Alias of Fintype.sum_equiv.

---

Fintype.sum_equiv is a specialization of Finset.sum_bij that automatically fills in most arguments.

See Equiv.sum_comp for a version without h.