ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Multiset.sub_filter_eq_filter_not
@[simp]
theorem sub_filter_eq_filter_not [DecidableEq α] (p) [DecidablePred p] (s : Multiset α) :
    s - s.filter p = s.filter (fun a ↦ ¬ p a) 
Arguments: {α : Type u_1} [DecidableEq α] (p : α → Prop) [DecidablePred p] (s : Multiset α)
Goal: s - Multiset.filter p s = Multiset.filter (fun a => ¬p a) s
-- Multiset.filter_eq'
theorem filter_eq' (s : Multiset α) (b : α) : s.filter (· = b) = replicate (count b s) b 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (b : α)
Goal: Multiset.filter (fun x => x = b) s = Multiset.replicate (Multiset.count b s) b
-- Multiset.filter_eq
theorem filter_eq (s : Multiset α) (b : α) : s.filter (Eq b) = replicate (count b s) b 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (b : α)
Goal: Multiset.filter (Eq b) s = Multiset.replicate (Multiset.count b s) b
-- Multiset.replicate_inter
@[simp]
theorem replicate_inter (n : ℕ) (x : α) (s : Multiset α) :
    replicate n x ∩ s = replicate (min n (s.count x)) x 
Arguments: {α : Type u_1} [DecidableEq α] (n : ℕ) (x : α) (s : Multiset α)
Goal: Multiset.replicate n x ∩ s = Multiset.replicate (min n (Multiset.count x s)) x
-- Multiset.inter_replicate
@[simp]
theorem inter_replicate (s : Multiset α) (n : ℕ) (x : α) :
    s ∩ replicate n x = replicate (min (s.count x) n) x 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (n : ℕ) (x : α)
Goal: s ∩ Multiset.replicate n x = Multiset.replicate (min (Multiset.count x s) n) x
-- Multiset.erase_attach_map_val
theorem erase_attach_map_val (s : Multiset α) (x : {x // x ∈ s}) :
    (s.attach.erase x).map (↑) = s.erase x 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (x : { x // x ∈ s })
Goal: Multiset.map Subtype.val (s.attach.erase x) = s.erase ↑x
-- Multiset.erase_attach_map
theorem erase_attach_map (s : Multiset α) (f : α → β) (x : {x // x ∈ s}) :
    (s.attach.erase x).map (fun j : {x // x ∈ s} ↦ f j) = (s.erase x).map f 
Arguments: {α : Type u_1} {β : Type v} [DecidableEq α] (s : Multiset α) (f : α → β) (x : { x // x ∈ s })
Goal: Multiset.map (fun j => f ↑j) (s.attach.erase x) = Multiset.map f (s.erase ↑x)
-- Multiset.addHom_ext
@[ext]
theorem addHom_ext [AddZeroClass β] ⦃f g : Multiset α →+ β⦄ (h : ∀ x, f {x} = g {x}) : f = g 
Arguments: {α : Type u_1} {β : Type v} [AddZeroClass β] ⦃f g : Multiset α →+ β⦄ (h : ∀ (x : α), f {x} = g {x})
Goal: f = g
-- Multiset.map_le_map_iff
@[simp]
theorem map_le_map_iff {f : α → β} (hf : Function.Injective f) {s t : Multiset α} :
    s.map f ≤ t.map f ↔ s ≤ t 
Arguments: {α : Type u_1} {β : Type v} {f : α → β} (hf : Function.Injective f) {s t : Multiset α}
Goal: Multiset.map f s ≤ Multiset.map f t ↔ s ≤ t
-- Multiset.mapEmbedding_apply
@[simps!]
def mapEmbedding (f : α ↪ β) : Multiset α ↪o Multiset β 
Arguments: {α : Type u_1} {β : Type v} (f : α ↪ β) (s : Multiset α)
Goal: (Multiset.mapEmbedding f) s = Multiset.map (⇑f) s
-- Multiset.count_eq_card_filter_eq
theorem count_eq_card_filter_eq [DecidableEq α] (s : Multiset α) (a : α) :
    s.count a = card (s.filter (a = ·)) 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (a : α)
Goal: Multiset.count a s = Multiset.card (Multiset.filter (fun x => a = x) s)
-- Multiset.map_count_True_eq_filter_card
@[simp]
theorem map_count_True_eq_filter_card (s : Multiset α) (p : α → Prop) [DecidablePred p] :
    (s.map p).count True = card (s.filter p) 
Arguments: {α : Type u_1} (s : Multiset α) (p : α → Prop) [DecidablePred p]
Goal: Multiset.count True (Multiset.map p s) = Multiset.card (Multiset.filter p s)
-- Multiset.rel_iff
@[mk_iff]
inductive Rel (r : α → β → Prop) : Multiset α → Multiset β → Prop
  | zero : Rel r 0 0
  | cons {a b as bs} : r a b → Rel r as bs → Rel r (a ::ₘ as) (b ::ₘ bs)
Arguments: {α : Type u_1} {β : Type v} (r : α → β → Prop)
Goal: ∀ (a : Multiset α) (a_1 : Multiset β),
  Multiset.Rel r a a_1 ↔
    a = 0 ∧ a_1 = 0 ∨ ∃ a_2 b as bs, r a_2 b ∧ Multiset.Rel r as bs ∧ a = a_2 ::ₘ as ∧ a_1 = b ::ₘ bs
-- _private.Mathlib.Data.Multiset.Basic.0.Multiset.rel_flip_aux
private theorem rel_flip_aux {s t} (h : Rel r s t) : Rel (flip r) t s 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {s : Multiset α} {t : Multiset β} (h : Multiset.Rel r s t)
Goal: Multiset.Rel (flip r) t s
-- Multiset.rel_flip
theorem rel_flip {s t} : Rel (flip r) s t ↔ Rel r t s 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {s : Multiset β} {t : Multiset α}
Goal: Multiset.Rel (flip r) s t ↔ Multiset.Rel r t s
-- Multiset.rel_refl_of_refl_on
theorem rel_refl_of_refl_on {m : Multiset α} {r : α → α → Prop} : (∀ x ∈ m, r x x) → Rel r m m 
Arguments: {α : Type u_1} {m : Multiset α} {r : α → α → Prop}
Goal: (∀ x ∈ m, r x x) → Multiset.Rel r m m
-- Multiset.rel_eq_refl
theorem rel_eq_refl {s : Multiset α} : Rel (· = ·) s s 
Arguments: {α : Type u_1} {s : Multiset α}
Goal: Multiset.Rel (fun x x_1 => x = x_1) s s
-- Multiset.rel_eq
theorem rel_eq {s t : Multiset α} : Rel (· = ·) s t ↔ s = t 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: Multiset.Rel (fun x x_1 => x = x_1) s t ↔ s = t
-- Multiset.Rel.mono
theorem Rel.mono {r p : α → β → Prop} {s t} (hst : Rel r s t)
    (h : ∀ a ∈ s, ∀ b ∈ t, r a b → p a b) : Rel p s t 
Arguments: {α : Type u_1} {β : Type v} {r p : α → β → Prop} {s : Multiset α} {t : Multiset β} (hst : Multiset.Rel r s t) (h : ∀ a ∈ s, ∀ b ∈ t, r a b → p a b)
Goal: Multiset.Rel p s t
-- Multiset.Rel.add
theorem Rel.add {s t u v} (hst : Rel r s t) (huv : Rel r u v) : Rel r (s + u) (t + v) 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {s : Multiset α} {t : Multiset β} {u : Multiset α} {v : Multiset β} (hst : Multiset.Rel r s t) (huv : Multiset.Rel r u v)
Goal: Multiset.Rel r (s + u) (t + v)
-- Multiset.rel_flip_eq
theorem rel_flip_eq {s t : Multiset α} : Rel (fun a b => b = a) s t ↔ s = t 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: Multiset.Rel (fun a b => b = a) s t ↔ s = t
-- Multiset.rel_zero_left
@[simp]
theorem rel_zero_left {b : Multiset β} : Rel r 0 b ↔ b = 0 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {b : Multiset β}
Goal: Multiset.Rel r 0 b ↔ b = 0
-- Multiset.rel_zero_right
@[simp]
theorem rel_zero_right {a : Multiset α} : Rel r a 0 ↔ a = 0 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {a : Multiset α}
Goal: Multiset.Rel r a 0 ↔ a = 0
-- Multiset.rel_cons_left
theorem rel_cons_left {a as bs} :
    Rel r (a ::ₘ as) bs ↔ ∃ b bs', r a b ∧ Rel r as bs' ∧ bs = b ::ₘ bs' 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {a : α} {as : Multiset α} {bs : Multiset β}
Goal: Multiset.Rel r (a ::ₘ as) bs ↔ ∃ b bs', r a b ∧ Multiset.Rel r as bs' ∧ bs = b ::ₘ bs'
-- Multiset.rel_cons_right
theorem rel_cons_right {as b bs} :
    Rel r as (b ::ₘ bs) ↔ ∃ a as', r a b ∧ Rel r as' bs ∧ as = a ::ₘ as' 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {as : Multiset α} {b : β} {bs : Multiset β}
Goal: Multiset.Rel r as (b ::ₘ bs) ↔ ∃ a as', r a b ∧ Multiset.Rel r as' bs ∧ as = a ::ₘ as'
-- Multiset.rel_add_left
theorem rel_add_left {as₀ as₁} :
    ∀ {bs}, Rel r (as₀ + as₁) bs ↔ ∃ bs₀ bs₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁ 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {as₀ as₁ : Multiset α} {bs : Multiset β}
Goal: Multiset.Rel r (as₀ + as₁) bs ↔ ∃ bs₀ bs₁, Multiset.Rel r as₀ bs₀ ∧ Multiset.Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
-- Multiset.rel_add_right
theorem rel_add_right {as bs₀ bs₁} :
    Rel r as (bs₀ + bs₁) ↔ ∃ as₀ as₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ as = as₀ + as₁ 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {as : Multiset α} {bs₀ bs₁ : Multiset β}
Goal: Multiset.Rel r as (bs₀ + bs₁) ↔ ∃ as₀ as₁, Multiset.Rel r as₀ bs₀ ∧ Multiset.Rel r as₁ bs₁ ∧ as = as₀ + as₁
-- Multiset.rel_map_left
theorem rel_map_left {s : Multiset γ} {f : γ → α} :
    ∀ {t}, Rel r (s.map f) t ↔ Rel (fun a b => r (f a) b) s t 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} {r : α → β → Prop} {s : Multiset γ} {f : γ → α} {t : Multiset β}
Goal: Multiset.Rel r (Multiset.map f s) t ↔ Multiset.Rel (fun a b => r (f a) b) s t
-- Multiset.rel_map_right
theorem rel_map_right {s : Multiset α} {t : Multiset γ} {f : γ → β} :
    Rel r s (t.map f) ↔ Rel (fun a b => r a (f b)) s t 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} {r : α → β → Prop} {s : Multiset α} {t : Multiset γ} {f : γ → β}
Goal: Multiset.Rel r s (Multiset.map f t) ↔ Multiset.Rel (fun a b => r a (f b)) s t
-- Multiset.rel_map
theorem rel_map {s : Multiset α} {t : Multiset β} {f : α → γ} {g : β → δ} :
    Rel p (s.map f) (t.map g) ↔ Rel (fun a b => p (f a) (g b)) s t 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} {δ : Type u_3} {p : γ → δ → Prop} {s : Multiset α} {t : Multiset β} {f : α → γ} {g : β → δ}
Goal: Multiset.Rel p (Multiset.map f s) (Multiset.map g t) ↔ Multiset.Rel (fun a b => p (f a) (g b)) s t
-- Multiset.card_eq_card_of_rel
theorem card_eq_card_of_rel {r : α → β → Prop} {s : Multiset α} {t : Multiset β} (h : Rel r s t) :
    card s = card t 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {s : Multiset α} {t : Multiset β} (h : Multiset.Rel r s t)
Goal: Multiset.card s = Multiset.card t
-- Multiset.exists_mem_of_rel_of_mem
theorem exists_mem_of_rel_of_mem {r : α → β → Prop} {s : Multiset α} {t : Multiset β}
    (h : Rel r s t) : ∀ {a : α}, a ∈ s → ∃ b ∈ t, r a b 
Arguments: {α : Type u_1} {β : Type v} {r : α → β → Prop} {s : Multiset α} {t : Multiset β} (h : Multiset.Rel r s t) {a : α}
Goal: a ∈ s → ∃ b ∈ t, r a b
-- Multiset.rel_of_forall
theorem rel_of_forall {m1 m2 : Multiset α} {r : α → α → Prop} (h : ∀ a b, a ∈ m1 → b ∈ m2 → r a b)
    (hc : card m1 = card m2) : m1.Rel r m2 
Arguments: {α : Type u_1} {m1 m2 : Multiset α} {r : α → α → Prop} (h : ∀ (a b : α), a ∈ m1 → b ∈ m2 → r a b) (hc : Multiset.card m1 = Multiset.card m2)
Goal: Multiset.Rel r m1 m2
-- Multiset.rel_replicate_left
theorem rel_replicate_left {m : Multiset α} {a : α} {r : α → α → Prop} {n : ℕ} :
    (replicate n a).Rel r m ↔ card m = n ∧ ∀ x, x ∈ m → r a x 
Arguments: {α : Type u_1} {m : Multiset α} {a : α} {r : α → α → Prop} {n : ℕ}
Goal: Multiset.Rel r (Multiset.replicate n a) m ↔ Multiset.card m = n ∧ ∀ x ∈ m, r a x
-- Multiset.rel_replicate_right
theorem rel_replicate_right {m : Multiset α} {a : α} {r : α → α → Prop} {n : ℕ} :
    m.Rel r (replicate n a) ↔ card m = n ∧ ∀ x, x ∈ m → r x a 
Arguments: {α : Type u_1} {m : Multiset α} {a : α} {r : α → α → Prop} {n : ℕ}
Goal: Multiset.Rel r m (Multiset.replicate n a) ↔ Multiset.card m = n ∧ ∀ x ∈ m, r x a
-- Multiset.Rel.trans
protected nonrec -- Porting note: added
theorem Rel.trans (r : α → α → Prop) [IsTrans α r] {s t u : Multiset α} (r1 : Rel r s t)
    (r2 : Rel r t u) : Rel r s u 
Arguments: {α : Type u_1} (r : α → α → Prop) [IsTrans α r] {s t u : Multiset α} (r1 : Multiset.Rel r s t) (r2 : Multiset.Rel r t u)
Goal: Multiset.Rel r s u
-- Multiset.Rel.countP_eq
theorem Rel.countP_eq (r : α → α → Prop) [IsTrans α r] [IsSymm α r] {s t : Multiset α} (x : α)
    [DecidablePred (r x)] (h : Rel r s t) : countP (r x) s = countP (r x) t 
Arguments: {α : Type u_1} (r : α → α → Prop) [IsTrans α r] [IsSymm α r] {s t : Multiset α} (x : α) [DecidablePred (r x)] (h : Multiset.Rel r s t)
Goal: Multiset.countP (r x) s = Multiset.countP (r x) t
-- Multiset.map_eq_map
theorem map_eq_map {f : α → β} (hf : Function.Injective f) {s t : Multiset α} :
    s.map f = t.map f ↔ s = t 
Arguments: {α : Type u_1} {β : Type v} {f : α → β} (hf : Function.Injective f) {s t : Multiset α}
Goal: Multiset.map f s = Multiset.map f t ↔ s = t
-- Multiset.map_injective
theorem map_injective {f : α → β} (hf : Function.Injective f) :
    Function.Injective (Multiset.map f) 
Arguments: {α : Type u_1} {β : Type v} {f : α → β} (hf : Function.Injective f)
Goal: Function.Injective (Multiset.map f)
-- Multiset.filter_attach'
lemma filter_attach' (s : Multiset α) (p : {a // a ∈ s} → Prop) [DecidableEq α]
    [DecidablePred p] :
    s.attach.filter p =
      (s.filter fun x ↦ ∃ h, p ⟨x, h⟩).attach.map (Subtype.map id fun x ↦ mem_of_mem_filter) 
Arguments: {α : Type u_1} (s : Multiset α) (p : { a // a ∈ s } → Prop) [DecidableEq α] [DecidablePred p]
Goal: Multiset.filter p s.attach =
  Multiset.map (Subtype.map id ⋯) (Multiset.filter (fun x => ∃ (h : x ∈ s), p ⟨x, h⟩) s).attach
-- Multiset.map_mk_eq_map_mk_of_rel
theorem map_mk_eq_map_mk_of_rel {r : α → α → Prop} {s t : Multiset α} (hst : s.Rel r t) :
    s.map (Quot.mk r) = t.map (Quot.mk r) 
Arguments: {α : Type u_1} {r : α → α → Prop} {s t : Multiset α} (hst : Multiset.Rel r s t)
Goal: Multiset.map (Quot.mk r) s = Multiset.map (Quot.mk r) t
-- Multiset.exists_multiset_eq_map_quot_mk
theorem exists_multiset_eq_map_quot_mk {r : α → α → Prop} (s : Multiset (Quot r)) :
    ∃ t : Multiset α, s = t.map (Quot.mk r) 
Arguments: {α : Type u_1} {r : α → α → Prop} (s : Multiset (Quot r))
Goal: ∃ t, s = Multiset.map (Quot.mk r) t
-- Multiset.induction_on_multiset_quot
theorem induction_on_multiset_quot {r : α → α → Prop} {p : Multiset (Quot r) → Prop}
    (s : Multiset (Quot r)) : (∀ s : Multiset α, p (s.map (Quot.mk r))) → p s 
Arguments: {α : Type u_1} {r : α → α → Prop} {p : Multiset (Quot r) → Prop} (s : Multiset (Quot r))
Goal: (∀ (s : Multiset α), p (Multiset.map (Quot.mk r) s)) → p s
-- Multiset.coe_disjoint
@[simp]
theorem coe_disjoint (l₁ l₂ : List α) : @Disjoint α l₁ l₂ ↔ l₁.Disjoint l₂ 
Arguments: {α : Type u_1} (l₁ l₂ : List α)
Goal: (↑l₁).Disjoint ↑l₂ ↔ l₁.Disjoint l₂
-- Multiset.Disjoint.symm
@[symm]
theorem Disjoint.symm {s t : Multiset α} (d : Disjoint s t) : Disjoint t s
  
Arguments: {α : Type u_1} {s t : Multiset α} (d : s.Disjoint t)
Goal: t.Disjoint s
-- Multiset.disjoint_comm
theorem disjoint_comm {s t : Multiset α} : Disjoint s t ↔ Disjoint t s 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: s.Disjoint t ↔ t.Disjoint s
-- Multiset.disjoint_left
theorem disjoint_left {s t : Multiset α} : Disjoint s t ↔ ∀ {a}, a ∈ s → a ∉ t 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: s.Disjoint t ↔ ∀ {a : α}, a ∈ s → a ∉ t
-- Multiset.disjoint_right
theorem disjoint_right {s t : Multiset α} : Disjoint s t ↔ ∀ {a}, a ∈ t → a ∉ s 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: s.Disjoint t ↔ ∀ {a : α}, a ∈ t → a ∉ s
-- Multiset.disjoint_iff_ne
theorem disjoint_iff_ne {s t : Multiset α} : Disjoint s t ↔ ∀ a ∈ s, ∀ b ∈ t, a ≠ b 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: s.Disjoint t ↔ ∀ a ∈ s, ∀ b ∈ t, a ≠ b
-- Multiset.disjoint_of_subset_left
theorem disjoint_of_subset_left {s t u : Multiset α} (h : s ⊆ u) (d : Disjoint u t) : Disjoint s t
  
Arguments: {α : Type u_1} {s t u : Multiset α} (h : s ⊆ u) (d : u.Disjoint t)
Goal: s.Disjoint t
-- Multiset.disjoint_of_subset_right
theorem disjoint_of_subset_right {s t u : Multiset α} (h : t ⊆ u) (d : Disjoint s u) : Disjoint s t
  
Arguments: {α : Type u_1} {s t u : Multiset α} (h : t ⊆ u) (d : s.Disjoint u)
Goal: s.Disjoint t
-- Multiset.disjoint_of_le_left
theorem disjoint_of_le_left {s t u : Multiset α} (h : s ≤ u) : Disjoint u t → Disjoint s t 
Arguments: {α : Type u_1} {s t u : Multiset α} (h : s ≤ u)
Goal: u.Disjoint t → s.Disjoint t
-- Multiset.disjoint_of_le_right
theorem disjoint_of_le_right {s t u : Multiset α} (h : t ≤ u) : Disjoint s u → Disjoint s t 
Arguments: {α : Type u_1} {s t u : Multiset α} (h : t ≤ u)
Goal: s.Disjoint u → s.Disjoint t
-- Multiset.zero_disjoint
@[simp]
theorem zero_disjoint (l : Multiset α) : Disjoint 0 l
  
Arguments: {α : Type u_1} (l : Multiset α)
Goal: Multiset.Disjoint 0 l
-- Multiset.singleton_disjoint
@[simp]
theorem singleton_disjoint {l : Multiset α} {a : α} : Disjoint {a} l ↔ a ∉ l 
Arguments: {α : Type u_1} {l : Multiset α} {a : α}
Goal: {a}.Disjoint l ↔ a ∉ l
-- Multiset.disjoint_singleton
@[simp]
theorem disjoint_singleton {l : Multiset α} {a : α} : Disjoint l {a} ↔ a ∉ l 
Arguments: {α : Type u_1} {l : Multiset α} {a : α}
Goal: l.Disjoint {a} ↔ a ∉ l
-- Multiset.disjoint_add_left
@[simp]
theorem disjoint_add_left {s t u : Multiset α} :
    Disjoint (s + t) u ↔ Disjoint s u ∧ Disjoint t u 
Arguments: {α : Type u_1} {s t u : Multiset α}
Goal: (s + t).Disjoint u ↔ s.Disjoint u ∧ t.Disjoint u
-- Multiset.disjoint_add_right
@[simp]
theorem disjoint_add_right {s t u : Multiset α} :
    Disjoint s (t + u) ↔ Disjoint s t ∧ Disjoint s u 
Arguments: {α : Type u_1} {s t u : Multiset α}
Goal: s.Disjoint (t + u) ↔ s.Disjoint t ∧ s.Disjoint u
-- Multiset.disjoint_cons_left
@[simp]
theorem disjoint_cons_left {a : α} {s t : Multiset α} :
    Disjoint (a ::ₘ s) t ↔ a ∉ t ∧ Disjoint s t 
Arguments: {α : Type u_1} {a : α} {s t : Multiset α}
Goal: (a ::ₘ s).Disjoint t ↔ a ∉ t ∧ s.Disjoint t
-- Multiset.disjoint_cons_right
@[simp]
theorem disjoint_cons_right {a : α} {s t : Multiset α} :
    Disjoint s (a ::ₘ t) ↔ a ∉ s ∧ Disjoint s t 
Arguments: {α : Type u_1} {a : α} {s t : Multiset α}
Goal: s.Disjoint (a ::ₘ t) ↔ a ∉ s ∧ s.Disjoint t
-- Multiset.inter_eq_zero_iff_disjoint
theorem inter_eq_zero_iff_disjoint [DecidableEq α] {s t : Multiset α} :
    s ∩ t = 0 ↔ Disjoint s t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s ∩ t = 0 ↔ s.Disjoint t
-- Multiset.disjoint_union_left
@[simp]
theorem disjoint_union_left [DecidableEq α] {s t u : Multiset α} :
    Disjoint (s ∪ t) u ↔ Disjoint s u ∧ Disjoint t u 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α}
Goal: (s ∪ t).Disjoint u ↔ s.Disjoint u ∧ t.Disjoint u
-- Multiset.disjoint_union_right
@[simp]
theorem disjoint_union_right [DecidableEq α] {s t u : Multiset α} :
    Disjoint s (t ∪ u) ↔ Disjoint s t ∧ Disjoint s u 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α}
Goal: s.Disjoint (t ∪ u) ↔ s.Disjoint t ∧ s.Disjoint u
-- Multiset.add_eq_union_iff_disjoint
theorem add_eq_union_iff_disjoint [DecidableEq α] {s t : Multiset α} :
    s + t = s ∪ t ↔ Disjoint s t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s + t = s ∪ t ↔ s.Disjoint t
-- Multiset.add_eq_union_left_of_le
lemma add_eq_union_left_of_le [DecidableEq α] {s t u : Multiset α} (h : t ≤ s) :
    u + s = u ∪ t ↔ u.Disjoint s ∧ s = t 
Arguments: {α : Type u_1} [DecidableEq α] {s t u : Multiset α} (h : t ≤ s)
Goal: u + s = u ∪ t ↔ u.Disjoint s ∧ s = t
-- Multiset.add_eq_union_right_of_le
lemma add_eq_union_right_of_le [DecidableEq α] {x y z : Multiset α} (h : z ≤ y) :
    x + y = x ∪ z ↔ y = z ∧ x.Disjoint y 
Arguments: {α : Type u_1} [DecidableEq α] {x y z : Multiset α} (h : z ≤ y)
Goal: x + y = x ∪ z ↔ y = z ∧ x.Disjoint y
-- Multiset.disjoint_map_map
theorem disjoint_map_map {f : α → γ} {g : β → γ} {s : Multiset α} {t : Multiset β} :
    Disjoint (s.map f) (t.map g) ↔ ∀ a ∈ s, ∀ b ∈ t, f a ≠ g b 
Arguments: {α : Type u_1} {β : Type v} {γ : Type u_2} {f : α → γ} {g : β → γ} {s : Multiset α} {t : Multiset β}
Goal: (Multiset.map f s).Disjoint (Multiset.map g t) ↔ ∀ a ∈ s, ∀ b ∈ t, f a ≠ g b
-- Multiset.pairwise_zero
@[simp]
theorem pairwise_zero (r : α → α → Prop) : Multiset.Pairwise r 0 
Arguments: {α : Type u_1} (r : α → α → Prop)
Goal: Multiset.Pairwise r 0
-- Multiset.pairwise_coe_iff
theorem pairwise_coe_iff {r : α → α → Prop} {l : List α} :
    Multiset.Pairwise r l ↔ ∃ l' : List α, l ~ l' ∧ l'.Pairwise r 
Arguments: {α : Type u_1} {r : α → α → Prop} {l : List α}
Goal: Multiset.Pairwise r ↑l ↔ ∃ l', l ~ l' ∧ List.Pairwise r l'
-- Multiset.pairwise_coe_iff_pairwise
theorem pairwise_coe_iff_pairwise {r : α → α → Prop} (hr : Symmetric r) {l : List α} :
    Multiset.Pairwise r l ↔ l.Pairwise r 
Arguments: {α : Type u_1} {r : α → α → Prop} (hr : Symmetric r) {l : List α}
Goal: Multiset.Pairwise r ↑l ↔ List.Pairwise r l
-- Multiset.map_set_pairwise
theorem map_set_pairwise {f : α → β} {r : β → β → Prop} {m : Multiset α}
    (h : { a | a ∈ m }.Pairwise fun a₁ a₂ => r (f a₁) (f a₂)) : { b | b ∈ m.map f }.Pairwise r 
Arguments: {α : Type u_1} {β : Type v} {f : α → β} {r : β → β → Prop} {m : Multiset α} (h : {a | a ∈ m}.Pairwise fun a₁ a₂ => r (f a₁) (f a₂))
Goal: {b | b ∈ Multiset.map f m}.Pairwise r
-- Multiset.choose_spec
theorem choose_spec (hp : ∃! a, a ∈ l ∧ p a) : choose p l hp ∈ l ∧ p (choose p l hp) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : Multiset α) (hp : ∃! a, a ∈ l ∧ p a)
Goal: Multiset.choose p l hp ∈ l ∧ p (Multiset.choose p l hp)
-- Multiset.choose_mem
theorem choose_mem (hp : ∃! a, a ∈ l ∧ p a) : choose p l hp ∈ l 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : Multiset α) (hp : ∃! a, a ∈ l ∧ p a)
Goal: Multiset.choose p l hp ∈ l
-- Multiset.choose_property
theorem choose_property (hp : ∃! a, a ∈ l ∧ p a) : p (choose p l hp) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (l : Multiset α) (hp : ∃! a, a ∈ l ∧ p a)
Goal: p (Multiset.choose p l hp)
-- Multiset.coe_subsingletonEquiv
@[simp]
theorem coe_subsingletonEquiv [Subsingleton α] :
    (subsingletonEquiv α : List α → Multiset α) = ofList 
Arguments: {α : Type u_1} [Subsingleton α]
Goal: ⇑(Multiset.subsingletonEquiv α) = Multiset.ofList
-- ZMod.val_lt
theorem val_lt {n : ℕ} [NeZero n] (a : ZMod n) : a.val < n 
Arguments: {n : ℕ} [NeZero n] (a : ZMod n)
Goal: a.val < n
-- ZMod.val_le
theorem val_le {n : ℕ} [NeZero n] (a : ZMod n) : a.val ≤ n 
Arguments: {n : ℕ} [NeZero n] (a : ZMod n)
Goal: a.val ≤ n
-- ZMod.val_zero
@[simp]
theorem val_zero : ∀ {n}, (0 : ZMod n).val = 0
  
Arguments: {n : ℕ}
Goal: ZMod.val 0 = 0
-- ZMod.val_one'
@[simp]
theorem val_one' : (1 : ZMod 0).val = 1 
Goal: ZMod.val 1 = 1
-- ZMod.val_neg'
@[simp]
theorem val_neg' {n : ZMod 0} : (-n).val = n.val 
Arguments: {n : ZMod 0}
Goal: (-n).val = n.val
-- ZMod.val_mul'
@[simp]
theorem val_mul' {m n : ZMod 0} : (m * n).val = m.val * n.val 
Arguments: {m n : ZMod 0}
Goal: (m * n).val = m.val * n.val
-- ZMod.val_natCast
@[simp]
theorem val_natCast {n : ℕ} (a : ℕ) : (a : ZMod n).val = a % n 
Arguments: {n : ℕ} (a : ℕ)
Goal: (↑a).val = a % n
-- ZMod.val_unit'
theorem val_unit' {n : ZMod 0} : IsUnit n ↔ n.val = 1 
Arguments: {n : ZMod 0}
Goal: IsUnit n ↔ n.val = 1
-- ZMod.eq_one_of_isUnit_natCast
lemma eq_one_of_isUnit_natCast {n : ℕ} (h : IsUnit (n : ZMod 0)) : n = 1 
Arguments: {n : ℕ} (h : IsUnit ↑n)
Goal: n = 1
-- ZMod.val_natCast_of_lt
theorem val_natCast_of_lt {n a : ℕ} (h : a < n) : (a : ZMod n).val = a 
Arguments: {n a : ℕ} (h : a < n)
Goal: (↑a).val = a
-- ZMod.addOrderOf_one
@[simp]
theorem addOrderOf_one (n : ℕ) : addOrderOf (1 : ZMod n) = n 
Arguments: (n : ℕ)
Goal: addOrderOf 1 = n
-- ZMod.addOrderOf_coe
@[simp]
theorem addOrderOf_coe (a : ℕ) {n : ℕ} (n0 : n ≠ 0) : addOrderOf (a : ZMod n) = n / n.gcd a 
Arguments: (a : ℕ) {n : ℕ} (n0 : n ≠ 0)
Goal: addOrderOf ↑a = n / n.gcd a
-- ZMod.addOrderOf_coe'
@[simp]
theorem addOrderOf_coe' {a : ℕ} (n : ℕ) (a0 : a ≠ 0) : addOrderOf (a : ZMod n) = n / n.gcd a 
Arguments: {a : ℕ} (n : ℕ) (a0 : a ≠ 0)
Goal: addOrderOf ↑a = n / n.gcd a
-- ZMod.ringChar_zmod_n
theorem ringChar_zmod_n (n : ℕ) : ringChar (ZMod n) = n 
Arguments: (n : ℕ)
Goal: ringChar (ZMod n) = n
-- ZMod.natCast_self
theorem natCast_self (n : ℕ) : (n : ZMod n) = 0 
Arguments: (n : ℕ)
Goal: ↑n = 0
-- ZMod.natCast_self'
@[simp]
theorem natCast_self' (n : ℕ) : (n + 1 : ZMod (n + 1)) = 0 
Arguments: (n : ℕ)
Goal: ↑n + 1 = 0
-- ZMod.cast_zero
@[simp]
theorem cast_zero : (cast (0 : ZMod n) : R) = 0 
Arguments: {n : ℕ} {R : Type u_1} [AddGroupWithOne R]
Goal: ZMod.cast 0 = 0
-- ZMod.cast_eq_val
theorem cast_eq_val [NeZero n] (a : ZMod n) : (cast a : R) = a.val 
Arguments: {n : ℕ} {R : Type u_1} [AddGroupWithOne R] [NeZero n] (a : ZMod n)
Goal: a.cast = ↑a.val
-- Prod.fst_zmod_cast
@[simp]
theorem _root_.Prod.fst_zmod_cast (a : ZMod n) : (cast a : R × S).fst = cast a 
Arguments: {n : ℕ} {R : Type u_1} [AddGroupWithOne R] {S : Type u_2} [AddGroupWithOne S] (a : ZMod n)
Goal: a.cast.1 = a.cast
-- Prod.snd_zmod_cast
@[simp]
theorem _root_.Prod.snd_zmod_cast (a : ZMod n) : (cast a : R × S).snd = cast a 
Arguments: {n : ℕ} {R : Type u_1} [AddGroupWithOne R] {S : Type u_2} [AddGroupWithOne S] (a : ZMod n)
Goal: a.cast.2 = a.cast
-- ZMod.natCast_zmod_val
theorem natCast_zmod_val {n : ℕ} [NeZero n] (a : ZMod n) : (a.val : ZMod n) = a 
Arguments: {n : ℕ} [NeZero n] (a : ZMod n)
Goal: ↑a.val = a
-- ZMod.natCast_rightInverse
theorem natCast_rightInverse [NeZero n] : Function.RightInverse val ((↑) : ℕ → ZMod n) 
Arguments: {n : ℕ} [NeZero n]
Goal: Function.RightInverse ZMod.val Nat.cast
-- ZMod.natCast_zmod_surjective
theorem natCast_zmod_surjective [NeZero n] : Function.Surjective ((↑) : ℕ → ZMod n) 
Arguments: {n : ℕ} [NeZero n]
Goal: Function.Surjective Nat.cast