ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Multiset.map_erase_of_mem
theorem map_erase_of_mem [DecidableEq α] [DecidableEq β] (f : α → β)
    (s : Multiset α) {x : α} (h : x ∈ s) : (s.erase x).map f = (s.map f).erase (f x) 
Arguments: {α : Type u_1} {β : Type v} [DecidableEq α] [DecidableEq β] (f : α → β) (s : Multiset α) {x : α} (h : x ∈ s)
Goal: Multiset.map f (s.erase x) = (Multiset.map f s).erase (f x)
-- Multiset.map_surjective_of_surjective
theorem map_surjective_of_surjective {f : α → β} (hf : Function.Surjective f) :
    Function.Surjective (map f) 
Arguments: {α : Type u_1} {β : Type v} {f : α → β} (hf : Function.Surjective f)
Goal: Function.Surjective (Multiset.map f)
-- Multiset.foldl_zero
@[simp]
theorem foldl_zero (f : β → α → β) (H b) : foldl f H b 0 = b 
Arguments: {α : Type u_1} {β : Type v} (f : β → α → β) (H : RightCommutative f) (b : β)
Goal: Multiset.foldl f H b 0 = b
-- Multiset.foldl_cons
@[simp]
theorem foldl_cons (f : β → α → β) (H b a s) : foldl f H b (a ::ₘ s) = foldl f H (f b a) s 
Arguments: {α : Type u_1} {β : Type v} (f : β → α → β) (H : RightCommutative f) (b : β) (a : α) (s : Multiset α)
Goal: Multiset.foldl f H b (a ::ₘ s) = Multiset.foldl f H (f b a) s
-- Multiset.foldl_add
@[simp]
theorem foldl_add (f : β → α → β) (H b s t) : foldl f H b (s + t) = foldl f H (foldl f H b s) t 
Arguments: {α : Type u_1} {β : Type v} (f : β → α → β) (H : RightCommutative f) (b : β) (s t : Multiset α)
Goal: Multiset.foldl f H b (s + t) = Multiset.foldl f H (Multiset.foldl f H b s) t
-- Multiset.foldr_zero
@[simp]
theorem foldr_zero (f : α → β → β) (H b) : foldr f H b 0 = b 
Arguments: {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (b : β)
Goal: Multiset.foldr f H b 0 = b
-- Multiset.foldr_cons
@[simp]
theorem foldr_cons (f : α → β → β) (H b a s) : foldr f H b (a ::ₘ s) = f a (foldr f H b s) 
Arguments: {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (b : β) (a : α) (s : Multiset α)
Goal: Multiset.foldr f H b (a ::ₘ s) = f a (Multiset.foldr f H b s)
-- Multiset.foldr_singleton
@[simp]
theorem foldr_singleton (f : α → β → β) (H b a) : foldr f H b ({a} : Multiset α) = f a b 
Arguments: {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (b : β) (a : α)
Goal: Multiset.foldr f H b {a} = f a b
-- Multiset.foldr_add
@[simp]
theorem foldr_add (f : α → β → β) (H b s t) : foldr f H b (s + t) = foldr f H (foldr f H b t) s 
Arguments: {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (b : β) (s t : Multiset α)
Goal: Multiset.foldr f H b (s + t) = Multiset.foldr f H (Multiset.foldr f H b t) s
-- Multiset.coe_foldr
@[simp]
theorem coe_foldr (f : α → β → β) (H : LeftCommutative f) (b : β) (l : List α) :
    foldr f H b l = l.foldr f b 
Arguments: {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (b : β) (l : List α)
Goal: Multiset.foldr f H b ↑l = List.foldr f b l
-- Multiset.coe_foldl
@[simp]
theorem coe_foldl (f : β → α → β) (H : RightCommutative f) (b : β) (l : List α) :
    foldl f H b l = l.foldl f b 
Arguments: {α : Type u_1} {β : Type v} (f : β → α → β) (H : RightCommutative f) (b : β) (l : List α)
Goal: Multiset.foldl f H b ↑l = List.foldl f b l
-- Multiset.coe_foldr_swap
theorem coe_foldr_swap (f : α → β → β) (H : LeftCommutative f) (b : β) (l : List α) :
    foldr f H b l = l.foldl (fun x y => f y x) b 
Arguments: {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (b : β) (l : List α)
Goal: Multiset.foldr f H b ↑l = List.foldl (fun x y => f y x) b l
-- Multiset.foldr_swap
theorem foldr_swap (f : α → β → β) (H : LeftCommutative f) (b : β) (s : Multiset α) :
    foldr f H b s = foldl (fun x y => f y x) (fun _x _y _z => (H _ _ _).symm) b s 
Arguments: {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (b : β) (s : Multiset α)
Goal: Multiset.foldr f H b s = Multiset.foldl (fun x y => f y x) ⋯ b s
-- Multiset.foldl_swap
theorem foldl_swap (f : β → α → β) (H : RightCommutative f) (b : β) (s : Multiset α) :
    foldl f H b s = foldr (fun x y => f y x) (fun _x _y _z => (H _ _ _).symm) b s 
Arguments: {α : Type u_1} {β : Type v} (f : β → α → β) (H : RightCommutative f) (b : β) (s : Multiset α)
Goal: Multiset.foldl f H b s = Multiset.foldr (fun x y => f y x) ⋯ b s
-- Multiset.foldr_induction'
theorem foldr_induction' (f : α → β → β) (H : LeftCommutative f) (x : β) (q : α → Prop)
    (p : β → Prop) (s : Multiset α) (hpqf : ∀ a b, q a → p b → p (f a b)) (px : p x)
    (q_s : ∀ a ∈ s, q a) : p (foldr f H x s) 
Arguments: {α : Type u_1} {β : Type v} (f : α → β → β) (H : LeftCommutative f) (x : β) (q : α → Prop) (p : β → Prop) (s : Multiset α) (hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)) (px : p x) (q_s : ∀ a ∈ s, q a)
Goal: p (Multiset.foldr f H x s)
-- Multiset.foldr_induction
theorem foldr_induction (f : α → α → α) (H : LeftCommutative f) (x : α) (p : α → Prop)
    (s : Multiset α) (p_f : ∀ a b, p a → p b → p (f a b)) (px : p x) (p_s : ∀ a ∈ s, p a) :
    p (foldr f H x s) 
Arguments: {α : Type u_1} (f : α → α → α) (H : LeftCommutative f) (x : α) (p : α → Prop) (s : Multiset α) (p_f : ∀ (a b : α), p a → p b → p (f a b)) (px : p x) (p_s : ∀ a ∈ s, p a)
Goal: p (Multiset.foldr f H x s)
-- Multiset.foldl_induction'
theorem foldl_induction' (f : β → α → β) (H : RightCommutative f) (x : β) (q : α → Prop)
    (p : β → Prop) (s : Multiset α) (hpqf : ∀ a b, q a → p b → p (f b a)) (px : p x)
    (q_s : ∀ a ∈ s, q a) : p (foldl f H x s) 
Arguments: {α : Type u_1} {β : Type v} (f : β → α → β) (H : RightCommutative f) (x : β) (q : α → Prop) (p : β → Prop) (s : Multiset α) (hpqf : ∀ (a : α) (b : β), q a → p b → p (f b a)) (px : p x) (q_s : ∀ a ∈ s, q a)
Goal: p (Multiset.foldl f H x s)
-- Multiset.foldl_induction
theorem foldl_induction (f : α → α → α) (H : RightCommutative f) (x : α) (p : α → Prop)
    (s : Multiset α) (p_f : ∀ a b, p a → p b → p (f b a)) (px : p x) (p_s : ∀ a ∈ s, p a) :
    p (foldl f H x s) 
Arguments: {α : Type u_1} (f : α → α → α) (H : RightCommutative f) (x : α) (p : α → Prop) (s : Multiset α) (p_f : ∀ (a b : α), p a → p b → p (f b a)) (px : p x) (p_s : ∀ a ∈ s, p a)
Goal: p (Multiset.foldl f H x s)
-- Multiset.coe_pmap
@[simp]
theorem coe_pmap {p : α → Prop} (f : ∀ a, p a → β) (l : List α) (H : ∀ a ∈ l, p a) :
    pmap f l H = l.pmap f H 
Arguments: {α : Type u_1} {β : Type v} {p : α → Prop} (f : (a : α) → p a → β) (l : List α) (H : ∀ a ∈ l, p a)
Goal: Multiset.pmap f (↑l) H = ↑(List.pmap f l H)
-- Multiset.pmap_zero
@[simp]
theorem pmap_zero {p : α → Prop} (f : ∀ a, p a → β) (h : ∀ a ∈ (0 : Multiset α), p a) :
    pmap f 0 h = 0 
Arguments: {α : Type u_1} {β : Type v} {p : α → Prop} (f : (a : α) → p a → β) (h : ∀ a ∈ 0, p a)
Goal: Multiset.pmap f 0 h = 0
-- Multiset.pmap_cons
@[simp]
theorem pmap_cons {p : α → Prop} (f : ∀ a, p a → β) (a : α) (m : Multiset α) :
    ∀ h : ∀ b ∈ a ::ₘ m, p b,
      pmap f (a ::ₘ m) h =
        f a (h a (mem_cons_self a m)) ::ₘ pmap f m fun a ha => h a <| mem_cons_of_mem ha 
Arguments: {α : Type u_1} {β : Type v} {p : α → Prop} (f : (a : α) → p a → β) (a : α) (m : Multiset α) (h : ∀ b ∈ a ::ₘ m, p b)
Goal: Multiset.pmap f (a ::ₘ m) h = f a ⋯ ::ₘ Multiset.pmap f m ⋯
-- Multiset.coe_attach
@[simp]
theorem coe_attach (l : List α) : @Eq (Multiset { x // x ∈ l }) (@attach α l) l.attach 
Arguments: {α : Type u_1} (l : List α)
Goal: (↑l).attach = ↑l.attach
-- Multiset.sizeOf_lt_sizeOf_of_mem
theorem sizeOf_lt_sizeOf_of_mem [SizeOf α] {x : α} {s : Multiset α} (hx : x ∈ s) :
    SizeOf.sizeOf x < SizeOf.sizeOf s 
Arguments: {α : Type u_1} [SizeOf α] {x : α} {s : Multiset α} (hx : x ∈ s)
Goal: sizeOf x < sizeOf s
-- Multiset.pmap_eq_map
theorem pmap_eq_map (p : α → Prop) (f : α → β) (s : Multiset α) :
    ∀ H, @pmap _ _ p (fun a _ => f a) s H = map f s 
Arguments: {α : Type u_1} {β : Type v} (p : α → Prop) (f : α → β) (s : Multiset α) (H : ∀ a ∈ s, p a)
Goal: Multiset.pmap (fun a x => f a) s H = Multiset.map f s
-- Multiset.pmap_congr
theorem pmap_congr {p q : α → Prop} {f : ∀ a, p a → β} {g : ∀ a, q a → β} (s : Multiset α) :
    ∀ {H₁ H₂}, (∀ a ∈ s, ∀ (h₁ h₂), f a h₁ = g a h₂) → pmap f s H₁ = pmap g s H₂ 
Arguments: {α : Type u_1} {β : Type v} {p q : α → Prop} {f : (a : α) → p a → β} {g : (a : α) → q a → β} (s : Multiset α) {H₁ : ∀ a ∈ s, p a} {H₂ : ∀ a ∈ s, q a}
Goal: (∀ a ∈ s, ∀ (h₁ : p a) (h₂ : q a), f a h₁ = g a h₂) → Multiset.pmap f s H₁ = Multiset.pmap g s H₂
-- Multiset.map_pmap
theorem map_pmap {p : α → Prop} (g : β → γ) (f : ∀ a, p a → β) (s) :
    ∀ H, map g (pmap f s H) = pmap (fun a h => g (f a h)) s H 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} {p : α → Prop} (g : β → γ) (f : (a : α) → p a → β) (s : Multiset α) (H : ∀ a ∈ s, p a)
Goal: Multiset.map g (Multiset.pmap f s H) = Multiset.pmap (fun a h => g (f a h)) s H
-- Multiset.pmap_eq_map_attach
theorem pmap_eq_map_attach {p : α → Prop} (f : ∀ a, p a → β) (s) :
    ∀ H, pmap f s H = s.attach.map fun x => f x.1 (H _ x.2) 
Arguments: {α : Type u_1} {β : Type v} {p : α → Prop} (f : (a : α) → p a → β) (s : Multiset α) (H : ∀ a ∈ s, p a)
Goal: Multiset.pmap f s H = Multiset.map (fun x => f ↑x ⋯) s.attach
-- Multiset.attach_map_val'
theorem attach_map_val' (s : Multiset α) (f : α → β) : (s.attach.map fun i => f i.val) = s.map f 
Arguments: {α : Type u_1} {β : Type v} (s : Multiset α) (f : α → β)
Goal: Multiset.map (fun i => f ↑i) s.attach = Multiset.map f s
-- Multiset.attach_map_val
@[simp]
theorem attach_map_val (s : Multiset α) : s.attach.map Subtype.val = s 
Arguments: {α : Type u_1} (s : Multiset α)
Goal: Multiset.map Subtype.val s.attach = s
-- Multiset.mem_attach
@[simp]
theorem mem_attach (s : Multiset α) : ∀ x, x ∈ s.attach 
Arguments: {α : Type u_1} (s : Multiset α) (x : { x // x ∈ s })
Goal: x ∈ s.attach
-- Multiset.mem_pmap
@[simp]
theorem mem_pmap {p : α → Prop} {f : ∀ a, p a → β} {s H b} :
    b ∈ pmap f s H ↔ ∃ (a : _) (h : a ∈ s), f a (H a h) = b 
Arguments: {α : Type u_1} {β : Type v} {p : α → Prop} {f : (a : α) → p a → β} {s : Multiset α} {H : ∀ a ∈ s, p a} {b : β}
Goal: b ∈ Multiset.pmap f s H ↔ ∃ a, ∃ (h : a ∈ s), f a ⋯ = b
-- Multiset.card_pmap
@[simp]
theorem card_pmap {p : α → Prop} (f : ∀ a, p a → β) (s H) : card (pmap f s H) = card s 
Arguments: {α : Type u_1} {β : Type v} {p : α → Prop} (f : (a : α) → p a → β) (s : Multiset α) (H : ∀ a ∈ s, p a)
Goal: Multiset.card (Multiset.pmap f s H) = Multiset.card s
-- Multiset.card_attach
@[simp]
theorem card_attach {m : Multiset α} : card (attach m) = card m 
Arguments: {α : Type u_1} {m : Multiset α}
Goal: Multiset.card m.attach = Multiset.card m
-- Multiset.attach_zero
@[simp]
theorem attach_zero : (0 : Multiset α).attach = 0 
Arguments: {α : Type u_1}
Goal: Multiset.attach 0 = 0
-- Multiset.attach_cons
theorem attach_cons (a : α) (m : Multiset α) :
    (a ::ₘ m).attach =
      ⟨a, mem_cons_self a m⟩ ::ₘ m.attach.map fun p => ⟨p.1, mem_cons_of_mem p.2⟩ 
Arguments: {α : Type u_1} (a : α) (m : Multiset α)
Goal: (a ::ₘ m).attach = ⟨a, ⋯⟩ ::ₘ Multiset.map (fun p => ⟨↑p, ⋯⟩) m.attach
-- Multiset.coe_sub
@[simp]
theorem coe_sub (s t : List α) : (s - t : Multiset α) = (s.diff t : List α) 
Arguments: {α : Type u_1} [DecidableEq α] (s t : List α)
Goal: ↑s - ↑t = ↑(s.diff t)
-- Multiset.sub_zero
protected theorem sub_zero (s : Multiset α) : s - 0 = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: s - 0 = s
-- Multiset.sub_cons
@[simp]
theorem sub_cons (a : α) (s t : Multiset α) : s - a ::ₘ t = s.erase a - t 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s t : Multiset α)
Goal: s - a ::ₘ t = s.erase a - t
-- Multiset.sub_le_iff_le_add
protected theorem sub_le_iff_le_add : s - t ≤ u ↔ s ≤ u + t 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α}
Goal: s - t ≤ u ↔ s ≤ u + t
-- Multiset.cons_sub_of_le
theorem cons_sub_of_le (a : α) {s t : Multiset α} (h : t ≤ s) : a ::ₘ s - t = a ::ₘ (s - t) 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) {s t : Multiset α} (h : t ≤ s)
Goal: a ::ₘ s - t = a ::ₘ (s - t)
-- Multiset.sub_eq_fold_erase
theorem sub_eq_fold_erase (s t : Multiset α) : s - t = foldl erase erase_comm s t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s - t = Multiset.foldl Multiset.erase ⋯ s t
-- Multiset.card_sub
@[simp]
theorem card_sub {s t : Multiset α} (h : t ≤ s) : card (s - t) = card s - card t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : t ≤ s)
Goal: Multiset.card (s - t) = Multiset.card s - Multiset.card t
-- Multiset.union_def
theorem union_def (s t : Multiset α) : s ∪ t = s - t + t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ∪ t = s - t + t
-- Multiset.le_union_left
theorem le_union_left (s t : Multiset α) : s ≤ s ∪ t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ≤ s ∪ t
-- Multiset.le_union_right
theorem le_union_right (s t : Multiset α) : t ≤ s ∪ t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: t ≤ s ∪ t
-- Multiset.eq_union_left
theorem eq_union_left : t ≤ s → s ∪ t = s 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: t ≤ s → s ∪ t = s
-- Multiset.union_le_union_right
theorem union_le_union_right (h : s ≤ t) (u) : s ∪ u ≤ t ∪ u 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : s ≤ t) (u : Multiset α)
Goal: s ∪ u ≤ t ∪ u
-- Multiset.union_le
theorem union_le (h₁ : s ≤ u) (h₂ : t ≤ u) : s ∪ t ≤ u 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α} (h₁ : s ≤ u) (h₂ : t ≤ u)
Goal: s ∪ t ≤ u
-- Multiset.mem_union
@[simp]
theorem mem_union : a ∈ s ∪ t ↔ a ∈ s ∨ a ∈ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} {a : α}
Goal: a ∈ s ∪ t ↔ a ∈ s ∨ a ∈ t
-- Multiset.map_union
@[simp]
theorem map_union [DecidableEq β] {f : α → β} (finj : Function.Injective f) {s t : Multiset α} :
    map f (s ∪ t) = map f s ∪ map f t 
Arguments: {α : Type u_1} {β : Type v} [DecidableEq α] [DecidableEq β] {f : α → β} (finj : Function.Injective f) {s t : Multiset α}
Goal: Multiset.map f (s ∪ t) = Multiset.map f s ∪ Multiset.map f t
-- Multiset.zero_union
@[simp] theorem zero_union : 0 ∪ s = s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α}
Goal: 0 ∪ s = s
-- Multiset.union_zero
@[simp] theorem union_zero : s ∪ 0 = s 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α}
Goal: s ∪ 0 = s
-- Multiset.inter_zero
@[simp]
theorem inter_zero (s : Multiset α) : s ∩ 0 = 0 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: s ∩ 0 = 0
-- Multiset.zero_inter
@[simp]
theorem zero_inter (s : Multiset α) : 0 ∩ s = 0 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: 0 ∩ s = 0
-- Multiset.cons_inter_of_pos
@[simp]
theorem cons_inter_of_pos {a} (s : Multiset α) {t} : a ∈ t → (a ::ₘ s) ∩ t = a ::ₘ s ∩ t.erase a 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} (s : Multiset α) {t : Multiset α}
Goal: a ∈ t → (a ::ₘ s) ∩ t = a ::ₘ s ∩ t.erase a
-- Multiset.cons_inter_of_neg
@[simp]
theorem cons_inter_of_neg {a} (s : Multiset α) {t} : a ∉ t → (a ::ₘ s) ∩ t = s ∩ t 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} (s : Multiset α) {t : Multiset α}
Goal: a ∉ t → (a ::ₘ s) ∩ t = s ∩ t
-- Multiset.inter_le_left
theorem inter_le_left (s t : Multiset α) : s ∩ t ≤ s 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ∩ t ≤ s
-- Multiset.inter_le_right
theorem inter_le_right (s : Multiset α) : ∀ t, s ∩ t ≤ t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ∩ t ≤ t
-- Multiset.le_inter
theorem le_inter (h₁ : s ≤ t) (h₂ : s ≤ u) : s ≤ t ∩ u 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α} (h₁ : s ≤ t) (h₂ : s ≤ u)
Goal: s ≤ t ∩ u
-- Multiset.mem_inter
@[simp]
theorem mem_inter : a ∈ s ∩ t ↔ a ∈ s ∧ a ∈ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} {a : α}
Goal: a ∈ s ∩ t ↔ a ∈ s ∧ a ∈ t
-- Multiset.sup_eq_union
@[simp]
theorem sup_eq_union (s t : Multiset α) : s ⊔ t = s ∪ t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ⊔ t = s ∪ t
-- Multiset.inf_eq_inter
@[simp]
theorem inf_eq_inter (s t : Multiset α) : s ⊓ t = s ∩ t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ⊓ t = s ∩ t
-- Multiset.le_inter_iff
@[simp]
theorem le_inter_iff : s ≤ t ∩ u ↔ s ≤ t ∧ s ≤ u 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α}
Goal: s ≤ t ∩ u ↔ s ≤ t ∧ s ≤ u
-- Multiset.union_le_iff
@[simp]
theorem union_le_iff : s ∪ t ≤ u ↔ s ≤ u ∧ t ≤ u 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α}
Goal: s ∪ t ≤ u ↔ s ≤ u ∧ t ≤ u
-- Multiset.union_comm
theorem union_comm (s t : Multiset α) : s ∪ t = t ∪ s 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ∪ t = t ∪ s
-- Multiset.inter_comm
theorem inter_comm (s t : Multiset α) : s ∩ t = t ∩ s 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ∩ t = t ∩ s
-- Multiset.eq_union_right
theorem eq_union_right (h : s ≤ t) : s ∪ t = t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : s ≤ t)
Goal: s ∪ t = t
-- Multiset.union_le_union_left
theorem union_le_union_left (h : s ≤ t) (u) : u ∪ s ≤ u ∪ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α} (h : s ≤ t) (u : Multiset α)
Goal: u ∪ s ≤ u ∪ t
-- Multiset.union_le_add
theorem union_le_add (s t : Multiset α) : s ∪ t ≤ s + t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ∪ t ≤ s + t
-- Multiset.union_add_distrib
theorem union_add_distrib (s t u : Multiset α) : s ∪ t + u = s + u ∪ (t + u) 
Arguments: {α : Type u_1} [DecidableEq α] (s t u : Multiset α)
Goal: s ∪ t + u = s + u ∪ (t + u)
-- Multiset.add_union_distrib
theorem add_union_distrib (s t u : Multiset α) : s + (t ∪ u) = s + t ∪ (s + u) 
Arguments: {α : Type u_1} [DecidableEq α] (s t u : Multiset α)
Goal: s + (t ∪ u) = s + t ∪ (s + u)
-- Multiset.cons_union_distrib
theorem cons_union_distrib (a : α) (s t : Multiset α) : a ::ₘ (s ∪ t) = a ::ₘ s ∪ a ::ₘ t 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s t : Multiset α)
Goal: a ::ₘ (s ∪ t) = a ::ₘ s ∪ a ::ₘ t
-- Multiset.inter_add_distrib
theorem inter_add_distrib (s t u : Multiset α) : s ∩ t + u = (s + u) ∩ (t + u) 
Arguments: {α : Type u_1} [DecidableEq α] (s t u : Multiset α)
Goal: s ∩ t + u = (s + u) ∩ (t + u)
-- Multiset.add_inter_distrib
theorem add_inter_distrib (s t u : Multiset α) : s + t ∩ u = (s + t) ∩ (s + u) 
Arguments: {α : Type u_1} [DecidableEq α] (s t u : Multiset α)
Goal: s + t ∩ u = (s + t) ∩ (s + u)
-- Multiset.cons_inter_distrib
theorem cons_inter_distrib (a : α) (s t : Multiset α) : a ::ₘ s ∩ t = (a ::ₘ s) ∩ (a ::ₘ t) 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s t : Multiset α)
Goal: a ::ₘ s ∩ t = (a ::ₘ s) ∩ (a ::ₘ t)
-- Multiset.union_add_inter
theorem union_add_inter (s t : Multiset α) : s ∪ t + s ∩ t = s + t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s ∪ t + s ∩ t = s + t
-- Multiset.sub_add_inter
theorem sub_add_inter (s t : Multiset α) : s - t + s ∩ t = s 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s - t + s ∩ t = s
-- Multiset.sub_inter
theorem sub_inter (s t : Multiset α) : s - s ∩ t = s - t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: s - s ∩ t = s - t
-- Multiset.filter_coe
@[simp, norm_cast] lemma filter_coe (l : List α) : filter p l = l.filter p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : List α)
Goal: Multiset.filter p ↑l = ↑(List.filter (fun b => decide (p b)) l)
-- Multiset.filter_zero
@[simp]
theorem filter_zero : filter p 0 = 0 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p]
Goal: Multiset.filter p 0 = 0
-- Multiset.filter_congr
theorem filter_congr {p q : α → Prop} [DecidablePred p] [DecidablePred q] {s : Multiset α} :
    (∀ x ∈ s, p x ↔ q x) → filter p s = filter q s 
Arguments: {α : Type u_1} {p q : α → Prop} [DecidablePred p] [DecidablePred q] {s : Multiset α}
Goal: (∀ x ∈ s, p x ↔ q x) → Multiset.filter p s = Multiset.filter q s
-- Multiset.filter_add
@[simp]
theorem filter_add (s t : Multiset α) : filter p (s + t) = filter p s + filter p t 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s t : Multiset α)
Goal: Multiset.filter p (s + t) = Multiset.filter p s + Multiset.filter p t
-- Multiset.filter_le
@[simp]
theorem filter_le (s : Multiset α) : filter p s ≤ s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Multiset α)
Goal: Multiset.filter p s ≤ s
-- Multiset.filter_subset
@[simp]
theorem filter_subset (s : Multiset α) : filter p s ⊆ s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Multiset α)
Goal: Multiset.filter p s ⊆ s
-- Multiset.filter_le_filter
theorem filter_le_filter {s t} (h : s ≤ t) : filter p s ≤ filter p t 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] {s t : Multiset α} (h : s ≤ t)
Goal: Multiset.filter p s ≤ Multiset.filter p t
-- Multiset.monotone_filter_left
theorem monotone_filter_left : Monotone (filter p) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p]
Goal: Monotone (Multiset.filter p)
-- Multiset.monotone_filter_right
theorem monotone_filter_right (s : Multiset α) ⦃p q : α → Prop⦄ [DecidablePred p] [DecidablePred q]
    (h : ∀ b, p b → q b) :
    s.filter p ≤ s.filter q 
Arguments: {α : Type u_1} (s : Multiset α) ⦃p q : α → Prop⦄ [DecidablePred p] [DecidablePred q] (h : ∀ (b : α), p b → q b)
Goal: Multiset.filter p s ≤ Multiset.filter q s
-- Multiset.filter_cons_of_pos
@[simp]
theorem filter_cons_of_pos {a : α} (s) : p a → filter p (a ::ₘ s) = a ::ₘ filter p s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} (s : Multiset α)
Goal: p a → Multiset.filter p (a ::ₘ s) = a ::ₘ Multiset.filter p s
-- Multiset.filter_cons_of_neg
@[simp]
theorem filter_cons_of_neg {a : α} (s) : ¬p a → filter p (a ::ₘ s) = filter p s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} (s : Multiset α)
Goal: ¬p a → Multiset.filter p (a ::ₘ s) = Multiset.filter p s
-- Multiset.mem_filter
@[simp]
theorem mem_filter {a : α} {s} : a ∈ filter p s ↔ a ∈ s ∧ p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} {s : Multiset α}
Goal: a ∈ Multiset.filter p s ↔ a ∈ s ∧ p a
-- Multiset.of_mem_filter
theorem of_mem_filter {a : α} {s} (h : a ∈ filter p s) : p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} {s : Multiset α} (h : a ∈ Multiset.filter p s)
Goal: p a
-- Multiset.mem_of_mem_filter
theorem mem_of_mem_filter {a : α} {s} (h : a ∈ filter p s) : a ∈ s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} {s : Multiset α} (h : a ∈ Multiset.filter p s)
Goal: a ∈ s
-- Multiset.mem_filter_of_mem
theorem mem_filter_of_mem {a : α} {l} (m : a ∈ l) (h : p a) : a ∈ filter p l 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} {l : Multiset α} (m : a ∈ l) (h : p a)
Goal: a ∈ Multiset.filter p l
-- Multiset.filter_eq_self
theorem filter_eq_self {s} : filter p s = s ↔ ∀ a ∈ s, p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Multiset α}
Goal: Multiset.filter p s = s ↔ ∀ a ∈ s, p a
-- Multiset.filter_eq_nil
theorem filter_eq_nil {s} : filter p s = 0 ↔ ∀ a ∈ s, ¬p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s : Multiset α}
Goal: Multiset.filter p s = 0 ↔ ∀ a ∈ s, ¬p a
-- Multiset.le_filter
theorem le_filter {s t} : s ≤ filter p t ↔ s ≤ t ∧ ∀ a ∈ s, p a 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {s t : Multiset α}
Goal: s ≤ Multiset.filter p t ↔ s ≤ t ∧ ∀ a ∈ s, p a
-- Multiset.filter_cons
theorem filter_cons {a : α} (s : Multiset α) :
    filter p (a ::ₘ s) = (if p a then {a} else 0) + filter p s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] {a : α} (s : Multiset α)
Goal: Multiset.filter p (a ::ₘ s) = (if p a then {a} else 0) + Multiset.filter p s
-- Multiset.filter_singleton
theorem filter_singleton {a : α} (p : α → Prop) [DecidablePred p] :
    filter p {a} = if p a then {a} else ∅ 
Arguments: {α : Type u_1} {a : α} (p : α → Prop) [DecidablePred p]
Goal: Multiset.filter p {a} = if p a then {a} else ∅
-- Multiset.filter_nsmul
theorem filter_nsmul (s : Multiset α) (n : ℕ) : filter p (n • s) = n • filter p s 
Arguments: {α : Type u_1} {p : α → Prop} [DecidablePred p] (s : Multiset α) (n : ℕ)
Goal: Multiset.filter p (n • s) = n • Multiset.filter p s
-- Multiset.filter_sub
@[simp]
theorem filter_sub [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