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_mul_prod_compl [fintype α] [decidable_eq α] (s : finset α) (f : α → β) :
(∏ i in s, f i) * (∏ i in sᶜ, f i) = ∏ i, f i | is_compl.prod_mul_prod is_compl_compl f | lemma | finset.prod_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"
] | [
"finset",
"fintype",
"is_compl.prod_mul_prod",
"is_compl_compl"
] | 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`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_compl_mul_prod [fintype α] [decidable_eq α] (s : finset α) (f : α → β) :
(∏ i in sᶜ, f i) * (∏ i in s, f i) = ∏ i, f i | (@is_compl_compl _ s _).symm.prod_mul_prod f | lemma | finset.prod_compl_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",
"fintype",
"is_compl_compl"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_sdiff [decidable_eq α] (h : s₁ ⊆ s₂) :
(∏ x in (s₂ \ s₁), f x) * (∏ x in s₁, f x) = (∏ x in s₂, f x) | by rw [←prod_union sdiff_disjoint, sdiff_union_of_subset h] | lemma | finset.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"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_disj_sum (s : finset α) (t : finset γ) (f : α ⊕ γ → β) :
∏ x in s.disj_sum t, f x = (∏ x in s, f (sum.inl x)) * (∏ x in t, f (sum.inr x)) | begin
rw [←map_inl_disj_union_map_inr, prod_disj_union, prod_map, prod_map],
refl,
end | lemma | finset.prod_disj_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",
"prod_map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_sum_elim (s : finset α) (t : finset γ) (f : α → β) (g : γ → β) :
∏ x in s.disj_sum t, sum.elim f g x = (∏ x in s, f x) * (∏ x in t, g x) | by simp | lemma | finset.prod_sum_elim | 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",
"sum.elim"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_bUnion [decidable_eq α] {s : finset γ} {t : γ → finset α}
(hs : set.pairwise_disjoint ↑s t) :
(∏ x in s.bUnion t, f x) = ∏ x in s, ∏ i in t x, f i | by rw [←disj_Union_eq_bUnion _ _ hs, prod_disj_Union] | lemma | finset.prod_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"
] | [
"finset",
"set.pairwise_disjoint"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_sigma {σ : α → Type*}
(s : finset α) (t : Π a, finset (σ a)) (f : sigma σ → β) :
(∏ x in s.sigma t, f x) = ∏ a in s, ∏ s in (t a), f ⟨a, s⟩ | by simp_rw [←disj_Union_map_sigma_mk, prod_disj_Union, prod_map, function.embedding.sigma_mk_apply] | lemma | finset.prod_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",
"prod_map"
] | Product over a sigma type equals the product of fiberwise products. For rewriting
in the reverse direction, use `finset.prod_sigma'`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_sigma' {σ : α → Type*}
(s : finset α) (t : Π a, finset (σ a)) (f : Π a, σ a → β) :
(∏ a in s, ∏ s in (t a), f a s) = ∏ x in s.sigma t, f x.1 x.2 | eq.symm $ prod_sigma s t (λ x, f x.1 x.2) | lemma | finset.prod_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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_bij {s : finset α} {t : finset γ} {f : α → β} {g : γ → β}
(i : Π a ∈ s, γ) (hi : ∀ a ha, i a ha ∈ t) (h : ∀ a ha, f a = g (i a ha))
(i_inj : ∀ a₁ a₂ ha₁ ha₂, i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂) (i_surj : ∀ b ∈ t, ∃ a ha, b = i a ha) :
(∏ x in s, f x) = (∏ x in t, g x) | congr_arg multiset.prod
(multiset.map_eq_map_of_bij_of_nodup f g s.2 t.2 i hi h i_inj i_surj) | lemma | finset.prod_bij | 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_eq_map_of_bij_of_nodup",
"multiset.prod"
] | Reorder a product.
The difference with `prod_bij'` is that the bijection is specified as a surjective injection,
rather than by an inverse function. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_bij' {s : finset α} {t : finset γ} {f : α → β} {g : γ → β}
(i : Π a ∈ s, γ) (hi : ∀ a ha, i a ha ∈ t) (h : ∀ a ha, f a = g (i a ha))
(j : Π a ∈ t, α) (hj : ∀ a ha, j a ha ∈ s) (left_inv : ∀ a ha, j (i a ha) (hi a ha) = a)
(right_inv : ∀ a ha, i (j a ha) (hj a ha) = a) :
(∏ x in s, f x) = (∏ x in t, g x) | begin
refine prod_bij i hi h _ _,
{intros a1 a2 h1 h2 eq, rw [←left_inv a1 h1, ←left_inv a2 h2], cc,},
{intros b hb, use j b hb, use hj b hb, exact (right_inv b hb).symm,},
end | lemma | finset.prod_bij' | 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"
] | Reorder a product.
The difference with `prod_bij` is that the bijection is specified with an inverse, rather than
as a surjective injection. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
equiv.prod_comp_finset {ι'} [decidable_eq ι] (e : ι ≃ ι') (f : ι' → β) {s' : finset ι'}
{s : finset ι}
(h : s = s'.image e.symm) :
∏ i' in s', f i' = ∏ i in s, f (e i) | begin
rw [h],
refine finset.prod_bij' (λ i' hi', e.symm i') (λ a ha, finset.mem_image_of_mem _ ha)
(λ a ha, by simp_rw [e.apply_symm_apply]) (λ i hi, e i) (λ a ha, _)
(λ a ha, e.apply_symm_apply a) (λ a ha, e.symm_apply_apply a),
rcases finset.mem_image.mp ha with ⟨i', hi', rfl⟩,
rwa [e.apply_symm_apply... | lemma | finset.equiv.prod_comp_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"
] | [
"finset",
"finset.mem_image_of_mem",
"finset.prod_bij'"
] | Reindexing a product over a finset along an equivalence.
See `equiv.prod_comp` for the version where `s` and `s'` are `univ`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_finset_product
(r : finset (γ × α)) (s : finset γ) (t : γ → finset α)
(h : ∀ p : γ × α, p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1) {f : γ × α → β} :
∏ p in r, f p = ∏ c in s, ∏ a in t c, f (c, a) | begin
refine eq.trans _ (prod_sigma s t (λ p, f (p.1, p.2))),
exact prod_bij' (λ p hp, ⟨p.1, p.2⟩) (λ p, mem_sigma.mpr ∘ (h p).mp)
(λ p hp, congr_arg f prod.mk.eta.symm) (λ p hp, (p.1, p.2))
(λ p, (h (p.1, p.2)).mpr ∘ mem_sigma.mp) (λ p hp, prod.mk.eta) (λ p hp, p.eta),
end | lemma | finset.prod_finset_product | 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_finset_product'
(r : finset (γ × α)) (s : finset γ) (t : γ → finset α)
(h : ∀ p : γ × α, p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1) {f : γ → α → β} :
∏ p in r, f p.1 p.2 = ∏ c in s, ∏ a in t c, f c a | prod_finset_product r s t h | lemma | finset.prod_finset_product' | 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_finset_product_right
(r : finset (α × γ)) (s : finset γ) (t : γ → finset α)
(h : ∀ p : α × γ, p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) {f : α × γ → β} :
∏ p in r, f p = ∏ c in s, ∏ a in t c, f (a, c) | begin
refine eq.trans _ (prod_sigma s t (λ p, f (p.2, p.1))),
exact prod_bij' (λ p hp, ⟨p.2, p.1⟩) (λ p, mem_sigma.mpr ∘ (h p).mp)
(λ p hp, congr_arg f prod.mk.eta.symm) (λ p hp, (p.2, p.1))
(λ p, (h (p.2, p.1)).mpr ∘ mem_sigma.mp) (λ p hp, prod.mk.eta) (λ p hp, p.eta),
end | lemma | finset.prod_finset_product_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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_finset_product_right'
(r : finset (α × γ)) (s : finset γ) (t : γ → finset α)
(h : ∀ p : α × γ, p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) {f : α → γ → β} :
∏ p in r, f p.1 p.2 = ∏ c in s, ∏ a in t c, f a c | prod_finset_product_right r s t h | lemma | finset.prod_finset_product_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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_fiberwise_of_maps_to [decidable_eq γ] {s : finset α} {t : finset γ} {g : α → γ}
(h : ∀ x ∈ s, g x ∈ t) (f : α → β) :
(∏ y in t, ∏ x in s.filter (λ x, g x = y), f x) = ∏ x in s, f x | begin
rw [← disj_Union_filter_eq_of_maps_to h] {occs := occurrences.pos [2]},
rw prod_disj_Union,
end | lemma | finset.prod_fiberwise_of_maps_to | 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_image' [decidable_eq α] {s : finset γ} {g : γ → α} (h : γ → β)
(eq : ∀ c ∈ s, f (g c) = ∏ x in s.filter (λ c', g c' = g c), h x) :
(∏ x in s.image g, f x) = ∏ x in s, h x | calc (∏ x in s.image g, f x) = ∏ x in s.image g, ∏ x in s.filter (λ c', g c' = x), h x :
prod_congr rfl $ λ x hx, let ⟨c, hcs, hc⟩ := mem_image.1 hx in hc ▸ (eq c hcs)
... = ∏ x in s, h x : prod_fiberwise_of_maps_to (λ x, mem_image_of_mem g) _ | lemma | finset.prod_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 | |
prod_mul_distrib : ∏ x in s, (f x * g x) = (∏ x in s, f x) * (∏ x in s, g x) | eq.trans (by rw one_mul; refl) fold_op_distrib | lemma | finset.prod_mul_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"
] | [
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_product {s : finset γ} {t : finset α} {f : γ×α → β} :
(∏ x in s ×ˢ t, f x) = ∏ x in s, ∏ y in t, f (x, y) | prod_finset_product (s ×ˢ t) s (λ a, t) (λ p, mem_product) | lemma | finset.prod_product | 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_product' {s : finset γ} {t : finset α} {f : γ → α → β} :
(∏ x in s ×ˢ t, f x.1 x.2) = ∏ x in s, ∏ y in t, f x y | prod_product | lemma | finset.prod_product' | 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"
] | An uncurried version of `finset.prod_product`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_product_right {s : finset γ} {t : finset α} {f : γ×α → β} :
(∏ x in s ×ˢ t, f x) = ∏ y in t, ∏ x in s, f (x, y) | prod_finset_product_right (s ×ˢ t) t (λ a, s) (λ p, mem_product.trans and.comm) | lemma | finset.prod_product_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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_product_right' {s : finset γ} {t : finset α} {f : γ → α → β} :
(∏ x in s ×ˢ t, f x.1 x.2) = ∏ y in t, ∏ x in s, f x y | prod_product_right | lemma | finset.prod_product_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"
] | An uncurried version of `finset.prod_product_right`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_comm' {s : finset γ} {t : γ → finset α} {t' : finset α} {s' : α → finset γ}
(h : ∀ x y, x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t') {f : γ → α → β} :
(∏ x in s, ∏ y in t x, f x y) = (∏ y in t', ∏ x in s' y, f x y) | begin
classical,
have : ∀ z : γ × α,
z ∈ s.bUnion (λ x, (t x).map $ function.embedding.sectr x _) ↔ z.1 ∈ s ∧ z.2 ∈ t z.1,
{ rintro ⟨x, y⟩, simp },
exact (prod_finset_product' _ _ _ this).symm.trans
(prod_finset_product_right' _ _ _ $ λ ⟨x, y⟩, (this _).trans ((h x y).trans and.comm))
end | lemma | finset.prod_comm' | 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",
"function.embedding.sectr"
] | Generalization of `finset.prod_comm` to the case when the inner `finset`s depend on the outer
variable. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_comm {s : finset γ} {t : finset α} {f : γ → α → β} :
(∏ x in s, ∏ y in t, f x y) = (∏ y in t, ∏ x in s, f x y) | prod_comm' $ λ _ _, iff.rfl | lemma | finset.prod_comm | 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_hom_rel [comm_monoid γ] {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 (∏ x in s, f x) (∏ x in s, g x) | by { delta finset.prod, apply multiset.prod_hom_rel; assumption } | lemma | finset.prod_hom_rel | 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",
"multiset.prod_hom_rel"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_one {f : α → β} {s : finset α} (h : ∀ x ∈ s, f x = 1) : (∏ x in s, f x) = 1 | calc (∏ x in s, f x) = ∏ x in s, 1 : finset.prod_congr rfl h
... = 1 : finset.prod_const_one | lemma | finset.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",
"finset.prod_congr",
"finset.prod_const_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_subset_one_on_sdiff [decidable_eq α] (h : s₁ ⊆ s₂) (hg : ∀ x ∈ (s₂ \ s₁), g x = 1)
(hfg : ∀ x ∈ s₁, f x = g x) : ∏ i in s₁, f i = ∏ i in s₂, g i | begin
rw [← prod_sdiff h, prod_eq_one hg, one_mul],
exact prod_congr rfl hfg
end | lemma | finset.prod_subset_one_on_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"
] | [
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_subset (h : s₁ ⊆ s₂) (hf : ∀ x ∈ s₂, x ∉ s₁ → f x = 1) :
(∏ x in s₁, f x) = ∏ x in s₂, f x | by haveI := classical.dec_eq α; exact prod_subset_one_on_sdiff h (by simpa) (λ _ _, rfl) | lemma | finset.prod_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"
] | [
"classical.dec_eq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_filter_of_ne {p : α → Prop} [decidable_pred p] (hp : ∀ x ∈ s, f x ≠ 1 → p x) :
(∏ x in (s.filter p), f x) = (∏ x in s, f x) | prod_subset (filter_subset _ _) $ λ x,
by { classical, rw [not_imp_comm, mem_filter], exact λ h₁ h₂, ⟨h₁, hp _ h₁ h₂⟩ } | lemma | finset.prod_filter_of_ne | 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"
] | [
"not_imp_comm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_filter_ne_one [∀ x, decidable (f x ≠ 1)] :
(∏ x in (s.filter $ λ x, f x ≠ 1), f x) = (∏ x in s, f x) | prod_filter_of_ne $ λ _ _, id | lemma | finset.prod_filter_ne_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"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_filter (p : α → Prop) [decidable_pred p] (f : α → β) :
(∏ a in s.filter p, f a) = (∏ a in s, if p a then f a else 1) | calc (∏ a in s.filter p, f a) = ∏ a in s.filter p, if p a then f a else 1 :
prod_congr rfl (assume a h, by rw [if_pos (mem_filter.1 h).2])
... = ∏ a in s, if p a then f a else 1 :
begin
refine prod_subset (filter_subset _ s) (assume x hs h, _),
rw [mem_filter, not_and] at h,
exact if_neg (h ... | lemma | finset.prod_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"
] | [
"not_and"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_single_of_mem {s : finset α} {f : α → β} (a : α) (h : a ∈ s)
(h₀ : ∀ b ∈ s, b ≠ a → f b = 1) : (∏ x in s, f x) = f a | begin
haveI := classical.dec_eq α,
calc (∏ x in s, f x) = ∏ x in {a}, f x :
begin
refine (prod_subset _ _).symm,
{ intros _ H, rwa mem_singleton.1 H },
{ simpa only [mem_singleton] }
end
... = f a : prod_singleton
end | lemma | finset.prod_eq_single_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"
] | [
"classical.dec_eq",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_single {s : finset α} {f : α → β} (a : α)
(h₀ : ∀ b ∈ s, b ≠ a → f b = 1) (h₁ : a ∉ s → f a = 1) : (∏ x in s, f x) = f a | by haveI := classical.dec_eq α;
from classical.by_cases
(assume : a ∈ s, prod_eq_single_of_mem a this h₀)
(assume : a ∉ s,
(prod_congr rfl $ λ b hb, h₀ b hb $ by rintro rfl; cc).trans $
prod_const_one.trans (h₁ this).symm) | lemma | finset.prod_eq_single | 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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_mul_of_mem {s : finset α} {f : α → β} (a b : α) (ha : a ∈ s) (hb : b ∈ s) (hn : a ≠ b)
(h₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1) : (∏ x in s, f x) = (f a) * (f b) | begin
haveI := classical.dec_eq α;
let s' := ({a, b} : finset α),
have hu : s' ⊆ s,
{ refine insert_subset.mpr _, apply and.intro ha, apply singleton_subset_iff.mpr hb },
have hf : ∀ c ∈ s, c ∉ s' → f c = 1,
{ intros c hc hcs,
apply h₀ c hc,
apply not_or_distrib.mp,
intro hab,
apply hcs,
... | lemma | finset.prod_eq_mul_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"
] | [
"classical.dec_eq",
"finset",
"finset.prod_pair"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_mul {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) :
(∏ x in s, f x) = (f a) * (f b) | begin
haveI := classical.dec_eq α;
by_cases h₁ : a ∈ s; by_cases h₂ : b ∈ s,
{ exact prod_eq_mul_of_mem a b h₁ h₂ hn h₀ },
{ rw [hb h₂, mul_one],
apply prod_eq_single_of_mem a h₁,
exact λ c hc hca, h₀ c hc ⟨hca, ne_of_mem_of_not_mem hc h₂⟩ },
{ rw [ha h₁, one_mul],
apply prod_eq_single_of_mem b h₂... | lemma | finset.prod_eq_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"
] | [
"classical.dec_eq",
"finset",
"mul_one",
"ne_of_mem_of_not_mem",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_attach {f : α → β} : (∏ x in s.attach, f x) = (∏ x in s, f x) | by haveI := classical.dec_eq α; exact
calc (∏ x in s.attach, f x.val) = (∏ x in (s.attach).image subtype.val, f x) :
by rw [prod_image]; exact assume x _ y _, subtype.eq
... = _ : by rw [attach_image_val] | lemma | finset.prod_attach | 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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_subtype_eq_prod_filter (f : α → β) {p : α → Prop} [decidable_pred p] :
∏ x in s.subtype p, f x = ∏ x in s.filter p, f x | begin
conv_lhs { erw ←prod_map (s.subtype p) (function.embedding.subtype _) f },
exact prod_congr (subtype_map _) (λ x hx, rfl)
end | lemma | finset.prod_subtype_eq_prod_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"
] | [
"function.embedding.subtype"
] | A product over `s.subtype p` equals one over `s.filter p`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_subtype_of_mem (f : α → β) {p : α → Prop} [decidable_pred p]
(h : ∀ x ∈ s, p x) : ∏ x in s.subtype p, f x = ∏ x in s, f x | by simp_rw [prod_subtype_eq_prod_filter, filter_true_of_mem h] | lemma | finset.prod_subtype_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"
] | [] | If all elements of a `finset` satisfy the predicate `p`, a product
over `s.subtype p` equals that product over `s`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_subtype_map_embedding {p : α → Prop} {s : finset {x // p x}} {f : {x // p x} → β}
{g : α → β} (h : ∀ x : {x // p x}, x ∈ s → g x = f x) :
∏ x in s.map (function.embedding.subtype _), g x = ∏ x in s, f x | begin
rw finset.prod_map,
exact finset.prod_congr rfl h
end | lemma | finset.prod_subtype_map_embedding | 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_congr",
"finset.prod_map",
"function.embedding.subtype"
] | 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`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_coe_sort_eq_attach (f : s → β) :
∏ (i : s), f i = ∏ i in s.attach, f i | rfl | lemma | finset.prod_coe_sort_eq_attach | 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_coe_sort :
∏ (i : s), f i = ∏ i in s, f i | prod_attach | lemma | finset.prod_coe_sort | 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_finset_coe (f : α → β) (s : finset α) :
∏ (i : (s : set α)), f i = ∏ i in s, f i | prod_coe_sort s f | lemma | finset.prod_finset_coe | 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_subtype {p : α → Prop} {F : fintype (subtype p)} (s : finset α)
(h : ∀ x, x ∈ s ↔ p x) (f : α → β) :
∏ a in s, f a = ∏ a : subtype p, f a | have (∈ s) = p, from set.ext h, by { substI p, rw ← prod_coe_sort, congr } | lemma | finset.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"
] | [
"finset",
"fintype",
"set.ext"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_congr_set
{α : Type*} [comm_monoid α] {β : Type*} [fintype β]
(s : set β) [decidable_pred (∈s)] (f : β → α) (g : s → α)
(w : ∀ (x : β) (h : x ∈ s), f x = g ⟨x, h⟩) (w' : ∀ (x : β), x ∉ s → f x = 1) :
finset.univ.prod f = finset.univ.prod g | begin
rw ←@finset.prod_subset _ _ s.to_finset finset.univ f _ (by simp),
{ rw finset.prod_subtype,
{ apply finset.prod_congr rfl,
exact λ ⟨x, h⟩ _, w x h, },
{ simp, }, },
{ rintro x _ h, exact w' x (by simpa using h), },
end | lemma | finset.prod_congr_set | 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_congr",
"finset.prod_subset",
"finset.prod_subtype",
"finset.univ",
"fintype"
] | 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`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_apply_dite {s : finset α} {p : α → Prop} {hp : decidable_pred p}
[decidable_pred (λ x, ¬ p x)] (f : Π (x : α), p x → γ) (g : Π (x : α), ¬p x → γ)
(h : γ → β) :
(∏ x in s, h (if hx : p x then f x hx else g x hx)) =
(∏ x in (s.filter p).attach, h (f x.1 (mem_filter.mp x.2).2)) *
(∏ x in (s.filter (λ x, ¬... | calc ∏ x in s, h (if hx : p x then f x hx else g x hx)
= (∏ x in s.filter p, h (if hx : p x then f x hx else g x hx)) *
(∏ x in s.filter (λ x, ¬ p x), h (if hx : p x then f x hx else g x hx)) :
(prod_filter_mul_prod_filter_not s p _).symm
... = (∏ x in (s.filter p).attach, h (if hx : p x.1 then f x.1 hx else ... | lemma | finset.prod_apply_dite | 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"
] | [
"congr_arg2",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_apply_ite {s : finset α}
{p : α → Prop} {hp : decidable_pred p} (f g : α → γ) (h : γ → β) :
(∏ x in s, h (if p x then f x else g x)) =
(∏ x in s.filter p, h (f x)) * (∏ x in s.filter (λ x, ¬ p x), h (g x)) | trans (prod_apply_dite _ _ _)
(congr_arg2 _ (@prod_attach _ _ _ _ (h ∘ f)) (@prod_attach _ _ _ _ (h ∘ g))) | lemma | finset.prod_apply_ite | 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"
] | [
"congr_arg2",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_dite {s : finset α} {p : α → Prop} {hp : decidable_pred p}
(f : Π (x : α), p x → β) (g : Π (x : α), ¬p x → β) :
(∏ x in s, if hx : p x then f x hx else g x hx) =
(∏ x in (s.filter p).attach, f x.1 (mem_filter.mp x.2).2) *
(∏ x in (s.filter (λ x, ¬ p x)).attach, g x.1 (mem_filter.mp x.2).2) | by simp [prod_apply_dite _ _ (λ x, x)] | lemma | finset.prod_dite | 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_ite {s : finset α}
{p : α → Prop} {hp : decidable_pred p} (f g : α → β) :
(∏ x in s, if p x then f x else g x) =
(∏ x in s.filter p, f x) * (∏ x in s.filter (λ x, ¬ p x), g x) | by simp [prod_apply_ite _ _ (λ x, x)] | lemma | finset.prod_ite | 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_ite_of_false {p : α → Prop} {hp : decidable_pred p} (f g : α → β)
(h : ∀ x ∈ s, ¬p x) : (∏ x in s, if p x then f x else g x) = (∏ x in s, g x) | by { rw prod_ite, simp [filter_false_of_mem h, filter_true_of_mem h] } | lemma | finset.prod_ite_of_false | 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_ite_of_true {p : α → Prop} {hp : decidable_pred p} (f g : α → β)
(h : ∀ x ∈ s, p x) : (∏ x in s, if p x then f x else g x) = (∏ x in s, f x) | by { simp_rw ←(ite_not (p _)), apply prod_ite_of_false, simpa } | lemma | finset.prod_ite_of_true | 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"
] | [
"ite_not"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_apply_ite_of_false {p : α → Prop} {hp : decidable_pred p} (f g : α → γ)
(k : γ → β) (h : ∀ x ∈ s, ¬p x) :
(∏ x in s, k (if p x then f x else g x)) = (∏ x in s, k (g x)) | by { simp_rw apply_ite k, exact prod_ite_of_false _ _ h } | lemma | finset.prod_apply_ite_of_false | 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"
] | [
"apply_ite"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_apply_ite_of_true {p : α → Prop} {hp : decidable_pred p} (f g : α → γ)
(k : γ → β) (h : ∀ x ∈ s, p x) :
(∏ x in s, k (if p x then f x else g x)) = (∏ x in s, k (f x)) | by { simp_rw apply_ite k, exact prod_ite_of_true _ _ h } | lemma | finset.prod_apply_ite_of_true | 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"
] | [
"apply_ite"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_extend_by_one [decidable_eq α] (s : finset α) (f : α → β) :
∏ i in s, (if i ∈ s then f i else 1) = ∏ i in s, f i | prod_congr rfl $ λ i hi, if_pos hi | lemma | finset.prod_extend_by_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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_ite_mem [decidable_eq α] (s t : finset α) (f : α → β) :
∏ i in s, (if i ∈ t then f i else 1) = ∏ i in (s ∩ t), f i | by rw [← finset.prod_filter, finset.filter_mem_eq_inter] | lemma | finset.prod_ite_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",
"finset.filter_mem_eq_inter",
"finset.prod_filter"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_dite_eq [decidable_eq α] (s : finset α) (a : α) (b : Π x : α, a = x → β) :
(∏ x in s, (if h : a = x then b x h else 1)) = ite (a ∈ s) (b a rfl) 1 | begin
split_ifs with h,
{ rw [finset.prod_eq_single a, dif_pos rfl],
{ intros, rw dif_neg, cc },
{ cc } },
{ rw finset.prod_eq_one,
intros, rw dif_neg, intro, cc }
end | lemma | finset.prod_dite_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",
"finset.prod_eq_one",
"finset.prod_eq_single"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_dite_eq' [decidable_eq α] (s : finset α) (a : α) (b : Π x : α, x = a → β) :
(∏ x in s, (if h : x = a then b x h else 1)) = ite (a ∈ s) (b a rfl) 1 | begin
split_ifs with h,
{ rw [finset.prod_eq_single a, dif_pos rfl],
{ intros, rw dif_neg, cc },
{ cc } },
{ rw finset.prod_eq_one,
intros, rw dif_neg, intro, cc }
end | lemma | finset.prod_dite_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",
"finset.prod_eq_one",
"finset.prod_eq_single"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_ite_eq [decidable_eq α] (s : finset α) (a : α) (b : α → β) :
(∏ x in s, (ite (a = x) (b x) 1)) = ite (a ∈ s) (b a) 1 | prod_dite_eq s a (λ x _, b x) | lemma | finset.prod_ite_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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_ite_eq' [decidable_eq α] (s : finset α) (a : α) (b : α → β) :
(∏ x in s, (ite (x = a) (b x) 1)) = ite (a ∈ s) (b a) 1 | prod_dite_eq' s a (λ x _, b x) | lemma | finset.prod_ite_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"
] | 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. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_ite_index (p : Prop) [decidable p] (s t : finset α) (f : α → β) :
(∏ x in if p then s else t, f x) = if p then ∏ x in s, f x else ∏ x in t, f x | apply_ite (λ s, ∏ x in s, f x) _ _ _ | lemma | finset.prod_ite_index | 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"
] | [
"apply_ite",
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_ite_irrel (p : Prop) [decidable p] (s : finset α) (f g : α → β) :
(∏ x in s, if p then f x else g x) = if p then ∏ x in s, f x else ∏ x in s, g x | by { split_ifs with h; refl } | lemma | finset.prod_ite_irrel | 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_dite_irrel (p : Prop) [decidable p] (s : finset α) (f : p → α → β) (g : ¬p → α → β) :
(∏ x in s, if h : p then f h x else g h x) = if h : p then ∏ x in s, f h x else ∏ x in s, g h x | by { split_ifs with h; refl } | lemma | finset.prod_dite_irrel | 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_pi_mul_single' [decidable_eq α] (a : α) (x : β) (s : finset α) :
∏ a' in s, pi.mul_single a x a' = if a ∈ s then x else 1 | prod_dite_eq' _ _ _ | lemma | finset.prod_pi_mul_single' | 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",
"pi.mul_single"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_pi_mul_single {β : α → Type*}
[decidable_eq α] [Π a, comm_monoid (β a)] (a : α) (f : Π a, β a) (s : finset α) :
∏ a' in s, pi.mul_single a' (f a') a = if a ∈ s then f a else 1 | prod_dite_eq _ _ _ | lemma | finset.prod_pi_mul_single | 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",
"pi.mul_single"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_bij_ne_one {s : finset α} {t : finset γ} {f : α → β} {g : γ → β}
(i : Π a ∈ s, f a ≠ 1 → γ) (hi : ∀ a h₁ h₂, i a h₁ h₂ ∈ t)
(i_inj : ∀ a₁ a₂ h₁₁ h₁₂ h₂₁ h₂₂, i a₁ h₁₁ h₁₂ = i a₂ h₂₁ h₂₂ → a₁ = a₂)
(i_surj : ∀ b ∈ t, g b ≠ 1 → ∃ a h₁ h₂, b = i a h₁ h₂)
(h : ∀ a h₁ h₂, f a = g (i a h₁ h₂)) :
(∏ x in s, f x... | by classical; exact
calc (∏ x in s, f x) = ∏ x in (s.filter $ λ x, f x ≠ 1), f x : prod_filter_ne_one.symm
... = ∏ x in (t.filter $ λ x, g x ≠ 1), g x :
prod_bij (assume a ha, i a (mem_filter.mp ha).1 (mem_filter.mp ha).2)
(assume a ha, (mem_filter.mp ha).elim $ λ h₁ h₂, mem_filter.mpr
⟨hi a h₁ h₂, ... | lemma | finset.prod_bij_ne_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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_dite_of_false {p : α → Prop} {hp : decidable_pred p}
(h : ∀ x ∈ s, ¬ p x) (f : Π (x : α), p x → β) (g : Π (x : α), ¬p x → β) :
(∏ x in s, if hx : p x then f x hx else g x hx) =
∏ (x : s), g x.val (h x.val x.property) | prod_bij (λ x hx, ⟨x,hx⟩) (λ x hx, by simp) (λ a ha, by { dsimp, rw dif_neg })
(λ a₁ a₂ h₁ h₂ hh, congr_arg coe hh) (λ b hb, ⟨b.1, b.2, by simp⟩) | lemma | finset.prod_dite_of_false | 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_dite_of_true {p : α → Prop} {hp : decidable_pred p}
(h : ∀ x ∈ s, p x) (f : Π (x : α), p x → β) (g : Π (x : α), ¬p x → β) :
(∏ x in s, if hx : p x then f x hx else g x hx) =
∏ (x : s), f x.val (h x.val x.property) | prod_bij (λ x hx, ⟨x,hx⟩) (λ x hx, by simp) (λ a ha, by { dsimp, rw dif_pos })
(λ a₁ a₂ h₁ h₂ hh, congr_arg coe hh) (λ b hb, ⟨b.1, b.2, by simp⟩) | lemma | finset.prod_dite_of_true | 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 | |
nonempty_of_prod_ne_one (h : (∏ x in s, f x) ≠ 1) : s.nonempty | s.eq_empty_or_nonempty.elim (λ H, false.elim $ h $ H.symm ▸ prod_empty) id | lemma | finset.nonempty_of_prod_ne_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"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
exists_ne_one_of_prod_ne_one (h : (∏ x in s, f x) ≠ 1) : ∃ a ∈ s, f a ≠ 1 | begin
classical,
rw ← prod_filter_ne_one at h,
rcases nonempty_of_prod_ne_one h with ⟨x, hx⟩,
exact ⟨x, (mem_filter.1 hx).1, (mem_filter.1 hx).2⟩
end | lemma | finset.exists_ne_one_of_prod_ne_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"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_range_succ_comm (f : ℕ → β) (n : ℕ) :
∏ x in range (n + 1), f x = f n * ∏ x in range n, f x | by rw [range_succ, prod_insert not_mem_range_self] | lemma | finset.prod_range_succ_comm | 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_range_succ (f : ℕ → β) (n : ℕ) :
∏ x in range (n + 1), f x = (∏ x in range n, f x) * f n | by simp only [mul_comm, prod_range_succ_comm] | lemma | finset.prod_range_succ | 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_comm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_range_succ' (f : ℕ → β) :
∀ n : ℕ, (∏ k in range (n + 1), f k) = (∏ k in range n, f (k+1)) * f 0 | | 0 := prod_range_succ _ _
| (n + 1) := by rw [prod_range_succ _ n, mul_right_comm, ← prod_range_succ', prod_range_succ] | lemma | finset.prod_range_succ' | 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_right_comm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eventually_constant_prod {u : ℕ → β} {N : ℕ} (hu : ∀ n ≥ N, u n = 1) {n : ℕ} (hn : N ≤ n) :
∏ k in range (n + 1), u k = ∏ k in range (N + 1), u k | begin
obtain ⟨m, rfl : n = N + m⟩ := le_iff_exists_add.mp hn,
clear hn,
induction m with m hm,
{ simp },
erw [prod_range_succ, hm],
simp [hu, @zero_le' ℕ],
end | lemma | finset.eventually_constant_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"
] | [
"zero_le'"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_range_add (f : ℕ → β) (n m : ℕ) :
∏ x in range (n + m), f x =
(∏ x in range n, f x) * (∏ x in range m, f (n + x)) | begin
induction m with m hm,
{ simp },
{ rw [nat.add_succ, prod_range_succ, hm, prod_range_succ, mul_assoc], },
end | lemma | finset.prod_range_add | 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_assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_range_add_div_prod_range {α : Type*} [comm_group α] (f : ℕ → α) (n m : ℕ) :
(∏ k in range (n + m), f k) / (∏ k in range n, f k) = ∏ k in finset.range m, f (n + k) | div_eq_of_eq_mul' (prod_range_add f n m) | lemma | finset.prod_range_add_div_prod_range | 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",
"div_eq_of_eq_mul'",
"finset.range"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_range_zero (f : ℕ → β) :
∏ k in range 0, f k = 1 | by rw [range_zero, prod_empty] | lemma | finset.prod_range_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"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_range_one (f : ℕ → β) :
∏ k in range 1, f k = f 0 | by { rw [range_one], apply @prod_singleton β ℕ 0 f } | lemma | finset.prod_range_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"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_list_map_count [decidable_eq α] (l : list α)
{M : Type*} [comm_monoid M] (f : α → M) :
(l.map f).prod = ∏ m in l.to_finset, (f m) ^ (l.count m) | begin
induction l with a s IH, { simp only [map_nil, prod_nil, count_nil, pow_zero, prod_const_one] },
simp only [list.map, list.prod_cons, to_finset_cons, IH],
by_cases has : a ∈ s.to_finset,
{ rw [insert_eq_of_mem has, ← insert_erase has, prod_insert (not_mem_erase _ _),
prod_insert (not_mem_erase _ _),... | lemma | finset.prod_list_map_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"
] | [
"comm_monoid",
"list.prod_cons",
"map_nil",
"mul_assoc",
"pow_one",
"pow_succ",
"pow_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_list_count [decidable_eq α] [comm_monoid α] (s : list α) :
s.prod = ∏ m in s.to_finset, m ^ (s.count m) | by simpa using prod_list_map_count s id | lemma | finset.prod_list_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"
] | [
"comm_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_list_count_of_subset [decidable_eq α] [comm_monoid α]
(m : list α) (s : finset α) (hs : m.to_finset ⊆ s) :
m.prod = ∏ i in s, i ^ (m.count i) | begin
rw prod_list_count,
refine prod_subset hs (λ x _ hx, _),
rw [mem_to_finset] at hx,
rw [count_eq_zero_of_not_mem hx, pow_zero],
end | lemma | finset.prod_list_count_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",
"pow_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sum_filter_count_eq_countp [decidable_eq α] (p : α → Prop) [decidable_pred p] (l : list α) :
∑ x in l.to_finset.filter p, l.count x = l.countp p | by simp [finset.sum, sum_map_count_dedup_filter_eq_countp p l] | lemma | finset.sum_filter_count_eq_countp | 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_multiset_map_count [decidable_eq α] (s : multiset α)
{M : Type*} [comm_monoid M] (f : α → M) :
(s.map f).prod = ∏ m in s.to_finset, (f m) ^ (s.count m) | by { refine quot.induction_on s (λ l, _), simp [prod_list_map_count l f] } | lemma | finset.prod_multiset_map_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"
] | [
"comm_monoid",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_multiset_count [decidable_eq α] [comm_monoid α] (s : multiset α) :
s.prod = ∏ m in s.to_finset, m ^ (s.count m) | by { convert prod_multiset_map_count s id, rw multiset.map_id } | lemma | finset.prod_multiset_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"
] | [
"comm_monoid",
"multiset",
"multiset.map_id"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_multiset_count_of_subset [decidable_eq α] [comm_monoid α]
(m : multiset α) (s : finset α) (hs : m.to_finset ⊆ s) :
m.prod = ∏ i in s, i ^ (m.count i) | begin
revert hs,
refine quot.induction_on m (λ l, _),
simp only [quot_mk_to_coe'', coe_prod, coe_count],
apply prod_list_count_of_subset l s
end | lemma | finset.prod_multiset_count_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"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_mem_multiset [decidable_eq α]
(m : multiset α) (f : {x // x ∈ m} → β) (g : α → β)
(hfg : ∀ x, f x = g x) :
∏ (x : {x // x ∈ m}), f x = ∏ x in m.to_finset, g x | prod_bij (λ x _, x.1) (λ x _, multiset.mem_to_finset.mpr x.2)
(λ _ _, hfg _)
(λ _ _ _ _ h, by { ext, assumption })
(λ y hy, ⟨⟨y, multiset.mem_to_finset.mp hy⟩, finset.mem_univ _, rfl⟩) | lemma | finset.prod_mem_multiset | 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.mem_univ",
"multiset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_induction {M : Type*} [comm_monoid M] (f : α → M) (p : M → Prop)
(p_mul : ∀ a b, p a → p b → p (a * b)) (p_one : p 1) (p_s : ∀ x ∈ s, p $ f x) :
p $ ∏ x in s, f x | multiset.prod_induction _ _ p_mul p_one (multiset.forall_mem_map_iff.mpr p_s) | lemma | finset.prod_induction | 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",
"multiset.prod_induction"
] | To prove a property of a product, it suffices to prove that
the property is multiplicative and holds on factors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_induction_nonempty {M : Type*} [comm_monoid M] (f : α → M) (p : M → Prop)
(p_mul : ∀ a b, p a → p b → p (a * b)) (hs_nonempty : s.nonempty) (p_s : ∀ x ∈ s, p $ f x) :
p $ ∏ x in s, f x | multiset.prod_induction_nonempty p p_mul (by simp [nonempty_iff_ne_empty.mp hs_nonempty])
(multiset.forall_mem_map_iff.mpr p_s) | lemma | finset.prod_induction_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",
"multiset.prod_induction_nonempty"
] | To prove a property of a product, it suffices to prove that
the property is multiplicative and holds on factors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_range_induction (f s : ℕ → β) (h0 : s 0 = 1) (h : ∀ n, s (n + 1) = s n * f n) (n : ℕ) :
∏ k in finset.range n, f k = s n | begin
induction n with k hk,
{ simp only [h0, finset.prod_range_zero] },
{ simp only [hk, finset.prod_range_succ, h, mul_comm] }
end | lemma | finset.prod_range_induction | 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_range_succ",
"finset.prod_range_zero",
"finset.range",
"mul_comm"
] | 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. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_range_div {M : Type*} [comm_group M] (f : ℕ → M) (n : ℕ) :
∏ i in range n, (f (i + 1) / f i) = f n / f 0 | by apply prod_range_induction; simp | lemma | finset.prod_range_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"
] | [
"comm_group"
] | A telescoping product along `{0, ..., n - 1}` of a commutative group valued function reduces to
the ratio of the last and first factors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_range_div' {M : Type*} [comm_group M] (f : ℕ → M) (n : ℕ) :
∏ i in range n, (f i / f (i + 1)) = f 0 / f n | by apply prod_range_induction; simp | lemma | finset.prod_range_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"
] | [
"comm_group"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eq_prod_range_div {M : Type*} [comm_group M] (f : ℕ → M) (n : ℕ) :
f n = f 0 * ∏ i in range n, (f (i + 1) / f i) | by rw [prod_range_div, mul_div_cancel'_right] | lemma | finset.eq_prod_range_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"
] | [
"comm_group",
"mul_div_cancel'_right"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eq_prod_range_div' {M : Type*} [comm_group M] (f : ℕ → M) (n : ℕ) :
f n = ∏ i in range (n + 1), if i = 0 then f 0 else f i / f (i - 1) | by { conv_lhs { rw [finset.eq_prod_range_div f] }, simp [finset.prod_range_succ', mul_comm] } | lemma | finset.eq_prod_range_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"
] | [
"comm_group",
"finset.eq_prod_range_div",
"finset.prod_range_succ'",
"mul_comm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sum_range_tsub [canonically_ordered_add_monoid α] [has_sub α] [has_ordered_sub α]
[contravariant_class α α (+) (≤)] {f : ℕ → α} (h : monotone f) (n : ℕ) :
∑ i in range n, (f (i+1) - f i) = f n - f 0 | begin
refine sum_range_induction _ _ (tsub_self _) (λ n, _) _,
have h₁ : f n ≤ f (n+1) := h (nat.le_succ _),
have h₂ : f 0 ≤ f n := h (nat.zero_le _),
rw [tsub_add_eq_add_tsub h₂, add_tsub_cancel_of_le h₁],
end | lemma | finset.sum_range_tsub | 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_tsub_cancel_of_le",
"canonically_ordered_add_monoid",
"contravariant_class",
"has_ordered_sub",
"monotone",
"tsub_add_eq_add_tsub",
"tsub_self"
] | 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. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_const (b : β) : (∏ x in s, b) = b ^ s.card | (congr_arg _ $ s.val.map_const b).trans $ multiset.prod_replicate s.card b | lemma | finset.prod_const | 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_replicate"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_eq_pow_card {b : β} (hf : ∀ a ∈ s, f a = b) :
∏ a in s, f a = b ^ s.card | (prod_congr rfl hf).trans $ prod_const _ | lemma | finset.prod_eq_pow_card | 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 | |
pow_eq_prod_const (b : β) : ∀ n, b ^ n = ∏ k in range n, b | by simp | lemma | finset.pow_eq_prod_const | 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_pow (s : finset α) (n : ℕ) (f : α → β) :
∏ x in s, f x ^ n = (∏ x in s, f x) ^ n | multiset.prod_map_pow | lemma | finset.prod_pow | 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_pow"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_flip {n : ℕ} (f : ℕ → β) :
∏ r in range (n + 1), f (n - r) = ∏ k in range (n + 1), f k | begin
induction n with n ih,
{ rw [prod_range_one, prod_range_one] },
{ rw [prod_range_succ', prod_range_succ _ (nat.succ n)],
simp [← ih] }
end | lemma | finset.prod_flip | 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"
] | [
"ih"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_involution {s : finset α} {f : α → β} :
∀ (g : Π a ∈ s, α)
(h : ∀ a ha, f a * f (g a ha) = 1)
(g_ne : ∀ a ha, f a ≠ 1 → g a ha ≠ a)
(g_mem : ∀ a ha, g a ha ∈ s)
(g_inv : ∀ a ha, g (g a ha) (g_mem a ha) = a),
(∏ x in s, f x) = 1 | by haveI := classical.dec_eq α;
haveI := classical.dec_eq β; exact
finset.strong_induction_on s
(λ s ih g h g_ne g_mem g_inv,
s.eq_empty_or_nonempty.elim (λ hs, hs.symm ▸ rfl)
(λ ⟨x, hx⟩,
have hmem : ∀ y ∈ (s.erase x).erase (g x hx), y ∈ s,
from λ y hy, (mem_of_mem_erase (mem_of_mem_erase hy))... | lemma | finset.prod_involution | 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.strong_induction_on",
"ih",
"mul_one",
"not_and_distrib",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
prod_comp [decidable_eq γ] (f : γ → β) (g : α → γ) :
∏ a in s, f (g a) = ∏ b in s.image g, f b ^ (s.filter (λ a, g a = b)).card | calc ∏ a in s, f (g a)
= ∏ x in (s.image g).sigma (λ b : γ, s.filter (λ a, g a = b)), f (g x.2) :
prod_bij (λ a ha, ⟨g a, a⟩) (by simp; tauto) (λ _ _, rfl) (by simp) -- `(by finish)` closes this
(by { rintro ⟨b_fst, b_snd⟩ H,
simp only [mem_image, exists_prop, mem_filter, mem_sigma] at H,
tauto ... | lemma | finset.prod_comp | 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_prop"
] | 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`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
prod_piecewise [decidable_eq α] (s t : finset α) (f g : α → β) :
(∏ x in s, (t.piecewise f g) x) = (∏ x in s ∩ t, f x) * (∏ x in s \ t, g x) | by { rw [piecewise, prod_ite, filter_mem_eq_inter, ← sdiff_eq_filter], } | lemma | finset.prod_piecewise | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.