ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Matroid.ofBaseOfFinite_E
@[simp] theorem ofBaseOfFinite_E {E : Set α} (hE : E.Finite) Base exists_base base_exchange
    subset_ground : (Matroid.ofBaseOfFinite
      hE Base exists_base base_exchange subset_ground).E = E 
Arguments: {α : Type u_1} {E : Set α} (hE : E.Finite) (Base : Set α → Prop) (exists_base : ∃ B, Base B) (base_exchange : Matroid.ExchangeProperty Base) (subset_ground : ∀ (B : Set α), Base B → B ⊆ E)
Goal: (Matroid.ofBaseOfFinite hE Base exists_base base_exchange subset_ground).E = E
-- Matroid.ofBaseOfFinite_base
@[simp] theorem ofBaseOfFinite_base {E : Set α} (hE : E.Finite) Base exists_base
    base_exchange subset_ground : (Matroid.ofBaseOfFinite
      hE Base exists_base base_exchange subset_ground).Base = Base 
Arguments: {α : Type u_1} {E : Set α} (hE : E.Finite) (Base : Set α → Prop) (exists_base : ∃ B, Base B) (base_exchange : Matroid.ExchangeProperty Base) (subset_ground : ∀ (B : Set α), Base B → B ⊆ E)
Goal: (Matroid.ofBaseOfFinite hE Base exists_base base_exchange subset_ground).Base = Base
-- Multiset.lists_coe
@[simp]
theorem lists_coe (l : List α) : lists (l : Multiset α) = l.permutations.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: (↑l).lists = l.permutations.toFinset
-- Multiset.mem_lists_iff
@[simp]
theorem mem_lists_iff (s : Multiset α) (l : List α) : l ∈ lists s ↔ s = ⟦l⟧ 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (l : List α)
Goal: l ∈ s.lists ↔ s = ⟦l⟧
-- Fintype.sum_bool
@[to_additive]
theorem prod_bool [CommMonoid α] (f : Bool → α) : ∏ b, f b = f true * f false 
Arguments: {α : Type u_1} [AddCommMonoid α] (f : Bool → α)
Goal: ∑ b : Bool, f b = f true + f false
-- Fintype.prod_bool
@[to_additive]
theorem prod_bool [CommMonoid α] (f : Bool → α) : ∏ b, f b = f true * f false 
Arguments: {α : Type u_1} [CommMonoid α] (f : Bool → α)
Goal: ∏ b : Bool, f b = f true * f false
-- Fintype.card_eq_sum_ones
theorem card_eq_sum_ones {α} [Fintype α] : Fintype.card α = ∑ _a : α, 1 
Arguments: {α : Type u_4} [Fintype α]
Goal: Fintype.card α = ∑ _a : α, 1
-- Fintype.sum_extend_by_zero
@[to_additive]
theorem prod_extend_by_one [CommMonoid α] (s : Finset ι) (f : ι → α) :
    ∏ i, (if i ∈ s then f i else 1) = ∏ i ∈ s, f i 
Arguments: {α : Type u_1} {ι : Type u_4} [DecidableEq ι] [Fintype ι] [AddCommMonoid α] (s : Finset ι) (f : ι → α)
Goal: (∑ i : ι, if i ∈ s then f i else 0) = ∑ i ∈ s, f i
-- Fintype.prod_extend_by_one
@[to_additive]
theorem prod_extend_by_one [CommMonoid α] (s : Finset ι) (f : ι → α) :
    ∏ i, (if i ∈ s then f i else 1) = ∏ i ∈ s, f i 
Arguments: {α : Type u_1} {ι : Type u_4} [DecidableEq ι] [Fintype ι] [CommMonoid α] (s : Finset ι) (f : ι → α)
Goal: (∏ i : ι, if i ∈ s then f i else 1) = ∏ i ∈ s, f i
-- Fintype.sum_eq_zero
@[to_additive]
theorem prod_eq_one (f : α → M) (h : ∀ a, f a = 1) : ∏ a, f a = 1 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [AddCommMonoid M] (f : α → M) (h : ∀ (a : α), f a = 0)
Goal: ∑ a : α, f a = 0
-- Fintype.prod_eq_one
@[to_additive]
theorem prod_eq_one (f : α → M) (h : ∀ a, f a = 1) : ∏ a, f a = 1 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [CommMonoid M] (f : α → M) (h : ∀ (a : α), f a = 1)
Goal: ∏ a : α, f a = 1
-- Fintype.prod_congr
@[to_additive]
theorem prod_congr (f g : α → M) (h : ∀ a, f a = g a) : ∏ a, f a = ∏ a, g a 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [CommMonoid M] (f g : α → M) (h : ∀ (a : α), f a = g a)
Goal: ∏ a : α, f a = ∏ a : α, g a
-- Fintype.sum_congr
@[to_additive]
theorem prod_congr (f g : α → M) (h : ∀ a, f a = g a) : ∏ a, f a = ∏ a, g a 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [AddCommMonoid M] (f g : α → M) (h : ∀ (a : α), f a = g a)
Goal: ∑ a : α, f a = ∑ a : α, g a
-- Fintype.sum_eq_single
@[to_additive]
theorem prod_eq_single {f : α → M} (a : α) (h : ∀ x ≠ a, f x = 1) : ∏ x, f x = f a 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [AddCommMonoid M] {f : α → M} (a : α) (h : ∀ (x : α), x ≠ a → f x = 0)
Goal: ∑ x : α, f x = f a
-- Fintype.prod_eq_single
@[to_additive]
theorem prod_eq_single {f : α → M} (a : α) (h : ∀ x ≠ a, f x = 1) : ∏ x, f x = f a 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [CommMonoid M] {f : α → M} (a : α) (h : ∀ (x : α), x ≠ a → f x = 1)
Goal: ∏ x : α, f x = f a
-- Fintype.sum_eq_add
@[to_additive]
theorem prod_eq_mul {f : α → M} (a b : α) (h₁ : a ≠ b) (h₂ : ∀ x, x ≠ a ∧ x ≠ b → f x = 1) :
    ∏ x, f x = f a * f b 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [AddCommMonoid M] {f : α → M} (a b : α) (h₁ : a ≠ b) (h₂ : ∀ (x : α), x ≠ a ∧ x ≠ b → f x = 0)
Goal: ∑ x : α, f x = f a + f b
-- Fintype.prod_eq_mul
@[to_additive]
theorem prod_eq_mul {f : α → M} (a b : α) (h₁ : a ≠ b) (h₂ : ∀ x, x ≠ a ∧ x ≠ b → f x = 1) :
    ∏ x, f x = f a * f b 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [CommMonoid M] {f : α → M} (a b : α) (h₁ : a ≠ b) (h₂ : ∀ (x : α), x ≠ a ∧ x ≠ b → f x = 1)
Goal: ∏ x : α, f x = f a * f b
-- Fintype.eq_of_subsingleton_of_sum_eq
@[to_additive "If a sum of a `Finset` of a subsingleton type has a given
  value, so do the terms in that sum."]
theorem eq_of_subsingleton_of_prod_eq {ι : Type*} [Subsingleton ι] {s : Finset ι} {f : ι → M}
    {b : M} (h : ∏ i ∈ s, f i = b) : ∀ i ∈ s, f i = b 
Arguments: {M : Type u_4} [AddCommMonoid M] {ι : Type u_5} [Subsingleton ι] {s : Finset ι} {f : ι → M} {b : M} (h : ∑ i ∈ s, f i = b) (i : ι)
Goal: i ∈ s → f i = b
-- Fintype.eq_of_subsingleton_of_prod_eq
@[to_additive "If a sum of a `Finset` of a subsingleton type has a given
  value, so do the terms in that sum."]
theorem eq_of_subsingleton_of_prod_eq {ι : Type*} [Subsingleton ι] {s : Finset ι} {f : ι → M}
    {b : M} (h : ∏ i ∈ s, f i = b) : ∀ i ∈ s, f i = b 
Arguments: {M : Type u_4} [CommMonoid M] {ι : Type u_5} [Subsingleton ι] {s : Finset ι} {f : ι → M} {b : M} (h : ∏ i ∈ s, f i = b) (i : ι)
Goal: i ∈ s → f i = b
-- Fintype.sum_option
@[to_additive (attr := simp)]
theorem Fintype.prod_option (f : Option α → M) : ∏ i, f i = f none * ∏ i, f (some i) 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [AddCommMonoid M] (f : Option α → M)
Goal: ∑ i : Option α, f i = f none + ∑ i : α, f (some i)
-- Fintype.prod_option
@[to_additive (attr := simp)]
theorem Fintype.prod_option (f : Option α → M) : ∏ i, f i = f none * ∏ i, f (some i) 
Arguments: {α : Type u_1} {M : Type u_4} [Fintype α] [CommMonoid M] (f : Option α → M)
Goal: ∏ i : Option α, f i = f none * ∏ i : α, f (some i)
-- Finset.card_pi
@[simp] lemma Finset.card_pi (s : Finset ι) (t : ∀ i, Finset (α i)) :
    (s.pi t).card = ∏ i ∈ s, card (t i) 
Arguments: {ι : Type u_4} {α : ι → Type u_6} [DecidableEq ι] (s : Finset ι) (t : (i : ι) → Finset (α i))
Goal: (s.pi t).card = ∏ i ∈ s, (t i).card
-- Fintype.card_piFinset
@[simp] lemma card_piFinset (s : ∀ i, Finset (α i)) :
    (piFinset s).card = ∏ i, (s i).card 
Arguments: {ι : Type u_4} {α : ι → Type u_6} [DecidableEq ι] [Fintype ι] (s : (i : ι) → Finset (α i))
Goal: (Fintype.piFinset s).card = ∏ i : ι, (s i).card
-- Fintype.card_piFinset_const
lemma card_piFinset_const {α : Type*} (s : Finset α) (n : ℕ) :
    (piFinset fun _ : Fin n ↦ s).card = s.card ^ n 
Arguments: {α : Type u_7} (s : Finset α) (n : ℕ)
Goal: (Fintype.piFinset fun x => s).card = s.card ^ n
-- Fintype.card_pi
@[simp] lemma card_pi [DecidableEq ι] [∀ i, Fintype (α i)] : card (∀ i, α i) = ∏ i, card (α i) 
Arguments: {ι : Type u_4} {α : ι → Type u_6} [Fintype ι] [DecidableEq ι] [(i : ι) → Fintype (α i)]
Goal: Fintype.card ((i : ι) → α i) = ∏ i : ι, Fintype.card (α i)
-- Fintype.card_pi_const
lemma card_pi_const (α : Type*) [Fintype α] (n : ℕ) : card (Fin n → α) = card α ^ n 
Arguments: (α : Type u_7) [Fintype α] (n : ℕ)
Goal: Fintype.card (Fin n → α) = Fintype.card α ^ n
-- Fintype.card_sigma
@[simp] nonrec lemma card_sigma [Fintype ι] [∀ i, Fintype (α i)] :
    card (Sigma α) = ∑ i, card (α i) 
Arguments: {ι : Type u_4} {α : ι → Type u_6} [Fintype ι] [(i : ι) → Fintype (α i)]
Goal: Fintype.card (Sigma α) = ∑ i : ι, Fintype.card (α i)
-- Fintype.card_filter_piFinset_eq_of_mem
lemma card_filter_piFinset_eq_of_mem (s : ∀ i, Finset (α i)) (i : ι) {a : α i} (ha : a ∈ s i) :
    ((piFinset s).filter fun f ↦ f i = a).card = ∏ j ∈ univ.erase i, (s j).card 
Arguments: {ι : Type u_4} {α : ι → Type u_6} [DecidableEq ι] [Fintype ι] [(i : ι) → DecidableEq (α i)] (s : (i : ι) → Finset (α i)) (i : ι) {a : α i} (ha : a ∈ s i)
Goal: (Finset.filter (fun f => f i = a) (Fintype.piFinset s)).card = ∏ j ∈ Finset.univ.erase i, (s j).card
-- Fintype.card_filter_piFinset_const_eq_of_mem
lemma card_filter_piFinset_const_eq_of_mem (s : Finset κ) (i : ι) {x : κ} (hx : x ∈ s) :
    ((piFinset fun _ ↦ s).filter fun f ↦ f i = x).card = s.card ^ (card ι - 1) 
Arguments: {ι : Type u_4} {κ : Type u_5} [DecidableEq ι] [DecidableEq κ] [Fintype ι] (s : Finset κ) (i : ι) {x : κ} (hx : x ∈ s)
Goal: (Finset.filter (fun f => f i = x) (Fintype.piFinset fun x => s)).card = s.card ^ (Fintype.card ι - 1)
-- Fintype.card_filter_piFinset_eq
lemma card_filter_piFinset_eq (s : ∀ i, Finset (α i)) (i : ι) (a : α i) :
    ((piFinset s).filter fun f ↦ f i = a).card =
      if a ∈ s i then ∏ b ∈ univ.erase i, (s b).card else 0 
Arguments: {ι : Type u_4} {α : ι → Type u_6} [DecidableEq ι] [Fintype ι] [(i : ι) → DecidableEq (α i)] (s : (i : ι) → Finset (α i)) (i : ι) (a : α i)
Goal: (Finset.filter (fun f => f i = a) (Fintype.piFinset s)).card =
  if a ∈ s i then ∏ b ∈ Finset.univ.erase i, (s b).card else 0
-- Fintype.card_filter_piFinset_const
lemma card_filter_piFinset_const (s : Finset κ) (i : ι) (j : κ) :
    ((piFinset fun _ ↦ s).filter fun f ↦ f i = j).card =
      if j ∈ s then s.card ^ (card ι - 1) else 0 
Arguments: {ι : Type u_4} {κ : Type u_5} [DecidableEq ι] [DecidableEq κ] [Fintype ι] (s : Finset κ) (i : ι) (j : κ)
Goal: (Finset.filter (fun f => f i = j) (Fintype.piFinset fun x => s)).card =
  if j ∈ s then s.card ^ (Fintype.card ι - 1) else 0
-- Fintype.card_fun
theorem Fintype.card_fun [DecidableEq α] [Fintype α] [Fintype β] :
    Fintype.card (α → β) = Fintype.card β ^ Fintype.card α 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [Fintype α] [Fintype β]
Goal: Fintype.card (α → β) = Fintype.card β ^ Fintype.card α
-- card_vector
@[simp]
theorem card_vector [Fintype α] (n : ℕ) : Fintype.card (Vector α n) = Fintype.card α ^ n 
Arguments: {α : Type u_1} [Fintype α] (n : ℕ)
Goal: Fintype.card (Mathlib.Vector α n) = Fintype.card α ^ n
-- Fin.sum_univ_eq_sum_range
@[to_additive "It is equivalent to sum a function over `fin n` or `finset.range n`."]
theorem Fin.prod_univ_eq_prod_range [CommMonoid α] (f : ℕ → α) (n : ℕ) :
    ∏ i : Fin n, f i = ∏ i ∈ range n, f i 
Arguments: {α : Type u_1} [AddCommMonoid α] (f : ℕ → α) (n : ℕ)
Goal: ∑ i : Fin n, f ↑i = ∑ i ∈ Finset.range n, f i
-- Fin.prod_univ_eq_prod_range
@[to_additive "It is equivalent to sum a function over `fin n` or `finset.range n`."]
theorem Fin.prod_univ_eq_prod_range [CommMonoid α] (f : ℕ → α) (n : ℕ) :
    ∏ i : Fin n, f i = ∏ i ∈ range n, f i 
Arguments: {α : Type u_1} [CommMonoid α] (f : ℕ → α) (n : ℕ)
Goal: ∏ i : Fin n, f ↑i = ∏ i ∈ Finset.range n, f i
-- Finset.sum_fin_eq_sum_range
@[to_additive]
theorem Finset.prod_fin_eq_prod_range [CommMonoid β] {n : ℕ} (c : Fin n → β) :
    ∏ i, c i = ∏ i ∈ Finset.range n, if h : i < n then c ⟨i, h⟩ else 1 
Arguments: {β : Type u_2} [AddCommMonoid β] {n : ℕ} (c : Fin n → β)
Goal: ∑ i : Fin n, c i = ∑ i ∈ Finset.range n, if h : i < n then c ⟨i, h⟩ else 0
-- Finset.prod_fin_eq_prod_range
@[to_additive]
theorem Finset.prod_fin_eq_prod_range [CommMonoid β] {n : ℕ} (c : Fin n → β) :
    ∏ i, c i = ∏ i ∈ Finset.range n, if h : i < n then c ⟨i, h⟩ else 1 
Arguments: {β : Type u_2} [CommMonoid β] {n : ℕ} (c : Fin n → β)
Goal: ∏ i : Fin n, c i = ∏ i ∈ Finset.range n, if h : i < n then c ⟨i, h⟩ else 1
-- Finset.prod_toFinset_eq_subtype
@[to_additive]
theorem Finset.prod_toFinset_eq_subtype {M : Type*} [CommMonoid M] [Fintype α] (p : α → Prop)
    [DecidablePred p] (f : α → M) : ∏ a ∈ { x | p x }.toFinset, f a = ∏ a : Subtype p, f a 
Arguments: {α : Type u_1} {M : Type u_4} [CommMonoid M] [Fintype α] (p : α → Prop) [DecidablePred p] (f : α → M)
Goal: ∏ a ∈ {x | p x}.toFinset, f a = ∏ a : Subtype p, f ↑a
-- Finset.sum_toFinset_eq_subtype
@[to_additive]
theorem Finset.prod_toFinset_eq_subtype {M : Type*} [CommMonoid M] [Fintype α] (p : α → Prop)
    [DecidablePred p] (f : α → M) : ∏ a ∈ { x | p x }.toFinset, f a = ∏ a : Subtype p, f a 
Arguments: {α : Type u_1} {M : Type u_4} [AddCommMonoid M] [Fintype α] (p : α → Prop) [DecidablePred p] (f : α → M)
Goal: ∑ a ∈ {x | p x}.toFinset, f a = ∑ a : Subtype p, f ↑a
-- Fintype.prod_dite
nonrec theorem Fintype.prod_dite [Fintype α] {p : α → Prop} [DecidablePred p] [CommMonoid β]
    (f : ∀ a, p a → β) (g : ∀ a, ¬p a → β) :
    (∏ a, dite (p a) (f a) (g a)) =
    (∏ a : { a // p a }, f a a.2) * ∏ a : { a // ¬p a }, g a a.2 
Arguments: {α : Type u_1} {β : Type u_2} [Fintype α] {p : α → Prop} [DecidablePred p] [CommMonoid β] (f : (a : α) → p a → β) (g : (a : α) → ¬p a → β)
Goal: ∏ a : α, dite (p a) (f a) (g a) = (∏ a : { a // p a }, f ↑a ⋯) * ∏ a : { a // ¬p a }, g ↑a ⋯
-- Fintype.prod_sum_elim
@[to_additive]
theorem Fintype.prod_sum_elim (f : α₁ → M) (g : α₂ → M) :
    ∏ x, Sum.elim f g x = (∏ a₁, f a₁) * ∏ a₂, g a₂ 
Arguments: {α₁ : Type u_4} {α₂ : Type u_5} {M : Type u_6} [Fintype α₁] [Fintype α₂] [CommMonoid M] (f : α₁ → M) (g : α₂ → M)
Goal: ∏ x : α₁ ⊕ α₂, Sum.elim f g x = (∏ a₁ : α₁, f a₁) * ∏ a₂ : α₂, g a₂
-- Fintype.sum_sum_elim
@[to_additive]
theorem Fintype.prod_sum_elim (f : α₁ → M) (g : α₂ → M) :
    ∏ x, Sum.elim f g x = (∏ a₁, f a₁) * ∏ a₂, g a₂ 
Arguments: {α₁ : Type u_4} {α₂ : Type u_5} {M : Type u_6} [Fintype α₁] [Fintype α₂] [AddCommMonoid M] (f : α₁ → M) (g : α₂ → M)
Goal: ∑ x : α₁ ⊕ α₂, Sum.elim f g x = ∑ a₁ : α₁, f a₁ + ∑ a₂ : α₂, g a₂
-- Fintype.prod_sum_type
@[to_additive (attr := simp)]
theorem Fintype.prod_sum_type (f : α₁ ⊕ α₂ → M) :
    ∏ x, f x = (∏ a₁, f (Sum.inl a₁)) * ∏ a₂, f (Sum.inr a₂) 
Arguments: {α₁ : Type u_4} {α₂ : Type u_5} {M : Type u_6} [Fintype α₁] [Fintype α₂] [CommMonoid M] (f : α₁ ⊕ α₂ → M)
Goal: ∏ x : α₁ ⊕ α₂, f x = (∏ a₁ : α₁, f (Sum.inl a₁)) * ∏ a₂ : α₂, f (Sum.inr a₂)
-- Fintype.sum_sum_type
@[to_additive (attr := simp)]
theorem Fintype.prod_sum_type (f : α₁ ⊕ α₂ → M) :
    ∏ x, f x = (∏ a₁, f (Sum.inl a₁)) * ∏ a₂, f (Sum.inr a₂) 
Arguments: {α₁ : Type u_4} {α₂ : Type u_5} {M : Type u_6} [Fintype α₁] [Fintype α₂] [AddCommMonoid M] (f : α₁ ⊕ α₂ → M)
Goal: ∑ x : α₁ ⊕ α₂, f x = ∑ a₁ : α₁, f (Sum.inl a₁) + ∑ a₂ : α₂, f (Sum.inr a₂)
-- Fintype.prod_prod_type
@[to_additive (attr := simp) Fintype.sum_prod_type]
theorem Fintype.prod_prod_type [CommMonoid γ] {f : α₁ × α₂ → γ} :
    ∏ x, f x = ∏ x, ∏ y, f (x, y) 
Arguments: {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [Fintype α₁] [Fintype α₂] [CommMonoid γ] {f : α₁ × α₂ → γ}
Goal: ∏ x : α₁ × α₂, f x = ∏ x : α₁, ∏ y : α₂, f (x, y)
-- Fintype.sum_prod_type
@[to_additive (attr := simp) Fintype.sum_prod_type]
theorem Fintype.prod_prod_type [CommMonoid γ] {f : α₁ × α₂ → γ} :
    ∏ x, f x = ∏ x, ∏ y, f (x, y) 
Arguments: {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [Fintype α₁] [Fintype α₂] [AddCommMonoid γ] {f : α₁ × α₂ → γ}
Goal: ∑ x : α₁ × α₂, f x = ∑ x : α₁, ∑ y : α₂, f (x, y)
-- Fintype.sum_prod_type'
@[to_additive Fintype.sum_prod_type' "An uncurried version of `Finset.sum_prod_type`"]
theorem Fintype.prod_prod_type' [CommMonoid γ] {f : α₁ → α₂ → γ} :
    ∏ x : α₁ × α₂, f x.1 x.2 = ∏ x, ∏ y, f x y 
Arguments: {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [Fintype α₁] [Fintype α₂] [AddCommMonoid γ] {f : α₁ → α₂ → γ}
Goal: ∑ x : α₁ × α₂, f x.1 x.2 = ∑ x : α₁, ∑ y : α₂, f x y
-- Fintype.prod_prod_type'
@[to_additive Fintype.sum_prod_type' "An uncurried version of `Finset.sum_prod_type`"]
theorem Fintype.prod_prod_type' [CommMonoid γ] {f : α₁ → α₂ → γ} :
    ∏ x : α₁ × α₂, f x.1 x.2 = ∏ x, ∏ y, f x y 
Arguments: {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [Fintype α₁] [Fintype α₂] [CommMonoid γ] {f : α₁ → α₂ → γ}
Goal: ∏ x : α₁ × α₂, f x.1 x.2 = ∏ x : α₁, ∏ y : α₂, f x y
-- Fintype.prod_prod_type_right
@[to_additive Fintype.sum_prod_type_right]
theorem Fintype.prod_prod_type_right [CommMonoid γ] {f : α₁ × α₂ → γ} :
    ∏ x, f x = ∏ y, ∏ x, f (x, y) 
Arguments: {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [Fintype α₁] [Fintype α₂] [CommMonoid γ] {f : α₁ × α₂ → γ}
Goal: ∏ x : α₁ × α₂, f x = ∏ y : α₂, ∏ x : α₁, f (x, y)
-- Fintype.sum_prod_type_right
@[to_additive Fintype.sum_prod_type_right]
theorem Fintype.prod_prod_type_right [CommMonoid γ] {f : α₁ × α₂ → γ} :
    ∏ x, f x = ∏ y, ∏ x, f (x, y) 
Arguments: {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [Fintype α₁] [Fintype α₂] [AddCommMonoid γ] {f : α₁ × α₂ → γ}
Goal: ∑ x : α₁ × α₂, f x = ∑ y : α₂, ∑ x : α₁, f (x, y)
-- Fintype.prod_prod_type_right'
@[to_additive Fintype.sum_prod_type_right' "An uncurried version of `Finset.sum_prod_type_right`"]
theorem Fintype.prod_prod_type_right' [CommMonoid γ] {f : α₁ → α₂ → γ} :
    ∏ x : α₁ × α₂, f x.1 x.2 = ∏ y, ∏ x, f x y 
Arguments: {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [Fintype α₁] [Fintype α₂] [CommMonoid γ] {f : α₁ → α₂ → γ}
Goal: ∏ x : α₁ × α₂, f x.1 x.2 = ∏ y : α₂, ∏ x : α₁, f x y
-- Fintype.sum_prod_type_right'
@[to_additive Fintype.sum_prod_type_right' "An uncurried version of `Finset.sum_prod_type_right`"]
theorem Fintype.prod_prod_type_right' [CommMonoid γ] {f : α₁ → α₂ → γ} :
    ∏ x : α₁ × α₂, f x.1 x.2 = ∏ y, ∏ x, f x y 
Arguments: {γ : Type u_3} {α₁ : Type u_4} {α₂ : Type u_5} [Fintype α₁] [Fintype α₂] [AddCommMonoid γ] {f : α₁ → α₂ → γ}
Goal: ∑ x : α₁ × α₂, f x.1 x.2 = ∑ y : α₂, ∑ x : α₁, f x y
-- finSumEquivOfFinset_inl
@[simp]
theorem finSumEquivOfFinset_inl (hm : s.card = m) (hn : sᶜ.card = n) (i : Fin m) :
    finSumEquivOfFinset hm hn (Sum.inl i) = s.orderEmbOfFin hm i 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] [LinearOrder α] {m n : ℕ} {s : Finset α} (hm : s.card = m) (hn : sᶜ.card = n) (i : Fin m)
Goal: (finSumEquivOfFinset hm hn) (Sum.inl i) = (s.orderEmbOfFin hm) i
-- finSumEquivOfFinset_inr
@[simp]
theorem finSumEquivOfFinset_inr (hm : s.card = m) (hn : sᶜ.card = n) (i : Fin n) :
    finSumEquivOfFinset hm hn (Sum.inr i) = sᶜ.orderEmbOfFin hn i 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] [LinearOrder α] {m n : ℕ} {s : Finset α} (hm : s.card = m) (hn : sᶜ.card = n) (i : Fin n)
Goal: (finSumEquivOfFinset hm hn) (Sum.inr i) = (sᶜ.orderEmbOfFin hn) i
-- List.count_not_add_count
@[simp]
theorem count_not_add_count (l : List Bool) (b : Bool) : count (!b) l + count b l = length l 
Arguments: (l : List Bool) (b : Bool)
Goal: List.count (!b) l + List.count b l = l.length
-- List.count_add_count_not
@[simp]
theorem count_add_count_not (l : List Bool) (b : Bool) : count b l + count (!b) l = length l 
Arguments: (l : List Bool) (b : Bool)
Goal: List.count b l + List.count (!b) l = l.length
-- List.count_false_add_count_true
@[simp]
theorem count_false_add_count_true (l : List Bool) : count false l + count true l = length l 
Arguments: (l : List Bool)
Goal: List.count false l + List.count true l = l.length
-- List.count_true_add_count_false
@[simp]
theorem count_true_add_count_false (l : List Bool) : count true l + count false l = length l 
Arguments: (l : List Bool)
Goal: List.count true l + List.count false l = l.length
-- List.Chain.count_not
theorem Chain.count_not :
    ∀ {b : Bool} {l : List Bool}, Chain (· ≠ ·) b l → count (!b) l = count b l + length l % 2
  
Arguments: {b : Bool} {l : List Bool}
Goal: List.Chain (fun x x_1 => x ≠ x_1) b l → List.count (!b) l = List.count b l + l.length % 2
-- List.Chain'.count_not_eq_count
theorem count_not_eq_count (hl : Chain' (· ≠ ·) l) (h2 : Even (length l)) (b : Bool) :
    count (!b) l = count b l 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l) (h2 : Even l.length) (b : Bool)
Goal: List.count (!b) l = List.count b l
-- List.Chain'.count_false_eq_count_true
theorem count_false_eq_count_true (hl : Chain' (· ≠ ·) l) (h2 : Even (length l)) :
    count false l = count true l 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l) (h2 : Even l.length)
Goal: List.count false l = List.count true l
-- List.Chain'.count_not_le_count_add_one
theorem count_not_le_count_add_one (hl : Chain' (· ≠ ·) l) (b : Bool) :
    count (!b) l ≤ count b l + 1 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l) (b : Bool)
Goal: List.count (!b) l ≤ List.count b l + 1
-- List.Chain'.count_false_le_count_true_add_one
theorem count_false_le_count_true_add_one (hl : Chain' (· ≠ ·) l) :
    count false l ≤ count true l + 1 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l)
Goal: List.count false l ≤ List.count true l + 1
-- List.Chain'.count_true_le_count_false_add_one
theorem count_true_le_count_false_add_one (hl : Chain' (· ≠ ·) l) :
    count true l ≤ count false l + 1 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l)
Goal: List.count true l ≤ List.count false l + 1
-- List.Chain'.two_mul_count_bool_of_even
theorem two_mul_count_bool_of_even (hl : Chain' (· ≠ ·) l) (h2 : Even (length l)) (b : Bool) :
    2 * count b l = length l 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l) (h2 : Even l.length) (b : Bool)
Goal: 2 * List.count b l = l.length
-- List.Chain'.two_mul_count_bool_eq_ite
theorem two_mul_count_bool_eq_ite (hl : Chain' (· ≠ ·) l) (b : Bool) :
    2 * count b l =
      if Even (length l) then length l else
      if Option.some b == l.head? then length l + 1 else length l - 1 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l) (b : Bool)
Goal: 2 * List.count b l =
  if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1
-- List.Chain'.length_sub_one_le_two_mul_count_bool
theorem length_sub_one_le_two_mul_count_bool (hl : Chain' (· ≠ ·) l) (b : Bool) :
    length l - 1 ≤ 2 * count b l 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l) (b : Bool)
Goal: l.length - 1 ≤ 2 * List.count b l
-- List.Chain'.length_div_two_le_count_bool
theorem length_div_two_le_count_bool (hl : Chain' (· ≠ ·) l) (b : Bool) :
    length l / 2 ≤ count b l 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l) (b : Bool)
Goal: l.length / 2 ≤ List.count b l
-- List.Chain'.two_mul_count_bool_le_length_add_one
theorem two_mul_count_bool_le_length_add_one (hl : Chain' (· ≠ ·) l) (b : Bool) :
    2 * count b l ≤ length l + 1 
Arguments: {l : List Bool} (hl : List.Chain' (fun x x_1 => x ≠ x_1) l) (b : Bool)
Goal: 2 * List.count b l ≤ l.length + 1
-- Fintype.card_finset
@[simp]
theorem Fintype.card_finset [Fintype α] : Fintype.card (Finset α) = 2 ^ Fintype.card α 
Arguments: {α : Type u_1} [Fintype α]
Goal: Fintype.card (Finset α) = 2 ^ Fintype.card α
-- Finset.powerset_univ
@[simp] lemma powerset_univ : (univ : Finset α).powerset = univ 
Arguments: {α : Type u_1} [Fintype α]
Goal: Finset.univ.powerset = Finset.univ
-- Finset.filter_subset_univ
lemma filter_subset_univ [DecidableEq α] (s : Finset α) :
    filter (fun t ↦ t ⊆ s) univ = powerset s 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: Finset.filter (fun t => t ⊆ s) Finset.univ = s.powerset
-- Finset.powerset_eq_univ
@[simp] lemma powerset_eq_univ : s.powerset = univ ↔ s = univ 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α}
Goal: s.powerset = Finset.univ ↔ s = Finset.univ
-- Finset.mem_powersetCard_univ
lemma mem_powersetCard_univ : s ∈ powersetCard k (univ : Finset α) ↔ card s = k 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} {k : ℕ}
Goal: s ∈ Finset.powersetCard k Finset.univ ↔ s.card = k
-- Finset.univ_filter_card_eq
@[simp] lemma univ_filter_card_eq (k : ℕ) :
    (univ : Finset (Finset α)).filter (fun s ↦ s.card = k) = univ.powersetCard k 
Arguments: (α : Type u_1) [Fintype α] (k : ℕ)
Goal: Finset.filter (fun s => s.card = k) Finset.univ = Finset.powersetCard k Finset.univ
-- Fintype.card_finset_len
@[simp]
theorem Fintype.card_finset_len [Fintype α] (k : ℕ) :
    Fintype.card { s : Finset α // s.card = k } = Nat.choose (Fintype.card α) k 
Arguments: {α : Type u_1} [Fintype α] (k : ℕ)
Goal: Fintype.card { s // s.card = k } = (Fintype.card α).choose k
-- Fintype.card_set
@[simp]
theorem Fintype.card_set [Fintype α] : Fintype.card (Set α) = 2 ^ Fintype.card α 
Arguments: {α : Type u_1} [Fintype α]
Goal: Fintype.card (Set α) = 2 ^ Fintype.card α