ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.coe_filter
@[simp, norm_cast]
theorem coe_filter (s : Finset α) : ↑(s.filter p) = ({ x ∈ ↑s | p x } : Set α) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Finset α)
Goal: ↑(Finset.filter p s) = {x | x ∈ s ∧ p x}
-- Finset.subset_coe_filter_of_subset_forall
theorem subset_coe_filter_of_subset_forall (s : Finset α) {t : Set α} (h₁ : t ⊆ s)
    (h₂ : ∀ x ∈ t, p x) : t ⊆ s.filter p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s : Finset α) {t : Set α} (h₁ : t ⊆ ↑s) (h₂ : ∀ x ∈ t, p x)
Goal: t ⊆ ↑(Finset.filter p s)
-- Finset.filter_singleton
theorem filter_singleton (a : α) : filter p {a} = if p a then {a} else ∅ 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (a : α)
Goal: Finset.filter p {a} = if p a then {a} else ∅
-- Finset.filter_cons_of_pos
theorem filter_cons_of_pos (a : α) (s : Finset α) (ha : a ∉ s) (hp : p a) :
    filter p (cons a s ha) = cons a (filter p s) (mem_filter.not.mpr <| mt And.left ha) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (a : α) (s : Finset α) (ha : a ∉ s) (hp : p a)
Goal: Finset.filter p (Finset.cons a s ha) = Finset.cons a (Finset.filter p s) ⋯
-- Finset.filter_cons_of_neg
theorem filter_cons_of_neg (a : α) (s : Finset α) (ha : a ∉ s) (hp : ¬p a) :
    filter p (cons a s ha) = filter p s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (a : α) (s : Finset α) (ha : a ∉ s) (hp : ¬p a)
Goal: Finset.filter p (Finset.cons a s ha) = Finset.filter p s
-- Finset.disjoint_filter
theorem disjoint_filter {s : Finset α} {p q : α → Prop} [DecidablePred p] [DecidablePred q] :
    Disjoint (s.filter p) (s.filter q) ↔ ∀ x ∈ s, p x → ¬q x 
Arguments: {α : Type u_1} {s : Finset α} {p q : α → Prop} [DecidablePred p] [DecidablePred q]
Goal: Disjoint (Finset.filter p s) (Finset.filter q s) ↔ ∀ x ∈ s, p x → ¬q x
-- Finset.disjoint_filter_filter
theorem disjoint_filter_filter {s t : Finset α}
    {p q : α → Prop} [DecidablePred p] [DecidablePred q] :
    Disjoint s t → Disjoint (s.filter p) (t.filter q) 
Arguments: {α : Type u_1} {s t : Finset α} {p q : α → Prop} [DecidablePred p] [DecidablePred q]
Goal: Disjoint s t → Disjoint (Finset.filter p s) (Finset.filter q t)
-- Finset.disjoint_filter_filter'
theorem disjoint_filter_filter' (s t : Finset α)
    {p q : α → Prop} [DecidablePred p] [DecidablePred q] (h : Disjoint p q) :
    Disjoint (s.filter p) (t.filter q) 
Arguments: {α : Type u_1} (s t : Finset α) {p q : α → Prop} [DecidablePred p] [DecidablePred q] (h : Disjoint p q)
Goal: Disjoint (Finset.filter p s) (Finset.filter q t)
-- Finset.disjoint_filter_filter_neg
theorem disjoint_filter_filter_neg (s t : Finset α) (p : α → Prop)
    [DecidablePred p] [∀ x, Decidable (¬p x)] :
    Disjoint (s.filter p) (t.filter fun a => ¬p a) 
Arguments: {α : Type u_1} (s t : Finset α) (p : α → Prop) [DecidablePred p] [(x : α) → Decidable ¬p x]
Goal: Disjoint (Finset.filter p s) (Finset.filter (fun a => ¬p a) t)
-- Finset.filter_disj_union
theorem filter_disj_union (s : Finset α) (t : Finset α) (h : Disjoint s t) :
    filter p (disjUnion s t h) = (filter p s).disjUnion (filter p t) (disjoint_filter_filter h) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] (s t : Finset α) (h : Disjoint s t)
Goal: Finset.filter p (s.disjUnion t h) = (Finset.filter p s).disjUnion (Finset.filter p t) ⋯
-- Set.pairwiseDisjoint_filter
lemma _root_.Set.pairwiseDisjoint_filter [DecidableEq β] (f : α → β) (s : Set β) (t : Finset α) :
    s.PairwiseDisjoint fun x ↦ t.filter (f · = x) 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (f : α → β) (s : Set β) (t : Finset α)
Goal: s.PairwiseDisjoint fun x => Finset.filter (fun x_1 => f x_1 = x) t
-- Finset.filter_cons
theorem filter_cons {a : α} (s : Finset α) (ha : a ∉ s) :
    filter p (cons a s ha) =
      (if p a then {a} else ∅ : Finset α).disjUnion (filter p s)
        (by
          split_ifs
          · rw [disjoint_singleton_left]
            exact mem_filter.not.mpr <| mt And.left ha
          · exact disjoint_empty_left _) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] {a : α} (s : Finset α) (ha : a ∉ s)
Goal: Finset.filter p (Finset.cons a s ha) = (if p a then {a} else ∅).disjUnion (Finset.filter p s) ⋯
-- Finset.filter_union
theorem filter_union (s₁ s₂ : Finset α) : (s₁ ∪ s₂).filter p = s₁.filter p ∪ s₂.filter p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (s₁ s₂ : Finset α)
Goal: Finset.filter p (s₁ ∪ s₂) = Finset.filter p s₁ ∪ Finset.filter p s₂
-- Finset.filter_union_right
theorem filter_union_right (s : Finset α) : s.filter p ∪ s.filter q = s.filter fun x => p x ∨ q x 
Arguments: {α : Type u_1} (p q : α → Prop) [DecidablePred p] [DecidablePred q] [DecidableEq α] (s : Finset α)
Goal: Finset.filter p s ∪ Finset.filter q s = Finset.filter (fun x => p x ∨ q x) s
-- Finset.filter_mem_eq_inter
theorem filter_mem_eq_inter {s t : Finset α} [∀ i, Decidable (i ∈ t)] :
    (s.filter fun i => i ∈ t) = s ∩ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Finset α} [(i : α) → Decidable (i ∈ t)]
Goal: Finset.filter (fun i => i ∈ t) s = s ∩ t
-- Finset.filter_inter_distrib
theorem filter_inter_distrib (s t : Finset α) : (s ∩ t).filter p = s.filter p ∩ t.filter p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (s t : Finset α)
Goal: Finset.filter p (s ∩ t) = Finset.filter p s ∩ Finset.filter p t
-- Finset.filter_inter
theorem filter_inter (s t : Finset α) : filter p s ∩ t = filter p (s ∩ t) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (s t : Finset α)
Goal: Finset.filter p s ∩ t = Finset.filter p (s ∩ t)
-- Finset.inter_filter
theorem inter_filter (s t : Finset α) : s ∩ filter p t = filter p (s ∩ t) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (s t : Finset α)
Goal: s ∩ Finset.filter p t = Finset.filter p (s ∩ t)
-- Finset.filter_insert
theorem filter_insert (a : α) (s : Finset α) :
    filter p (insert a s) = if p a then insert a (filter p s) else filter p s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (a : α) (s : Finset α)
Goal: Finset.filter p (insert a s) = if p a then insert a (Finset.filter p s) else Finset.filter p s
-- Finset.filter_erase
theorem filter_erase (a : α) (s : Finset α) : filter p (erase s a) = erase (filter p s) a 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (a : α) (s : Finset α)
Goal: Finset.filter p (s.erase a) = (Finset.filter p s).erase a
-- Finset.filter_or
theorem filter_or (s : Finset α) : (s.filter fun a => p a ∨ q a) = s.filter p ∪ s.filter q 
Arguments: {α : Type u_1} (p q : α → Prop) [DecidablePred p] [DecidablePred q] [DecidableEq α] (s : Finset α)
Goal: Finset.filter (fun a => p a ∨ q a) s = Finset.filter p s ∪ Finset.filter q s
-- Finset.filter_and
theorem filter_and (s : Finset α) : (s.filter fun a => p a ∧ q a) = s.filter p ∩ s.filter q 
Arguments: {α : Type u_1} (p q : α → Prop) [DecidablePred p] [DecidablePred q] [DecidableEq α] (s : Finset α)
Goal: Finset.filter (fun a => p a ∧ q a) s = Finset.filter p s ∩ Finset.filter q s
-- Finset.filter_not
theorem filter_not (s : Finset α) : (s.filter fun a => ¬p a) = s \ s.filter p 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (s : Finset α)
Goal: Finset.filter (fun a => ¬p a) s = s \ Finset.filter p s
-- Finset.filter_and_not
lemma filter_and_not (s : Finset α) (p q : α → Prop) [DecidablePred p] [DecidablePred q] :
    s.filter (fun a ↦ p a ∧ ¬ q a) = s.filter p \ s.filter q 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α) (p q : α → Prop) [DecidablePred p] [DecidablePred q]
Goal: Finset.filter (fun a => p a ∧ ¬q a) s = Finset.filter p s \ Finset.filter q s
-- Finset.sdiff_eq_filter
theorem sdiff_eq_filter (s₁ s₂ : Finset α) : s₁ \ s₂ = filter (· ∉ s₂) s₁ 
Arguments: {α : Type u_1} [DecidableEq α] (s₁ s₂ : Finset α)
Goal: s₁ \ s₂ = Finset.filter (fun x => x ∉ s₂) s₁
-- Finset.sdiff_eq_self
theorem sdiff_eq_self (s₁ s₂ : Finset α) : s₁ \ s₂ = s₁ ↔ s₁ ∩ s₂ ⊆ ∅ 
Arguments: {α : Type u_1} [DecidableEq α] (s₁ s₂ : Finset α)
Goal: s₁ \ s₂ = s₁ ↔ s₁ ∩ s₂ ⊆ ∅
-- Finset.subset_union_elim
theorem subset_union_elim {s : Finset α} {t₁ t₂ : Set α} (h : ↑s ⊆ t₁ ∪ t₂) :
    ∃ s₁ s₂ : Finset α, s₁ ∪ s₂ = s ∧ ↑s₁ ⊆ t₁ ∧ ↑s₂ ⊆ t₂ \ t₁ 
Arguments: {α : Type u_1} [DecidableEq α] {s : Finset α} {t₁ t₂ : Set α} (h : ↑s ⊆ t₁ ∪ t₂)
Goal: ∃ s₁ s₂, s₁ ∪ s₂ = s ∧ ↑s₁ ⊆ t₁ ∧ ↑s₂ ⊆ t₂ \ t₁
-- Finset.filter_eq
theorem filter_eq [DecidableEq β] (s : Finset β) (b : β) :
    s.filter (Eq b) = ite (b ∈ s) {b} ∅ 
Arguments: {β : Type u_2} [DecidableEq β] (s : Finset β) (b : β)
Goal: Finset.filter (Eq b) s = if b ∈ s then {b} else ∅
-- Finset.filter_eq'
theorem filter_eq' [DecidableEq β] (s : Finset β) (b : β) :
    (s.filter fun a => a = b) = ite (b ∈ s) {b} ∅ 
Arguments: {β : Type u_2} [DecidableEq β] (s : Finset β) (b : β)
Goal: Finset.filter (fun a => a = b) s = if b ∈ s then {b} else ∅
-- Finset.filter_ne
theorem filter_ne [DecidableEq β] (s : Finset β) (b : β) :
    (s.filter fun a => b ≠ a) = s.erase b 
Arguments: {β : Type u_2} [DecidableEq β] (s : Finset β) (b : β)
Goal: Finset.filter (fun a => b ≠ a) s = s.erase b
-- Finset.filter_ne'
theorem filter_ne' [DecidableEq β] (s : Finset β) (b : β) : (s.filter fun a => a ≠ b) = s.erase b 
Arguments: {β : Type u_2} [DecidableEq β] (s : Finset β) (b : β)
Goal: Finset.filter (fun a => a ≠ b) s = s.erase b
-- Finset.filter_inter_filter_neg_eq
theorem filter_inter_filter_neg_eq (s t : Finset α) :
    (s.filter p ∩ t.filter fun a => ¬p a) = ∅ 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] (s t : Finset α)
Goal: Finset.filter p s ∩ Finset.filter (fun a => ¬p a) t = ∅
-- Finset.filter_union_filter_of_codisjoint
theorem filter_union_filter_of_codisjoint (s : Finset α) (h : Codisjoint p q) :
    s.filter p ∪ s.filter q = s 
Arguments: {α : Type u_1} (p q : α → Prop) [DecidablePred p] [DecidablePred q] [DecidableEq α] (s : Finset α) (h : Codisjoint p q)
Goal: Finset.filter p s ∪ Finset.filter q s = s
-- Finset.filter_union_filter_neg_eq
theorem filter_union_filter_neg_eq [∀ x, Decidable (¬p x)] (s : Finset α) :
    (s.filter p ∪ s.filter fun a => ¬p a) = s 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] [DecidableEq α] [(x : α) → Decidable ¬p x] (s : Finset α)
Goal: Finset.filter p s ∪ Finset.filter (fun a => ¬p a) s = s
-- Finset.filter_inj
lemma filter_inj : s.filter p = t.filter p ↔ ∀ ⦃a⦄, p a → (a ∈ s ↔ a ∈ t) 
Arguments: {α : Type u_1} (p : α → Prop) [DecidablePred p] {s t : Finset α}
Goal: Finset.filter p s = Finset.filter p t ↔ ∀ ⦃a : α⦄, p a → (a ∈ s ↔ a ∈ t)
-- Finset.filter_inj'
lemma filter_inj' : s.filter p = s.filter q ↔ ∀ ⦃a⦄, a ∈ s → (p a ↔ q a) 
Arguments: {α : Type u_1} (p q : α → Prop) [DecidablePred p] [DecidablePred q] {s : Finset α}
Goal: Finset.filter p s = Finset.filter q s ↔ ∀ ⦃a : α⦄, a ∈ s → (p a ↔ q a)
-- Finset.range_val
@[simp]
theorem range_val (n : ℕ) : (range n).1 = Multiset.range n 
Arguments: (n : ℕ)
Goal: (Finset.range n).val = Multiset.range n
-- Finset.mem_range
@[simp]
theorem mem_range : m ∈ range n ↔ m < n 
Arguments: {n m : ℕ}
Goal: m ∈ Finset.range n ↔ m < n
-- Finset.coe_range
@[simp, norm_cast]
theorem coe_range (n : ℕ) : (range n : Set ℕ) = Set.Iio n 
Arguments: (n : ℕ)
Goal: ↑(Finset.range n) = Set.Iio n
-- Finset.range_zero
@[simp]
theorem range_zero : range 0 = ∅ 
Goal: Finset.range 0 = ∅
-- Finset.range_one
@[simp]
theorem range_one : range 1 = {0} 
Goal: Finset.range 1 = {0}
-- Finset.range_succ
theorem range_succ : range (succ n) = insert n (range n) 
Arguments: {n : ℕ}
Goal: Finset.range n.succ = insert n (Finset.range n)
-- Finset.range_add_one
theorem range_add_one : range (n + 1) = insert n (range n) 
Arguments: {n : ℕ}
Goal: Finset.range (n + 1) = insert n (Finset.range n)
-- Finset.not_mem_range_self
theorem not_mem_range_self : n ∉ range n 
Arguments: {n : ℕ}
Goal: n ∉ Finset.range n
-- Finset.self_mem_range_succ
theorem self_mem_range_succ (n : ℕ) : n ∈ range (n + 1) 
Arguments: (n : ℕ)
Goal: n ∈ Finset.range (n + 1)
-- Finset.range_subset
@[simp]
theorem range_subset {n m} : range n ⊆ range m ↔ n ≤ m 
Arguments: {n m : ℕ}
Goal: Finset.range n ⊆ Finset.range m ↔ n ≤ m
-- Finset.range_mono
theorem range_mono : Monotone range 
Goal: Monotone Finset.range
-- Finset.mem_range_succ_iff
theorem mem_range_succ_iff {a b : ℕ} : a ∈ Finset.range b.succ ↔ a ≤ b 
Arguments: {a b : ℕ}
Goal: a ∈ Finset.range b.succ ↔ a ≤ b
-- Finset.mem_range_le
theorem mem_range_le {n x : ℕ} (hx : x ∈ range n) : x ≤ n 
Arguments: {n x : ℕ} (hx : x ∈ Finset.range n)
Goal: x ≤ n
-- Finset.mem_range_sub_ne_zero
theorem mem_range_sub_ne_zero {n x : ℕ} (hx : x ∈ range n) : n - x ≠ 0 
Arguments: {n x : ℕ} (hx : x ∈ Finset.range n)
Goal: n - x ≠ 0
-- Finset.nonempty_range_iff
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem nonempty_range_iff : (range n).Nonempty ↔ n ≠ 0 
Arguments: {n : ℕ}
Goal: (Finset.range n).Nonempty ↔ n ≠ 0
-- Finset.range_eq_empty_iff
@[simp]
theorem range_eq_empty_iff : range n = ∅ ↔ n = 0 
Arguments: {n : ℕ}
Goal: Finset.range n = ∅ ↔ n = 0
-- Finset.nonempty_range_succ
theorem nonempty_range_succ : (range <| n + 1).Nonempty 
Arguments: {n : ℕ}
Goal: (Finset.range (n + 1)).Nonempty
-- Finset.range_filter_eq
@[simp]
theorem range_filter_eq {n m : ℕ} : (range n).filter (· = m) = if m < n then {m} else ∅ 
Arguments: {n m : ℕ}
Goal: Finset.filter (fun x => x = m) (Finset.range n) = if m < n then {m} else ∅
-- Finset.range_nontrivial
lemma range_nontrivial {n : ℕ} (hn : 1 < n) : (Finset.range n).Nontrivial 
Arguments: {n : ℕ} (hn : 1 < n)
Goal: (Finset.range n).Nontrivial
-- Finset.exists_mem_empty_iff
theorem exists_mem_empty_iff (p : α → Prop) : (∃ x, x ∈ (∅ : Finset α) ∧ p x) ↔ False 
Arguments: {α : Type u_1} (p : α → Prop)
Goal: (∃ x ∈ ∅, p x) ↔ False
-- Finset.exists_mem_insert
theorem exists_mem_insert [DecidableEq α] (a : α) (s : Finset α) (p : α → Prop) :
    (∃ x, x ∈ insert a s ∧ p x) ↔ p a ∨ ∃ x, x ∈ s ∧ p x 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Finset α) (p : α → Prop)
Goal: (∃ x ∈ insert a s, p x) ↔ p a ∨ ∃ x ∈ s, p x
-- Finset.forall_mem_empty_iff
theorem forall_mem_empty_iff (p : α → Prop) : (∀ x, x ∈ (∅ : Finset α) → p x) ↔ True 
Arguments: {α : Type u_1} (p : α → Prop)
Goal: (∀ x ∈ ∅, p x) ↔ True
-- Finset.forall_mem_insert
theorem forall_mem_insert [DecidableEq α] (a : α) (s : Finset α) (p : α → Prop) :
    (∀ x, x ∈ insert a s → p x) ↔ p a ∧ ∀ x, x ∈ s → p x 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Finset α) (p : α → Prop)
Goal: (∀ x ∈ insert a s, p x) ↔ p a ∧ ∀ x ∈ s, p x
-- Finset.forall_of_forall_insert
theorem forall_of_forall_insert [DecidableEq α] {p : α → Prop} {a : α} {s : Finset α}
    (H : ∀ x, x ∈ insert a s → p x) (x) (h : x ∈ s) : p x 
Arguments: {α : Type u_1} [DecidableEq α] {p : α → Prop} {a : α} {s : Finset α} (H : ∀ x ∈ insert a s, p x) (x : α) (h : x ∈ s)
Goal: p x
-- coe_notMemRangeEquiv
@[simp]
theorem coe_notMemRangeEquiv (k : ℕ) :
    (notMemRangeEquiv k : { n // n ∉ range k } → ℕ) = fun (i : { n // n ∉ range k }) => i - k 
Arguments: (k : ℕ)
Goal: ⇑(notMemRangeEquiv k) = fun i => ↑i - k
-- coe_notMemRangeEquiv_symm
@[simp]
theorem coe_notMemRangeEquiv_symm (k : ℕ) :
    ((notMemRangeEquiv k).symm : ℕ → { n // n ∉ range k }) = fun j => ⟨j + k, by simp⟩ 
Arguments: (k : ℕ)
Goal: ⇑(notMemRangeEquiv k).symm = fun j => ⟨j + k, ⋯⟩
-- Multiset.toFinset_val
@[simp]
theorem toFinset_val (s : Multiset α) : s.toFinset.1 = s.dedup 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: s.toFinset.val = s.dedup
-- Multiset.toFinset_eq
theorem toFinset_eq {s : Multiset α} (n : Nodup s) : Finset.mk s n = s.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α} (n : s.Nodup)
Goal: { val := s, nodup := n } = s.toFinset
-- Multiset.Nodup.toFinset_inj
theorem Nodup.toFinset_inj {l l' : Multiset α} (hl : Nodup l) (hl' : Nodup l')
    (h : l.toFinset = l'.toFinset) : l = l' 
Arguments: {α : Type u_1} [DecidableEq α] {l l' : Multiset α} (hl : l.Nodup) (hl' : l'.Nodup) (h : l.toFinset = l'.toFinset)
Goal: l = l'
-- Multiset.mem_toFinset
@[simp]
theorem mem_toFinset {a : α} {s : Multiset α} : a ∈ s.toFinset ↔ a ∈ s 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {s : Multiset α}
Goal: a ∈ s.toFinset ↔ a ∈ s
-- Multiset.toFinset_zero
@[simp]
theorem toFinset_zero : toFinset (0 : Multiset α) = ∅ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Multiset.toFinset 0 = ∅
-- Multiset.toFinset_cons
@[simp]
theorem toFinset_cons (a : α) (s : Multiset α) : toFinset (a ::ₘ s) = insert a (toFinset s) 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (s : Multiset α)
Goal: (a ::ₘ s).toFinset = insert a s.toFinset
-- Multiset.toFinset_singleton
@[simp]
theorem toFinset_singleton (a : α) : toFinset ({a} : Multiset α) = {a} 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: {a}.toFinset = {a}
-- Multiset.toFinset_add
@[simp]
theorem toFinset_add (s t : Multiset α) : toFinset (s + t) = toFinset s ∪ toFinset t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: (s + t).toFinset = s.toFinset ∪ t.toFinset
-- Multiset.toFinset_nsmul
@[simp]
theorem toFinset_nsmul (s : Multiset α) : ∀ n ≠ 0, (n • s).toFinset = s.toFinset
  
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (n : ℕ)
Goal: n ≠ 0 → (n • s).toFinset = s.toFinset
-- Multiset.toFinset_eq_singleton_iff
theorem toFinset_eq_singleton_iff (s : Multiset α) (a : α) :
    s.toFinset = {a} ↔ card s ≠ 0 ∧ s = card s • {a} 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (a : α)
Goal: s.toFinset = {a} ↔ Multiset.card s ≠ 0 ∧ s = Multiset.card s • {a}
-- Multiset.toFinset_inter
@[simp]
theorem toFinset_inter (s t : Multiset α) : toFinset (s ∩ t) = toFinset s ∩ toFinset t 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: (s ∩ t).toFinset = s.toFinset ∩ t.toFinset
-- Multiset.toFinset_union
@[simp]
theorem toFinset_union (s t : Multiset α) : (s ∪ t).toFinset = s.toFinset ∪ t.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (s t : Multiset α)
Goal: (s ∪ t).toFinset = s.toFinset ∪ t.toFinset
-- Multiset.toFinset_eq_empty
@[simp]
theorem toFinset_eq_empty {m : Multiset α} : m.toFinset = ∅ ↔ m = 0 
Arguments: {α : Type u_1} [DecidableEq α] {m : Multiset α}
Goal: m.toFinset = ∅ ↔ m = 0
-- Multiset.toFinset_nonempty
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem toFinset_nonempty : s.toFinset.Nonempty ↔ s ≠ 0 
Arguments: {α : Type u_1} [DecidableEq α] {s : Multiset α}
Goal: s.toFinset.Nonempty ↔ s ≠ 0
-- Multiset.toFinset_subset
@[simp]
theorem toFinset_subset : s.toFinset ⊆ t.toFinset ↔ s ⊆ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s.toFinset ⊆ t.toFinset ↔ s ⊆ t
-- Multiset.toFinset_ssubset
@[simp]
theorem toFinset_ssubset : s.toFinset ⊂ t.toFinset ↔ s ⊂ t 
Arguments: {α : Type u_1} [DecidableEq α] {s t : Multiset α}
Goal: s.toFinset ⊂ t.toFinset ↔ s ⊂ t
-- Multiset.toFinset_dedup
@[simp]
theorem toFinset_dedup (m : Multiset α) : m.dedup.toFinset = m.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (m : Multiset α)
Goal: m.dedup.toFinset = m.toFinset
-- Multiset.toFinset_filter
@[simp]
theorem toFinset_filter (s : Multiset α) (p : α → Prop) [DecidablePred p] :
    Multiset.toFinset (s.filter p) = s.toFinset.filter p 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α) (p : α → Prop) [DecidablePred p]
Goal: (Multiset.filter p s).toFinset = Finset.filter p s.toFinset
-- Finset.val_toFinset
@[simp]
theorem val_toFinset [DecidableEq α] (s : Finset α) : s.val.toFinset = s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: s.val.toFinset = s
-- Finset.val_le_iff_val_subset
theorem val_le_iff_val_subset {a : Finset α} {b : Multiset α} : a.val ≤ b ↔ a.val ⊆ b 
Arguments: {α : Type u_1} {a : Finset α} {b : Multiset α}
Goal: a.val ≤ b ↔ a.val ⊆ b
-- List.toFinset_val
@[simp]
theorem toFinset_val (l : List α) : l.toFinset.1 = (l.dedup : Multiset α) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l.toFinset.val = ↑l.dedup
-- List.toFinset_coe
@[simp]
theorem toFinset_coe (l : List α) : (l : Multiset α).toFinset = l.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: (↑l).toFinset = l.toFinset
-- List.toFinset_eq
theorem toFinset_eq (n : Nodup l) : @Finset.mk α l n = l.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} (n : l.Nodup)
Goal: { val := ↑l, nodup := n } = l.toFinset
-- List.mem_toFinset
@[simp]
theorem mem_toFinset : a ∈ l.toFinset ↔ a ∈ l 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} {a : α}
Goal: a ∈ l.toFinset ↔ a ∈ l
-- List.coe_toFinset
@[simp, norm_cast]
theorem coe_toFinset (l : List α) : (l.toFinset : Set α) = { a | a ∈ l } 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: ↑l.toFinset = {a | a ∈ l}
-- List.toFinset_nil
@[simp]
theorem toFinset_nil : toFinset (@nil α) = ∅ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: [].toFinset = ∅
-- List.toFinset_cons
@[simp]
theorem toFinset_cons : toFinset (a :: l) = insert a (toFinset l) 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} {a : α}
Goal: (a :: l).toFinset = insert a l.toFinset
-- List.toFinset_surj_on
theorem toFinset_surj_on : Set.SurjOn toFinset { l : List α | l.Nodup } Set.univ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Set.SurjOn List.toFinset {l | l.Nodup} Set.univ
-- List.toFinset_surjective
theorem toFinset_surjective : Surjective (toFinset : List α → Finset α) 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Function.Surjective List.toFinset
-- List.toFinset_eq_iff_perm_dedup
theorem toFinset_eq_iff_perm_dedup : l.toFinset = l'.toFinset ↔ l.dedup ~ l'.dedup 
Arguments: {α : Type u_1} [DecidableEq α] {l l' : List α}
Goal: l.toFinset = l'.toFinset ↔ l.dedup.Perm l'.dedup
-- List.toFinset.ext_iff
theorem toFinset.ext_iff {a b : List α} : a.toFinset = b.toFinset ↔ ∀ x, x ∈ a ↔ x ∈ b 
Arguments: {α : Type u_1} [DecidableEq α] {a b : List α}
Goal: a.toFinset = b.toFinset ↔ ∀ (x : α), x ∈ a ↔ x ∈ b
-- List.toFinset.ext
theorem toFinset.ext : (∀ x, x ∈ l ↔ x ∈ l') → l.toFinset = l'.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] {l l' : List α}
Goal: (∀ (x : α), x ∈ l ↔ x ∈ l') → l.toFinset = l'.toFinset
-- List.toFinset_eq_of_perm
theorem toFinset_eq_of_perm (l l' : List α) (h : l ~ l') : l.toFinset = l'.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (l l' : List α) (h : l.Perm l')
Goal: l.toFinset = l'.toFinset
-- List.perm_of_nodup_nodup_toFinset_eq
theorem perm_of_nodup_nodup_toFinset_eq (hl : Nodup l) (hl' : Nodup l')
    (h : l.toFinset = l'.toFinset) : l ~ l' 
Arguments: {α : Type u_1} [DecidableEq α] {l l' : List α} (hl : l.Nodup) (hl' : l'.Nodup) (h : l.toFinset = l'.toFinset)
Goal: l.Perm l'
-- List.toFinset_append
@[simp]
theorem toFinset_append : toFinset (l ++ l') = l.toFinset ∪ l'.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] {l l' : List α}
Goal: (l ++ l').toFinset = l.toFinset ∪ l'.toFinset
-- List.toFinset_reverse
@[simp]
theorem toFinset_reverse {l : List α} : toFinset l.reverse = l.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α}
Goal: l.reverse.toFinset = l.toFinset
-- List.toFinset_replicate_of_ne_zero
theorem toFinset_replicate_of_ne_zero {n : ℕ} (hn : n ≠ 0) :
    (List.replicate n a).toFinset = {a} 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {n : ℕ} (hn : n ≠ 0)
Goal: (List.replicate n a).toFinset = {a}
-- List.toFinset_union
@[simp]
theorem toFinset_union (l l' : List α) : (l ∪ l').toFinset = l.toFinset ∪ l'.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (l l' : List α)
Goal: (l ∪ l').toFinset = l.toFinset ∪ l'.toFinset
-- List.toFinset_inter
@[simp]
theorem toFinset_inter (l l' : List α) : (l ∩ l').toFinset = l.toFinset ∩ l'.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (l l' : List α)
Goal: (l ∩ l').toFinset = l.toFinset ∩ l'.toFinset
-- List.toFinset_eq_empty_iff
@[simp]
theorem toFinset_eq_empty_iff (l : List α) : l.toFinset = ∅ ↔ l = nil 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l.toFinset = ∅ ↔ l = []
-- List.toFinset_nonempty_iff
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem toFinset_nonempty_iff (l : List α) : l.toFinset.Nonempty ↔ l ≠ [] 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l.toFinset.Nonempty ↔ l ≠ []