ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Multiset.filter_union
@[simp]
theorem filter_union [DecidableEq α] (s t : Multiset α) :
    filter p (s ∪ t) = filter p s ∪ filter p t 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (s t : Multiset α)
Goal: Multiset.filter p (s ∪ t) = Multiset.filter p s ∪ Multiset.filter p t
-- Multiset.filter_inter
@[simp]
theorem filter_inter [DecidableEq α] (s t : Multiset α) :
    filter p (s ∩ t) = filter p s ∩ filter p t 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (s t : Multiset α)
Goal: Multiset.filter p (s ∩ t) = Multiset.filter p s ∩ Multiset.filter p t
-- Multiset.filter_filter
@[simp]
theorem filter_filter (q) [DecidablePred q] (s : Multiset α) :
    filter p (filter q s) = filter (fun a => p a ∧ q a) s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (q : α → Prop) [DecidablePred q] (s : Multiset α)
Goal: Multiset.filter p (Multiset.filter q s) = Multiset.filter (fun a => p a ∧ q a) s
-- Multiset.filter_comm
lemma filter_comm (q) [DecidablePred q] (s : Multiset α) :
    filter p (filter q s) = filter q (filter p s) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (q : α → Prop) [DecidablePred q] (s : Multiset α)
Goal: Multiset.filter p (Multiset.filter q s) = Multiset.filter q (Multiset.filter p s)
-- Multiset.filter_add_filter
theorem filter_add_filter (q) [DecidablePred q] (s : Multiset α) :
    filter p s + filter q s = filter (fun a => p a ∨ q a) s + filter (fun a => p a ∧ q a) s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (q : α → Prop) [DecidablePred q] (s : Multiset α)
Goal: Multiset.filter p s + Multiset.filter q s =
  Multiset.filter (fun a => p a ∨ q a) s + Multiset.filter (fun a => p a ∧ q a) s
-- Multiset.filter_add_not
theorem filter_add_not (s : Multiset α) : filter p s + filter (fun a => ¬p a) s = s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Multiset α)
Goal: Multiset.filter p s + Multiset.filter (fun a => ¬p a) s = s
-- Multiset.filter_map
theorem filter_map (f : β → α) (s : Multiset β) : filter p (map f s) = map f (filter (p ∘ f) s) 
Arguments: {α : Type u_1} {β : Type v} (p : α → Prop) [DecidablePred p] (f : β → α) (s : Multiset β)
Goal: Multiset.filter p (Multiset.map f s) = Multiset.map f (Multiset.filter (p ∘ f) s)
-- Multiset.map_filter'
lemma map_filter' {f : α → β} (hf : Injective f) (s : Multiset α)
    [DecidablePred fun b => ∃ a, p a ∧ f a = b] :
    (s.filter p).map f = (s.map f).filter fun b => ∃ a, p a ∧ f a = b 
Arguments: {α : Type u_1} {β : Type v} (p : α → Prop) [DecidablePred p] {f : α → β} (hf : Function.Injective f) (s : Multiset α) [DecidablePred fun b => ∃ a, p a ∧ f a = b]
Goal: Multiset.map f (Multiset.filter p s) = Multiset.filter (fun b => ∃ a, p a ∧ f a = b) (Multiset.map f s)
-- Multiset.card_filter_le_iff
lemma card_filter_le_iff (s : Multiset α) (P : α → Prop) [DecidablePred P] (n : ℕ) :
    card (s.filter P) ≤ n ↔ ∀ s' ≤ s, n < card s' → ∃ a ∈ s', ¬ P a 
Arguments: {α : Type u_1} (s : Multiset α) (P : α → Prop) [DecidablePred P] (n : ℕ)
Goal: Multiset.card (Multiset.filter P s) ≤ n ↔ ∀ s' ≤ s, n < Multiset.card s' → ∃ a ∈ s', ¬P a
-- Multiset.filterMap_coe
@[simp, norm_cast]
lemma filterMap_coe (f : α → Option β) (l : List α) : filterMap f l = l.filterMap f 
Arguments: {α : Type u_1} {β : Type v} (f : α → Option β) (l : List α)
Goal: Multiset.filterMap f ↑l = ↑(List.filterMap f l)
-- Multiset.filterMap_zero
@[simp]
theorem filterMap_zero (f : α → Option β) : filterMap f 0 = 0 
Arguments: {α : Type u_1} {β : Type v} (f : α → Option β)
Goal: Multiset.filterMap f 0 = 0
-- Multiset.filterMap_cons_none
@[simp]
theorem filterMap_cons_none {f : α → Option β} (a : α) (s : Multiset α) (h : f a = none) :
    filterMap f (a ::ₘ s) = filterMap f s 
Arguments: {α : Type u_1} {β : Type v} {f : α → Option β} (a : α) (s : Multiset α) (h : f a = none)
Goal: Multiset.filterMap f (a ::ₘ s) = Multiset.filterMap f s
-- Multiset.filterMap_cons_some
@[simp]
theorem filterMap_cons_some (f : α → Option β) (a : α) (s : Multiset α) {b : β}
    (h : f a = some b) : filterMap f (a ::ₘ s) = b ::ₘ filterMap f s 
Arguments: {α : Type u_1} {β : Type v} (f : α → Option β) (a : α) (s : Multiset α) {b : β} (h : f a = some b)
Goal: Multiset.filterMap f (a ::ₘ s) = b ::ₘ Multiset.filterMap f s
-- Multiset.filterMap_eq_map
theorem filterMap_eq_map (f : α → β) : filterMap (some ∘ f) = map f 
Arguments: {α : Type u_1} {β : Type v} (f : α → β)
Goal: Multiset.filterMap (some ∘ f) = Multiset.map f
-- Multiset.filterMap_eq_filter
theorem filterMap_eq_filter : filterMap (Option.guard p) = filter p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p]
Goal: Multiset.filterMap (Option.guard p) = Multiset.filter p
-- Multiset.filterMap_filterMap
theorem filterMap_filterMap (f : α → Option β) (g : β → Option γ) (s : Multiset α) :
    filterMap g (filterMap f s) = filterMap (fun x => (f x).bind g) s 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} (f : α → Option β) (g : β → Option γ) (s : Multiset α)
Goal: Multiset.filterMap g (Multiset.filterMap f s) = Multiset.filterMap (fun x => (f x).bind g) s
-- Multiset.map_filterMap
theorem map_filterMap (f : α → Option β) (g : β → γ) (s : Multiset α) :
    map g (filterMap f s) = filterMap (fun x => (f x).map g) s 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} (f : α → Option β) (g : β → γ) (s : Multiset α)
Goal: Multiset.map g (Multiset.filterMap f s) = Multiset.filterMap (fun x => Option.map g (f x)) s
-- Multiset.filterMap_map
theorem filterMap_map (f : α → β) (g : β → Option γ) (s : Multiset α) :
    filterMap g (map f s) = filterMap (g ∘ f) s 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} (f : α → β) (g : β → Option γ) (s : Multiset α)
Goal: Multiset.filterMap g (Multiset.map f s) = Multiset.filterMap (g ∘ f) s
-- Multiset.filter_filterMap
theorem filter_filterMap (f : α → Option β) (p : β → Prop) [DecidablePred p] (s : Multiset α) :
    filter p (filterMap f s) = filterMap (fun x => (f x).filter p) s 
Arguments: {α : Type u_1} {β : Type v} (f : α → Option β) (p : β → Prop) [DecidablePred p] (s : Multiset α)
Goal: Multiset.filter p (Multiset.filterMap f s) = Multiset.filterMap (fun x => Option.filter (fun b => decide (p b)) (f x)) s
-- Multiset.filterMap_filter
theorem filterMap_filter (f : α → Option β) (s : Multiset α) :
    filterMap f (filter p s) = filterMap (fun x => if p x then f x else none) s 
Arguments: {α : Type u_1} {β : Type v} (p : α → Prop) [DecidablePred p] (f : α → Option β) (s : Multiset α)
Goal: Multiset.filterMap f (Multiset.filter p s) = Multiset.filterMap (fun x => if p x then f x else none) s
-- Multiset.filterMap_some
@[simp]
theorem filterMap_some (s : Multiset α) : filterMap some s = s 
Arguments: {α : Type u_1} (s : Multiset α)
Goal: Multiset.filterMap some s = s
-- Multiset.mem_filterMap
@[simp]
theorem mem_filterMap (f : α → Option β) (s : Multiset α) {b : β} :
    b ∈ filterMap f s ↔ ∃ a, a ∈ s ∧ f a = some b 
Arguments: {α : Type u_1} {β : Type v} (f : α → Option β) (s : Multiset α) {b : β}
Goal: b ∈ Multiset.filterMap f s ↔ ∃ a ∈ s, f a = some b
-- Multiset.map_filterMap_of_inv
theorem map_filterMap_of_inv (f : α → Option β) (g : β → α) (H : ∀ x : α, (f x).map g = some x)
    (s : Multiset α) : map g (filterMap f s) = s 
Arguments: {α : Type u_1} {β : Type v} (f : α → Option β) (g : β → α) (H : ∀ (x : α), Option.map g (f x) = some x) (s : Multiset α)
Goal: Multiset.map g (Multiset.filterMap f s) = s
-- Multiset.filterMap_le_filterMap
theorem filterMap_le_filterMap (f : α → Option β) {s t : Multiset α} (h : s ≤ t) :
    filterMap f s ≤ filterMap f t 
Arguments: {α : Type u_1} {β : Type v} (f : α → Option β) {s t : Multiset α} (h : s ≤ t)
Goal: Multiset.filterMap f s ≤ Multiset.filterMap f t
-- Multiset.coe_countP
@[simp]
theorem coe_countP (l : List α) : countP p l = l.countP p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : List α)
Goal: Multiset.countP p ↑l = List.countP (fun b => decide (p b)) l
-- Multiset.countP_zero
@[simp]
theorem countP_zero : countP p 0 = 0 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p]
Goal: Multiset.countP p 0 = 0
-- Multiset.countP_cons_of_pos
@[simp]
theorem countP_cons_of_pos {a : α} (s) : p a → countP p (a ::ₘ s) = countP p s + 1 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} (s : Multiset α)
Goal: p a → Multiset.countP p (a ::ₘ s) = Multiset.countP p s + 1
-- Multiset.countP_cons_of_neg
@[simp]
theorem countP_cons_of_neg {a : α} (s) : ¬p a → countP p (a ::ₘ s) = countP p s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} (s : Multiset α)
Goal: ¬p a → Multiset.countP p (a ::ₘ s) = Multiset.countP p s
-- Multiset.countP_cons
theorem countP_cons (b : α) (s) : countP p (b ::ₘ s) = countP p s + if p b then 1 else 0 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (b : α) (s : Multiset α)
Goal: Multiset.countP p (b ::ₘ s) = Multiset.countP p s + if p b then 1 else 0
-- Multiset.countP_eq_card_filter
theorem countP_eq_card_filter (s) : countP p s = card (filter p s) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Multiset α)
Goal: Multiset.countP p s = Multiset.card (Multiset.filter p s)
-- Multiset.countP_le_card
theorem countP_le_card (s) : countP p s ≤ card s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Multiset α)
Goal: Multiset.countP p s ≤ Multiset.card s
-- Multiset.countP_add
@[simp]
theorem countP_add (s t) : countP p (s + t) = countP p s + countP p t 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s t : Multiset α)
Goal: Multiset.countP p (s + t) = Multiset.countP p s + Multiset.countP p t
-- Multiset.countP_nsmul
@[simp]
theorem countP_nsmul (s) (n : ℕ) : countP p (n • s) = n * countP p s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Multiset α) (n : ℕ)
Goal: Multiset.countP p (n • s) = n * Multiset.countP p s
-- Multiset.card_eq_countP_add_countP
theorem card_eq_countP_add_countP (s) : card s = countP p s + countP (fun x => ¬p x) s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Multiset α)
Goal: Multiset.card s = Multiset.countP p s + Multiset.countP (fun x => ¬p x) s
-- Multiset.coe_countPAddMonoidHom
@[simp]
theorem coe_countPAddMonoidHom : (countPAddMonoidHom p : Multiset α → ℕ) = countP p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p]
Goal: ⇑(Multiset.countPAddMonoidHom p) = Multiset.countP p
-- Multiset.countP_sub
@[simp]
theorem countP_sub [DecidableEq α] {s t : Multiset α} (h : t ≤ s) :
    countP p (s - t) = countP p s - countP p t 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] {s t : Multiset α} (h : t ≤ s)
Goal: Multiset.countP p (s - t) = Multiset.countP p s - Multiset.countP p t
-- Multiset.countP_le_of_le
theorem countP_le_of_le {s t} (h : s ≤ t) : countP p s ≤ countP p t 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] {s t : Multiset α} (h : s ≤ t)
Goal: Multiset.countP p s ≤ Multiset.countP p t
-- Multiset.countP_filter
@[simp]
theorem countP_filter (q) [DecidablePred q] (s : Multiset α) :
    countP p (filter q s) = countP (fun a => p a ∧ q a) s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (q : α → Prop) [DecidablePred q] (s : Multiset α)
Goal: Multiset.countP p (Multiset.filter q s) = Multiset.countP (fun a => p a ∧ q a) s
-- Multiset.countP_eq_countP_filter_add
theorem countP_eq_countP_filter_add (s) (p q : α → Prop) [DecidablePred p] [DecidablePred q] :
    countP p s = (filter q s).countP p + (filter (fun a => ¬q a) s).countP p 
Arguments: {α : Type u_1} (s : Multiset α) (p q : α → Prop) [DecidablePred p] [DecidablePred q]
Goal: Multiset.countP p s = Multiset.countP p (Multiset.filter q s) + Multiset.countP p (Multiset.filter (fun a => ¬q a) s)
-- Multiset.countP_True
@[simp]
theorem countP_True {s : Multiset α} : countP (fun _ => True) s = card s 
Arguments: {α : Type u_1} {s : Multiset α}
Goal: Multiset.countP (fun x => True) s = Multiset.card s
-- Multiset.countP_False
@[simp]
theorem countP_False {s : Multiset α} : countP (fun _ => False) s = 0 
Arguments: {α : Type u_1} {s : Multiset α}
Goal: Multiset.countP (fun x => False) s = 0
-- Multiset.countP_map
theorem countP_map (f : α → β) (s : Multiset α) (p : β → Prop) [DecidablePred p] :
    countP p (map f s) = card (s.filter fun a => p (f a)) 
Arguments: {α : Type u_1} {β : Type v} (f : α → β) (s : Multiset α) (p : β → Prop) [DecidablePred p]
Goal: Multiset.countP p (Multiset.map f s) = Multiset.card (Multiset.filter (fun a => p (f a)) s)
-- Multiset.countP_attach
lemma countP_attach (s : Multiset α) : s.attach.countP (fun a : {a // a ∈ s} ↦ p a) = s.countP p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Multiset α)
Goal: Multiset.countP (fun a => p ↑a) s.attach = Multiset.countP p s
-- Multiset.filter_attach
lemma filter_attach (s : Multiset α) (p : α → Prop) [DecidablePred p] :
    (s.attach.filter fun a : {a // a ∈ s} ↦ p ↑a) =
      (s.filter p).attach.map (Subtype.map id fun _ ↦ Multiset.mem_of_mem_filter) 
Arguments: {α : Type u_1} (s : Multiset α) (p : α → Prop) [DecidablePred p]
Goal: Multiset.filter (fun a => p ↑a) s.attach = Multiset.map (Subtype.map id ⋯) (Multiset.filter p s).attach
-- Multiset.countP_pos
theorem countP_pos {s} : 0 < countP p s ↔ ∃ a ∈ s, p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Multiset α}
Goal: 0 < Multiset.countP p s ↔ ∃ a ∈ s, p a
-- Multiset.countP_eq_zero
theorem countP_eq_zero {s} : countP p s = 0 ↔ ∀ a ∈ s, ¬p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Multiset α}
Goal: Multiset.countP p s = 0 ↔ ∀ a ∈ s, ¬p a
-- Multiset.countP_eq_card
theorem countP_eq_card {s} : countP p s = card s ↔ ∀ a ∈ s, p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Multiset α}
Goal: Multiset.countP p s = Multiset.card s ↔ ∀ a ∈ s, p a
-- Multiset.countP_pos_of_mem
theorem countP_pos_of_mem {s a} (h : a ∈ s) (pa : p a) : 0 < countP p s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Multiset α} {a : α} (h : a ∈ s) (pa : p a)
Goal: 0 < Multiset.countP p s
-- Multiset.countP_congr
theorem countP_congr {s s' : Multiset α} (hs : s = s')
    {p p' : α → Prop} [DecidablePred p] [DecidablePred p']
    (hp : ∀ x ∈ s, p x = p' x) : s.countP p = s'.countP p' 
Arguments: {α : Type u_1} {s s' : Multiset α} (hs : s = s') {p p' : α → Prop} [DecidablePred p] [DecidablePred p'] (hp : ∀ x ∈ s, p x = p' x)
Goal: Multiset.countP p s = Multiset.countP p' s'
-- Multiset.coe_count
@[simp]
theorem coe_count (a : α) (l : List α) : count a (ofList l) = l.count a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: Multiset.count a ↑l = List.count a l
-- Multiset.count_zero
@[simp]
theorem count_zero (a : α) : count a 0 = 0 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: Multiset.count a 0 = 0
-- Multiset.count_cons_self
@[simp]
theorem count_cons_self (a : α) (s : Multiset α) : count a (a ::ₘ s) = count a s + 1 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Multiset α)
Goal: Multiset.count a (a ::ₘ s) = Multiset.count a s + 1
-- Multiset.count_cons_of_ne
@[simp]
theorem count_cons_of_ne {a b : α} (h : a ≠ b) (s : Multiset α) : count a (b ::ₘ s) = count a s 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} (h : a ≠ b) (s : Multiset α)
Goal: Multiset.count a (b ::ₘ s) = Multiset.count a s
-- Multiset.count_le_card
theorem count_le_card (a : α) (s) : count a s ≤ card s 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Multiset α)
Goal: Multiset.count a s ≤ Multiset.card s
-- Multiset.count_le_of_le
theorem count_le_of_le (a : α) {s t} : s ≤ t → count a s ≤ count a t 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) {s t : Multiset α}
Goal: s ≤ t → Multiset.count a s ≤ Multiset.count a t
-- Multiset.count_le_count_cons
theorem count_le_count_cons (a b : α) (s : Multiset α) : count a s ≤ count a (b ::ₘ s) 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α) (s : Multiset α)
Goal: Multiset.count a s ≤ Multiset.count a (b ::ₘ s)
-- Multiset.count_cons
theorem count_cons (a b : α) (s : Multiset α) :
    count a (b ::ₘ s) = count a s + if a = b then 1 else 0 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α) (s : Multiset α)
Goal: Multiset.count a (b ::ₘ s) = Multiset.count a s + if a = b then 1 else 0
-- Multiset.count_singleton_self
theorem count_singleton_self (a : α) : count a ({a} : Multiset α) = 1 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: Multiset.count a {a} = 1
-- Multiset.count_singleton
theorem count_singleton (a b : α) : count a ({b} : Multiset α) = if a = b then 1 else 0 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α)
Goal: Multiset.count a {b} = if a = b then 1 else 0
-- Multiset.count_add
@[simp]
theorem count_add (a : α) : ∀ s t, count a (s + t) = count a s + count a t 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s t : Multiset α)
Goal: Multiset.count a (s + t) = Multiset.count a s + Multiset.count a t
-- Multiset.coe_countAddMonoidHom
@[simp]
theorem coe_countAddMonoidHom {a : α} : (countAddMonoidHom a : Multiset α → ℕ) = count a 
Arguments: {α : Type u_1} [DecidableEq α] {a : α}
Goal: ⇑(Multiset.countAddMonoidHom a) = Multiset.count a
-- Multiset.count_nsmul
@[simp]
theorem count_nsmul (a : α) (n s) : count a (n • s) = n * count a s 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (n : ℕ) (s : Multiset α)
Goal: Multiset.count a (n • s) = n * Multiset.count a s
-- Multiset.count_attach
@[simp]
lemma count_attach (a : {x // x ∈ s}) : s.attach.count a = s.count ↑a 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} (a : { x // x ∈ s })
Goal: Multiset.count a s.attach = Multiset.count (↑a) s
-- Multiset.count_pos
theorem count_pos {a : α} {s : Multiset α} : 0 < count a s ↔ a ∈ s 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α}
Goal: 0 < Multiset.count a s ↔ a ∈ s
-- Multiset.one_le_count_iff_mem
theorem one_le_count_iff_mem {a : α} {s : Multiset α} : 1 ≤ count a s ↔ a ∈ s 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α}
Goal: 1 ≤ Multiset.count a s ↔ a ∈ s
-- Multiset.count_eq_zero_of_not_mem
@[simp]
theorem count_eq_zero_of_not_mem {a : α} {s : Multiset α} (h : a ∉ s) : count a s = 0 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α} (h : a ∉ s)
Goal: Multiset.count a s = 0
-- Multiset.count_ne_zero
lemma count_ne_zero {a : α} : count a s ≠ 0 ↔ a ∈ s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} {a : α}
Goal: Multiset.count a s ≠ 0 ↔ a ∈ s
-- Multiset.count_eq_zero
@[simp] lemma count_eq_zero {a : α} : count a s = 0 ↔ a ∉ s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} {a : α}
Goal: Multiset.count a s = 0 ↔ a ∉ s
-- Multiset.count_eq_card
theorem count_eq_card {a : α} {s} : count a s = card s ↔ ∀ x ∈ s, a = x 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α}
Goal: Multiset.count a s = Multiset.card s ↔ ∀ x ∈ s, a = x
-- Multiset.count_replicate_self
@[simp]
theorem count_replicate_self (a : α) (n : ℕ) : count a (replicate n a) = n 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (n : ℕ)
Goal: Multiset.count a (Multiset.replicate n a) = n
-- Multiset.count_replicate
theorem count_replicate (a b : α) (n : ℕ) : count a (replicate n b) = if a = b then n else 0 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α) (n : ℕ)
Goal: Multiset.count a (Multiset.replicate n b) = if a = b then n else 0
-- Multiset.count_erase_self
@[simp]
theorem count_erase_self (a : α) (s : Multiset α) : count a (erase s a) = count a s - 1 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Multiset α)
Goal: Multiset.count a (s.erase a) = Multiset.count a s - 1
-- Multiset.count_erase_of_ne
@[simp]
theorem count_erase_of_ne {a b : α} (ab : a ≠ b) (s : Multiset α) :
    count a (erase s b) = count a s 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} (ab : a ≠ b) (s : Multiset α)
Goal: Multiset.count a (s.erase b) = Multiset.count a s
-- Multiset.count_sub
@[simp]
theorem count_sub (a : α) (s t : Multiset α) : count a (s - t) = count a s - count a t 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s t : Multiset α)
Goal: Multiset.count a (s - t) = Multiset.count a s - Multiset.count a t
-- Multiset.count_union
@[simp]
theorem count_union (a : α) (s t : Multiset α) : count a (s ∪ t) = max (count a s) (count a t) 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s t : Multiset α)
Goal: Multiset.count a (s ∪ t) = max (Multiset.count a s) (Multiset.count a t)
-- Multiset.count_inter
@[simp]
theorem count_inter (a : α) (s t : Multiset α) : count a (s ∩ t) = min (count a s) (count a t) 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s t : Multiset α)
Goal: Multiset.count a (s ∩ t) = min (Multiset.count a s) (Multiset.count a t)
-- Multiset.le_count_iff_replicate_le
theorem le_count_iff_replicate_le {a : α} {s : Multiset α} {n : ℕ} :
    n ≤ count a s ↔ replicate n a ≤ s 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α} {n : ℕ}
Goal: n ≤ Multiset.count a s ↔ Multiset.replicate n a ≤ s
-- Multiset.count_filter_of_pos
@[simp]
theorem count_filter_of_pos {p} [DecidablePred p] {a} {s : Multiset α} (h : p a) :
    count a (filter p s) = count a s 
Arguments: {α : Type u_1} [DecidableEq α] {p : α → Prop} [DecidablePred p] {a : α} {s : Multiset α} (h : p a)
Goal: Multiset.count a (Multiset.filter p s) = Multiset.count a s
-- Multiset.count_filter_of_neg
@[simp]
theorem count_filter_of_neg {p} [DecidablePred p] {a} {s : Multiset α} (h : ¬p a) :
    count a (filter p s) = 0 
Arguments: {α : Type u_1} [DecidableEq α] {p : α → Prop} [DecidablePred p] {a : α} {s : Multiset α} (h : ¬p a)
Goal: Multiset.count a (Multiset.filter p s) = 0
-- Multiset.count_filter
theorem count_filter {p} [DecidablePred p] {a} {s : Multiset α} :
    count a (filter p s) = if p a then count a s else 0 
Arguments: {α : Type u_1} [DecidableEq α] {p : α → Prop} [DecidablePred p] {a : α} {s : Multiset α}
Goal: Multiset.count a (Multiset.filter p s) = if p a then Multiset.count a s else 0
-- Multiset.ext
theorem ext {s t : Multiset α} : s = t ↔ ∀ a, count a s = count a t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s = t ↔ ∀ (a : α), Multiset.count a s = Multiset.count a t
-- Multiset.ext'
@[ext]
theorem ext' {s t : Multiset α} : (∀ a, count a s = count a t) → s = t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: (∀ (a : α), Multiset.count a s = Multiset.count a t) → s = t
-- Multiset.count_injective
lemma count_injective : Injective fun (s : Multiset α) a ↦ s.count a 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Function.Injective fun s a => Multiset.count a s
-- Multiset.coe_inter
@[simp]
theorem coe_inter (s t : List α) : (s ∩ t : Multiset α) = (s.bagInter t : List α) 
Arguments: {α : Type u_1} [DecidableEq α] (s t : List α)
Goal: ↑s ∩ ↑t = ↑(s.bagInter t)
-- Multiset.le_iff_count
theorem le_iff_count {s t : Multiset α} : s ≤ t ↔ ∀ a, count a s ≤ count a t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s ≤ t ↔ ∀ (a : α), Multiset.count a s ≤ Multiset.count a t
-- Multiset.count_map
theorem count_map {α β : Type*} (f : α → β) (s : Multiset α) [DecidableEq β] (b : β) :
    count b (map f s) = card (s.filter fun a => b = f a) 
Arguments: {α : Type u_3} {β : Type u_4} (f : α → β) (s : Multiset α) [DecidableEq β] (b : β)
Goal: Multiset.count b (Multiset.map f s) = Multiset.card (Multiset.filter (fun a => b = f a) s)
-- Multiset.count_map_eq_count
theorem count_map_eq_count [DecidableEq β] (f : α → β) (s : Multiset α)
    (hf : Set.InjOn f { x : α | x ∈ s }) (x) (H : x ∈ s) : (s.map f).count (f x) = s.count x 
Arguments: {α : Type u_1} {β : Type v} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Multiset α) (hf : Set.InjOn f {x | x ∈ s}) (x : α) (H : x ∈ s)
Goal: Multiset.count (f x) (Multiset.map f s) = Multiset.count x s
-- Multiset.count_map_eq_count'
theorem count_map_eq_count' [DecidableEq β] (f : α → β) (s : Multiset α) (hf : Function.Injective f)
    (x : α) : (s.map f).count (f x) = s.count x 
Arguments: {α : Type u_1} {β : Type v} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Multiset α) (hf : Function.Injective f) (x : α)
Goal: Multiset.count (f x) (Multiset.map f s) = Multiset.count x s