ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Multiset.mem_of_mem_toEnumFinset
theorem Multiset.mem_of_mem_toEnumFinset {p : α × ℕ} (h : p ∈ m.toEnumFinset) : p.1 ∈ m 
Arguments: {α : Type u_1} [DecidableEq α] {m : Multiset α} {p : α × ℕ} (h : p ∈ m.toEnumFinset)
Goal: p.1 ∈ m
-- Multiset.toEnumFinset_filter_eq
@[simp] lemma toEnumFinset_filter_eq (m : Multiset α) (a : α) :
    m.toEnumFinset.filter (·.1 = a) = {a} ×ˢ Finset.range (m.count a) 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α) (a : α)
Goal: Finset.filter (fun x => x.1 = a) m.toEnumFinset = {a} ×ˢ Finset.range (Multiset.count a m)
-- Multiset.map_toEnumFinset_fst
@[simp] lemma map_toEnumFinset_fst (m : Multiset α) : m.toEnumFinset.val.map Prod.fst = m 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: Multiset.map Prod.fst m.toEnumFinset.val = m
-- Multiset.image_toEnumFinset_fst
@[simp] lemma image_toEnumFinset_fst (m : Multiset α) :
    m.toEnumFinset.image Prod.fst = m.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: Finset.image Prod.fst m.toEnumFinset = m.toFinset
-- Multiset.map_fst_le_of_subset_toEnumFinset
@[simp] lemma map_fst_le_of_subset_toEnumFinset {s : Finset (α × ℕ)} (hsm : s ⊆ m.toEnumFinset) :
    s.1.map Prod.fst ≤ m 
Arguments: {α : Type u_1} [DecidableEq α] {m : Multiset α} {s : Finset (α × ℕ)} (hsm : s ⊆ m.toEnumFinset)
Goal: Multiset.map Prod.fst s.val ≤ m
-- Multiset.toEnumFinset_mono
@[mono]
theorem Multiset.toEnumFinset_mono {m₁ m₂ : Multiset α} (h : m₁ ≤ m₂) :
    m₁.toEnumFinset ⊆ m₂.toEnumFinset 
Arguments: {α : Type u_1} [DecidableEq α] {m₁ m₂ : Multiset α} (h : m₁ ≤ m₂)
Goal: m₁.toEnumFinset ⊆ m₂.toEnumFinset
-- Multiset.toEnumFinset_subset_iff
@[simp]
theorem Multiset.toEnumFinset_subset_iff {m₁ m₂ : Multiset α} :
    m₁.toEnumFinset ⊆ m₂.toEnumFinset ↔ m₁ ≤ m₂ 
Arguments: {α : Type u_1} [DecidableEq α] {m₁ m₂ : Multiset α}
Goal: m₁.toEnumFinset ⊆ m₂.toEnumFinset ↔ m₁ ≤ m₂
-- Multiset.coeEmbedding_apply
@[simps]
def Multiset.coeEmbedding (m : Multiset α) : m ↪ α × ℕ 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α) (x : m.ToType)
Goal: m.coeEmbedding x = (x.fst, ↑x.snd)
-- Multiset.coeEquiv_symm_apply_snd_val
@[simps]
def Multiset.coeEquiv (m : Multiset α) : m ≃ m.toEnumFinset 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α) (x : { x // x ∈ m.toEnumFinset })
Goal: ↑(m.coeEquiv.symm x).snd = (↑x).2
-- Multiset.coeEquiv_apply_coe
@[simps]
def Multiset.coeEquiv (m : Multiset α) : m ≃ m.toEnumFinset 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α) (x : m.ToType)
Goal: ↑(m.coeEquiv x) = m.coeEmbedding x
-- Multiset.coeEquiv_symm_apply_fst
@[simps]
def Multiset.coeEquiv (m : Multiset α) : m ≃ m.toEnumFinset 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α) (x : { x // x ∈ m.toEnumFinset })
Goal: (m.coeEquiv.symm x).fst = (↑x).1
-- Multiset.toEmbedding_coeEquiv_trans
@[simp]
theorem Multiset.toEmbedding_coeEquiv_trans (m : Multiset α) :
    m.coeEquiv.toEmbedding.trans (Function.Embedding.subtype _) = m.coeEmbedding 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: m.coeEquiv.toEmbedding.trans (Function.Embedding.subtype fun x => x ∈ m.toEnumFinset) = m.coeEmbedding
-- Multiset.map_univ_coeEmbedding
theorem Multiset.map_univ_coeEmbedding (m : Multiset α) :
    (Finset.univ : Finset m).map m.coeEmbedding = m.toEnumFinset 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: Finset.map m.coeEmbedding Finset.univ = m.toEnumFinset
-- Multiset.map_univ_coe
@[simp]
theorem Multiset.map_univ_coe (m : Multiset α) :
    (Finset.univ : Finset m).val.map (fun x : m ↦ (x : α)) = m 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: Multiset.map (fun x => x.fst) Finset.univ.val = m
-- Multiset.map_univ
@[simp]
theorem Multiset.map_univ {β : Type*} (m : Multiset α) (f : α → β) :
    ((Finset.univ : Finset m).val.map fun (x : m) ↦ f (x : α)) = m.map f 
Arguments: {α : Type u_1} [DecidableEq α] {β : Type u_2} (m : Multiset α) (f : α → β)
Goal: Multiset.map (fun x => f x.fst) Finset.univ.val = Multiset.map f m
-- Multiset.card_toEnumFinset
@[simp]
theorem Multiset.card_toEnumFinset (m : Multiset α) : m.toEnumFinset.card = Multiset.card m 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: m.toEnumFinset.card = Multiset.card m
-- Multiset.card_coe
@[simp]
theorem Multiset.card_coe (m : Multiset α) : Fintype.card m = Multiset.card m 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: Fintype.card m.ToType = Multiset.card m
-- Multiset.prod_eq_prod_coe
@[to_additive]
theorem Multiset.prod_eq_prod_coe [CommMonoid α] (m : Multiset α) : m.prod = ∏ x : m, (x : α) 
Arguments: {α : Type u_1} [DecidableEq α] [CommMonoid α] (m : Multiset α)
Goal: m.prod = ∏ x : m.ToType, x.fst
-- Multiset.sum_eq_sum_coe
@[to_additive]
theorem Multiset.prod_eq_prod_coe [CommMonoid α] (m : Multiset α) : m.prod = ∏ x : m, (x : α) 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommMonoid α] (m : Multiset α)
Goal: m.sum = ∑ x : m.ToType, x.fst
-- Multiset.sum_eq_sum_toEnumFinset
@[to_additive]
theorem Multiset.prod_eq_prod_toEnumFinset [CommMonoid α] (m : Multiset α) :
    m.prod = ∏ x ∈ m.toEnumFinset, x.1 
Arguments: {α : Type u_1} [DecidableEq α] [AddCommMonoid α] (m : Multiset α)
Goal: m.sum = ∑ x ∈ m.toEnumFinset, x.1
-- Multiset.prod_eq_prod_toEnumFinset
@[to_additive]
theorem Multiset.prod_eq_prod_toEnumFinset [CommMonoid α] (m : Multiset α) :
    m.prod = ∏ x ∈ m.toEnumFinset, x.1 
Arguments: {α : Type u_1} [DecidableEq α] [CommMonoid α] (m : Multiset α)
Goal: m.prod = ∏ x ∈ m.toEnumFinset, x.1
-- Multiset.prod_toEnumFinset
@[to_additive]
theorem Multiset.prod_toEnumFinset {β : Type*} [CommMonoid β] (m : Multiset α) (f : α → ℕ → β) :
    ∏ x ∈ m.toEnumFinset, f x.1 x.2 = ∏ x : m, f x x.2 
Arguments: {α : Type u_1} [DecidableEq α] {β : Type u_2} [CommMonoid β] (m : Multiset α) (f : α → ℕ → β)
Goal: ∏ x ∈ m.toEnumFinset, f x.1 x.2 = ∏ x : m.ToType, f x.fst ↑x.snd
-- Multiset.sum_toEnumFinset
@[to_additive]
theorem Multiset.prod_toEnumFinset {β : Type*} [CommMonoid β] (m : Multiset α) (f : α → ℕ → β) :
    ∏ x ∈ m.toEnumFinset, f x.1 x.2 = ∏ x : m, f x x.2 
Arguments: {α : Type u_1} [DecidableEq α] {β : Type u_2} [AddCommMonoid β] (m : Multiset α) (f : α → ℕ → β)
Goal: ∑ x ∈ m.toEnumFinset, f x.1 x.2 = ∑ x : m.ToType, f x.fst ↑x.snd
-- Multiset.fmap_def
@[simp]
theorem fmap_def {α' β'} {s : Multiset α'} (f : α' → β') : f <$> s = s.map f 
Arguments: {α' β' : Type u_1} {s : Multiset α'} (f : α' → β')
Goal: f <$> s = Multiset.map f s
-- Multiset.pure_def
@[simp]
theorem pure_def {α} : (pure : α → Multiset α) = singleton 
Arguments: {α : Type u_1}
Goal: pure = singleton
-- Multiset.bind_def
@[simp]
theorem bind_def {α β} : (· >>= ·) = @bind α β 
Arguments: {α β : Type u_1}
Goal: (fun x x_1 => x >>= x_1) = Multiset.bind
-- Multiset.map_comp_coe
@[simp]
theorem map_comp_coe {α β} (h : α → β) :
    Functor.map h ∘ Coe.coe = (Coe.coe ∘ Functor.map h : List α → Multiset β) 
Arguments: {α β : Type u_1} (h : α → β)
Goal: Functor.map h ∘ Coe.coe = Coe.coe ∘ Functor.map h
-- Multiset.id_traverse
theorem id_traverse {α : Type*} (x : Multiset α) : traverse (pure : α → Id α) x = x 
Arguments: {α : Type u_1} (x : Multiset α)
Goal: Multiset.traverse pure x = x
-- Multiset.comp_traverse
theorem comp_traverse {G H : Type _ → Type _} [Applicative G] [Applicative H] [CommApplicative G]
    [CommApplicative H] {α β γ : Type _} (g : α → G β) (h : β → H γ) (x : Multiset α) :
    traverse (Comp.mk ∘ Functor.map h ∘ g) x =
    Comp.mk (Functor.map (traverse h) (traverse g x)) 
Arguments: {G H : Type u_1 → Type u_1} [Applicative G] [Applicative H] [CommApplicative G] [CommApplicative H] {α β γ : Type u_1} (g : α → G β) (h : β → H γ) (x : Multiset α)
Goal: Multiset.traverse (Functor.Comp.mk ∘ Functor.map h ∘ g) x =
  Functor.Comp.mk (Multiset.traverse h <$> Multiset.traverse g x)
-- Multiset.map_traverse
theorem map_traverse {G : Type* → Type _} [Applicative G] [CommApplicative G] {α β γ : Type _}
    (g : α → G β) (h : β → γ) (x : Multiset α) :
    Functor.map (Functor.map h) (traverse g x) = traverse (Functor.map h ∘ g) x 
Arguments: {G : Type u_1 → Type u_1} [Applicative G] [CommApplicative G] {α β γ : Type u_1} (g : α → G β) (h : β → γ) (x : Multiset α)
Goal: Functor.map h <$> Multiset.traverse g x = Multiset.traverse (Functor.map h ∘ g) x
-- Multiset.traverse_map
theorem traverse_map {G : Type* → Type _} [Applicative G] [CommApplicative G] {α β γ : Type _}
    (g : α → β) (h : β → G γ) (x : Multiset α) : traverse h (map g x) = traverse (h ∘ g) x 
Arguments: {G : Type u_1 → Type u_1} [Applicative G] [CommApplicative G] {α β γ : Type u_1} (g : α → β) (h : β → G γ) (x : Multiset α)
Goal: Multiset.traverse h (Multiset.map g x) = Multiset.traverse (h ∘ g) x
-- Multiset.naturality
theorem naturality {G H : Type _ → Type _} [Applicative G] [Applicative H] [CommApplicative G]
    [CommApplicative H] (eta : ApplicativeTransformation G H) {α β : Type _} (f : α → G β)
    (x : Multiset α) : eta (traverse f x) = traverse (@eta _ ∘ f) x 
Arguments: {G H : Type u_1 → Type u_1} [Applicative G] [Applicative H] [CommApplicative G] [CommApplicative H] (eta : ApplicativeTransformation G H) {α β : Type u_1} (f : α → G β) (x : Multiset α)
Goal: (fun {α} => eta.app α) (Multiset.traverse f x) = Multiset.traverse ((fun {α} => eta.app α) ∘ f) x
-- Multiset.powersetAux_eq_map_coe
theorem powersetAux_eq_map_coe {l : List α} : powersetAux l = (sublists l).map (↑) 
Arguments: {α : Type u_1} {l : List α}
Goal: Multiset.powersetAux l = List.map Multiset.ofList l.sublists
-- Multiset.mem_powersetAux
@[simp]
theorem mem_powersetAux {l : List α} {s} : s ∈ powersetAux l ↔ s ≤ ↑l 
Arguments: {α : Type u_1} {l : List α} {s : Multiset α}
Goal: s ∈ Multiset.powersetAux l ↔ s ≤ ↑l
-- Multiset.powersetAux_perm_powersetAux'
theorem powersetAux_perm_powersetAux' {l : List α} : powersetAux l ~ powersetAux' l 
Arguments: {α : Type u_1} {l : List α}
Goal: (Multiset.powersetAux l).Perm (Multiset.powersetAux' l)
-- Multiset.powersetAux'_nil
@[simp]
theorem powersetAux'_nil : powersetAux' (@nil α) = [0] 
Arguments: {α : Type u_1}
Goal: Multiset.powersetAux' [] = [0]
-- Multiset.powersetAux'_cons
@[simp]
theorem powersetAux'_cons (a : α) (l : List α) :
    powersetAux' (a :: l) = powersetAux' l ++ List.map (cons a) (powersetAux' l) 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: Multiset.powersetAux' (a :: l) = Multiset.powersetAux' l ++ List.map (Multiset.cons a) (Multiset.powersetAux' l)
-- Multiset.powerset_aux'_perm
theorem powerset_aux'_perm {l₁ l₂ : List α} (p : l₁ ~ l₂) : powersetAux' l₁ ~ powersetAux' l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (p : l₁.Perm l₂)
Goal: (Multiset.powersetAux' l₁).Perm (Multiset.powersetAux' l₂)
-- Multiset.powersetAux_perm
theorem powersetAux_perm {l₁ l₂ : List α} (p : l₁ ~ l₂) : powersetAux l₁ ~ powersetAux l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (p : l₁.Perm l₂)
Goal: (Multiset.powersetAux l₁).Perm (Multiset.powersetAux l₂)
-- Multiset.powerset_coe
theorem powerset_coe (l : List α) : @powerset α l = ((sublists l).map (↑) : List (Multiset α)) 
Arguments: {α : Type u_1} (l : List α)
Goal: (↑l).powerset = ↑(List.map Multiset.ofList l.sublists)
-- Multiset.powerset_coe'
@[simp]
theorem powerset_coe' (l : List α) : @powerset α l = ((sublists' l).map (↑) : List (Multiset α)) 
Arguments: {α : Type u_1} (l : List α)
Goal: (↑l).powerset = ↑(List.map Multiset.ofList l.sublists')
-- Multiset.powerset_zero
@[simp]
theorem powerset_zero : @powerset α 0 = {0} 
Arguments: {α : Type u_1}
Goal: Multiset.powerset 0 = {0}
-- Multiset.powerset_cons
@[simp]
theorem powerset_cons (a : α) (s) : powerset (a ::ₘ s) = powerset s + map (cons a) (powerset s) 
Arguments: {α : Type u_1} (a : α) (s : Multiset α)
Goal: (a ::ₘ s).powerset = s.powerset + Multiset.map (Multiset.cons a) s.powerset
-- Multiset.mem_powerset
@[simp]
theorem mem_powerset {s t : Multiset α} : s ∈ powerset t ↔ s ≤ t 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: s ∈ t.powerset ↔ s ≤ t
-- Multiset.map_single_le_powerset
theorem map_single_le_powerset (s : Multiset α) : s.map singleton ≤ powerset s 
Arguments: {α : Type u_1} (s : Multiset α)
Goal: Multiset.map singleton s ≤ s.powerset
-- Multiset.card_powerset
@[simp]
theorem card_powerset (s : Multiset α) : card (powerset s) = 2 ^ card s 
Arguments: {α : Type u_1} (s : Multiset α)
Goal: Multiset.card s.powerset = 2 ^ Multiset.card s
-- Multiset.revzip_powersetAux
theorem revzip_powersetAux {l : List α} ⦃x⦄ (h : x ∈ revzip (powersetAux l)) : x.1 + x.2 = ↑l 
Arguments: {α : Type u_1} {l : List α} ⦃x : Multiset α × Multiset α⦄ (h : x ∈ (Multiset.powersetAux l).revzip)
Goal: x.1 + x.2 = ↑l
-- Multiset.revzip_powersetAux'
theorem revzip_powersetAux' {l : List α} ⦃x⦄ (h : x ∈ revzip (powersetAux' l)) :
    x.1 + x.2 = ↑l 
Arguments: {α : Type u_1} {l : List α} ⦃x : Multiset α × Multiset α⦄ (h : x ∈ (Multiset.powersetAux' l).revzip)
Goal: x.1 + x.2 = ↑l
-- Multiset.revzip_powersetAux_lemma
theorem revzip_powersetAux_lemma {α : Type*} [DecidableEq α] (l : List α) {l' : List (Multiset α)}
    (H : ∀ ⦃x : _ × _⦄, x ∈ revzip l' → x.1 + x.2 = ↑l) :
    revzip l' = l'.map fun x => (x, (l : Multiset α) - x) 
Arguments: {α : Type u_2} [DecidableEq α] (l : List α) {l' : List (Multiset α)} (H : ∀ ⦃x : Multiset α × Multiset α⦄, x ∈ l'.revzip → x.1 + x.2 = ↑l)
Goal: l'.revzip = List.map (fun x => (x, ↑l - x)) l'
-- Multiset.revzip_powersetAux_perm_aux'
theorem revzip_powersetAux_perm_aux' {l : List α} :
    revzip (powersetAux l) ~ revzip (powersetAux' l) 
Arguments: {α : Type u_1} {l : List α}
Goal: (Multiset.powersetAux l).revzip.Perm (Multiset.powersetAux' l).revzip
-- Multiset.revzip_powersetAux_perm
theorem revzip_powersetAux_perm {l₁ l₂ : List α} (p : l₁ ~ l₂) :
    revzip (powersetAux l₁) ~ revzip (powersetAux l₂) 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (p : l₁.Perm l₂)
Goal: (Multiset.powersetAux l₁).revzip.Perm (Multiset.powersetAux l₂).revzip
-- Multiset.powersetCardAux_eq_map_coe
theorem powersetCardAux_eq_map_coe {n} {l : List α} :
    powersetCardAux n l = (sublistsLen n l).map (↑) 
Arguments: {α : Type u_1} {n : ℕ} {l : List α}
Goal: Multiset.powersetCardAux n l = List.map Multiset.ofList (List.sublistsLen n l)
-- Multiset.mem_powersetCardAux
@[simp]
theorem mem_powersetCardAux {n} {l : List α} {s} : s ∈ powersetCardAux n l ↔ s ≤ ↑l ∧ card s = n 
Arguments: {α : Type u_1} {n : ℕ} {l : List α} {s : Multiset α}
Goal: s ∈ Multiset.powersetCardAux n l ↔ s ≤ ↑l ∧ Multiset.card s = n
-- Multiset.powersetCardAux_zero
@[simp]
theorem powersetCardAux_zero (l : List α) : powersetCardAux 0 l = [0] 
Arguments: {α : Type u_1} (l : List α)
Goal: Multiset.powersetCardAux 0 l = [0]
-- Multiset.powersetCardAux_nil
@[simp]
theorem powersetCardAux_nil (n : ℕ) : powersetCardAux (n + 1) (@nil α) = [] 
Arguments: {α : Type u_1} (n : ℕ)
Goal: Multiset.powersetCardAux (n + 1) [] = []
-- Multiset.powersetCardAux_cons
@[simp]
theorem powersetCardAux_cons (n : ℕ) (a : α) (l : List α) :
    powersetCardAux (n + 1) (a :: l) =
      powersetCardAux (n + 1) l ++ List.map (cons a) (powersetCardAux n l) 
Arguments: {α : Type u_1} (n : ℕ) (a : α) (l : List α)
Goal: Multiset.powersetCardAux (n + 1) (a :: l) =
  Multiset.powersetCardAux (n + 1) l ++ List.map (Multiset.cons a) (Multiset.powersetCardAux n l)
-- Multiset.powersetCardAux_perm
theorem powersetCardAux_perm {n} {l₁ l₂ : List α} (p : l₁ ~ l₂) :
    powersetCardAux n l₁ ~ powersetCardAux n l₂ 
Arguments: {α : Type u_1} {n : ℕ} {l₁ l₂ : List α} (p : l₁.Perm l₂)
Goal: (Multiset.powersetCardAux n l₁).Perm (Multiset.powersetCardAux n l₂)
-- Multiset.powersetCard_coe'
theorem powersetCard_coe' (n) (l : List α) : @powersetCard α n l = powersetCardAux n l 
Arguments: {α : Type u_1} (n : ℕ) (l : List α)
Goal: Multiset.powersetCard n ↑l = ↑(Multiset.powersetCardAux n l)
-- Multiset.powersetCard_coe
theorem powersetCard_coe (n) (l : List α) :
    @powersetCard α n l = ((sublistsLen n l).map (↑) : List (Multiset α)) 
Arguments: {α : Type u_1} (n : ℕ) (l : List α)
Goal: Multiset.powersetCard n ↑l = ↑(List.map Multiset.ofList (List.sublistsLen n l))
-- Multiset.powersetCard_zero_left
@[simp]
theorem powersetCard_zero_left (s : Multiset α) : powersetCard 0 s = {0} 
Arguments: {α : Type u_1} (s : Multiset α)
Goal: Multiset.powersetCard 0 s = {0}
-- Multiset.powersetCard_zero_right
theorem powersetCard_zero_right (n : ℕ) : @powersetCard α (n + 1) 0 = 0 
Arguments: {α : Type u_1} (n : ℕ)
Goal: Multiset.powersetCard (n + 1) 0 = 0
-- Multiset.powersetCard_cons
@[simp]
theorem powersetCard_cons (n : ℕ) (a : α) (s) :
    powersetCard (n + 1) (a ::ₘ s) = powersetCard (n + 1) s + map (cons a) (powersetCard n s) 
Arguments: {α : Type u_1} (n : ℕ) (a : α) (s : Multiset α)
Goal: Multiset.powersetCard (n + 1) (a ::ₘ s) =
  Multiset.powersetCard (n + 1) s + Multiset.map (Multiset.cons a) (Multiset.powersetCard n s)
-- Multiset.powersetCard_one
theorem powersetCard_one (s : Multiset α) : powersetCard 1 s = s.map singleton 
Arguments: {α : Type u_1} (s : Multiset α)
Goal: Multiset.powersetCard 1 s = Multiset.map singleton s
-- Multiset.mem_powersetCard
@[simp]
theorem mem_powersetCard {n : ℕ} {s t : Multiset α} : s ∈ powersetCard n t ↔ s ≤ t ∧ card s = n 
Arguments: {α : Type u_1} {n : ℕ} {s t : Multiset α}
Goal: s ∈ Multiset.powersetCard n t ↔ s ≤ t ∧ Multiset.card s = n
-- Multiset.card_powersetCard
@[simp]
theorem card_powersetCard (n : ℕ) (s : Multiset α) :
    card (powersetCard n s) = Nat.choose (card s) n 
Arguments: {α : Type u_1} (n : ℕ) (s : Multiset α)
Goal: Multiset.card (Multiset.powersetCard n s) = (Multiset.card s).choose n
-- Multiset.powersetCard_le_powerset
theorem powersetCard_le_powerset (n : ℕ) (s : Multiset α) : powersetCard n s ≤ powerset s 
Arguments: {α : Type u_1} (n : ℕ) (s : Multiset α)
Goal: Multiset.powersetCard n s ≤ s.powerset
-- Multiset.powersetCard_mono
theorem powersetCard_mono (n : ℕ) {s t : Multiset α} (h : s ≤ t) :
    powersetCard n s ≤ powersetCard n t 
Arguments: {α : Type u_1} (n : ℕ) {s t : Multiset α} (h : s ≤ t)
Goal: Multiset.powersetCard n s ≤ Multiset.powersetCard n t
-- Multiset.powersetCard_eq_empty
@[simp]
theorem powersetCard_eq_empty {α : Type*} (n : ℕ) {s : Multiset α} (h : card s < n) :
    powersetCard n s = 0 
Arguments: {α : Type u_2} (n : ℕ) {s : Multiset α} (h : Multiset.card s < n)
Goal: Multiset.powersetCard n s = 0
-- Multiset.powersetCard_card_add
@[simp]
theorem powersetCard_card_add (s : Multiset α) {i : ℕ} (hi : 0 < i) :
    s.powersetCard (card s + i) = 0 
Arguments: {α : Type u_1} (s : Multiset α) {i : ℕ} (hi : 0 < i)
Goal: Multiset.powersetCard (Multiset.card s + i) s = 0
-- Multiset.powersetCard_map
theorem powersetCard_map {β : Type*} (f : α → β) (n : ℕ) (s : Multiset α) :
    powersetCard n (s.map f) = (powersetCard n s).map (map f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (n : ℕ) (s : Multiset α)
Goal: Multiset.powersetCard n (Multiset.map f s) = Multiset.map (Multiset.map f) (Multiset.powersetCard n s)
-- Multiset.pairwise_disjoint_powersetCard
theorem pairwise_disjoint_powersetCard (s : Multiset α) :
    _root_.Pairwise fun i j => Multiset.Disjoint (s.powersetCard i) (s.powersetCard j) 
Arguments: {α : Type u_1} (s : Multiset α)
Goal: Pairwise fun i j => (Multiset.powersetCard i s).Disjoint (Multiset.powersetCard j s)
-- Multiset.bind_powerset_len
theorem bind_powerset_len {α : Type*} (S : Multiset α) :
    (bind (Multiset.range (card S + 1)) fun k => S.powersetCard k) = S.powerset 
Arguments: {α : Type u_2} (S : Multiset α)
Goal: ((Multiset.range (Multiset.card S + 1)).bind fun k => Multiset.powersetCard k S) = S.powerset
-- Multiset.nodup_powerset
@[simp]
theorem nodup_powerset {s : Multiset α} : Nodup (powerset s) ↔ Nodup s 
Arguments: {α : Type u_1} {s : Multiset α}
Goal: s.powerset.Nodup ↔ s.Nodup
-- Multiset.Nodup.powersetCard
protected theorem Nodup.powersetCard {n : ℕ} {s : Multiset α} (h : Nodup s) :
    Nodup (powersetCard n s) 
Arguments: {α : Type u_1} {n : ℕ} {s : Multiset α} (h : s.Nodup)
Goal: (Multiset.powersetCard n s).Nodup
-- Multiset.sym2_coe
@[simp] theorem sym2_coe (xs : List α) : (xs : Multiset α).sym2 = xs.sym2 
Arguments: {α : Type u_1} (xs : List α)
Goal: (↑xs).sym2 = ↑xs.sym2
-- Multiset.sym2_eq_zero_iff
@[simp]
theorem sym2_eq_zero_iff {m : Multiset α} : m.sym2 = 0 ↔ m = 0 
Arguments: {α : Type u_1} {m : Multiset α}
Goal: m.sym2 = 0 ↔ m = 0
-- Multiset.sym2_zero
@[simp]
theorem sym2_zero : (0 : Multiset α).sym2 = 0 
Arguments: {α : Type u_1}
Goal: Multiset.sym2 0 = 0
-- Multiset.sym2_cons
theorem sym2_cons (a : α) (m : Multiset α) :
    (m.cons a).sym2 = ((m.cons a).map <| fun b => s(a, b)) + m.sym2 
Arguments: {α : Type u_1} (a : α) (m : Multiset α)
Goal: (a ::ₘ m).sym2 = Multiset.map (fun b => s(a, b)) (a ::ₘ m) + m.sym2
-- Multiset.sym2_map
theorem sym2_map (f : α → β) (m : Multiset α) :
    (m.map f).sym2 = m.sym2.map (Sym2.map f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (m : Multiset α)
Goal: (Multiset.map f m).sym2 = Multiset.map (Sym2.map f) m.sym2
-- Multiset.mk_mem_sym2_iff
theorem mk_mem_sym2_iff {m : Multiset α} {a b : α} :
    s(a, b) ∈ m.sym2 ↔ a ∈ m ∧ b ∈ m 
Arguments: {α : Type u_1} {m : Multiset α} {a b : α}
Goal: s(a, b) ∈ m.sym2 ↔ a ∈ m ∧ b ∈ m
-- Multiset.mem_sym2_iff
theorem mem_sym2_iff {m : Multiset α} {z : Sym2 α} :
    z ∈ m.sym2 ↔ ∀ y ∈ z, y ∈ m 
Arguments: {α : Type u_1} {m : Multiset α} {z : Sym2 α}
Goal: z ∈ m.sym2 ↔ ∀ y ∈ z, y ∈ m
-- Multiset.Nodup.sym2
protected theorem Nodup.sym2 {m : Multiset α} (h : m.Nodup) : m.sym2.Nodup 
Arguments: {α : Type u_1} {m : Multiset α} (h : m.Nodup)
Goal: m.sym2.Nodup
-- Multiset.sym2_mono
@[simp, mono]
theorem sym2_mono {m m' : Multiset α} (h : m ≤ m') : m.sym2 ≤ m'.sym2 
Arguments: {α : Type u_1} {m m' : Multiset α} (h : m ≤ m')
Goal: m.sym2 ≤ m'.sym2
-- Multiset.monotone_sym2
theorem monotone_sym2 : Monotone (Multiset.sym2 : Multiset α → _) 
Arguments: {α : Type u_1}
Goal: Monotone Multiset.sym2
-- Multiset.card_sym2
theorem card_sym2 {m : Multiset α} :
    Multiset.card m.sym2 = Nat.choose (Multiset.card m + 1) 2 
Arguments: {α : Type u_1} {m : Multiset α}
Goal: Multiset.card m.sym2 = (Multiset.card m + 1).choose 2
-- Multiset.dedup_sym2
theorem dedup_sym2 [DecidableEq α] (m : Multiset α) : m.sym2.dedup = m.dedup.sym2 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: m.sym2.dedup = m.dedup.sym2
-- Multiset.Pi.cons_same
theorem cons_same {b : δ a} {f : ∀ a ∈ m, δ a} (h : a ∈ a ::ₘ m) :
    cons m a b f a h = b 
Arguments: {α : Type u_1} [DecidableEq α] {δ : α → Sort u_2} {m : Multiset α} {a : α} {b : δ a} {f : (a : α) → a ∈ m → δ a} (h : a ∈ a ::ₘ m)
Goal: Multiset.Pi.cons m a b f a h = b
-- Multiset.Pi.cons_ne
theorem cons_ne {a a' : α} {b : δ a} {f : ∀ a ∈ m, δ a} (h' : a' ∈ a ::ₘ m)
    (h : a' ≠ a) : Pi.cons m a b f a' h' = f a' ((mem_cons.1 h').resolve_left h) 
Arguments: {α : Type u_1} [DecidableEq α] {δ : α → Sort u_2} {m : Multiset α} {a a' : α} {b : δ a} {f : (a : α) → a ∈ m → δ a} (h' : a' ∈ a ::ₘ m) (h : a' ≠ a)
Goal: Multiset.Pi.cons m a b f a' h' = f a' ⋯
-- Multiset.Pi.cons_swap
theorem cons_swap {a a' : α} {b : δ a} {b' : δ a'} {m : Multiset α} {f : ∀ a ∈ m, δ a}
    (h : a ≠ a') : HEq (Pi.cons (a' ::ₘ m) a b (Pi.cons m a' b' f))
      (Pi.cons (a ::ₘ m) a' b' (Pi.cons m a b f)) 
Arguments: {α : Type u_1} [DecidableEq α] {δ : α → Sort u_2} {a a' : α} {b : δ a} {b' : δ a'} {m : Multiset α} {f : (a : α) → a ∈ m → δ a} (h : a ≠ a')
Goal: HEq (Multiset.Pi.cons (a' ::ₘ m) a b (Multiset.Pi.cons m a' b' f))
  (Multiset.Pi.cons (a ::ₘ m) a' b' (Multiset.Pi.cons m a b f))
-- Multiset.Pi.cons_eta
@[simp, nolint simpNF] -- Porting note: false positive, this lemma can prove itself
theorem cons_eta {m : Multiset α} {a : α} (f : ∀ a' ∈ a ::ₘ m, δ a') :
    (cons m a (f _ (mem_cons_self _ _)) fun a' ha' => f a' (mem_cons_of_mem ha')) = f 
Arguments: {α : Type u_1} [DecidableEq α] {δ : α → Sort u_2} {m : Multiset α} {a : α} (f : (a' : α) → a' ∈ a ::ₘ m → δ a')
Goal: (Multiset.Pi.cons m a (f a ⋯) fun a' ha' => f a' ⋯) = f