statement stringlengths 1 2.88k | proof stringlengths 0 13.9k | type stringclasses 10
values | symbolic_name stringlengths 1 131 | library stringclasses 417
values | filename stringlengths 17 80 | imports listlengths 0 16 | deps listlengths 0 64 | docstring stringlengths 0 10.2k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
prod_inter_mul_prod_diff [decidable_eq α] (s t : finset α) (f : α → β) :
(∏ x in s ∩ t, f x) * (∏ x in s \ t, f x) = (∏ x in s, f x) | by { convert (s.prod_piecewise t f f).symm, simp [finset.piecewise] } | lemma | finset.prod_inter_mul_prod_diff | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"finset.piecewise"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_mul_prod_diff_singleton [decidable_eq α] {s : finset α} {i : α} (h : i ∈ s)
(f : α → β) : ∏ x in s, f x = f i * ∏ x in s \ {i}, f x | by { convert (s.prod_inter_mul_prod_diff {i} f).symm, simp [h] } | lemma | finset.prod_eq_mul_prod_diff_singleton | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_prod_diff_singleton_mul [decidable_eq α] {s : finset α} {i : α} (h : i ∈ s)
(f : α → β) : ∏ x in s, f x = (∏ x in s \ {i}, f x) * f i | by { rw [prod_eq_mul_prod_diff_singleton h, mul_comm] } | lemma | finset.prod_eq_prod_diff_singleton_mul | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"mul_comm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.fintype.prod_eq_mul_prod_compl [decidable_eq α] [fintype α] (a : α) (f : α → β) :
∏ i, f i = (f a) * ∏ i in {a}ᶜ, f i | prod_eq_mul_prod_diff_singleton (mem_univ a) f | lemma | fintype.prod_eq_mul_prod_compl | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"fintype"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.fintype.prod_eq_prod_compl_mul [decidable_eq α] [fintype α] (a : α) (f : α → β) :
∏ i, f i = (∏ i in {a}ᶜ, f i) * f a | prod_eq_prod_diff_singleton_mul (mem_univ a) f | lemma | fintype.prod_eq_prod_compl_mul | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"fintype"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
dvd_prod_of_mem (f : α → β) {a : α} {s : finset α} (ha : a ∈ s) :
f a ∣ ∏ i in s, f i | begin
classical,
rw finset.prod_eq_mul_prod_diff_singleton ha,
exact dvd_mul_right _ _,
end | lemma | finset.dvd_prod_of_mem | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"dvd_mul_right",
"finset",
"finset.prod_eq_mul_prod_diff_singleton"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_partition (R : setoid α) [decidable_rel R.r] :
(∏ x in s, f x) = ∏ xbar in s.image quotient.mk, ∏ y in s.filter (λ y, ⟦y⟧ = xbar), f y | begin
refine (finset.prod_image' f (λ x hx, _)).symm,
refl,
end | lemma | finset.prod_partition | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset.prod_image'"
] | A product can be partitioned into a product of products, each equivalent under a setoid. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_cancels_of_partition_cancels (R : setoid α) [decidable_rel R.r]
(h : ∀ x ∈ s, (∏ a in s.filter (λ y, y ≈ x), f a) = 1) : (∏ x in s, f x) = 1 | begin
rw [prod_partition R, ←finset.prod_eq_one],
intros xbar xbar_in_s,
obtain ⟨x, x_in_s, xbar_eq_x⟩ := mem_image.mp xbar_in_s,
rw [←xbar_eq_x, filter_congr (λ y _, @quotient.eq _ R y x)],
apply h x x_in_s,
end | lemma | finset.prod_cancels_of_partition_cancels | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"quotient.eq"
] | If we can partition a product into subsets that cancel out, then the whole product cancels. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_update_of_not_mem [decidable_eq α] {s : finset α} {i : α}
(h : i ∉ s) (f : α → β) (b : β) : (∏ x in s, function.update f i b x) = (∏ x in s, f x) | begin
apply prod_congr rfl (λ j hj, _),
have : j ≠ i, by { assume eq, rw eq at hj, exact h hj },
simp [this]
end | lemma | finset.prod_update_of_not_mem | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_update_of_mem [decidable_eq α] {s : finset α} {i : α} (h : i ∈ s) (f : α → β) (b : β) :
(∏ x in s, function.update f i b x) = b * (∏ x in s \ (singleton i), f x) | by { rw [update_eq_piecewise, prod_piecewise], simp [h] } | lemma | finset.prod_update_of_mem | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eq_of_card_le_one_of_prod_eq {s : finset α} (hc : s.card ≤ 1) {f : α → β} {b : β}
(h : ∏ x in s, f x = b) : ∀ x ∈ s, f x = b | begin
intros x hx,
by_cases hc0 : s.card = 0,
{ exact false.elim (card_ne_zero_of_mem hx hc0) },
{ have h1 : s.card = 1 := le_antisymm hc (nat.one_le_of_lt (nat.pos_of_ne_zero hc0)),
rw card_eq_one at h1,
cases h1 with x2 hx2,
rw [hx2, mem_singleton] at hx,
simp_rw hx2 at h,
rw hx,
rw pr... | lemma | finset.eq_of_card_le_one_of_prod_eq | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"nat.one_le_of_lt"
] | If a product of a `finset` of size at most 1 has a given value, so
do the terms in that product. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_prod_erase [decidable_eq α] (s : finset α) (f : α → β) {a : α} (h : a ∈ s) :
f a * (∏ x in s.erase a, f x) = ∏ x in s, f x | by rw [← prod_insert (not_mem_erase a s), insert_erase h] | lemma | finset.mul_prod_erase | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | 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. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_erase_mul [decidable_eq α] (s : finset α) (f : α → β) {a : α} (h : a ∈ s) :
(∏ x in s.erase a, f x) * f a = ∏ x in s, f x | by rw [mul_comm, mul_prod_erase s f h] | lemma | finset.prod_erase_mul | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"mul_comm"
] | A variant of `finset.mul_prod_erase` with the multiplication swapped. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_erase [decidable_eq α] (s : finset α) {f : α → β} {a : α} (h : f a = 1) :
∏ x in s.erase a, f x = ∏ x in s, f x | begin
rw ←sdiff_singleton_eq_erase,
refine prod_subset (sdiff_subset _ _) (λ x hx hnx, _),
rw sdiff_singleton_eq_erase at hnx,
rwa eq_of_mem_of_not_mem_erase hx hnx
end | lemma | finset.prod_erase | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | If a function applied at a point is 1, a product is unchanged by
removing that point, if present, from a `finset`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_ite_one {f : α → Prop} [decidable_pred f] (hf : (s : set α).pairwise_disjoint f)
(a : β) :
∏ i in s, ite (f i) a 1 = ite (∃ i ∈ s, f i) a 1 | begin
split_ifs,
{ obtain ⟨i, hi, hfi⟩ := h,
rw [prod_eq_single_of_mem _ hi, if_pos hfi],
exact λ j hj h, if_neg (λ hfj, (hf hj hi h).le_bot ⟨hfj, hfi⟩) },
{ push_neg at h,
rw prod_eq_one,
exact λ i hi, if_neg (h i hi) }
end | lemma | finset.prod_ite_one | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [] | See also `finset.prod_boole`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_erase_lt_of_one_lt {γ : Type*} [decidable_eq α] [ordered_comm_monoid γ]
[covariant_class γ γ (*) (<)] {s : finset α} {d : α} (hd : d ∈ s) {f : α → γ} (hdf : 1 < f d) :
∏ (m : α) in s.erase d, f m < ∏ (m : α) in s, f m | begin
nth_rewrite_rhs 0 ←finset.insert_erase hd,
rw finset.prod_insert (finset.not_mem_erase d s),
exact lt_mul_of_one_lt_left' _ hdf,
end | lemma | finset.prod_erase_lt_of_one_lt | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"covariant_class",
"finset",
"finset.not_mem_erase",
"finset.prod_insert",
"lt_mul_of_one_lt_left'",
"ordered_comm_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eq_one_of_prod_eq_one {s : finset α} {f : α → β} {a : α} (hp : ∏ x in s, f x = 1)
(h1 : ∀ x ∈ s, x ≠ a → f x = 1) : ∀ x ∈ s, f x = 1 | begin
intros x hx,
classical,
by_cases h : x = a,
{ rw h,
rw h at hx,
rw [←prod_subset (singleton_subset_iff.2 hx)
(λ t ht ha, h1 t ht (not_mem_singleton.1 ha)),
prod_singleton] at hp,
exact hp },
{ exact h1 x hx h }
end | lemma | finset.eq_one_of_prod_eq_one | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | If a product is 1 and the function is 1 except possibly at one
point, it is 1 everywhere on the `finset`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_pow_boole [decidable_eq α] (s : finset α) (f : α → β) (a : α) :
(∏ x in s, (f x)^(ite (a = x) 1 0)) = ite (a ∈ s) (f a) 1 | by simp | lemma | finset.prod_pow_boole | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_dvd_prod_of_dvd {S : finset α} (g1 g2 : α → β) (h : ∀ a ∈ S, g1 a ∣ g2 a) :
S.prod g1 ∣ S.prod g2 | begin
classical,
apply finset.induction_on' S, { simp },
intros a T haS _ haT IH,
repeat { rw finset.prod_insert haT },
exact mul_dvd_mul (h a haS) IH,
end | lemma | finset.prod_dvd_prod_of_dvd | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"finset.induction_on'",
"finset.prod_insert",
"mul_dvd_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_dvd_prod_of_subset {ι M : Type*} [comm_monoid M] (s t : finset ι) (f : ι → M)
(h : s ⊆ t) : ∏ i in s, f i ∣ ∏ i in t, f i | multiset.prod_dvd_prod_of_le $ multiset.map_le_map $ by simpa | lemma | finset.prod_dvd_prod_of_subset | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"finset",
"multiset.map_le_map",
"multiset.prod_dvd_prod_of_le"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_add_prod_eq [comm_semiring β] {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) : ∏ i in s, g i + ∏ i in s, h i = ∏ i in s, f i | by { classical, simp_rw [prod_eq_mul_prod_diff_singleton hi, ← h1, right_distrib],
congr' 2; apply prod_congr rfl; simpa } | lemma | finset.prod_add_prod_eq | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_semiring",
"finset",
"right_distrib"
] | 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`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
card_eq_sum_ones (s : finset α) : s.card = ∑ _ in s, 1 | by simp | lemma | finset.card_eq_sum_ones | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sum_const_nat {m : ℕ} {f : α → ℕ} (h₁ : ∀ x ∈ s, f x = m) :
(∑ x in s, f x) = card s * m | begin
rw [← nat.nsmul_eq_mul, ← sum_const],
apply sum_congr rfl h₁
end | lemma | finset.sum_const_nat | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"nat.nsmul_eq_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
nat_cast_card_filter [add_comm_monoid_with_one β] (p) [decidable_pred p] (s : finset α) :
((filter p s).card : β) = ∑ a in s, if p a then 1 else 0 | by simp only [add_zero, sum_const, nsmul_eq_mul, eq_self_iff_true, sum_const_zero, sum_ite,
nsmul_one] | lemma | finset.nat_cast_card_filter | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_comm_monoid_with_one",
"filter",
"finset",
"nsmul_eq_mul",
"nsmul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
card_filter (p) [decidable_pred p] (s : finset α) :
(filter p s).card = ∑ a in s, ite (p a) 1 0 | nat_cast_card_filter _ _ | lemma | finset.card_filter | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"filter",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sum_boole {s : finset α} {p : α → Prop} [add_comm_monoid_with_one β] {hp : decidable_pred p} :
(∑ x in s, if p x then 1 else 0 : β) = (s.filter p).card | (nat_cast_card_filter _ _).symm | lemma | finset.sum_boole | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_comm_monoid_with_one",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.commute.sum_right [non_unital_non_assoc_semiring β] (s : finset α)
(f : α → β) (b : β) (h : ∀ i ∈ s, commute b (f i)) :
commute b (∑ i in s, f i) | commute.multiset_sum_right _ _ $ λ b hb, begin
obtain ⟨i, hi, rfl⟩ := multiset.mem_map.mp hb,
exact h _ hi
end | lemma | commute.sum_right | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"commute",
"commute.multiset_sum_right",
"finset",
"non_unital_non_assoc_semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.commute.sum_left [non_unital_non_assoc_semiring β] (s : finset α)
(f : α → β) (b : β) (h : ∀ i ∈ s, commute (f i) b) :
commute (∑ i in s, f i) b | (commute.sum_right _ _ _ $ λ i hi, (h _ hi).symm).symm | lemma | commute.sum_left | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"commute",
"commute.sum_right",
"finset",
"non_unital_non_assoc_semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
op_sum [add_comm_monoid β] {s : finset α} (f : α → β) :
op (∑ x in s, f x) = ∑ x in s, op (f x) | (op_add_equiv : β ≃+ βᵐᵒᵖ).map_sum _ _ | lemma | finset.op_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_comm_monoid",
"finset"
] | Moving to the opposite additive commutative monoid commutes with summing. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
unop_sum [add_comm_monoid β] {s : finset α} (f : α → βᵐᵒᵖ) :
unop (∑ x in s, f x) = ∑ x in s, unop (f x) | (op_add_equiv : β ≃+ βᵐᵒᵖ).symm.map_sum _ _ | lemma | finset.unop_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_comm_monoid",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_inv_distrib : (∏ x in s, (f x)⁻¹) = (∏ x in s, f x)⁻¹ | multiset.prod_map_inv | lemma | finset.prod_inv_distrib | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset.prod_map_inv"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_div_distrib : (∏ x in s, f x / g x) = (∏ x in s, f x) / ∏ x in s, g x | multiset.prod_map_div | lemma | finset.prod_div_distrib | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset.prod_map_div"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_zpow (f : α → β) (s : finset α) (n : ℤ) : ∏ a in s, (f a) ^ n = (∏ a in s, f a) ^ n | multiset.prod_map_zpow | lemma | finset.prod_zpow | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"multiset.prod_map_zpow"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_sdiff_eq_div (h : s₁ ⊆ s₂) :
(∏ x in (s₂ \ s₁), f x) = (∏ x in s₂, f x) / (∏ x in s₁, f x) | by rw [eq_div_iff_mul_eq', prod_sdiff h] | lemma | finset.prod_sdiff_eq_div | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"eq_div_iff_mul_eq'"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_sdiff_div_prod_sdiff :
(∏ x in s₂ \ s₁, f x) / (∏ x in s₁ \ s₂, f x) = (∏ x in s₂, f x) / (∏ x in s₁, f x) | by simp [← finset.prod_sdiff (@inf_le_left _ _ s₁ s₂),
← finset.prod_sdiff (@inf_le_right _ _ s₁ s₂)] | lemma | finset.prod_sdiff_div_prod_sdiff | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset.prod_sdiff",
"inf_le_left",
"inf_le_right"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_erase_eq_div {a : α} (h : a ∈ s) : (∏ x in s.erase a, f x) = (∏ x in s, f x) / f a | by rw [eq_div_iff_mul_eq', prod_erase_mul _ _ h] | lemma | finset.prod_erase_eq_div | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"eq_div_iff_mul_eq'"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
card_sigma {σ : α → Type*} (s : finset α) (t : Π a, finset (σ a)) :
card (s.sigma t) = ∑ a in s, card (t a) | multiset.card_sigma _ _ | theorem | finset.card_sigma | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"multiset.card_sigma"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
card_disj_Union (s : finset α) (t : α → finset β) (h) :
(s.disj_Union t h).card = s.sum (λ i, (t i).card) | multiset.card_bind _ _ | lemma | finset.card_disj_Union | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"multiset.card_bind"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
card_bUnion [decidable_eq β] {s : finset α} {t : α → finset β}
(h : ∀ x ∈ s, ∀ y ∈ s, x ≠ y → disjoint (t x) (t y)) :
(s.bUnion t).card = ∑ u in s, card (t u) | calc (s.bUnion t).card = ∑ i in s.bUnion t, 1 : by simp
... = ∑ a in s, ∑ i in t a, 1 : finset.sum_bUnion h
... = ∑ u in s, card (t u) : by simp | lemma | finset.card_bUnion | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"disjoint",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
card_bUnion_le [decidable_eq β] {s : finset α} {t : α → finset β} :
(s.bUnion t).card ≤ ∑ a in s, (t a).card | by haveI := classical.dec_eq α; exact
finset.induction_on s (by simp)
(λ a s has ih,
calc ((insert a s).bUnion t).card ≤ (t a).card + (s.bUnion t).card :
by rw bUnion_insert; exact finset.card_union_le _ _
... ≤ ∑ a in insert a s, card (t a) :
by rw sum_insert has; exact add_le_add_left ih _) | lemma | finset.card_bUnion_le | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"classical.dec_eq",
"finset",
"finset.card_union_le",
"finset.induction_on",
"ih"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
card_eq_sum_card_fiberwise [decidable_eq β] {f : α → β} {s : finset α} {t : finset β}
(H : ∀ x ∈ s, f x ∈ t) :
s.card = ∑ a in t, (s.filter (λ x, f x = a)).card | by simp only [card_eq_sum_ones, sum_fiberwise_of_maps_to H] | theorem | finset.card_eq_sum_card_fiberwise | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
card_eq_sum_card_image [decidable_eq β] (f : α → β) (s : finset α) :
s.card = ∑ a in s.image f, (s.filter (λ x, f x = a)).card | card_eq_sum_card_fiberwise (λ _, mem_image_of_mem _) | theorem | finset.card_eq_sum_card_image | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mem_sum {f : α → multiset β} (s : finset α) (b : β) :
b ∈ ∑ x in s, f x ↔ ∃ a ∈ s, b ∈ f a | begin
classical,
refine s.induction_on (by simp) _,
{ intros a t hi ih,
simp [sum_insert hi, ih, or_and_distrib_right, exists_or_distrib] }
end | lemma | finset.mem_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"exists_or_distrib",
"finset",
"ih",
"multiset",
"or_and_distrib_right"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_zero (ha : a ∈ s) (h : f a = 0) : (∏ x in s, f x) = 0 | by { haveI := classical.dec_eq α, rw [←prod_erase_mul _ _ ha, h, mul_zero] } | lemma | finset.prod_eq_zero | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"classical.dec_eq",
"mul_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_boole {s : finset α} {p : α → Prop} [decidable_pred p] :
∏ i in s, ite (p i) (1 : β) (0 : β) = ite (∀ i ∈ s, p i) 1 0 | begin
split_ifs,
{ apply prod_eq_one,
intros i hi,
rw if_pos (h i hi) },
{ push_neg at h,
rcases h with ⟨i, hi, hq⟩,
apply prod_eq_zero hi,
rw [if_neg hq] },
end | lemma | finset.prod_boole | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_zero_iff : (∏ x in s, f x) = 0 ↔ (∃ a ∈ s, f a = 0) | begin
classical,
apply finset.induction_on s,
exact ⟨not.elim one_ne_zero, λ ⟨_, H, _⟩, H.elim⟩,
assume a s ha ih,
rw [prod_insert ha, mul_eq_zero, bex_def, exists_mem_insert, ih, ← bex_def]
end | lemma | finset.prod_eq_zero_iff | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"bex_def",
"finset.induction_on",
"ih",
"mul_eq_zero",
"one_ne_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_ne_zero_iff : (∏ x in s, f x) ≠ 0 ↔ (∀ a ∈ s, f a ≠ 0) | by { rw [ne, prod_eq_zero_iff], push_neg } | theorem | finset.prod_ne_zero_iff | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_unique_nonempty {α β : Type*} [comm_monoid β] [unique α]
(s : finset α) (f : α → β) (h : s.nonempty) :
(∏ x in s, f x) = f default | by rw [h.eq_singleton_default, finset.prod_singleton] | lemma | finset.prod_unique_nonempty | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"finset",
"finset.prod_singleton",
"unique"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sum_nat_mod (s : finset α) (n : ℕ) (f : α → ℕ) :
(∑ i in s, f i) % n = (∑ i in s, f i % n) % n | (multiset.sum_nat_mod _ _).trans $ by rw [finset.sum, multiset.map_map] | lemma | finset.sum_nat_mod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"multiset.map_map",
"multiset.sum_nat_mod"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_nat_mod (s : finset α) (n : ℕ) (f : α → ℕ) :
(∏ i in s, f i) % n = (∏ i in s, f i % n) % n | (multiset.prod_nat_mod _ _).trans $ by rw [finset.prod, multiset.map_map] | lemma | finset.prod_nat_mod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"finset.prod",
"multiset.map_map",
"multiset.prod_nat_mod"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sum_int_mod (s : finset α) (n : ℤ) (f : α → ℤ) :
(∑ i in s, f i) % n = (∑ i in s, f i % n) % n | (multiset.sum_int_mod _ _).trans $ by rw [finset.sum, multiset.map_map] | lemma | finset.sum_int_mod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"multiset.map_map",
"multiset.sum_int_mod"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_int_mod (s : finset α) (n : ℤ) (f : α → ℤ) :
(∏ i in s, f i) % n = (∏ i in s, f i % n) % n | (multiset.prod_int_mod _ _).trans $ by rw [finset.prod, multiset.map_map] | lemma | finset.prod_int_mod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"finset.prod",
"multiset.map_map",
"multiset.prod_int_mod"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_bijective {α β M : Type*} [fintype α] [fintype β] [comm_monoid M]
(e : α → β) (he : function.bijective e) (f : α → M) (g : β → M) (h : ∀ x, f x = g (e x)) :
∏ x : α, f x = ∏ x : β, g x | prod_bij
(λ x _, e x)
(λ x _, mem_univ (e x))
(λ x _, h x)
(λ x x' _ _ h, he.injective h)
(λ y _, (he.surjective y).imp $ λ a h, ⟨mem_univ _, h.symm⟩) | lemma | fintype.prod_bijective | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"fintype"
] | `fintype.prod_bijective` is a variant of `finset.prod_bij` that accepts `function.bijective`.
See `function.bijective.prod_comp` for a version without `h`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_equiv {α β M : Type*} [fintype α] [fintype β] [comm_monoid M]
(e : α ≃ β) (f : α → M) (g : β → M) (h : ∀ x, f x = g (e x)) :
∏ x : α, f x = ∏ x : β, g x | prod_bijective e e.bijective f g h | lemma | fintype.prod_equiv | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"fintype"
] | `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`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_unique {α β : Type*} [comm_monoid β] [unique α] [fintype α] (f : α → β) :
(∏ x : α, f x) = f default | by rw [univ_unique, prod_singleton] | lemma | fintype.prod_unique | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"fintype",
"unique"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_empty {α β : Type*} [comm_monoid β] [is_empty α] [fintype α] (f : α → β) :
(∏ x : α, f x) = 1 | finset.prod_of_empty _ | lemma | fintype.prod_empty | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"finset.prod_of_empty",
"fintype",
"is_empty"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_subsingleton {α β : Type*} [comm_monoid β] [subsingleton α] [fintype α]
(f : α → β) (a : α) :
(∏ x : α, f x) = f a | begin
haveI : unique α := unique_of_subsingleton a,
convert prod_unique f
end | lemma | fintype.prod_subsingleton | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"fintype",
"unique",
"unique_of_subsingleton"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_subtype_mul_prod_subtype {α β : Type*} [fintype α] [comm_monoid β]
(p : α → Prop) (f : α → β) [decidable_pred p] :
(∏ (i : {x // p x}), f i) * (∏ i : {x // ¬ p x}, f i) = ∏ i, f i | begin
classical,
let s := {x | p x}.to_finset,
rw [← finset.prod_subtype s, ← finset.prod_subtype sᶜ],
{ exact finset.prod_mul_prod_compl _ _ },
{ simp },
{ simp }
end | lemma | fintype.prod_subtype_mul_prod_subtype | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"finset.prod_mul_prod_compl",
"finset.prod_subtype",
"fintype"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_to_finset {M : Type*} [decidable_eq α] [comm_monoid M]
(f : α → M) : ∀ {l : list α} (hl : l.nodup), l.to_finset.prod f = (l.map f).prod | | [] _ := by simp
| (a :: l) hl := let ⟨not_mem, hl⟩ := list.nodup_cons.mp hl in
by simp [finset.prod_insert (mt list.mem_to_finset.mp not_mem), prod_to_finset hl] | lemma | list.prod_to_finset | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"finset.prod_insert"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
disjoint_list_sum_left {a : multiset α} {l : list (multiset α)} :
multiset.disjoint l.sum a ↔ ∀ b ∈ l, multiset.disjoint b a | begin
induction l with b bs ih,
{ simp only [zero_disjoint, list.not_mem_nil, is_empty.forall_iff, forall_const, list.sum_nil], },
{ simp_rw [list.sum_cons, disjoint_add_left, list.mem_cons_iff, forall_eq_or_imp],
simp [and.congr_left_iff, iff_self, ih], },
end | lemma | multiset.disjoint_list_sum_left | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"and.congr_left_iff",
"forall_const",
"forall_eq_or_imp",
"ih",
"is_empty.forall_iff",
"multiset",
"multiset.disjoint"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
disjoint_list_sum_right {a : multiset α} {l : list (multiset α)} :
multiset.disjoint a l.sum ↔ ∀ b ∈ l, multiset.disjoint a b | by simpa only [disjoint_comm] using disjoint_list_sum_left | lemma | multiset.disjoint_list_sum_right | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset",
"multiset.disjoint"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
disjoint_sum_left {a : multiset α} {i : multiset (multiset α)} :
multiset.disjoint i.sum a ↔ ∀ b ∈ i, multiset.disjoint b a | quotient.induction_on i $ λ l, begin
rw [quot_mk_to_coe, multiset.coe_sum],
exact disjoint_list_sum_left,
end | lemma | multiset.disjoint_sum_left | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset",
"multiset.disjoint"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
disjoint_sum_right {a : multiset α} {i : multiset (multiset α)} :
multiset.disjoint a i.sum ↔ ∀ b ∈ i, multiset.disjoint a b | by simpa only [disjoint_comm] using disjoint_sum_left | lemma | multiset.disjoint_sum_right | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset",
"multiset.disjoint"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
disjoint_finset_sum_left {β : Type*} {i : finset β} {f : β → multiset α} {a : multiset α} :
multiset.disjoint (i.sum f) a ↔ ∀ b ∈ i, multiset.disjoint (f b) a | begin
convert (@disjoint_sum_left _ a) (map f i.val),
simp [and.congr_left_iff, iff_self],
end | lemma | multiset.disjoint_finset_sum_left | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"and.congr_left_iff",
"finset",
"multiset",
"multiset.disjoint"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
disjoint_finset_sum_right {β : Type*} {i : finset β} {f : β → multiset α} {a : multiset α} :
multiset.disjoint a (i.sum f) ↔ ∀ b ∈ i, multiset.disjoint a (f b) | by simpa only [disjoint_comm] using disjoint_finset_sum_left | lemma | multiset.disjoint_finset_sum_right | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"multiset",
"multiset.disjoint"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
add_eq_union_left_of_le {x y z : multiset α} (h : y ≤ x) :
z + x = z ∪ y ↔ z.disjoint x ∧ x = y | begin
rw ←add_eq_union_iff_disjoint,
split,
{ intro h0,
rw and_iff_right_of_imp,
{ exact (le_of_add_le_add_left $ h0.trans_le $ union_le_add z y).antisymm h, },
{ rintro rfl,
exact h0, } },
{ rintro ⟨h0, rfl⟩,
exact h0, }
end | lemma | multiset.add_eq_union_left_of_le | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"and_iff_right_of_imp",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
add_eq_union_right_of_le {x y z : multiset α} (h : z ≤ y) :
x + y = x ∪ z ↔ y = z ∧ x.disjoint y | by simpa only [and_comm] using add_eq_union_left_of_le h | lemma | multiset.add_eq_union_right_of_le | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
finset_sum_eq_sup_iff_disjoint {β : Type*} {i : finset β} {f : β → multiset α} :
i.sum f = i.sup f ↔ ∀ x y ∈ i, x ≠ y → multiset.disjoint (f x) (f y) | begin
induction i using finset.cons_induction_on with z i hz hr,
{ simp only [finset.not_mem_empty, is_empty.forall_iff, implies_true_iff,
finset.sum_empty, finset.sup_empty, bot_eq_zero, eq_self_iff_true], },
{ simp_rw [finset.sum_cons hz, finset.sup_cons, finset.mem_cons, multiset.sup_eq_union,
fora... | lemma | multiset.finset_sum_eq_sup_iff_disjoint | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"finset.cons_induction_on",
"finset.mem_cons",
"finset.not_mem_empty",
"finset.sup_cons",
"finset.sup_empty",
"forall_and_distrib",
"forall_eq_or_imp",
"imp_and_distrib",
"is_empty.forall_iff",
"multiset",
"multiset.disjoint",
"multiset.sup_eq_union",
"ne_of_mem_of_not_mem"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sup_powerset_len {α : Type*} [decidable_eq α] (x : multiset α) :
finset.sup (finset.range (x.card + 1)) (λ k, x.powerset_len k) = x.powerset | begin
convert bind_powerset_len x,
rw [multiset.bind, multiset.join, ←finset.range_val, ←finset.sum_eq_multiset_sum],
exact eq.symm (finset_sum_eq_sup_iff_disjoint.mpr
(λ _ _ _ _ h, pairwise_disjoint_powerset_len x h)),
end | lemma | multiset.sup_powerset_len | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset.range",
"finset.sup",
"multiset",
"multiset.bind",
"multiset.join"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_finset_sum_count_eq (s : multiset α) :
(∑ a in s.to_finset, s.count a) = s.card | calc (∑ a in s.to_finset, s.count a) = (∑ a in s.to_finset, s.count a • 1) :
by simp only [smul_eq_mul, mul_one]
... = (s.map (λ _, 1)).sum : (finset.sum_multiset_map_count _ _).symm
... = s.card : by simp | lemma | multiset.to_finset_sum_count_eq | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"mul_one",
"multiset",
"smul_eq_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
count_sum' {s : finset β} {a : α} {f : β → multiset α} :
count a (∑ x in s, f x) = ∑ x in s, count a (f x) | by { dunfold finset.sum, rw count_sum } | lemma | multiset.count_sum' | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_finset_sum_count_nsmul_eq (s : multiset α) :
(∑ a in s.to_finset, s.count a • {a}) = s | by rw [← finset.sum_multiset_map_count, multiset.sum_map_singleton] | lemma | multiset.to_finset_sum_count_nsmul_eq | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset",
"multiset.sum_map_singleton"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
exists_smul_of_dvd_count (s : multiset α) {k : ℕ}
(h : ∀ (a : α), a ∈ s → k ∣ multiset.count a s) :
∃ (u : multiset α), s = k • u | begin
use ∑ a in s.to_finset, (s.count a / k) • {a},
have h₂ : ∑ (x : α) in s.to_finset, k • (count x s / k) • ({x} : multiset α) =
∑ (x : α) in s.to_finset, count x s • {x},
{ apply finset.sum_congr rfl,
intros x hx,
rw [← mul_nsmul, nat.mul_div_cancel' (h x (mem_to_finset.mp hx))] },
rw [← finset.... | theorem | multiset.exists_smul_of_dvd_count | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset",
"multiset.count"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_finset_prod_dvd_prod [comm_monoid α] (S : multiset α) : S.to_finset.prod id ∣ S.prod | begin
rw finset.prod_eq_multiset_prod,
refine multiset.prod_dvd_prod_of_le _,
simp [multiset.dedup_le S],
end | lemma | multiset.to_finset_prod_dvd_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"finset.prod_eq_multiset_prod",
"multiset",
"multiset.dedup_le",
"multiset.prod_dvd_prod_of_le"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_sum {α : Type*} {ι : Type*} [comm_monoid α] (f : ι → multiset α) (s : finset ι) :
(∑ x in s, f x).prod = ∏ x in s, (f x).prod | begin
classical,
induction s using finset.induction_on with a t hat ih,
{ rw [finset.sum_empty, finset.prod_empty, multiset.prod_zero] },
{ rw [finset.sum_insert hat, finset.prod_insert hat, multiset.prod_add, ih] }
end | lemma | multiset.prod_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"finset",
"finset.induction_on",
"finset.prod_empty",
"finset.prod_insert",
"ih",
"multiset",
"multiset.prod_add",
"multiset.prod_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_list_sum [add_monoid_with_one β] (s : list ℕ) :
(↑(s.sum) : β) = (s.map coe).sum | map_list_sum (cast_add_monoid_hom β) _ | lemma | nat.cast_list_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_monoid_with_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_list_prod [semiring β] (s : list ℕ) :
(↑(s.prod) : β) = (s.map coe).prod | map_list_prod (cast_ring_hom β) _ | lemma | nat.cast_list_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"map_list_prod",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_multiset_sum [add_comm_monoid_with_one β] (s : multiset ℕ) :
(↑(s.sum) : β) = (s.map coe).sum | map_multiset_sum (cast_add_monoid_hom β) _ | lemma | nat.cast_multiset_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_comm_monoid_with_one",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_multiset_prod [comm_semiring β] (s : multiset ℕ) :
(↑(s.prod) : β) = (s.map coe).prod | map_multiset_prod (cast_ring_hom β) _ | lemma | nat.cast_multiset_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_semiring",
"map_multiset_prod",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_sum [add_comm_monoid_with_one β] (s : finset α) (f : α → ℕ) :
↑(∑ x in s, f x : ℕ) = (∑ x in s, (f x : β)) | map_sum (cast_add_monoid_hom β) _ _ | lemma | nat.cast_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_comm_monoid_with_one",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_prod [comm_semiring β] (f : α → ℕ) (s : finset α) :
(↑∏ i in s, f i : β) = ∏ i in s, f i | map_prod (cast_ring_hom β) _ _ | lemma | nat.cast_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_semiring",
"finset",
"map_prod"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_list_sum [add_group_with_one β] (s : list ℤ) :
(↑(s.sum) : β) = (s.map coe).sum | map_list_sum (cast_add_hom β) _ | lemma | int.cast_list_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_group_with_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_list_prod [ring β] (s : list ℤ) :
(↑(s.prod) : β) = (s.map coe).prod | map_list_prod (cast_ring_hom β) _ | lemma | int.cast_list_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"map_list_prod",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_multiset_sum [add_comm_group_with_one β] (s : multiset ℤ) :
(↑(s.sum) : β) = (s.map coe).sum | map_multiset_sum (cast_add_hom β) _ | lemma | int.cast_multiset_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_comm_group_with_one",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_multiset_prod {R : Type*} [comm_ring R] (s : multiset ℤ) :
(↑(s.prod) : R) = (s.map coe).prod | map_multiset_prod (cast_ring_hom R) _ | lemma | int.cast_multiset_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_ring",
"map_multiset_prod",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_sum [add_comm_group_with_one β] (s : finset α) (f : α → ℤ) :
↑(∑ x in s, f x : ℤ) = (∑ x in s, (f x : β)) | map_sum (cast_add_hom β) _ _ | lemma | int.cast_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"add_comm_group_with_one",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
cast_prod {R : Type*} [comm_ring R] (f : α → ℤ) (s : finset α) :
(↑∏ i in s, f i : R) = ∏ i in s, f i | (int.cast_ring_hom R).map_prod _ _ | lemma | int.cast_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_ring",
"finset",
"int.cast_ring_hom",
"map_prod"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
units.coe_prod {M : Type*} [comm_monoid M] (f : α → Mˣ)
(s : finset α) : (↑∏ i in s, f i : M) = ∏ i in s, f i | (units.coe_hom M).map_prod _ _ | lemma | units.coe_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_monoid",
"finset",
"map_prod",
"units.coe_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
units.mk0_prod [comm_group_with_zero β] (s : finset α) (f : α → β) (h) :
units.mk0 (∏ b in s, f b) h =
∏ b in s.attach, units.mk0 (f b) (λ hh, h (finset.prod_eq_zero b.2 hh)) | by { classical, induction s using finset.induction_on; simp* } | lemma | units.mk0_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"comm_group_with_zero",
"finset",
"finset.induction_on",
"finset.prod_eq_zero",
"units.mk0"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
nat_abs_sum_le {ι : Type*} (s : finset ι) (f : ι → ℤ) :
(∑ i in s, f i).nat_abs ≤ ∑ i in s, (f i).nat_abs | begin
classical,
apply finset.induction_on s,
{ simp only [finset.sum_empty, int.nat_abs_zero] },
{ intros i s his IH,
simp only [his, finset.sum_insert, not_false_iff],
exact (int.nat_abs_add_le _ _).trans (add_le_add le_rfl IH) }
end | lemma | nat_abs_sum_le | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset",
"finset.induction_on",
"int.nat_abs_add_le",
"le_rfl"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_mul_list_prod (s : list α) : of_mul s.prod = (s.map of_mul).sum | by simpa [of_mul] | lemma | of_mul_list_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_mul_list_sum (s : list (additive α)) :
to_mul s.sum = (s.map to_mul).prod | by simpa [to_mul, of_mul] | lemma | to_mul_list_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"additive"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_add_list_prod (s : list α) : of_add s.sum = (s.map of_add).prod | by simpa [of_add] | lemma | of_add_list_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_add_list_sum (s : list (multiplicative α)) :
to_add s.prod = (s.map to_add).sum | by simpa [to_add, of_add] | lemma | to_add_list_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiplicative"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_mul_multiset_prod (s : multiset α) :
of_mul s.prod = (s.map of_mul).sum | by simpa [of_mul] | lemma | of_mul_multiset_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_mul_multiset_sum (s : multiset (additive α)) :
to_mul s.sum = (s.map to_mul).prod | by simpa [to_mul, of_mul] | lemma | to_mul_multiset_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"additive",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_mul_prod (s : finset ι) (f : ι → α) :
of_mul (∏ i in s, f i) = ∑ i in s, of_mul (f i) | rfl | lemma | of_mul_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_mul_sum (s : finset ι) (f : ι → additive α) :
to_mul (∑ i in s, f i) = ∏ i in s, to_mul (f i) | rfl | lemma | to_mul_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"additive",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_add_multiset_prod (s : multiset α) :
of_add s.sum = (s.map of_add).prod | by simpa [of_add] | lemma | of_add_multiset_prod | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_add_multiset_sum (s : multiset (multiplicative α)) :
to_add s.prod = (s.map to_add).sum | by simpa [to_add, of_add] | lemma | to_add_multiset_sum | algebra.big_operators | src/algebra/big_operators/basic.lean | [
"algebra.big_operators.multiset.lemmas",
"algebra.group.pi",
"algebra.group_power.lemmas",
"algebra.hom.equiv.basic",
"algebra.ring.opposite",
"data.finset.sum",
"data.fintype.basic",
"data.finset.sigma",
"data.multiset.powerset",
"data.set.pairwise.basic"
] | [
"multiplicative",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.