ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Matroid.dual_indep_iff_exists
@[simp] theorem dual_indep_iff_exists (hI : I ⊆ M.E := by aesop_mat) :
    M✶.Indep I ↔ (∃ B, M.Base B ∧ Disjoint I B) 
Arguments: {α : Type u_1} {M : Matroid α} {I : Set α} (hI : I ⊆ M.E := by aesop_mat)
Goal: M✶.Indep I ↔ ∃ B, M.Base B ∧ Disjoint I B
-- Matroid.dual_dep_iff_forall
theorem dual_dep_iff_forall : (M✶.Dep I) ↔ (∀ B, M.Base B → (I ∩ B).Nonempty) ∧ I ⊆ M.E 
Arguments: {α : Type u_1} {M : Matroid α} {I : Set α}
Goal: M✶.Dep I ↔ (∀ (B : Set α), M.Base B → (I ∩ B).Nonempty) ∧ I ⊆ M.E
-- Matroid.dual_base_iff
@[simp] theorem dual_base_iff (hB : B ⊆ M.E := by aesop_mat) : M✶.Base B ↔ M.Base (M.E \ B) 
Arguments: {α : Type u_1} {M : Matroid α} {B : Set α} (hB : B ⊆ M.E := by aesop_mat)
Goal: M✶.Base B ↔ M.Base (M.E \ B)
-- Matroid.dual_base_iff'
theorem dual_base_iff' : M✶.Base B ↔ M.Base (M.E \ B) ∧ B ⊆ M.E 
Arguments: {α : Type u_1} {M : Matroid α} {B : Set α}
Goal: M✶.Base B ↔ M.Base (M.E \ B) ∧ B ⊆ M.E
-- Matroid.setOf_dual_base_eq
theorem setOf_dual_base_eq : {B | M✶.Base B} = (fun X ↦ M.E \ X) '' {B | M.Base B} 
Arguments: {α : Type u_1} {M : Matroid α}
Goal: {B | M✶.Base B} = (fun X => M.E \ X) '' {B | M.Base B}
-- Matroid.dual_dual
@[simp] theorem dual_dual (M : Matroid α) : M✶✶ = M 
Arguments: {α : Type u_1} (M : Matroid α)
Goal: M✶✶ = M
-- Matroid.dual_involutive
theorem dual_involutive : Function.Involutive (dual : Matroid α → Matroid α) 
Arguments: {α : Type u_1}
Goal: Function.Involutive Matroid.dual
-- Matroid.dual_injective
theorem dual_injective : Function.Injective (dual : Matroid α → Matroid α) 
Arguments: {α : Type u_1}
Goal: Function.Injective Matroid.dual
-- Matroid.dual_inj
@[simp] theorem dual_inj {M₁ M₂ : Matroid α} : M₁✶ = M₂✶ ↔ M₁ = M₂ 
Arguments: {α : Type u_1} {M₁ M₂ : Matroid α}
Goal: M₁✶ = M₂✶ ↔ M₁ = M₂
-- Matroid.eq_dual_comm
theorem eq_dual_comm {M₁ M₂ : Matroid α} : M₁ = M₂✶ ↔ M₂ = M₁✶ 
Arguments: {α : Type u_1} {M₁ M₂ : Matroid α}
Goal: M₁ = M₂✶ ↔ M₂ = M₁✶
-- Matroid.eq_dual_iff_dual_eq
theorem eq_dual_iff_dual_eq {M₁ M₂ : Matroid α} : M₁ = M₂✶ ↔ M₁✶ = M₂ 
Arguments: {α : Type u_1} {M₁ M₂ : Matroid α}
Goal: M₁ = M₂✶ ↔ M₁✶ = M₂
-- Matroid.Base.compl_base_of_dual
theorem Base.compl_base_of_dual (h : M✶.Base B) : M.Base (M.E \ B) 
Arguments: {α : Type u_1} {M : Matroid α} {B : Set α} (h : M✶.Base B)
Goal: M.Base (M.E \ B)
-- Matroid.Base.compl_base_dual
theorem Base.compl_base_dual (h : M.Base B) : M✶.Base (M.E \ B) 
Arguments: {α : Type u_1} {M : Matroid α} {B : Set α} (h : M.Base B)
Goal: M✶.Base (M.E \ B)
-- Matroid.Base.compl_inter_basis_of_inter_basis
theorem Base.compl_inter_basis_of_inter_basis (hB : M.Base B) (hBX : M.Basis (B ∩ X) X) :
    M✶.Basis ((M.E \ B) ∩ (M.E \ X)) (M.E \ X) 
Arguments: {α : Type u_1} {M : Matroid α} {B X : Set α} (hB : M.Base B) (hBX : M.Basis (B ∩ X) X)
Goal: M✶.Basis (M.E \ B ∩ (M.E \ X)) (M.E \ X)
-- Matroid.Base.inter_basis_iff_compl_inter_basis_dual
theorem Base.inter_basis_iff_compl_inter_basis_dual (hB : M.Base B) (hX : X ⊆ M.E := by aesop_mat) :
    M.Basis (B ∩ X) X ↔ M✶.Basis ((M.E \ B) ∩ (M.E \ X)) (M.E \ X) 
Arguments: {α : Type u_1} {M : Matroid α} {B X : Set α} (hB : M.Base B) (hX : X ⊆ M.E := by aesop_mat)
Goal: M.Basis (B ∩ X) X ↔ M✶.Basis (M.E \ B ∩ (M.E \ X)) (M.E \ X)
-- Matroid.base_iff_dual_base_compl
theorem base_iff_dual_base_compl (hB : B ⊆ M.E := by aesop_mat) :
    M.Base B ↔ M✶.Base (M.E \ B) 
Arguments: {α : Type u_1} {M : Matroid α} {B : Set α} (hB : B ⊆ M.E := by aesop_mat)
Goal: M.Base B ↔ M✶.Base (M.E \ B)
-- Matroid.ground_not_base
theorem ground_not_base (M : Matroid α) [h : RkPos M✶] : ¬M.Base M.E 
Arguments: {α : Type u_1} (M : Matroid α) [h : M✶.RkPos]
Goal: ¬M.Base M.E
-- Matroid.Base.ssubset_ground
theorem Base.ssubset_ground [h : RkPos M✶] (hB : M.Base B) : B ⊂ M.E 
Arguments: {α : Type u_1} {M : Matroid α} {B : Set α} [h : M✶.RkPos] (hB : M.Base B)
Goal: B ⊂ M.E
-- Matroid.Indep.ssubset_ground
theorem Indep.ssubset_ground [h : RkPos M✶] (hI : M.Indep I) : I ⊂ M.E 
Arguments: {α : Type u_1} {M : Matroid α} {I : Set α} [h : M✶.RkPos] (hI : M.Indep I)
Goal: I ⊂ M.E
-- Matroid.coindep_def
theorem coindep_def : M.Coindep X ↔ M✶.Indep X 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α}
Goal: M.Coindep X ↔ M✶.Indep X
-- Matroid.Coindep.indep
theorem Coindep.indep (hX : M.Coindep X) : M✶.Indep X 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α} (hX : M.Coindep X)
Goal: M✶.Indep X
-- Matroid.dual_coindep_iff
@[simp] theorem dual_coindep_iff : M✶.Coindep X ↔ M.Indep X 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α}
Goal: M✶.Coindep X ↔ M.Indep X
-- Matroid.Indep.coindep
theorem Indep.coindep (hI : M.Indep I) : M✶.Coindep I 
Arguments: {α : Type u_1} {M : Matroid α} {I : Set α} (hI : M.Indep I)
Goal: M✶.Coindep I
-- Matroid.coindep_iff_exists'
theorem coindep_iff_exists' : M.Coindep X ↔ (∃ B, M.Base B ∧ B ⊆ M.E \ X) ∧ X ⊆ M.E 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α}
Goal: M.Coindep X ↔ (∃ B, M.Base B ∧ B ⊆ M.E \ X) ∧ X ⊆ M.E
-- Matroid.coindep_iff_exists
theorem coindep_iff_exists (hX : X ⊆ M.E := by aesop_mat) :
    M.Coindep X ↔ ∃ B, M.Base B ∧ B ⊆ M.E \ X 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α} (hX : X ⊆ M.E := by aesop_mat)
Goal: M.Coindep X ↔ ∃ B, M.Base B ∧ B ⊆ M.E \ X
-- Matroid.coindep_iff_subset_compl_base
theorem coindep_iff_subset_compl_base : M.Coindep X ↔ ∃ B, M.Base B ∧ X ⊆ M.E \ B 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α}
Goal: M.Coindep X ↔ ∃ B, M.Base B ∧ X ⊆ M.E \ B
-- Matroid.Coindep.subset_ground
@[aesop unsafe 10% (rule_sets := [Matroid])]
theorem Coindep.subset_ground (hX : M.Coindep X) : X ⊆ M.E 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α} (hX : M.Coindep X)
Goal: X ⊆ M.E
-- Matroid.Coindep.exists_base_subset_compl
theorem Coindep.exists_base_subset_compl (h : M.Coindep X) : ∃ B, M.Base B ∧ B ⊆ M.E \ X 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α} (h : M.Coindep X)
Goal: ∃ B, M.Base B ∧ B ⊆ M.E \ X
-- Matroid.Coindep.exists_subset_compl_base
theorem Coindep.exists_subset_compl_base (h : M.Coindep X) : ∃ B, M.Base B ∧ X ⊆ M.E \ B 
Arguments: {α : Type u_1} {M : Matroid α} {X : Set α} (h : M.Coindep X)
Goal: ∃ B, M.Base B ∧ X ⊆ M.E \ B
-- Finset.nodup
structure Finset (α : Type*) where
    val : Multiset α
    nodup : Nodup val
Arguments: {α : Type u_4} (self : Finset α)
Goal: self.val.Nodup
-- Finset.eq_of_veq
theorem eq_of_veq : ∀ {s t : Finset α}, s.1 = t.1 → s = t
  
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s.val = t.val → s = t
-- Finset.val_injective
theorem val_injective : Injective (val : Finset α → Multiset α) 
Arguments: {α : Type u_1}
Goal: Function.Injective Finset.val
-- Finset.val_inj
@[simp]
theorem val_inj {s t : Finset α} : s.1 = t.1 ↔ s = t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s.val = t.val ↔ s = t
-- Finset.dedup_eq_self
@[simp]
theorem dedup_eq_self [DecidableEq α] (s : Finset α) : dedup s.1 = s.1 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: s.val.dedup = s.val
-- Finset.mem_def
theorem mem_def {a : α} {s : Finset α} : a ∈ s ↔ a ∈ s.1 
Arguments: {α : Type u_1} {a : α} {s : Finset α}
Goal: a ∈ s ↔ a ∈ s.val
-- Finset.mem_val
@[simp]
theorem mem_val {a : α} {s : Finset α} : a ∈ s.1 ↔ a ∈ s 
Arguments: {α : Type u_1} {a : α} {s : Finset α}
Goal: a ∈ s.val ↔ a ∈ s
-- Finset.mem_mk
@[simp]
theorem mem_mk {a : α} {s nd} : a ∈ @Finset.mk α s nd ↔ a ∈ s 
Arguments: {α : Type u_1} {a : α} {s : Multiset α} {nd : s.Nodup}
Goal: a ∈ { val := s, nodup := nd } ↔ a ∈ s
-- Finset.forall_mem_not_eq
@[simp] lemma forall_mem_not_eq {s : Finset α} {a : α} : (∀ b ∈ s, ¬ a = b) ↔ a ∉ s 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: (∀ b ∈ s, ¬a = b) ↔ a ∉ s
-- Finset.forall_mem_not_eq'
@[simp] lemma forall_mem_not_eq' {s : Finset α} {a : α} : (∀ b ∈ s, ¬ b = a) ↔ a ∉ s 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: (∀ b ∈ s, ¬b = a) ↔ a ∉ s
-- Finset.mem_coe
@[simp, norm_cast]
theorem mem_coe {a : α} {s : Finset α} : a ∈ (s : Set α) ↔ a ∈ (s : Finset α) 
Arguments: {α : Type u_1} {a : α} {s : Finset α}
Goal: a ∈ ↑s ↔ a ∈ s
-- Finset.setOf_mem
@[simp]
theorem setOf_mem {α} {s : Finset α} : { a | a ∈ s } = s 
Arguments: {α : Type u_4} {s : Finset α}
Goal: {a | a ∈ s} = ↑s
-- Finset.coe_mem
@[simp]
theorem coe_mem {s : Finset α} (x : (s : Set α)) : ↑x ∈ s 
Arguments: {α : Type u_1} {s : Finset α} (x : ↑↑s)
Goal: ↑x ∈ s
-- Finset.mk_coe
theorem mk_coe {s : Finset α} (x : (s : Set α)) {h} : (⟨x, h⟩ : (s : Set α)) = x 
Arguments: {α : Type u_1} {s : Finset α} (x : ↑↑s) {h : ↑x ∈ ↑s}
Goal: ⟨↑x, h⟩ = x
-- Finset.ext_iff
theorem ext_iff {s₁ s₂ : Finset α} : s₁ = s₂ ↔ ∀ a, a ∈ s₁ ↔ a ∈ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: s₁ = s₂ ↔ ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂
-- Finset.ext
@[ext]
theorem ext {s₁ s₂ : Finset α} : (∀ a, a ∈ s₁ ↔ a ∈ s₂) → s₁ = s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: (∀ (a : α), a ∈ s₁ ↔ a ∈ s₂) → s₁ = s₂
-- Finset.coe_inj
@[simp, norm_cast]
theorem coe_inj {s₁ s₂ : Finset α} : (s₁ : Set α) = s₂ ↔ s₁ = s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: ↑s₁ = ↑s₂ ↔ s₁ = s₂
-- Finset.coe_injective
theorem coe_injective {α} : Injective ((↑) : Finset α → Set α) 
Arguments: {α : Type u_4}
Goal: Function.Injective Finset.toSet
-- Finset.forall_coe
protected theorem forall_coe {α : Type*} (s : Finset α) (p : s → Prop) :
    (∀ x : s, p x) ↔ ∀ (x : α) (h : x ∈ s), p ⟨x, h⟩ 
Arguments: {α : Type u_4} (s : Finset α) (p : { x // x ∈ s } → Prop)
Goal: (∀ (x : { x // x ∈ s }), p x) ↔ ∀ (x : α) (h : x ∈ s), p ⟨x, h⟩
-- Finset.exists_coe
protected theorem exists_coe {α : Type*} (s : Finset α) (p : s → Prop) :
    (∃ x : s, p x) ↔ ∃ (x : α) (h : x ∈ s), p ⟨x, h⟩ 
Arguments: {α : Type u_4} (s : Finset α) (p : { x // x ∈ s } → Prop)
Goal: (∃ x, p x) ↔ ∃ x, ∃ (h : x ∈ s), p ⟨x, h⟩
-- Finset.coe_sort_coe
@[simp, norm_cast]
theorem coe_sort_coe (s : Finset α) : ((s : Set α) : Sort _) = s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: ↑↑s = { x // x ∈ s }
-- Finset.subset_def
theorem subset_def : s ⊆ t ↔ s.1 ⊆ t.1 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s ⊆ t ↔ s.val ⊆ t.val
-- Finset.ssubset_def
theorem ssubset_def : s ⊂ t ↔ s ⊆ t ∧ ¬t ⊆ s 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s ⊂ t ↔ s ⊆ t ∧ ¬t ⊆ s
-- Finset.Subset.refl
theorem Subset.refl (s : Finset α) : s ⊆ s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s ⊆ s
-- Finset.Subset.rfl
protected theorem Subset.rfl {s : Finset α} : s ⊆ s 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s ⊆ s
-- Finset.subset_of_eq
protected theorem subset_of_eq {s t : Finset α} (h : s = t) : s ⊆ t 
Arguments: {α : Type u_1} {s t : Finset α} (h : s = t)
Goal: s ⊆ t
-- Finset.Subset.trans
theorem Subset.trans {s₁ s₂ s₃ : Finset α} : s₁ ⊆ s₂ → s₂ ⊆ s₃ → s₁ ⊆ s₃ 
Arguments: {α : Type u_1} {s₁ s₂ s₃ : Finset α}
Goal: s₁ ⊆ s₂ → s₂ ⊆ s₃ → s₁ ⊆ s₃
-- Finset.Superset.trans
theorem Superset.trans {s₁ s₂ s₃ : Finset α} : s₁ ⊇ s₂ → s₂ ⊇ s₃ → s₁ ⊇ s₃ 
Arguments: {α : Type u_1} {s₁ s₂ s₃ : Finset α}
Goal: s₁ ⊇ s₂ → s₂ ⊇ s₃ → s₁ ⊇ s₃
-- Finset.mem_of_subset
theorem mem_of_subset {s₁ s₂ : Finset α} {a : α} : s₁ ⊆ s₂ → a ∈ s₁ → a ∈ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α} {a : α}
Goal: s₁ ⊆ s₂ → a ∈ s₁ → a ∈ s₂
-- Finset.not_mem_mono
theorem not_mem_mono {s t : Finset α} (h : s ⊆ t) {a : α} : a ∉ t → a ∉ s 
Arguments: {α : Type u_1} {s t : Finset α} (h : s ⊆ t) {a : α}
Goal: a ∉ t → a ∉ s
-- Finset.Subset.antisymm
theorem Subset.antisymm {s₁ s₂ : Finset α} (H₁ : s₁ ⊆ s₂) (H₂ : s₂ ⊆ s₁) : s₁ = s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α} (H₁ : s₁ ⊆ s₂) (H₂ : s₂ ⊆ s₁)
Goal: s₁ = s₂
-- Finset.subset_iff
theorem subset_iff {s₁ s₂ : Finset α} : s₁ ⊆ s₂ ↔ ∀ ⦃x⦄, x ∈ s₁ → x ∈ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: s₁ ⊆ s₂ ↔ ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂
-- Finset.coe_subset
@[simp, norm_cast]
theorem coe_subset {s₁ s₂ : Finset α} : (s₁ : Set α) ⊆ s₂ ↔ s₁ ⊆ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: ↑s₁ ⊆ ↑s₂ ↔ s₁ ⊆ s₂
-- Finset.val_le_iff
@[simp]
theorem val_le_iff {s₁ s₂ : Finset α} : s₁.1 ≤ s₂.1 ↔ s₁ ⊆ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: s₁.val ≤ s₂.val ↔ s₁ ⊆ s₂
-- Finset.Subset.antisymm_iff
theorem Subset.antisymm_iff {s₁ s₂ : Finset α} : s₁ = s₂ ↔ s₁ ⊆ s₂ ∧ s₂ ⊆ s₁ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: s₁ = s₂ ↔ s₁ ⊆ s₂ ∧ s₂ ⊆ s₁
-- Finset.not_subset
theorem not_subset : ¬s ⊆ t ↔ ∃ x ∈ s, x ∉ t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: ¬s ⊆ t ↔ ∃ x ∈ s, x ∉ t
-- Finset.le_eq_subset
@[simp]
theorem le_eq_subset : ((· ≤ ·) : Finset α → Finset α → Prop) = (· ⊆ ·) 
Arguments: {α : Type u_1}
Goal: (fun x x_1 => x ≤ x_1) = fun x x_1 => x ⊆ x_1
-- Finset.lt_eq_subset
@[simp]
theorem lt_eq_subset : ((· < ·) : Finset α → Finset α → Prop) = (· ⊂ ·) 
Arguments: {α : Type u_1}
Goal: (fun x x_1 => x < x_1) = fun x x_1 => x ⊂ x_1
-- Finset.le_iff_subset
theorem le_iff_subset {s₁ s₂ : Finset α} : s₁ ≤ s₂ ↔ s₁ ⊆ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: s₁ ≤ s₂ ↔ s₁ ⊆ s₂
-- Finset.lt_iff_ssubset
theorem lt_iff_ssubset {s₁ s₂ : Finset α} : s₁ < s₂ ↔ s₁ ⊂ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: s₁ < s₂ ↔ s₁ ⊂ s₂
-- Finset.coe_ssubset
@[simp, norm_cast]
theorem coe_ssubset {s₁ s₂ : Finset α} : (s₁ : Set α) ⊂ s₂ ↔ s₁ ⊂ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: ↑s₁ ⊂ ↑s₂ ↔ s₁ ⊂ s₂
-- Finset.val_lt_iff
@[simp]
theorem val_lt_iff {s₁ s₂ : Finset α} : s₁.1 < s₂.1 ↔ s₁ ⊂ s₂ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α}
Goal: s₁.val < s₂.val ↔ s₁ ⊂ s₂
-- Finset.val_strictMono
lemma val_strictMono : StrictMono (val : Finset α → Multiset α) 
Arguments: {α : Type u_1}
Goal: StrictMono Finset.val
-- Finset.ssubset_iff_subset_ne
theorem ssubset_iff_subset_ne {s t : Finset α} : s ⊂ t ↔ s ⊆ t ∧ s ≠ t 
Arguments: {α : Type u_1} {s t : Finset α}
Goal: s ⊂ t ↔ s ⊆ t ∧ s ≠ t
-- Finset.ssubset_iff_of_subset
theorem ssubset_iff_of_subset {s₁ s₂ : Finset α} (h : s₁ ⊆ s₂) : s₁ ⊂ s₂ ↔ ∃ x ∈ s₂, x ∉ s₁ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α} (h : s₁ ⊆ s₂)
Goal: s₁ ⊂ s₂ ↔ ∃ x ∈ s₂, x ∉ s₁
-- Finset.ssubset_of_ssubset_of_subset
theorem ssubset_of_ssubset_of_subset {s₁ s₂ s₃ : Finset α} (hs₁s₂ : s₁ ⊂ s₂) (hs₂s₃ : s₂ ⊆ s₃) :
    s₁ ⊂ s₃ 
Arguments: {α : Type u_1} {s₁ s₂ s₃ : Finset α} (hs₁s₂ : s₁ ⊂ s₂) (hs₂s₃ : s₂ ⊆ s₃)
Goal: s₁ ⊂ s₃
-- Finset.ssubset_of_subset_of_ssubset
theorem ssubset_of_subset_of_ssubset {s₁ s₂ s₃ : Finset α} (hs₁s₂ : s₁ ⊆ s₂) (hs₂s₃ : s₂ ⊂ s₃) :
    s₁ ⊂ s₃ 
Arguments: {α : Type u_1} {s₁ s₂ s₃ : Finset α} (hs₁s₂ : s₁ ⊆ s₂) (hs₂s₃ : s₂ ⊂ s₃)
Goal: s₁ ⊂ s₃
-- Finset.exists_of_ssubset
theorem exists_of_ssubset {s₁ s₂ : Finset α} (h : s₁ ⊂ s₂) : ∃ x ∈ s₂, x ∉ s₁ 
Arguments: {α : Type u_1} {s₁ s₂ : Finset α} (h : s₁ ⊂ s₂)
Goal: ∃ x ∈ s₂, x ∉ s₁
-- Finset.coe_coeEmb
@[simp]
theorem coe_coeEmb : ⇑(coeEmb : Finset α ↪o Set α) = ((↑) : Finset α → Set α) 
Arguments: {α : Type u_1}
Goal: ⇑Finset.coeEmb = Finset.toSet
-- Finset.coe_nonempty
@[simp, norm_cast]
theorem coe_nonempty {s : Finset α} : (s : Set α).Nonempty ↔ s.Nonempty 
Arguments: {α : Type u_1} {s : Finset α}
Goal: (↑s).Nonempty ↔ s.Nonempty
-- Finset.nonempty_coe_sort
theorem nonempty_coe_sort {s : Finset α} : Nonempty (s : Type _) ↔ s.Nonempty 
Arguments: {α : Type u_1} {s : Finset α}
Goal: Nonempty { x // x ∈ s } ↔ s.Nonempty
-- Finset.Nonempty.exists_mem
theorem Nonempty.exists_mem {s : Finset α} (h : s.Nonempty) : ∃ x : α, x ∈ s 
Arguments: {α : Type u_1} {s : Finset α} (h : s.Nonempty)
Goal: ∃ x, x ∈ s
-- Finset.Nonempty.mono
theorem Nonempty.mono {s t : Finset α} (hst : s ⊆ t) (hs : s.Nonempty) : t.Nonempty 
Arguments: {α : Type u_1} {s t : Finset α} (hst : s ⊆ t) (hs : s.Nonempty)
Goal: t.Nonempty
-- Finset.Nonempty.forall_const
theorem Nonempty.forall_const {s : Finset α} (h : s.Nonempty) {p : Prop} : (∀ x ∈ s, p) ↔ p 
Arguments: {α : Type u_1} {s : Finset α} (h : s.Nonempty) {p : Prop}
Goal: (∀ x ∈ s, p) ↔ p
-- Finset.Nonempty.to_subtype
theorem Nonempty.to_subtype {s : Finset α} : s.Nonempty → Nonempty s 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.Nonempty → Nonempty { x // x ∈ s }
-- Finset.Nonempty.to_type
theorem Nonempty.to_type {s : Finset α} : s.Nonempty → Nonempty α 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.Nonempty → Nonempty α
-- Finset.empty_val
@[simp]
theorem empty_val : (∅ : Finset α).1 = 0 
Arguments: {α : Type u_1}
Goal: ∅.val = 0
-- Finset.not_mem_empty
@[simp]
theorem not_mem_empty (a : α) : a ∉ (∅ : Finset α) 
Arguments: {α : Type u_1} (a : α)
Goal: a ∉ ∅
-- Finset.not_nonempty_empty
@[simp]
theorem not_nonempty_empty : ¬(∅ : Finset α).Nonempty 
Arguments: {α : Type u_1}
Goal: ¬∅.Nonempty
-- Finset.mk_zero
@[simp]
theorem mk_zero : (⟨0, nodup_zero⟩ : Finset α) = ∅ 
Arguments: {α : Type u_1}
Goal: { val := 0, nodup := ⋯ } = ∅
-- Finset.ne_empty_of_mem
theorem ne_empty_of_mem {a : α} {s : Finset α} (h : a ∈ s) : s ≠ ∅ 
Arguments: {α : Type u_1} {a : α} {s : Finset α} (h : a ∈ s)
Goal: s ≠ ∅
-- Finset.Nonempty.ne_empty
theorem Nonempty.ne_empty {s : Finset α} (h : s.Nonempty) : s ≠ ∅ 
Arguments: {α : Type u_1} {s : Finset α} (h : s.Nonempty)
Goal: s ≠ ∅
-- Finset.empty_subset
@[simp]
theorem empty_subset (s : Finset α) : ∅ ⊆ s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: ∅ ⊆ s
-- Finset.eq_empty_of_forall_not_mem
theorem eq_empty_of_forall_not_mem {s : Finset α} (H : ∀ x, x ∉ s) : s = ∅ 
Arguments: {α : Type u_1} {s : Finset α} (H : ∀ (x : α), x ∉ s)
Goal: s = ∅
-- Finset.eq_empty_iff_forall_not_mem
theorem eq_empty_iff_forall_not_mem {s : Finset α} : s = ∅ ↔ ∀ x, x ∉ s 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s = ∅ ↔ ∀ (x : α), x ∉ s
-- Finset.val_eq_zero
@[simp]
theorem val_eq_zero {s : Finset α} : s.1 = 0 ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.val = 0 ↔ s = ∅
-- Finset.subset_empty
theorem subset_empty {s : Finset α} : s ⊆ ∅ ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s ⊆ ∅ ↔ s = ∅
-- Finset.not_ssubset_empty
@[simp]
theorem not_ssubset_empty (s : Finset α) : ¬s ⊂ ∅ 
Arguments: {α : Type u_1} (s : Finset α)
Goal: ¬s ⊂ ∅
-- Finset.nonempty_of_ne_empty
theorem nonempty_of_ne_empty {s : Finset α} (h : s ≠ ∅) : s.Nonempty 
Arguments: {α : Type u_1} {s : Finset α} (h : s ≠ ∅)
Goal: s.Nonempty
-- Finset.nonempty_iff_ne_empty
theorem nonempty_iff_ne_empty {s : Finset α} : s.Nonempty ↔ s ≠ ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: s.Nonempty ↔ s ≠ ∅
-- Finset.not_nonempty_iff_eq_empty
@[simp]
theorem not_nonempty_iff_eq_empty {s : Finset α} : ¬s.Nonempty ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: ¬s.Nonempty ↔ s = ∅
-- Finset.eq_empty_or_nonempty
theorem eq_empty_or_nonempty (s : Finset α) : s = ∅ ∨ s.Nonempty 
Arguments: {α : Type u_1} (s : Finset α)
Goal: s = ∅ ∨ s.Nonempty
-- Finset.coe_empty
@[simp, norm_cast]
theorem coe_empty : ((∅ : Finset α) : Set α) = ∅ 
Arguments: {α : Type u_1}
Goal: ↑∅ = ∅
-- Finset.coe_eq_empty
@[simp, norm_cast]
theorem coe_eq_empty {s : Finset α} : (s : Set α) = ∅ ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: ↑s = ∅ ↔ s = ∅
-- Finset.isEmpty_coe_sort
theorem isEmpty_coe_sort {s : Finset α} : IsEmpty (s : Type _) ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α}
Goal: IsEmpty { x // x ∈ s } ↔ s = ∅
-- Finset.eq_empty_of_isEmpty
theorem eq_empty_of_isEmpty [IsEmpty α] (s : Finset α) : s = ∅ 
Arguments: {α : Type u_1} [IsEmpty α] (s : Finset α)
Goal: s = ∅
-- Finset.bot_eq_empty
@[simp]
theorem bot_eq_empty : (⊥ : Finset α) = ∅ 
Arguments: {α : Type u_1}
Goal: ⊥ = ∅
-- Finset.empty_ssubset
@[simp]
theorem empty_ssubset : ∅ ⊂ s ↔ s.Nonempty 
Arguments: {α : Type u_1} {s : Finset α}
Goal: ∅ ⊂ s ↔ s.Nonempty
-- Finset.singleton_val
@[simp]
theorem singleton_val (a : α) : ({a} : Finset α).1 = {a} 
Arguments: {α : Type u_1} (a : α)
Goal: {a}.val = {a}
-- Finset.mem_singleton
@[simp]
theorem mem_singleton {a b : α} : b ∈ ({a} : Finset α) ↔ b = a 
Arguments: {α : Type u_1} {a b : α}
Goal: b ∈ {a} ↔ b = a
-- Finset.eq_of_mem_singleton
theorem eq_of_mem_singleton {x y : α} (h : x ∈ ({y} : Finset α)) : x = y 
Arguments: {α : Type u_1} {x y : α} (h : x ∈ {y})
Goal: x = y
-- Finset.not_mem_singleton
theorem not_mem_singleton {a b : α} : a ∉ ({b} : Finset α) ↔ a ≠ b 
Arguments: {α : Type u_1} {a b : α}
Goal: a ∉ {b} ↔ a ≠ b
-- Finset.mem_singleton_self
theorem mem_singleton_self (a : α) : a ∈ ({a} : Finset α) 
Arguments: {α : Type u_1} (a : α)
Goal: a ∈ {a}
-- Finset.val_eq_singleton_iff
@[simp]
theorem val_eq_singleton_iff {a : α} {s : Finset α} : s.val = {a} ↔ s = {a} 
Arguments: {α : Type u_1} {a : α} {s : Finset α}
Goal: s.val = {a} ↔ s = {a}
-- Finset.singleton_injective
theorem singleton_injective : Injective (singleton : α → Finset α) 
Arguments: {α : Type u_1}
Goal: Function.Injective singleton
-- Finset.singleton_inj
@[simp]
theorem singleton_inj : ({a} : Finset α) = {b} ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: {a} = {b} ↔ a = b
-- Finset.singleton_nonempty
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
theorem singleton_nonempty (a : α) : ({a} : Finset α).Nonempty 
Arguments: {α : Type u_1} (a : α)
Goal: {a}.Nonempty
-- Finset.singleton_ne_empty
@[simp]
theorem singleton_ne_empty (a : α) : ({a} : Finset α) ≠ ∅ 
Arguments: {α : Type u_1} (a : α)
Goal: {a} ≠ ∅
-- Finset.empty_ssubset_singleton
theorem empty_ssubset_singleton : (∅ : Finset α) ⊂ {a} 
Arguments: {α : Type u_1} {a : α}
Goal: ∅ ⊂ {a}
-- Finset.coe_singleton
@[simp, norm_cast]
theorem coe_singleton (a : α) : (({a} : Finset α) : Set α) = {a} 
Arguments: {α : Type u_1} (a : α)
Goal: ↑{a} = {a}
-- Finset.coe_eq_singleton
@[simp, norm_cast]
theorem coe_eq_singleton {s : Finset α} {a : α} : (s : Set α) = {a} ↔ s = {a} 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: ↑s = {a} ↔ s = {a}
-- Finset.coe_subset_singleton
@[norm_cast]
lemma coe_subset_singleton : (s : Set α) ⊆ {a} ↔ s ⊆ {a} 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: ↑s ⊆ {a} ↔ s ⊆ {a}
-- Finset.singleton_subset_coe
@[norm_cast]
lemma singleton_subset_coe : {a} ⊆ (s : Set α) ↔ {a} ⊆ s 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: {a} ⊆ ↑s ↔ {a} ⊆ s
-- Finset.eq_singleton_iff_unique_mem
theorem eq_singleton_iff_unique_mem {s : Finset α} {a : α} : s = {a} ↔ a ∈ s ∧ ∀ x ∈ s, x = a 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: s = {a} ↔ a ∈ s ∧ ∀ x ∈ s, x = a
-- Finset.eq_singleton_iff_nonempty_unique_mem
theorem eq_singleton_iff_nonempty_unique_mem {s : Finset α} {a : α} :
    s = {a} ↔ s.Nonempty ∧ ∀ x ∈ s, x = a 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: s = {a} ↔ s.Nonempty ∧ ∀ x ∈ s, x = a
-- Finset.nonempty_iff_eq_singleton_default
theorem nonempty_iff_eq_singleton_default [Unique α] {s : Finset α} :
    s.Nonempty ↔ s = {default} 
Arguments: {α : Type u_1} [Unique α] {s : Finset α}
Goal: s.Nonempty ↔ s = {default}
-- Finset.singleton_iff_unique_mem
theorem singleton_iff_unique_mem (s : Finset α) : (∃ a, s = {a}) ↔ ∃! a, a ∈ s 
Arguments: {α : Type u_1} (s : Finset α)
Goal: (∃ a, s = {a}) ↔ ∃! a, a ∈ s
-- Finset.singleton_subset_set_iff
theorem singleton_subset_set_iff {s : Set α} {a : α} : ↑({a} : Finset α) ⊆ s ↔ a ∈ s 
Arguments: {α : Type u_1} {s : Set α} {a : α}
Goal: ↑{a} ⊆ s ↔ a ∈ s
-- Finset.singleton_subset_iff
@[simp]
theorem singleton_subset_iff {s : Finset α} {a : α} : {a} ⊆ s ↔ a ∈ s 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: {a} ⊆ s ↔ a ∈ s
-- Finset.subset_singleton_iff
@[simp]
theorem subset_singleton_iff {s : Finset α} {a : α} : s ⊆ {a} ↔ s = ∅ ∨ s = {a} 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: s ⊆ {a} ↔ s = ∅ ∨ s = {a}
-- Finset.singleton_subset_singleton
theorem singleton_subset_singleton : ({a} : Finset α) ⊆ {b} ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: {a} ⊆ {b} ↔ a = b
-- Finset.Nonempty.subset_singleton_iff
protected theorem Nonempty.subset_singleton_iff {s : Finset α} {a : α} (h : s.Nonempty) :
    s ⊆ {a} ↔ s = {a} 
Arguments: {α : Type u_1} {s : Finset α} {a : α} (h : s.Nonempty)
Goal: s ⊆ {a} ↔ s = {a}
-- Finset.subset_singleton_iff'
theorem subset_singleton_iff' {s : Finset α} {a : α} : s ⊆ {a} ↔ ∀ b ∈ s, b = a 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: s ⊆ {a} ↔ ∀ b ∈ s, b = a
-- Finset.ssubset_singleton_iff
@[simp]
theorem ssubset_singleton_iff {s : Finset α} {a : α} : s ⊂ {a} ↔ s = ∅ 
Arguments: {α : Type u_1} {s : Finset α} {a : α}
Goal: s ⊂ {a} ↔ s = ∅
-- Finset.eq_empty_of_ssubset_singleton
theorem eq_empty_of_ssubset_singleton {s : Finset α} {x : α} (hs : s ⊂ {x}) : s = ∅ 
Arguments: {α : Type u_1} {s : Finset α} {x : α} (hs : s ⊂ {x})
Goal: s = ∅