ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib.Vector.toList_set
@[simp]
theorem toList_set (v : Vector α n) (i : Fin n) (a : α) :
    (v.set i a).toList = v.toList.set i a 
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n) (i : Fin n) (a : α)
Goal: (v.set i a).toList = v.toList.set (↑i) a
-- Mathlib.Vector.get_set_same
@[simp]
theorem get_set_same (v : Vector α n) (i : Fin n) (a : α) : (v.set i a).get i = a 
Arguments: {n : ℕ} {α : Type u_1} (v : Mathlib.Vector α n) (i : Fin n) (a : α)
Goal: (v.set i a).get i = a
-- Mathlib.Vector.get_set_of_ne
theorem get_set_of_ne {v : Vector α n} {i j : Fin n} (h : i ≠ j) (a : α) :
    (v.set i a).get j = v.get j 
Arguments: {n : ℕ} {α : Type u_1} {v : Mathlib.Vector α n} {i j : Fin n} (h : i ≠ j) (a : α)
Goal: (v.set i a).get j = v.get j
-- Mathlib.Vector.get_set_eq_if
theorem get_set_eq_if {v : Vector α n} {i j : Fin n} (a : α) :
    (v.set i a).get j = if i = j then a else v.get j 
Arguments: {n : ℕ} {α : Type u_1} {v : Mathlib.Vector α n} {i j : Fin n} (a : α)
Goal: (v.set i a).get j = if i = j then a else v.get j
-- Mathlib.Vector.sum_set
@[to_additive]
theorem prod_set [Monoid α] (v : Vector α n) (i : Fin n) (a : α) :
    (v.set i a).toList.prod = (v.take i).toList.prod * a * (v.drop (i + 1)).toList.prod 
Arguments: {n : ℕ} {α : Type u_1} [AddMonoid α] (v : Mathlib.Vector α n) (i : Fin n) (a : α)
Goal: (v.set i a).toList.sum = (Mathlib.Vector.take (↑i) v).toList.sum + a + (Mathlib.Vector.drop (↑i + 1) v).toList.sum
-- Mathlib.Vector.prod_set
@[to_additive]
theorem prod_set [Monoid α] (v : Vector α n) (i : Fin n) (a : α) :
    (v.set i a).toList.prod = (v.take i).toList.prod * a * (v.drop (i + 1)).toList.prod 
Arguments: {n : ℕ} {α : Type u_1} [Monoid α] (v : Mathlib.Vector α n) (i : Fin n) (a : α)
Goal: (v.set i a).toList.prod = (Mathlib.Vector.take (↑i) v).toList.prod * a * (Mathlib.Vector.drop (↑i + 1) v).toList.prod
-- Mathlib.Vector.prod_set'
@[to_additive]
theorem prod_set' [CommGroup α] (v : Vector α n) (i : Fin n) (a : α) :
    (v.set i a).toList.prod = v.toList.prod * (v.get i)⁻¹ * a 
Arguments: {n : ℕ} {α : Type u_1} [CommGroup α] (v : Mathlib.Vector α n) (i : Fin n) (a : α)
Goal: (v.set i a).toList.prod = v.toList.prod * (v.get i)⁻¹ * a
-- Mathlib.Vector.sum_set'
@[to_additive]
theorem prod_set' [CommGroup α] (v : Vector α n) (i : Fin n) (a : α) :
    (v.set i a).toList.prod = v.toList.prod * (v.get i)⁻¹ * a 
Arguments: {n : ℕ} {α : Type u_1} [AddCommGroup α] (v : Mathlib.Vector α n) (i : Fin n) (a : α)
Goal: (v.set i a).toList.sum = v.toList.sum + -v.get i + a
-- Mathlib.Vector.traverse_def
@[simp]
protected theorem traverse_def (f : α → F β) (x : α) :
    ∀ xs : Vector α n, (x ::ᵥ xs).traverse f = cons <$> f x <*> xs.traverse f 
Arguments: {n : ℕ} {F : Type u → Type u} [Applicative F] {α β : Type u} (f : α → F β) (x : α) (xs : Mathlib.Vector α n)
Goal: Mathlib.Vector.traverse f (x ::ᵥ xs) = Seq.seq (Mathlib.Vector.cons <$> f x) fun x => Mathlib.Vector.traverse f xs
-- Mathlib.Vector.id_traverse
protected theorem id_traverse : ∀ x : Vector α n, x.traverse (pure : _ → Id _) = x 
Arguments: {n : ℕ} {α : Type u} (x : Mathlib.Vector α n)
Goal: Mathlib.Vector.traverse pure x = x
-- Mathlib.Vector.comp_traverse
@[nolint unusedArguments]
protected theorem comp_traverse (f : β → F γ) (g : α → G β) (x : Vector α n) :
    Vector.traverse (Comp.mk ∘ Functor.map f ∘ g) x =
      Comp.mk (Vector.traverse f <$> Vector.traverse g x) 
Arguments: {n : ℕ} {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative G] {α β γ : Type u} (f : β → F γ) (g : α → G β) (x : Mathlib.Vector α n)
Goal: Mathlib.Vector.traverse (Functor.Comp.mk ∘ Functor.map f ∘ g) x =
  Functor.Comp.mk (Mathlib.Vector.traverse f <$> Mathlib.Vector.traverse g x)
-- Mathlib.Vector.traverse_eq_map_id
protected theorem traverse_eq_map_id {α β} (f : α → β) :
    ∀ x : Vector α n, x.traverse ((pure : _ → Id _) ∘ f) = (pure : _ → Id _) (map f x) 
Arguments: {n : ℕ} {α β : Type u_1} (f : α → β) (x : Mathlib.Vector α n)
Goal: Mathlib.Vector.traverse (pure ∘ f) x = pure (Mathlib.Vector.map f x)
-- Mathlib.Vector.naturality
protected theorem naturality {α β : Type u} (f : α → F β) (x : Vector α n) :
    η (x.traverse f) = x.traverse (@η _ ∘ f) 
Arguments: {n : ℕ} {F G : Type u → Type u} [Applicative F] [Applicative G] [LawfulApplicative G] [LawfulApplicative F] (η : ApplicativeTransformation F G) {α β : Type u} (f : α → F β) (x : Mathlib.Vector α n)
Goal: (fun {α} => η.app α) (Mathlib.Vector.traverse f x) = Mathlib.Vector.traverse ((fun {α} => η.app α) ∘ f) x
-- Mathlib.Vector.replicate_succ
@[simp]
theorem replicate_succ (val : α) :
    replicate (n+1) val = val ::ᵥ (replicate n val) 
Arguments: {α : Type u_1} {n : ℕ} (val : α)
Goal: Mathlib.Vector.replicate (n + 1) val = val ::ᵥ Mathlib.Vector.replicate n val
-- Mathlib.Vector.get_append_cons_zero
@[simp] lemma get_append_cons_zero : get (append (x ::ᵥ xs) ys) ⟨0, by omega⟩ = x 
Arguments: {α : Type u_1} {m n : ℕ} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector α m) {x : α}
Goal: ((x ::ᵥ xs).append ys).get ⟨0, ⋯⟩ = x
-- Mathlib.Vector.get_append_cons_succ
@[simp]
theorem get_append_cons_succ {i : Fin (n + m)} {h} :
    get (append (x ::ᵥ xs) ys) ⟨i+1, h⟩ = get (append xs ys) i 
Arguments: {α : Type u_1} {m n : ℕ} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector α m) {x : α} {i : Fin (n + m)} {h : ↑i + 1 < n.succ + m}
Goal: ((x ::ᵥ xs).append ys).get ⟨↑i + 1, h⟩ = (xs.append ys).get i
-- Mathlib.Vector.append_nil
@[simp]
theorem append_nil : append xs nil = xs 
Arguments: {α : Type u_1} {n : ℕ} (xs : Mathlib.Vector α n)
Goal: xs.append Mathlib.Vector.nil = xs
-- Mathlib.Vector.get_map₂
@[simp]
theorem get_map₂ (v₁ : Vector α n) (v₂ : Vector β n) (f : α → β → γ) (i : Fin n) :
    get (map₂ f v₁ v₂) i = f (get v₁ i) (get v₂ i) 
Arguments: {α : Type u_2} {β : Type u_3} {n : ℕ} {γ : Type u_1} (v₁ : Mathlib.Vector α n) (v₂ : Mathlib.Vector β n) (f : α → β → γ) (i : Fin n)
Goal: (Mathlib.Vector.map₂ f v₁ v₂).get i = f (v₁.get i) (v₂.get i)
-- Mathlib.Vector.mapAccumr_cons
@[simp]
theorem mapAccumr_cons :
    mapAccumr f (x ::ᵥ xs) s
    = let r := mapAccumr f xs s
      let q := f x r.1
      (q.1, q.2 ::ᵥ r.2) 
Arguments: {α : Type u_2} {n : ℕ} (xs : Mathlib.Vector α n)
Goal: ∀ {α_1 : Type} {β : Type u_1} {f : α → α_1 → α_1 × β} {x : α} {s : α_1},
  Mathlib.Vector.mapAccumr f (x ::ᵥ xs) s =
    let r := Mathlib.Vector.mapAccumr f xs s;
    let q := f x r.1;
    (q.1, q.2 ::ᵥ r.2)
-- Mathlib.Vector.mapAccumr₂_cons
@[simp]
theorem mapAccumr₂_cons :
    mapAccumr₂ f (x ::ᵥ xs) (y ::ᵥ ys) s
    = let r := mapAccumr₂ f xs ys s
      let q := f x y r.1
      (q.1, q.2 ::ᵥ r.2) 
Arguments: {α β : Type} {n : ℕ} (xs : Mathlib.Vector α n) (ys : Mathlib.Vector β n)
Goal: ∀ {α_1 β_1 : Type} {f : α → β → α_1 → α_1 × β_1} {x : α} {y : β} {s : α_1},
  Mathlib.Vector.mapAccumr₂ f (x ::ᵥ xs) (y ::ᵥ ys) s =
    let r := Mathlib.Vector.mapAccumr₂ f xs ys s;
    let q := f x y r.1;
    (q.1, q.2 ::ᵥ r.2)
-- Multiset.coe_nodup
@[simp]
theorem coe_nodup {l : List α} : @Nodup α l ↔ l.Nodup 
Arguments: {α : Type u_1} {l : List α}
Goal: (↑l).Nodup ↔ l.Nodup
-- Multiset.nodup_zero
@[simp]
theorem nodup_zero : @Nodup α 0 
Arguments: {α : Type u_1}
Goal: Multiset.Nodup 0
-- Multiset.nodup_cons
@[simp]
theorem nodup_cons {a : α} {s : Multiset α} : Nodup (a ::ₘ s) ↔ a ∉ s ∧ Nodup s 
Arguments: {α : Type u_1} {a : α} {s : Multiset α}
Goal: (a ::ₘ s).Nodup ↔ a ∉ s ∧ s.Nodup
-- Multiset.Nodup.cons
theorem Nodup.cons (m : a ∉ s) (n : Nodup s) : Nodup (a ::ₘ s) 
Arguments: {α : Type u_1} {s : Multiset α} {a : α} (m : a ∉ s) (n : s.Nodup)
Goal: (a ::ₘ s).Nodup
-- Multiset.nodup_singleton
@[simp]
theorem nodup_singleton : ∀ a : α, Nodup ({a} : Multiset α) 
Arguments: {α : Type u_1} (a : α)
Goal: {a}.Nodup
-- Multiset.Nodup.of_cons
theorem Nodup.of_cons (h : Nodup (a ::ₘ s)) : Nodup s 
Arguments: {α : Type u_1} {s : Multiset α} {a : α} (h : (a ::ₘ s).Nodup)
Goal: s.Nodup
-- Multiset.Nodup.not_mem
theorem Nodup.not_mem (h : Nodup (a ::ₘ s)) : a ∉ s 
Arguments: {α : Type u_1} {s : Multiset α} {a : α} (h : (a ::ₘ s).Nodup)
Goal: a ∉ s
-- Multiset.nodup_of_le
theorem nodup_of_le {s t : Multiset α} (h : s ≤ t) : Nodup t → Nodup s 
Arguments: {α : Type u_1} {s t : Multiset α} (h : s ≤ t)
Goal: t.Nodup → s.Nodup
-- Multiset.not_nodup_pair
theorem not_nodup_pair : ∀ a : α, ¬Nodup (a ::ₘ a ::ₘ 0) 
Arguments: {α : Type u_1} (a : α)
Goal: ¬(a ::ₘ a ::ₘ 0).Nodup
-- Multiset.nodup_iff_le
theorem nodup_iff_le {s : Multiset α} : Nodup s ↔ ∀ a : α, ¬a ::ₘ a ::ₘ 0 ≤ s 
Arguments: {α : Type u_1} {s : Multiset α}
Goal: s.Nodup ↔ ∀ (a : α), ¬a ::ₘ a ::ₘ 0 ≤ s
-- Multiset.nodup_iff_ne_cons_cons
theorem nodup_iff_ne_cons_cons {s : Multiset α} : s.Nodup ↔ ∀ a t, s ≠ a ::ₘ a ::ₘ t 
Arguments: {α : Type u_1} {s : Multiset α}
Goal: s.Nodup ↔ ∀ (a : α) (t : Multiset α), s ≠ a ::ₘ a ::ₘ t
-- Multiset.nodup_iff_count_le_one
theorem nodup_iff_count_le_one [DecidableEq α] {s : Multiset α} : Nodup s ↔ ∀ a, count a s ≤ 1 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α}
Goal: s.Nodup ↔ ∀ (a : α), Multiset.count a s ≤ 1
-- Multiset.nodup_iff_count_eq_one
theorem nodup_iff_count_eq_one [DecidableEq α] : Nodup s ↔ ∀ a ∈ s, count a s = 1 
Arguments: {α : Type u_1} {s : Multiset α} [DecidableEq α]
Goal: s.Nodup ↔ ∀ a ∈ s, Multiset.count a s = 1
-- Multiset.count_eq_one_of_mem
@[simp]
theorem count_eq_one_of_mem [DecidableEq α] {a : α} {s : Multiset α} (d : Nodup s) (h : a ∈ s) :
    count a s = 1 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α} (d : s.Nodup) (h : a ∈ s)
Goal: Multiset.count a s = 1
-- Multiset.count_eq_of_nodup
theorem count_eq_of_nodup [DecidableEq α] {a : α} {s : Multiset α} (d : Nodup s) :
    count a s = if a ∈ s then 1 else 0 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α} (d : s.Nodup)
Goal: Multiset.count a s = if a ∈ s then 1 else 0
-- Multiset.nodup_iff_pairwise
theorem nodup_iff_pairwise {α} {s : Multiset α} : Nodup s ↔ Pairwise (· ≠ ·) s 
Arguments: {α : Type u_4} {s : Multiset α}
Goal: s.Nodup ↔ Multiset.Pairwise (fun x x_1 => x ≠ x_1) s
-- Multiset.Nodup.pairwise
protected theorem Nodup.pairwise : (∀ a ∈ s, ∀ b ∈ s, a ≠ b → r a b) → Nodup s → Pairwise r s 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Multiset α}
Goal: (∀ a ∈ s, ∀ b ∈ s, a ≠ b → r a b) → s.Nodup → Multiset.Pairwise r s
-- Multiset.Pairwise.forall
theorem Pairwise.forall (H : Symmetric r) (hs : Pairwise r s) :
    ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → a ≠ b → r a b 
Arguments: {α : Type u_1} {r : α → α → Prop} {s : Multiset α} (H : Symmetric r) (hs : Multiset.Pairwise r s) ⦃a : α⦄
Goal: a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a ≠ b → r a b
-- Multiset.nodup_add
theorem nodup_add {s t : Multiset α} : Nodup (s + t) ↔ Nodup s ∧ Nodup t ∧ Disjoint s t 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: (s + t).Nodup ↔ s.Nodup ∧ t.Nodup ∧ s.Disjoint t
-- Multiset.disjoint_of_nodup_add
theorem disjoint_of_nodup_add {s t : Multiset α} (d : Nodup (s + t)) : Disjoint s t 
Arguments: {α : Type u_1} {s t : Multiset α} (d : (s + t).Nodup)
Goal: s.Disjoint t
-- Multiset.Nodup.add_iff
theorem Nodup.add_iff (d₁ : Nodup s) (d₂ : Nodup t) : Nodup (s + t) ↔ Disjoint s t 
Arguments: {α : Type u_1} {s t : Multiset α} (d₁ : s.Nodup) (d₂ : t.Nodup)
Goal: (s + t).Nodup ↔ s.Disjoint t
-- Multiset.Nodup.of_map
theorem Nodup.of_map (f : α → β) : Nodup (map f s) → Nodup s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} (f : α → β)
Goal: (Multiset.map f s).Nodup → s.Nodup
-- Multiset.Nodup.map_on
theorem Nodup.map_on {f : α → β} :
    (∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y) → Nodup s → Nodup (map f s) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} {f : α → β}
Goal: (∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y) → s.Nodup → (Multiset.map f s).Nodup
-- Multiset.Nodup.map
theorem Nodup.map {f : α → β} {s : Multiset α} (hf : Injective f) : Nodup s → Nodup (map f s) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {s : Multiset α} (hf : Function.Injective f)
Goal: s.Nodup → (Multiset.map f s).Nodup
-- Multiset.nodup_map_iff_of_inj_on
theorem nodup_map_iff_of_inj_on {f : α → β} (d : ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y) :
    Nodup (map f s) ↔ Nodup s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} {f : α → β} (d : ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y)
Goal: (Multiset.map f s).Nodup ↔ s.Nodup
-- Multiset.nodup_map_iff_of_injective
theorem nodup_map_iff_of_injective {f : α → β} (d : Function.Injective f) :
    Nodup (map f s) ↔ Nodup s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} {f : α → β} (d : Function.Injective f)
Goal: (Multiset.map f s).Nodup ↔ s.Nodup
-- Multiset.inj_on_of_nodup_map
theorem inj_on_of_nodup_map {f : α → β} {s : Multiset α} :
    Nodup (map f s) → ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {s : Multiset α}
Goal: (Multiset.map f s).Nodup → ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y
-- Multiset.nodup_map_iff_inj_on
theorem nodup_map_iff_inj_on {f : α → β} {s : Multiset α} (d : Nodup s) :
    Nodup (map f s) ↔ ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {s : Multiset α} (d : s.Nodup)
Goal: (Multiset.map f s).Nodup ↔ ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y
-- Multiset.Nodup.filter
theorem Nodup.filter (p : α → Prop) [DecidablePred p] {s} : Nodup s → Nodup (filter p s) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] {s : Multiset α}
Goal: s.Nodup → (Multiset.filter p s).Nodup
-- Multiset.nodup_attach
@[simp]
theorem nodup_attach {s : Multiset α} : Nodup (attach s) ↔ Nodup s 
Arguments: {α : Type u_1} {s : Multiset α}
Goal: s.attach.Nodup ↔ s.Nodup
-- Multiset.Nodup.pmap
theorem Nodup.pmap {p : α → Prop} {f : ∀ a, p a → β} {s : Multiset α} {H}
    (hf : ∀ a ha b hb, f a ha = f b hb → a = b) : Nodup s → Nodup (pmap f s H) 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} {f : (a : α) → p a → β} {s : Multiset α} {H : ∀ a ∈ s, p a} (hf : ∀ (a : α) (ha : p a) (b : α) (hb : p b), f a ha = f b hb → a = b)
Goal: s.Nodup → (Multiset.pmap f s H).Nodup
-- Multiset.Nodup.erase_eq_filter
theorem Nodup.erase_eq_filter [DecidableEq α] (a : α) {s} :
    Nodup s → s.erase a = Multiset.filter (· ≠ a) s 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) {s : Multiset α}
Goal: s.Nodup → s.erase a = Multiset.filter (fun x => x ≠ a) s
-- Multiset.Nodup.erase
theorem Nodup.erase [DecidableEq α] (a : α) {l} : Nodup l → Nodup (l.erase a) 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) {l : Multiset α}
Goal: l.Nodup → (l.erase a).Nodup
-- Multiset.Nodup.mem_erase_iff
theorem Nodup.mem_erase_iff [DecidableEq α] {a b : α} {l} (d : Nodup l) :
    a ∈ l.erase b ↔ a ≠ b ∧ a ∈ l 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} {l : Multiset α} (d : l.Nodup)
Goal: a ∈ l.erase b ↔ a ≠ b ∧ a ∈ l
-- Multiset.Nodup.not_mem_erase
theorem Nodup.not_mem_erase [DecidableEq α] {a : α} {s} (h : Nodup s) : a ∉ s.erase a 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α} (h : s.Nodup)
Goal: a ∉ s.erase a
-- Multiset.Nodup.filterMap
protected theorem Nodup.filterMap (f : α → Option β) (H : ∀ a a' b, b ∈ f a → b ∈ f a' → a = a') :
    Nodup s → Nodup (filterMap f s) 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} (f : α → Option β) (H : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a')
Goal: s.Nodup → (Multiset.filterMap f s).Nodup
-- Multiset.nodup_range
theorem nodup_range (n : ℕ) : Nodup (range n) 
Arguments: (n : ℕ)
Goal: (Multiset.range n).Nodup
-- Multiset.Nodup.inter_left
theorem Nodup.inter_left [DecidableEq α] (t) : Nodup s → Nodup (s ∩ t) 
Arguments: {α : Type u_1} {s : Multiset α} [DecidableEq α] (t : Multiset α)
Goal: s.Nodup → (s ∩ t).Nodup
-- Multiset.Nodup.inter_right
theorem Nodup.inter_right [DecidableEq α] (s) : Nodup t → Nodup (s ∩ t) 
Arguments: {α : Type u_1} {t : Multiset α} [DecidableEq α] (s : Multiset α)
Goal: t.Nodup → (s ∩ t).Nodup
-- Multiset.nodup_union
@[simp]
theorem nodup_union [DecidableEq α] {s t : Multiset α} : Nodup (s ∪ t) ↔ Nodup s ∧ Nodup t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: (s ∪ t).Nodup ↔ s.Nodup ∧ t.Nodup
-- Multiset.Nodup.ext
theorem Nodup.ext {s t : Multiset α} : Nodup s → Nodup t → (s = t ↔ ∀ a, a ∈ s ↔ a ∈ t) 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: s.Nodup → t.Nodup → (s = t ↔ ∀ (a : α), a ∈ s ↔ a ∈ t)
-- Multiset.le_iff_subset
theorem le_iff_subset {s t : Multiset α} : Nodup s → (s ≤ t ↔ s ⊆ t) 
Arguments: {α : Type u_1} {s t : Multiset α}
Goal: s.Nodup → (s ≤ t ↔ s ⊆ t)
-- Multiset.range_le
theorem range_le {m n : ℕ} : range m ≤ range n ↔ m ≤ n 
Arguments: {m n : ℕ}
Goal: Multiset.range m ≤ Multiset.range n ↔ m ≤ n
-- Multiset.mem_sub_of_nodup
theorem mem_sub_of_nodup [DecidableEq α] {a : α} {s t : Multiset α} (d : Nodup s) :
    a ∈ s - t ↔ a ∈ s ∧ a ∉ t 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s t : Multiset α} (d : s.Nodup)
Goal: a ∈ s - t ↔ a ∈ s ∧ a ∉ t
-- Multiset.map_eq_map_of_bij_of_nodup
theorem map_eq_map_of_bij_of_nodup (f : α → γ) (g : β → γ) {s : Multiset α} {t : Multiset β}
    (hs : s.Nodup) (ht : t.Nodup) (i : ∀ a ∈ s, β) (hi : ∀ a ha, i a ha ∈ t)
    (i_inj : ∀ a₁ ha₁ a₂ ha₂, i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂)
    (i_surj : ∀ b ∈ t, ∃ a ha, i a ha = b) (h : ∀ a ha, f a = g (i a ha)) : s.map f = t.map g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → γ) (g : β → γ) {s : Multiset α} {t : Multiset β} (hs : s.Nodup) (ht : t.Nodup) (i : (a : α) → a ∈ s → β) (hi : ∀ (a : α) (ha : a ∈ s), i a ha ∈ t) (i_inj : ∀ (a₁ : α) (ha₁ : a₁ ∈ s) (a₂ : α) (ha₂ : a₂ ∈ s), i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂) (i_surj : ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), i a ha = b) (h : ∀ (a : α) (ha : a ∈ s), f a = g (i a ha))
Goal: Multiset.map f s = Multiset.map g t
-- List.sym2_map
theorem sym2_map (f : α → β) (xs : List α) :
    (xs.map f).sym2 = xs.sym2.map (Sym2.map f) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (xs : List α)
Goal: (List.map f xs).sym2 = List.map (Sym2.map f) xs.sym2
-- List.mem_sym2_cons_iff
theorem mem_sym2_cons_iff {x : α} {xs : List α} {z : Sym2 α} :
    z ∈ (x :: xs).sym2 ↔ z = s(x, x) ∨ (∃ y, y ∈ xs ∧ z = s(x, y)) ∨ z ∈ xs.sym2 
Arguments: {α : Type u_1} {x : α} {xs : List α} {z : Sym2 α}
Goal: z ∈ (x :: xs).sym2 ↔ z = s(x, x) ∨ (∃ y ∈ xs, z = s(x, y)) ∨ z ∈ xs.sym2
-- List.sym2_eq_nil_iff
@[simp]
theorem sym2_eq_nil_iff {xs : List α} : xs.sym2 = [] ↔ xs = [] 
Arguments: {α : Type u_1} {xs : List α}
Goal: xs.sym2 = [] ↔ xs = []
-- List.left_mem_of_mk_mem_sym2
theorem left_mem_of_mk_mem_sym2 {xs : List α} {a b : α}
    (h : s(a, b) ∈ xs.sym2) : a ∈ xs 
Arguments: {α : Type u_1} {xs : List α} {a b : α} (h : s(a, b) ∈ xs.sym2)
Goal: a ∈ xs
-- List.right_mem_of_mk_mem_sym2
theorem right_mem_of_mk_mem_sym2 {xs : List α} {a b : α}
    (h : s(a, b) ∈ xs.sym2) : b ∈ xs 
Arguments: {α : Type u_1} {xs : List α} {a b : α} (h : s(a, b) ∈ xs.sym2)
Goal: b ∈ xs
-- List.mk_mem_sym2
theorem mk_mem_sym2 {xs : List α} {a b : α} (ha : a ∈ xs) (hb : b ∈ xs) :
    s(a, b) ∈ xs.sym2 
Arguments: {α : Type u_1} {xs : List α} {a b : α} (ha : a ∈ xs) (hb : b ∈ xs)
Goal: s(a, b) ∈ xs.sym2
-- List.mk_mem_sym2_iff
theorem mk_mem_sym2_iff {xs : List α} {a b : α} :
    s(a, b) ∈ xs.sym2 ↔ a ∈ xs ∧ b ∈ xs 
Arguments: {α : Type u_1} {xs : List α} {a b : α}
Goal: s(a, b) ∈ xs.sym2 ↔ a ∈ xs ∧ b ∈ xs
-- List.mem_sym2_iff
theorem mem_sym2_iff {xs : List α} {z : Sym2 α} :
    z ∈ xs.sym2 ↔ ∀ y ∈ z, y ∈ xs 
Arguments: {α : Type u_1} {xs : List α} {z : Sym2 α}
Goal: z ∈ xs.sym2 ↔ ∀ y ∈ z, y ∈ xs
-- List.Nodup.sym2
protected theorem Nodup.sym2 {xs : List α} (h : xs.Nodup) : xs.sym2.Nodup 
Arguments: {α : Type u_1} {xs : List α} (h : xs.Nodup)
Goal: xs.sym2.Nodup
-- List.map_mk_sublist_sym2
theorem map_mk_sublist_sym2 (x : α) (xs : List α) (h : x ∈ xs) :
    map (fun y ↦ s(x, y)) xs <+ xs.sym2 
Arguments: {α : Type u_1} (x : α) (xs : List α) (h : x ∈ xs)
Goal: (List.map (fun y => s(x, y)) xs).Sublist xs.sym2
-- List.map_mk_disjoint_sym2
theorem map_mk_disjoint_sym2 (x : α) (xs : List α) (h : x ∉ xs) :
    (map (fun y ↦ s(x, y)) xs).Disjoint xs.sym2 
Arguments: {α : Type u_1} (x : α) (xs : List α) (h : x ∉ xs)
Goal: (List.map (fun y => s(x, y)) xs).Disjoint xs.sym2
-- List.dedup_sym2
theorem dedup_sym2 [DecidableEq α] (xs : List α) : xs.sym2.dedup = xs.dedup.sym2 
Arguments: {α : Type u_1} [DecidableEq α] (xs : List α)
Goal: xs.sym2.dedup = xs.dedup.sym2
-- List.Perm.sym2
protected theorem Perm.sym2 {xs ys : List α} (h : xs ~ ys) :
    xs.sym2 ~ ys.sym2 
Arguments: {α : Type u_1} {xs ys : List α} (h : xs.Perm ys)
Goal: xs.sym2.Perm ys.sym2
-- List.Sublist.sym2
protected theorem Sublist.sym2 {xs ys : List α} (h : xs <+ ys) : xs.sym2 <+ ys.sym2 
Arguments: {α : Type u_1} {xs ys : List α} (h : xs.Sublist ys)
Goal: xs.sym2.Sublist ys.sym2
-- List.Subperm.sym2
protected theorem Subperm.sym2 {xs ys : List α} (h : xs <+~ ys) : xs.sym2 <+~ ys.sym2 
Arguments: {α : Type u_1} {xs ys : List α} (h : xs.Subperm ys)
Goal: xs.sym2.Subperm ys.sym2
-- List.length_sym2
theorem length_sym2 {xs : List α} : xs.sym2.length = Nat.choose (xs.length + 1) 2 
Arguments: {α : Type u_1} {xs : List α}
Goal: xs.sym2.length = (xs.length + 1).choose 2
-- List.sym_one_eq
theorem sym_one_eq : xs.sym 1 = xs.map (· ::ₛ .nil) 
Arguments: {α : Type u_1} {xs : List α}
Goal: List.sym 1 xs = List.map (fun x => x ::ₛ Sym.nil) xs
-- List.sym2_eq_sym_two
theorem sym2_eq_sym_two : xs.sym2.map (Sym2.equivSym α) = xs.sym 2 
Arguments: {α : Type u_1} {xs : List α}
Goal: List.map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs
-- List.sym_map
theorem sym_map {β : Type*} (f : α → β) (n : ℕ) (xs : List α) :
    (xs.map f).sym n = (xs.sym n).map (Sym.map f) 
Arguments: {α : Type u_1} {β : Type u_3} (f : α → β) (n : ℕ) (xs : List α)
Goal: List.sym n (List.map f xs) = List.map (Sym.map f) (List.sym n xs)
-- List.Sublist.sym
protected theorem Sublist.sym (n : ℕ) {xs ys : List α} (h : xs <+ ys) : xs.sym n <+ ys.sym n 
Arguments: {α : Type u_1} (n : ℕ) {xs ys : List α} (h : xs.Sublist ys)
Goal: (List.sym n xs).Sublist (List.sym n ys)
-- List.sym_sublist_sym_cons
theorem sym_sublist_sym_cons {a : α} : xs.sym n <+ (a :: xs).sym n 
Arguments: {α : Type u_1} {xs : List α} {n : ℕ} {a : α}
Goal: (List.sym n xs).Sublist (List.sym n (a :: xs))
-- List.mem_of_mem_of_mem_sym
theorem mem_of_mem_of_mem_sym {n : ℕ} {xs : List α} {a : α} {z : Sym α n}
    (ha : a ∈ z) (hz : z ∈ xs.sym n) : a ∈ xs 
Arguments: {α : Type u_1} {n : ℕ} {xs : List α} {a : α} {z : Sym α n} (ha : a ∈ z) (hz : z ∈ List.sym n xs)
Goal: a ∈ xs
-- List.first_mem_of_cons_mem_sym
theorem first_mem_of_cons_mem_sym {xs : List α} {n : ℕ} {a : α} {z : Sym α n}
    (h : a ::ₛ z ∈ xs.sym (n + 1)) : a ∈ xs 
Arguments: {α : Type u_1} {xs : List α} {n : ℕ} {a : α} {z : Sym α n} (h : a ::ₛ z ∈ List.sym (n + 1) xs)
Goal: a ∈ xs
-- List.Nodup.sym
protected theorem Nodup.sym (n : ℕ) {xs : List α} (h : xs.Nodup) : (xs.sym n).Nodup 
Arguments: {α : Type u_1} (n : ℕ) {xs : List α} (h : xs.Nodup)
Goal: (List.sym n xs).Nodup
-- List.length_sym
theorem length_sym {n : ℕ} {xs : List α} :
    (xs.sym n).length = Nat.multichoose xs.length n 
Arguments: {α : Type u_1} {n : ℕ} {xs : List α}
Goal: (List.sym n xs).length = xs.length.multichoose n
-- Multiset.coe_mk
theorem Multiset.coe_mk {x : α} {i : Fin (m.count x)} : ↑(m.mkToType x i) = x 
Arguments: {α : Type u_1} [DecidableEq α] {m : Multiset α} {x : α} {i : Fin (Multiset.count x m)}
Goal: (m.mkToType x i).fst = x
-- Multiset.coe_mem
@[simp] lemma Multiset.coe_mem {x : m} : ↑x ∈ m 
Arguments: {α : Type u_1} [DecidableEq α] {m : Multiset α} {x : m.ToType}
Goal: x.fst ∈ m
-- Multiset.forall_coe
@[simp]
protected theorem Multiset.forall_coe (p : m → Prop) :
    (∀ x : m, p x) ↔ ∀ (x : α) (i : Fin (m.count x)), p ⟨x, i⟩ 
Arguments: {α : Type u_1} [DecidableEq α] {m : Multiset α} (p : m.ToType → Prop)
Goal: (∀ (x : m.ToType), p x) ↔ ∀ (x : α) (i : Fin (Multiset.count x m)), p ⟨x, i⟩
-- Multiset.exists_coe
@[simp]
protected theorem Multiset.exists_coe (p : m → Prop) :
    (∃ x : m, p x) ↔ ∃ (x : α) (i : Fin (m.count x)), p ⟨x, i⟩ 
Arguments: {α : Type u_1} [DecidableEq α] {m : Multiset α} (p : m.ToType → Prop)
Goal: (∃ x, p x) ↔ ∃ x i, p ⟨x, i⟩
-- Multiset.mem_toEnumFinset
@[simp]
theorem Multiset.mem_toEnumFinset (m : Multiset α) (p : α × ℕ) :
    p ∈ m.toEnumFinset ↔ p.2 < m.count p.1 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α) (p : α × ℕ)
Goal: p ∈ m.toEnumFinset ↔ p.2 < Multiset.count p.1 m