File: Mathlib/Data/Set/Basic.lean

full_name: Set.instBooleanAlgebraSet
code: instance instBooleanAlgebraSet : BooleanAlgebra (Set α) 
goal: BooleanAlgebra (Set α)

full_name: Set.instHasSSubset
code: instance : HasSSubset (Set α) 
goal: HasSSubset (Set α)

full_name: Set.top_eq_univ
code: @[simp]
theorem top_eq_univ : (⊤ : Set α) = univ 
goal: ⊤ = Set.univ

full_name: Set.bot_eq_empty
code: @[simp]
theorem bot_eq_empty : (⊥ : Set α) = ∅ 
goal: ⊥ = ∅

full_name: Set.sup_eq_union
code: @[simp]
theorem sup_eq_union : ((· ⊔ ·) : Set α → Set α → Set α) = (· ∪ ·) 
goal: (fun x x_1 => x ⊔ x_1) = fun x x_1 => x ∪ x_1

full_name: Set.inf_eq_inter
code: @[simp]
theorem inf_eq_inter : ((· ⊓ ·) : Set α → Set α → Set α) = (· ∩ ·) 
goal: (fun x x_1 => x ⊓ x_1) = fun x x_1 => x ∩ x_1

full_name: Set.le_eq_subset
code: @[simp]
theorem le_eq_subset : ((· ≤ ·) : Set α → Set α → Prop) = (· ⊆ ·) 
goal: (fun x x_1 => x ≤ x_1) = fun x x_1 => x ⊆ x_1

full_name: Set.lt_eq_ssubset
code: @[simp]
theorem lt_eq_ssubset : ((· < ·) : Set α → Set α → Prop) = (· ⊂ ·) 
goal: (fun x x_1 => x < x_1) = fun x x_1 => x ⊂ x_1

full_name: Set.le_iff_subset
code: theorem le_iff_subset : s ≤ t ↔ s ⊆ t 
goal: s ≤ t ↔ s ⊆ t

full_name: Set.lt_iff_ssubset
code: theorem lt_iff_ssubset : s < t ↔ s ⊂ t 
goal: s < t ↔ s ⊂ t

full_name: Set.PiSetCoe.canLift
code: instance PiSetCoe.canLift (ι : Type u) (α : ι → Type v) [∀ i, Nonempty (α i)] (s : Set ι) :
    CanLift (∀ i : s, α i) (∀ i, α i) (fun f i => f i) fun _ => True 
goal: CanLift ((i : ↑s) → α ↑i) ((i : ι) → α i) (fun f i => f ↑i) fun x => True

full_name: Set.PiSetCoe.canLift'
code: instance PiSetCoe.canLift' (ι : Type u) (α : Type v) [Nonempty α] (s : Set ι) :
    CanLift (s → α) (ι → α) (fun f i => f i) fun _ => True 
goal: CanLift (↑s → α) (ι → α) (fun f i => f ↑i) fun x => True

full_name: instCoeTCElem
code: instance (s : Set α) : CoeTC s α 
goal: CoeTC (↑s) α

full_name: Set.coe_eq_subtype
code: theorem Set.coe_eq_subtype (s : Set α) : ↥s = { x // x ∈ s } 
goal: ↑s = { x // x ∈ s }

full_name: Set.coe_setOf
code: @[simp]
theorem Set.coe_setOf (p : α → Prop) : ↥{ x | p x } = { x // p x } 
goal: ↑{x | p x} = { x // p x }

full_name: SetCoe.forall
code: theorem SetCoe.forall {s : Set α} {p : s → Prop} : (∀ x : s, p x) ↔ ∀ (x) (h : x ∈ s), p ⟨x, h⟩ 
goal: (∀ (x : ↑s), p x) ↔ ∀ (x : α) (h : x ∈ s), p ⟨x, h⟩

full_name: SetCoe.exists
code: theorem SetCoe.exists {s : Set α} {p : s → Prop} :
    (∃ x : s, p x) ↔ ∃ (x : _) (h : x ∈ s), p ⟨x, h⟩ 
goal: (∃ x, p x) ↔ ∃ x, ∃ (h : x ∈ s), p ⟨x, h⟩

full_name: SetCoe.exists'
code: theorem SetCoe.exists' {s : Set α} {p : ∀ x, x ∈ s → Prop} :
    (∃ (x : _) (h : x ∈ s), p x h) ↔ ∃ x : s, p x.1 x.2 
goal: (∃ x, ∃ (h : x ∈ s), p x h) ↔ ∃ x, p ↑x ⋯

full_name: SetCoe.forall'
code: theorem SetCoe.forall' {s : Set α} {p : ∀ x, x ∈ s → Prop} :
    (∀ (x) (h : x ∈ s), p x h) ↔ ∀ x : s, p x.1 x.2 
goal: (∀ (x : α) (h : x ∈ s), p x h) ↔ ∀ (x : ↑s), p ↑x ⋯

full_name: set_coe_cast
code: @[simp]
theorem set_coe_cast :
    ∀ {s t : Set α} (H' : s = t) (H : ↥s = ↥t) (x : s), cast H x = ⟨x.1, H' ▸ x.2⟩
  
goal: cast H x = ⟨↑x, ⋯⟩

full_name: SetCoe.ext
code: theorem SetCoe.ext {s : Set α} {a b : s} : (a : α) = b → a = b 
goal: ↑a = ↑b → a = b

full_name: SetCoe.ext_iff
code: theorem SetCoe.ext_iff {s : Set α} {a b : s} : (↑a : α) = ↑b ↔ a = b 
goal: ↑a = ↑b ↔ a = b

full_name: Subtype.mem
code: /-- See also `Subtype.prop` -/
theorem Subtype.mem {α : Type*} {s : Set α} (p : s) : (p : α) ∈ s 
goal: ↑p ∈ s

full_name: Eq.subset
code: /-- Duplicate of `Eq.subset'`, which currently has elaboration problems. -/
theorem Eq.subset {α} {s t : Set α} : s = t → s ⊆ t 
goal: s = t → s ⊆ t

full_name: Set.instInhabited
code: instance : Inhabited (Set α) 
goal: Inhabited (Set α)

full_name: Set.ext_iff
code: protected theorem ext_iff {s t : Set α} : s = t ↔ ∀ x, x ∈ s ↔ x ∈ t 
goal: s = t ↔ ∀ (x : α), x ∈ s ↔ x ∈ t

full_name: Set.mem_of_mem_of_subset
code: @[trans]
theorem mem_of_mem_of_subset {x : α} {s t : Set α} (hx : x ∈ s) (h : s ⊆ t) : x ∈ t 
goal: x ∈ t

full_name: Set.forall_in_swap
code: theorem forall_in_swap {p : α → β → Prop} : (∀ a ∈ s, ∀ (b), p a b) ↔ ∀ (b), ∀ a ∈ s, p a b 
goal: (∀ a ∈ s, ∀ (b : β), p a b) ↔ ∀ (b : β), ∀ a ∈ s, p a b

full_name: Set.mem_setOf
code: theorem mem_setOf {a : α} {p : α → Prop} : a ∈ { x | p x } ↔ p a 
goal: a ∈ {x | p x} ↔ p a

full_name: Membership.mem.out
code: /-- If `h : a ∈ {x | p x}` then `h.out : p x`. These are definitionally equal, but this can
nevertheless be useful for various reasons, e.g. to apply further projection notation or in an
argument to `simp`. -/
theorem _root_.Membership.mem.out {p : α → Prop} {a : α} (h : a ∈ { x | p x }) : p a 
goal: p a

full_name: Set.nmem_setOf_iff
code: theorem nmem_setOf_iff {a : α} {p : α → Prop} : a ∉ { x | p x } ↔ ¬p a 
goal: a ∉ {x | p x} ↔ ¬p a

full_name: Set.setOf_mem_eq
code: @[simp]
theorem setOf_mem_eq {s : Set α} : { x | x ∈ s } = s 
goal: {x | x ∈ s} = s

full_name: Set.setOf_set
code: theorem setOf_set {s : Set α} : setOf s = s 
goal: setOf s = s

full_name: Set.setOf_app_iff
code: theorem setOf_app_iff {p : α → Prop} {x : α} : { x | p x } x ↔ p x 
goal: {x | p x} x ↔ p x

full_name: Set.mem_def
code: theorem mem_def {a : α} {s : Set α} : a ∈ s ↔ s a 
goal: a ∈ s ↔ s a

full_name: Set.setOf_bijective
code: theorem setOf_bijective : Bijective (setOf : (α → Prop) → Set α) 
goal: Function.Bijective setOf

full_name: Set.subset_setOf
code: theorem subset_setOf {p : α → Prop} {s : Set α} : s ⊆ setOf p ↔ ∀ x, x ∈ s → p x 
goal: s ⊆ setOf p ↔ ∀ x ∈ s, p x

full_name: Set.setOf_subset
code: theorem setOf_subset {p : α → Prop} {s : Set α} : setOf p ⊆ s ↔ ∀ x, p x → x ∈ s 
goal: setOf p ⊆ s ↔ ∀ (x : α), p x → x ∈ s

full_name: Set.setOf_subset_setOf
code: @[simp]
theorem setOf_subset_setOf {p q : α → Prop} : { a | p a } ⊆ { a | q a } ↔ ∀ a, p a → q a 
goal: {a | p a} ⊆ {a | q a} ↔ ∀ (a : α), p a → q a

full_name: Set.setOf_and
code: theorem setOf_and {p q : α → Prop} : { a | p a ∧ q a } = { a | p a } ∩ { a | q a } 
goal: {a | p a ∧ q a} = {a | p a} ∩ {a | q a}

full_name: Set.setOf_or
code: theorem setOf_or {p q : α → Prop} : { a | p a ∨ q a } = { a | p a } ∪ { a | q a } 
goal: {a | p a ∨ q a} = {a | p a} ∪ {a | q a}

full_name: Set.instIsReflSubset
code: instance : IsRefl (Set α) (· ⊆ ·) 
goal: IsRefl (Set α) fun x x_1 => x ⊆ x_1

full_name: Set.instIsTransSubset
code: instance : IsTrans (Set α) (· ⊆ ·) 
goal: IsTrans (Set α) fun x x_1 => x ⊆ x_1

full_name: Set.instTransSubset
code: instance : Trans ((· ⊆ ·) : Set α → Set α → Prop) (· ⊆ ·) (· ⊆ ·) 
goal: Trans (fun x x_1 => x ⊆ x_1) (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊆ x_1

full_name: Set.instIsAntisymmSubset
code: instance : IsAntisymm (Set α) (· ⊆ ·) 
goal: IsAntisymm (Set α) fun x x_1 => x ⊆ x_1

full_name: Set.instIsIrreflSSubset
code: instance : IsIrrefl (Set α) (· ⊂ ·) 
goal: IsIrrefl (Set α) fun x x_1 => x ⊂ x_1

full_name: Set.instIsTransSSubset
code: instance : IsTrans (Set α) (· ⊂ ·) 
goal: IsTrans (Set α) fun x x_1 => x ⊂ x_1

full_name: Set.instTransSSubset
code: instance : Trans ((· ⊂ ·) : Set α → Set α → Prop) (· ⊂ ·) (· ⊂ ·) 
goal: Trans (fun x x_1 => x ⊂ x_1) (fun x x_1 => x ⊂ x_1) fun x x_1 => x ⊂ x_1

full_name: Set.instTransSSubsetSubset
code: instance : Trans ((· ⊂ ·) : Set α → Set α → Prop) (· ⊆ ·) (· ⊂ ·) 
goal: Trans (fun x x_1 => x ⊂ x_1) (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1

full_name: Set.instTransSubsetSSubset
code: instance : Trans ((· ⊆ ·) : Set α → Set α → Prop) (· ⊂ ·) (· ⊂ ·) 
goal: Trans (fun x x_1 => x ⊆ x_1) (fun x x_1 => x ⊂ x_1) fun x x_1 => x ⊂ x_1

full_name: Set.instIsAsymmSSubset
code: instance : IsAsymm (Set α) (· ⊂ ·) 
goal: IsAsymm (Set α) fun x x_1 => x ⊂ x_1

full_name: Set.instIsNonstrictStrictOrderSubsetSSubset
code: instance : IsNonstrictStrictOrder (Set α) (· ⊆ ·) (· ⊂ ·) 
goal: IsNonstrictStrictOrder (Set α) (fun x x_1 => x ⊆ x_1) fun x x_1 => x ⊂ x_1

full_name: Set.subset_def
code: theorem subset_def : (s ⊆ t) = ∀ x, x ∈ s → x ∈ t 
goal: (s ⊆ t) = ∀ x ∈ s, x ∈ t

full_name: Set.ssubset_def
code: theorem ssubset_def : (s ⊂ t) = (s ⊆ t ∧ ¬t ⊆ s) 
goal: (s ⊂ t) = (s ⊆ t ∧ ¬t ⊆ s)

full_name: Set.Subset.refl
code: @[refl]
theorem Subset.refl (a : Set α) : a ⊆ a 
goal: a ⊆ a

full_name: Set.Subset.rfl
code: theorem Subset.rfl {s : Set α} : s ⊆ s 
goal: s ⊆ s

full_name: Set.Subset.trans
code: @[trans]
theorem Subset.trans {a b c : Set α} (ab : a ⊆ b) (bc : b ⊆ c) : a ⊆ c 
goal: a ⊆ c

full_name: Set.mem_of_eq_of_mem
code: @[trans]
theorem mem_of_eq_of_mem {x y : α} {s : Set α} (hx : x = y) (h : y ∈ s) : x ∈ s 
goal: x ∈ s

full_name: Set.Subset.antisymm
code: theorem Subset.antisymm {a b : Set α} (h₁ : a ⊆ b) (h₂ : b ⊆ a) : a = b 
goal: a = b

full_name: Set.Subset.antisymm_iff
code: theorem Subset.antisymm_iff {a b : Set α} : a = b ↔ a ⊆ b ∧ b ⊆ a 
goal: a = b ↔ a ⊆ b ∧ b ⊆ a

full_name: Set.eq_of_subset_of_subset
code: theorem eq_of_subset_of_subset {a b : Set α} : a ⊆ b → b ⊆ a → a = b 
goal: a ⊆ b → b ⊆ a → a = b

full_name: Set.mem_of_subset_of_mem
code: theorem mem_of_subset_of_mem {s₁ s₂ : Set α} {a : α} (h : s₁ ⊆ s₂) : a ∈ s₁ → a ∈ s₂ 
goal: a ∈ s₁ → a ∈ s₂

full_name: Set.not_mem_subset
code: theorem not_mem_subset (h : s ⊆ t) : a ∉ t → a ∉ s 
goal: a ∉ t → a ∉ s

full_name: Set.not_subset
code: theorem not_subset : ¬s ⊆ t ↔ ∃ a ∈ s, a ∉ t 
goal: ¬s ⊆ t ↔ ∃ a ∈ s, a ∉ t

full_name: Set.eq_of_forall_subset_iff
code: lemma eq_of_forall_subset_iff (h : ∀ u, s ⊆ u ↔ t ⊆ u) : s = t 
goal: s = t

full_name: Set.eq_or_ssubset_of_subset
code: protected theorem eq_or_ssubset_of_subset (h : s ⊆ t) : s = t ∨ s ⊂ t 
goal: s = t ∨ s ⊂ t

full_name: Set.exists_of_ssubset
code: theorem exists_of_ssubset {s t : Set α} (h : s ⊂ t) : ∃ x ∈ t, x ∉ s 
goal: ∃ x ∈ t, x ∉ s

full_name: Set.ssubset_iff_subset_ne
code: protected theorem ssubset_iff_subset_ne {s t : Set α} : s ⊂ t ↔ s ⊆ t ∧ s ≠ t 
goal: s ⊂ t ↔ s ⊆ t ∧ s ≠ t

full_name: Set.ssubset_iff_of_subset
code: theorem ssubset_iff_of_subset {s t : Set α} (h : s ⊆ t) : s ⊂ t ↔ ∃ x ∈ t, x ∉ s 
goal: s ⊂ t ↔ ∃ x ∈ t, x ∉ s

full_name: Set.ssubset_of_ssubset_of_subset
code: protected theorem ssubset_of_ssubset_of_subset {s₁ s₂ s₃ : Set α} (hs₁s₂ : s₁ ⊂ s₂)
    (hs₂s₃ : s₂ ⊆ s₃) : s₁ ⊂ s₃ 
goal: s₁ ⊂ s₃

full_name: Set.ssubset_of_subset_of_ssubset
code: protected theorem ssubset_of_subset_of_ssubset {s₁ s₂ s₃ : Set α} (hs₁s₂ : s₁ ⊆ s₂)
    (hs₂s₃ : s₂ ⊂ s₃) : s₁ ⊂ s₃ 
goal: s₁ ⊂ s₃

full_name: Set.not_mem_empty
code: theorem not_mem_empty (x : α) : ¬x ∈ (∅ : Set α) 
goal: x ∉ ∅

full_name: Set.not_not_mem
code: theorem not_not_mem : ¬a ∉ s ↔ a ∈ s 
goal: ¬a ∉ s ↔ a ∈ s

full_name: Set.nonempty_coe_sort
code: theorem nonempty_coe_sort {s : Set α} : Nonempty (↥s) ↔ s.Nonempty 
goal: Nonempty ↑s ↔ s.Nonempty

full_name: Set.nonempty_def
code: theorem nonempty_def : s.Nonempty ↔ ∃ x, x ∈ s 
goal: s.Nonempty ↔ ∃ x, x ∈ s

full_name: Set.nonempty_of_mem
code: theorem nonempty_of_mem {x} (h : x ∈ s) : s.Nonempty 
goal: s.Nonempty

full_name: Set.Nonempty.not_subset_empty
code: theorem Nonempty.not_subset_empty : s.Nonempty → ¬s ⊆ ∅
  
goal: s.Nonempty → ¬s ⊆ ∅

full_name: Set.Nonempty.some
code: /-- Extract a witness from `s.Nonempty`. This function might be used instead of case analysis
on the argument. Note that it makes a proof depend on the `Classical.choice` axiom. -/
protected noncomputable def Nonempty.some (h : s.Nonempty) : α 
goal: α

full_name: Set.Nonempty.some_mem
code: protected theorem Nonempty.some_mem (h : s.Nonempty) : h.some ∈ s 
goal: h.some ∈ s

full_name: Set.Nonempty.mono
code: theorem Nonempty.mono (ht : s ⊆ t) (hs : s.Nonempty) : t.Nonempty 
goal: t.Nonempty

full_name: Set.nonempty_of_not_subset
code: theorem nonempty_of_not_subset (h : ¬s ⊆ t) : (s \ t).Nonempty 
goal: (s \ t).Nonempty

full_name: Set.nonempty_of_ssubset
code: theorem nonempty_of_ssubset (ht : s ⊂ t) : (t \ s).Nonempty 
goal: (t \ s).Nonempty

full_name: Set.Nonempty.of_diff
code: theorem Nonempty.of_diff (h : (s \ t).Nonempty) : s.Nonempty 
goal: s.Nonempty

full_name: Set.nonempty_of_ssubset'
code: theorem nonempty_of_ssubset' (ht : s ⊂ t) : t.Nonempty 
goal: t.Nonempty

full_name: Set.Nonempty.inl
code: theorem Nonempty.inl (hs : s.Nonempty) : (s ∪ t).Nonempty 
goal: (s ∪ t).Nonempty

full_name: Set.Nonempty.inr
code: theorem Nonempty.inr (ht : t.Nonempty) : (s ∪ t).Nonempty 
goal: (s ∪ t).Nonempty

full_name: Set.union_nonempty
code: @[simp]
theorem union_nonempty : (s ∪ t).Nonempty ↔ s.Nonempty ∨ t.Nonempty 
goal: (s ∪ t).Nonempty ↔ s.Nonempty ∨ t.Nonempty

full_name: Set.Nonempty.left
code: theorem Nonempty.left (h : (s ∩ t).Nonempty) : s.Nonempty 
goal: s.Nonempty

full_name: Set.Nonempty.right
code: theorem Nonempty.right (h : (s ∩ t).Nonempty) : t.Nonempty 
goal: t.Nonempty

full_name: Set.inter_nonempty
code: theorem inter_nonempty : (s ∩ t).Nonempty ↔ ∃ x, x ∈ s ∧ x ∈ t 
goal: (s ∩ t).Nonempty ↔ ∃ x ∈ s, x ∈ t

full_name: Set.inter_nonempty_iff_exists_left
code: theorem inter_nonempty_iff_exists_left : (s ∩ t).Nonempty ↔ ∃ x ∈ s, x ∈ t 
goal: (s ∩ t).Nonempty ↔ ∃ x ∈ s, x ∈ t

full_name: Set.inter_nonempty_iff_exists_right
code: theorem inter_nonempty_iff_exists_right : (s ∩ t).Nonempty ↔ ∃ x ∈ t, x ∈ s 
goal: (s ∩ t).Nonempty ↔ ∃ x ∈ t, x ∈ s

full_name: Set.nonempty_iff_univ_nonempty
code: theorem nonempty_iff_univ_nonempty : Nonempty α ↔ (univ : Set α).Nonempty 
goal: Nonempty α ↔ Set.univ.Nonempty

full_name: Set.univ_nonempty
code: @[simp]
theorem univ_nonempty : ∀ [Nonempty α], (univ : Set α).Nonempty
  
goal: Set.univ.Nonempty

full_name: Set.Nonempty.to_subtype
code: theorem Nonempty.to_subtype : s.Nonempty → Nonempty (↥s) 
goal: s.Nonempty → Nonempty ↑s

full_name: Set.Nonempty.to_type
code: theorem Nonempty.to_type : s.Nonempty → Nonempty α 
goal: s.Nonempty → Nonempty α

full_name: Set.univ.nonempty
code: instance univ.nonempty [Nonempty α] : Nonempty (↥(Set.univ : Set α)) 
goal: Nonempty ↑Set.univ

full_name: Set.nonempty_of_nonempty_subtype
code: theorem nonempty_of_nonempty_subtype [Nonempty (↥s)] : s.Nonempty 
goal: s.Nonempty

full_name: Set.empty_def
code: theorem empty_def : (∅ : Set α) = { _x : α | False } 
goal: ∅ = {_x | False}

full_name: Set.mem_empty_iff_false
code: @[simp]
theorem mem_empty_iff_false (x : α) : x ∈ (∅ : Set α) ↔ False 
goal: x ∈ ∅ ↔ False

full_name: Set.setOf_false
code: @[simp]
theorem setOf_false : { _a : α | False } = ∅ 
goal: {_a | False} = ∅

full_name: Set.setOf_bot
code: @[simp] theorem setOf_bot : { _x : α | ⊥ } = ∅ 
goal: {_x | ⊥} = ∅

full_name: Set.empty_subset
code: @[simp]
theorem empty_subset (s : Set α) : ∅ ⊆ s 
goal: ∅ ⊆ s

full_name: Set.subset_empty_iff
code: @[simp]
theorem subset_empty_iff {s : Set α} : s ⊆ ∅ ↔ s = ∅ 
goal: s ⊆ ∅ ↔ s = ∅

full_name: Set.eq_empty_iff_forall_not_mem
code: theorem eq_empty_iff_forall_not_mem {s : Set α} : s = ∅ ↔ ∀ x, x ∉ s 
goal: s = ∅ ↔ ∀ (x : α), x ∉ s

full_name: Set.eq_empty_of_forall_not_mem
code: theorem eq_empty_of_forall_not_mem (h : ∀ x, x ∉ s) : s = ∅ 
goal: s = ∅

full_name: Set.eq_empty_of_subset_empty
code: theorem eq_empty_of_subset_empty {s : Set α} : s ⊆ ∅ → s = ∅ 
goal: s ⊆ ∅ → s = ∅

full_name: Set.eq_empty_of_isEmpty
code: theorem eq_empty_of_isEmpty [IsEmpty α] (s : Set α) : s = ∅ 
goal: s = ∅

full_name: Set.uniqueEmpty
code: /-- There is exactly one set of a type that is empty. -/
instance uniqueEmpty [IsEmpty α] : Unique (Set α) 
goal: Unique (Set α)

full_name: Set.not_nonempty_iff_eq_empty
code: /-- See also `Set.nonempty_iff_ne_empty`. -/
theorem not_nonempty_iff_eq_empty {s : Set α} : ¬s.Nonempty ↔ s = ∅ 
goal: ¬s.Nonempty ↔ s = ∅

full_name: Set.nonempty_iff_ne_empty
code: /-- See also `Set.not_nonempty_iff_eq_empty`. -/
theorem nonempty_iff_ne_empty : s.Nonempty ↔ s ≠ ∅ 
goal: s.Nonempty ↔ s ≠ ∅

full_name: Set.not_nonempty_iff_eq_empty'
code: /-- See also `nonempty_iff_ne_empty'`. -/
theorem not_nonempty_iff_eq_empty' : ¬Nonempty s ↔ s = ∅ 
goal: ¬Nonempty ↑s ↔ s = ∅

full_name: Set.nonempty_iff_ne_empty'
code: /-- See also `not_nonempty_iff_eq_empty'`. -/
theorem nonempty_iff_ne_empty' : Nonempty s ↔ s ≠ ∅ 
goal: Nonempty ↑s ↔ s ≠ ∅

full_name: Set.not_nonempty_empty
code: @[simp]
theorem not_nonempty_empty : ¬(∅ : Set α).Nonempty 
goal: ¬∅.Nonempty

full_name: Set.isEmpty_coe_sort
code: theorem isEmpty_coe_sort {s : Set α} : IsEmpty (↥s) ↔ s = ∅ 
goal: IsEmpty ↑s ↔ s = ∅

full_name: Set.eq_empty_or_nonempty
code: theorem eq_empty_or_nonempty (s : Set α) : s = ∅ ∨ s.Nonempty 
goal: s = ∅ ∨ s.Nonempty

full_name: Set.subset_eq_empty
code: theorem subset_eq_empty {s t : Set α} (h : t ⊆ s) (e : s = ∅) : t = ∅ 
goal: t = ∅

full_name: Set.forall_mem_empty
code: theorem forall_mem_empty {p : α → Prop} : (∀ x ∈ (∅ : Set α), p x) ↔ True 
goal: (∀ x ∈ ∅, p x) ↔ True

full_name: Set.instIsEmptyElemEmptyCollection
code: instance (α : Type u) : IsEmpty.{u + 1} (↥(∅ : Set α)) 
goal: IsEmpty ↑∅

full_name: Set.empty_ssubset
code: @[simp]
theorem empty_ssubset : ∅ ⊂ s ↔ s.Nonempty 
goal: ∅ ⊂ s ↔ s.Nonempty

full_name: Set.setOf_true
code: @[simp]
theorem setOf_true : { _x : α | True } = univ 
goal: {_x | True} = Set.univ

full_name: Set.setOf_top
code: @[simp] theorem setOf_top : { _x : α | ⊤ } = univ 
goal: {_x | ⊤} = Set.univ

full_name: Set.univ_eq_empty_iff
code: @[simp]
theorem univ_eq_empty_iff : (univ : Set α) = ∅ ↔ IsEmpty α 
goal: Set.univ = ∅ ↔ IsEmpty α

full_name: Set.empty_ne_univ
code: theorem empty_ne_univ [Nonempty α] : (∅ : Set α) ≠ univ 
goal: ∅ ≠ Set.univ

full_name: Set.subset_univ
code: @[simp]
theorem subset_univ (s : Set α) : s ⊆ univ 
goal: s ⊆ Set.univ

full_name: Set.univ_subset_iff
code: @[simp]
theorem univ_subset_iff {s : Set α} : univ ⊆ s ↔ s = univ 
goal: Set.univ ⊆ s ↔ s = Set.univ

full_name: Set.eq_univ_iff_forall
code: theorem eq_univ_iff_forall {s : Set α} : s = univ ↔ ∀ x, x ∈ s 
goal: s = Set.univ ↔ ∀ (x : α), x ∈ s

full_name: Set.eq_univ_of_forall
code: theorem eq_univ_of_forall {s : Set α} : (∀ x, x ∈ s) → s = univ 
goal: (∀ (x : α), x ∈ s) → s = Set.univ

full_name: Set.Nonempty.eq_univ
code: theorem Nonempty.eq_univ [Subsingleton α] : s.Nonempty → s = univ 
goal: s.Nonempty → s = Set.univ

full_name: Set.eq_univ_of_subset
code: theorem eq_univ_of_subset {s t : Set α} (h : s ⊆ t) (hs : s = univ) : t = univ 
goal: t = Set.univ

full_name: Set.exists_mem_of_nonempty
code: theorem exists_mem_of_nonempty (α) : ∀ [Nonempty α], ∃ x : α, x ∈ (univ : Set α)
  
goal: ∃ x, x ∈ Set.univ

full_name: Set.ne_univ_iff_exists_not_mem
code: theorem ne_univ_iff_exists_not_mem {α : Type*} (s : Set α) : s ≠ univ ↔ ∃ a, a ∉ s 
goal: s ≠ Set.univ ↔ ∃ a, a ∉ s

full_name: Set.not_subset_iff_exists_mem_not_mem
code: theorem not_subset_iff_exists_mem_not_mem {α : Type*} {s t : Set α} :
    ¬s ⊆ t ↔ ∃ x, x ∈ s ∧ x ∉ t 
goal: ¬s ⊆ t ↔ ∃ x ∈ s, x ∉ t

full_name: Set.univ_unique
code: theorem univ_unique [Unique α] : @Set.univ α = {default} 
goal: Set.univ = {default}

full_name: Set.ssubset_univ_iff
code: theorem ssubset_univ_iff : s ⊂ univ ↔ s ≠ univ 
goal: s ⊂ Set.univ ↔ s ≠ Set.univ

full_name: Set.nontrivial_of_nonempty
code: instance nontrivial_of_nonempty [Nonempty α] : Nontrivial (Set α) 
goal: Nontrivial (Set α)

full_name: Set.union_def
code: theorem union_def {s₁ s₂ : Set α} : s₁ ∪ s₂ = { a | a ∈ s₁ ∨ a ∈ s₂ } 
goal: s₁ ∪ s₂ = {a | a ∈ s₁ ∨ a ∈ s₂}

full_name: Set.mem_union_left
code: theorem mem_union_left {x : α} {a : Set α} (b : Set α) : x ∈ a → x ∈ a ∪ b 
goal: x ∈ a → x ∈ a ∪ b

full_name: Set.mem_union_right
code: theorem mem_union_right {x : α} {b : Set α} (a : Set α) : x ∈ b → x ∈ a ∪ b 
goal: x ∈ b → x ∈ a ∪ b

full_name: Set.mem_or_mem_of_mem_union
code: theorem mem_or_mem_of_mem_union {x : α} {a b : Set α} (H : x ∈ a ∪ b) : x ∈ a ∨ x ∈ b 
goal: x ∈ a ∨ x ∈ b

full_name: Set.MemUnion.elim
code: theorem MemUnion.elim {x : α} {a b : Set α} {P : Prop} (H₁ : x ∈ a ∪ b) (H₂ : x ∈ a → P)
    (H₃ : x ∈ b → P) : P 
goal: P

full_name: Set.mem_union
code: @[simp]
theorem mem_union (x : α) (a b : Set α) : x ∈ a ∪ b ↔ x ∈ a ∨ x ∈ b 
goal: x ∈ a ∪ b ↔ x ∈ a ∨ x ∈ b

full_name: Set.union_self
code: @[simp]
theorem union_self (a : Set α) : a ∪ a = a 
goal: a ∪ a = a

full_name: Set.union_empty
code: @[simp]
theorem union_empty (a : Set α) : a ∪ ∅ = a 
goal: a ∪ ∅ = a

full_name: Set.empty_union
code: @[simp]
theorem empty_union (a : Set α) : ∅ ∪ a = a 
goal: ∅ ∪ a = a

full_name: Set.union_comm
code: theorem union_comm (a b : Set α) : a ∪ b = b ∪ a 
goal: a ∪ b = b ∪ a

full_name: Set.union_assoc
code: theorem union_assoc (a b c : Set α) : a ∪ b ∪ c = a ∪ (b ∪ c) 
goal: a ∪ b ∪ c = a ∪ (b ∪ c)

full_name: Set.union_isAssoc
code: instance union_isAssoc : Std.Associative (α := Set α) (· ∪ ·) 
goal: Std.Associative fun x x_1 => x ∪ x_1

full_name: Set.union_isComm
code: instance union_isComm : Std.Commutative (α := Set α) (· ∪ ·) 
goal: Std.Commutative fun x x_1 => x ∪ x_1

full_name: Set.union_left_comm
code: theorem union_left_comm (s₁ s₂ s₃ : Set α) : s₁ ∪ (s₂ ∪ s₃) = s₂ ∪ (s₁ ∪ s₃) 
goal: s₁ ∪ (s₂ ∪ s₃) = s₂ ∪ (s₁ ∪ s₃)

full_name: Set.union_right_comm
code: theorem union_right_comm (s₁ s₂ s₃ : Set α) : s₁ ∪ s₂ ∪ s₃ = s₁ ∪ s₃ ∪ s₂ 
goal: s₁ ∪ s₂ ∪ s₃ = s₁ ∪ s₃ ∪ s₂

full_name: Set.union_eq_left
code: @[simp]
theorem union_eq_left {s t : Set α} : s ∪ t = s ↔ t ⊆ s 
goal: s ∪ t = s ↔ t ⊆ s

full_name: Set.union_eq_right
code: @[simp]
theorem union_eq_right {s t : Set α} : s ∪ t = t ↔ s ⊆ t 
goal: s ∪ t = t ↔ s ⊆ t

full_name: Set.union_eq_self_of_subset_left
code: theorem union_eq_self_of_subset_left {s t : Set α} (h : s ⊆ t) : s ∪ t = t 
goal: s ∪ t = t

full_name: Set.union_eq_self_of_subset_right
code: theorem union_eq_self_of_subset_right {s t : Set α} (h : t ⊆ s) : s ∪ t = s 
goal: s ∪ t = s

full_name: Set.subset_union_left
code: @[simp]
theorem subset_union_left {s t : Set α} : s ⊆ s ∪ t 
goal: s ⊆ s ∪ t

full_name: Set.subset_union_right
code: @[simp]
theorem subset_union_right {s t : Set α} : t ⊆ s ∪ t 
goal: t ⊆ s ∪ t

full_name: Set.union_subset
code: theorem union_subset {s t r : Set α} (sr : s ⊆ r) (tr : t ⊆ r) : s ∪ t ⊆ r 
goal: s ∪ t ⊆ r

full_name: Set.union_subset_iff
code: @[simp]
theorem union_subset_iff {s t u : Set α} : s ∪ t ⊆ u ↔ s ⊆ u ∧ t ⊆ u 
goal: s ∪ t ⊆ u ↔ s ⊆ u ∧ t ⊆ u

full_name: Set.union_subset_union
code: @[gcongr]
theorem union_subset_union {s₁ s₂ t₁ t₂ : Set α} (h₁ : s₁ ⊆ s₂) (h₂ : t₁ ⊆ t₂) :
    s₁ ∪ t₁ ⊆ s₂ ∪ t₂ 
goal: s₁ ∪ t₁ ⊆ s₂ ∪ t₂

full_name: Set.union_subset_union_left
code: @[gcongr]
theorem union_subset_union_left {s₁ s₂ : Set α} (t) (h : s₁ ⊆ s₂) : s₁ ∪ t ⊆ s₂ ∪ t 
goal: s₁ ∪ t ⊆ s₂ ∪ t

full_name: Set.union_subset_union_right
code: @[gcongr]
theorem union_subset_union_right (s) {t₁ t₂ : Set α} (h : t₁ ⊆ t₂) : s ∪ t₁ ⊆ s ∪ t₂ 
goal: s ∪ t₁ ⊆ s ∪ t₂

full_name: Set.subset_union_of_subset_left
code: theorem subset_union_of_subset_left {s t : Set α} (h : s ⊆ t) (u : Set α) : s ⊆ t ∪ u 
goal: s ⊆ t ∪ u

full_name: Set.subset_union_of_subset_right
code: theorem subset_union_of_subset_right {s u : Set α} (h : s ⊆ u) (t : Set α) : s ⊆ t ∪ u 
goal: s ⊆ t ∪ u

full_name: Set.union_congr_left
code: theorem union_congr_left (ht : t ⊆ s ∪ u) (hu : u ⊆ s ∪ t) : s ∪ t = s ∪ u 
goal: s ∪ t = s ∪ u

full_name: Set.union_congr_right
code: theorem union_congr_right (hs : s ⊆ t ∪ u) (ht : t ⊆ s ∪ u) : s ∪ u = t ∪ u 
goal: s ∪ u = t ∪ u

full_name: Set.union_eq_union_iff_left
code: theorem union_eq_union_iff_left : s ∪ t = s ∪ u ↔ t ⊆ s ∪ u ∧ u ⊆ s ∪ t 
goal: s ∪ t = s ∪ u ↔ t ⊆ s ∪ u ∧ u ⊆ s ∪ t

full_name: Set.union_eq_union_iff_right
code: theorem union_eq_union_iff_right : s ∪ u = t ∪ u ↔ s ⊆ t ∪ u ∧ t ⊆ s ∪ u 
goal: s ∪ u = t ∪ u ↔ s ⊆ t ∪ u ∧ t ⊆ s ∪ u

full_name: Set.union_empty_iff
code: @[simp]
theorem union_empty_iff {s t : Set α} : s ∪ t = ∅ ↔ s = ∅ ∧ t = ∅ 
goal: s ∪ t = ∅ ↔ s = ∅ ∧ t = ∅

full_name: Set.union_univ
code: @[simp]
theorem union_univ (s : Set α) : s ∪ univ = univ 
goal: s ∪ Set.univ = Set.univ

full_name: Set.univ_union
code: @[simp]
theorem univ_union (s : Set α) : univ ∪ s = univ 
goal: Set.univ ∪ s = Set.univ

full_name: Set.inter_def
code: theorem inter_def {s₁ s₂ : Set α} : s₁ ∩ s₂ = { a | a ∈ s₁ ∧ a ∈ s₂ } 
goal: s₁ ∩ s₂ = {a | a ∈ s₁ ∧ a ∈ s₂}

full_name: Set.mem_inter_iff
code: @[simp, mfld_simps]
theorem mem_inter_iff (x : α) (a b : Set α) : x ∈ a ∩ b ↔ x ∈ a ∧ x ∈ b 
goal: x ∈ a ∩ b ↔ x ∈ a ∧ x ∈ b

full_name: Set.mem_inter
code: theorem mem_inter {x : α} {a b : Set α} (ha : x ∈ a) (hb : x ∈ b) : x ∈ a ∩ b 
goal: x ∈ a ∩ b

full_name: Set.mem_of_mem_inter_left
code: theorem mem_of_mem_inter_left {x : α} {a b : Set α} (h : x ∈ a ∩ b) : x ∈ a 
goal: x ∈ a

full_name: Set.mem_of_mem_inter_right
code: theorem mem_of_mem_inter_right {x : α} {a b : Set α} (h : x ∈ a ∩ b) : x ∈ b 
goal: x ∈ b

full_name: Set.inter_self
code: @[simp]
theorem inter_self (a : Set α) : a ∩ a = a 
goal: a ∩ a = a

full_name: Set.inter_empty
code: @[simp]
theorem inter_empty (a : Set α) : a ∩ ∅ = ∅ 
goal: a ∩ ∅ = ∅

full_name: Set.empty_inter
code: @[simp]
theorem empty_inter (a : Set α) : ∅ ∩ a = ∅ 
goal: ∅ ∩ a = ∅

full_name: Set.inter_comm
code: theorem inter_comm (a b : Set α) : a ∩ b = b ∩ a 
goal: a ∩ b = b ∩ a

full_name: Set.inter_assoc
code: theorem inter_assoc (a b c : Set α) : a ∩ b ∩ c = a ∩ (b ∩ c) 
goal: a ∩ b ∩ c = a ∩ (b ∩ c)

full_name: Set.inter_isAssoc
code: instance inter_isAssoc : Std.Associative (α := Set α) (· ∩ ·) 
goal: Std.Associative fun x x_1 => x ∩ x_1

full_name: Set.inter_isComm
code: instance inter_isComm : Std.Commutative (α := Set α) (· ∩ ·) 
goal: Std.Commutative fun x x_1 => x ∩ x_1

full_name: Set.inter_left_comm
code: theorem inter_left_comm (s₁ s₂ s₃ : Set α) : s₁ ∩ (s₂ ∩ s₃) = s₂ ∩ (s₁ ∩ s₃) 
goal: s₁ ∩ (s₂ ∩ s₃) = s₂ ∩ (s₁ ∩ s₃)

full_name: Set.inter_right_comm
code: theorem inter_right_comm (s₁ s₂ s₃ : Set α) : s₁ ∩ s₂ ∩ s₃ = s₁ ∩ s₃ ∩ s₂ 
goal: s₁ ∩ s₂ ∩ s₃ = s₁ ∩ s₃ ∩ s₂

full_name: Set.inter_subset_left
code: @[simp, mfld_simps]
theorem inter_subset_left {s t : Set α} : s ∩ t ⊆ s 
goal: s ∩ t ⊆ s

full_name: Set.inter_subset_right
code: @[simp]
theorem inter_subset_right {s t : Set α} : s ∩ t ⊆ t 
goal: s ∩ t ⊆ t

full_name: Set.subset_inter
code: theorem subset_inter {s t r : Set α} (rs : r ⊆ s) (rt : r ⊆ t) : r ⊆ s ∩ t 
goal: r ⊆ s ∩ t

full_name: Set.subset_inter_iff
code: @[simp]
theorem subset_inter_iff {s t r : Set α} : r ⊆ s ∩ t ↔ r ⊆ s ∧ r ⊆ t 
goal: r ⊆ s ∩ t ↔ r ⊆ s ∧ r ⊆ t

full_name: Set.inter_eq_left
code: @[simp] lemma inter_eq_left : s ∩ t = s ↔ s ⊆ t 
goal: s ∩ t = s ↔ s ⊆ t

full_name: Set.inter_eq_right
code: @[simp] lemma inter_eq_right : s ∩ t = t ↔ t ⊆ s 
goal: s ∩ t = t ↔ t ⊆ s

full_name: Set.left_eq_inter
code: @[simp] lemma left_eq_inter : s = s ∩ t ↔ s ⊆ t 
goal: s = s ∩ t ↔ s ⊆ t

full_name: Set.right_eq_inter
code: @[simp] lemma right_eq_inter : t = s ∩ t ↔ t ⊆ s 
goal: t = s ∩ t ↔ t ⊆ s

full_name: Set.inter_eq_self_of_subset_left
code: theorem inter_eq_self_of_subset_left {s t : Set α} : s ⊆ t → s ∩ t = s 
goal: s ⊆ t → s ∩ t = s

full_name: Set.inter_eq_self_of_subset_right
code: theorem inter_eq_self_of_subset_right {s t : Set α} : t ⊆ s → s ∩ t = t 
goal: t ⊆ s → s ∩ t = t

full_name: Set.inter_congr_left
code: theorem inter_congr_left (ht : s ∩ u ⊆ t) (hu : s ∩ t ⊆ u) : s ∩ t = s ∩ u 
goal: s ∩ t = s ∩ u

full_name: Set.inter_congr_right
code: theorem inter_congr_right (hs : t ∩ u ⊆ s) (ht : s ∩ u ⊆ t) : s ∩ u = t ∩ u 
goal: s ∩ u = t ∩ u

full_name: Set.inter_eq_inter_iff_left
code: theorem inter_eq_inter_iff_left : s ∩ t = s ∩ u ↔ s ∩ u ⊆ t ∧ s ∩ t ⊆ u 
goal: s ∩ t = s ∩ u ↔ s ∩ u ⊆ t ∧ s ∩ t ⊆ u

full_name: Set.inter_eq_inter_iff_right
code: theorem inter_eq_inter_iff_right : s ∩ u = t ∩ u ↔ t ∩ u ⊆ s ∧ s ∩ u ⊆ t 
goal: s ∩ u = t ∩ u ↔ t ∩ u ⊆ s ∧ s ∩ u ⊆ t

full_name: Set.inter_univ
code: @[simp, mfld_simps]
theorem inter_univ (a : Set α) : a ∩ univ = a 
goal: a ∩ Set.univ = a

full_name: Set.univ_inter
code: @[simp, mfld_simps]
theorem univ_inter (a : Set α) : univ ∩ a = a 
goal: Set.univ ∩ a = a

full_name: Set.inter_subset_inter
code: @[gcongr]
theorem inter_subset_inter {s₁ s₂ t₁ t₂ : Set α} (h₁ : s₁ ⊆ t₁) (h₂ : s₂ ⊆ t₂) :
    s₁ ∩ s₂ ⊆ t₁ ∩ t₂ 
goal: s₁ ∩ s₂ ⊆ t₁ ∩ t₂

full_name: Set.inter_subset_inter_left
code: @[gcongr]
theorem inter_subset_inter_left {s t : Set α} (u : Set α) (H : s ⊆ t) : s ∩ u ⊆ t ∩ u 
goal: s ∩ u ⊆ t ∩ u

full_name: Set.inter_subset_inter_right
code: @[gcongr]
theorem inter_subset_inter_right {s t : Set α} (u : Set α) (H : s ⊆ t) : u ∩ s ⊆ u ∩ t 
goal: u ∩ s ⊆ u ∩ t

full_name: Set.union_inter_cancel_left
code: theorem union_inter_cancel_left {s t : Set α} : (s ∪ t) ∩ s = s 
goal: (s ∪ t) ∩ s = s

full_name: Set.union_inter_cancel_right
code: theorem union_inter_cancel_right {s t : Set α} : (s ∪ t) ∩ t = t 
goal: (s ∪ t) ∩ t = t

full_name: Set.inter_setOf_eq_sep
code: theorem inter_setOf_eq_sep (s : Set α) (p : α → Prop) : s ∩ {a | p a} = {a ∈ s | p a} 
goal: s ∩ {a | p a} = {a | a ∈ s ∧ p a}

full_name: Set.setOf_inter_eq_sep
code: theorem setOf_inter_eq_sep (p : α → Prop) (s : Set α) : {a | p a} ∩ s = {a ∈ s | p a} 
goal: {a | p a} ∩ s = {a | a ∈ s ∧ p a}

full_name: Set.inter_union_distrib_left
code: theorem inter_union_distrib_left (s t u : Set α) : s ∩ (t ∪ u) = s ∩ t ∪ s ∩ u 
goal: s ∩ (t ∪ u) = s ∩ t ∪ s ∩ u

full_name: Set.union_inter_distrib_right
code: theorem union_inter_distrib_right (s t u : Set α) : (s ∪ t) ∩ u = s ∩ u ∪ t ∩ u 
goal: (s ∪ t) ∩ u = s ∩ u ∪ t ∩ u

full_name: Set.union_inter_distrib_left
code: theorem union_inter_distrib_left (s t u : Set α) : s ∪ t ∩ u = (s ∪ t) ∩ (s ∪ u) 
goal: s ∪ t ∩ u = (s ∪ t) ∩ (s ∪ u)

full_name: Set.inter_union_distrib_right
code: theorem inter_union_distrib_right (s t u : Set α) : s ∩ t ∪ u = (s ∪ u) ∩ (t ∪ u) 
goal: s ∩ t ∪ u = (s ∪ u) ∩ (t ∪ u)

full_name: Set.union_union_distrib_left
code: theorem union_union_distrib_left (s t u : Set α) : s ∪ (t ∪ u) = s ∪ t ∪ (s ∪ u) 
goal: s ∪ (t ∪ u) = s ∪ t ∪ (s ∪ u)

full_name: Set.union_union_distrib_right
code: theorem union_union_distrib_right (s t u : Set α) : s ∪ t ∪ u = s ∪ u ∪ (t ∪ u) 
goal: s ∪ t ∪ u = s ∪ u ∪ (t ∪ u)

full_name: Set.inter_inter_distrib_left
code: theorem inter_inter_distrib_left (s t u : Set α) : s ∩ (t ∩ u) = s ∩ t ∩ (s ∩ u) 
goal: s ∩ (t ∩ u) = s ∩ t ∩ (s ∩ u)

full_name: Set.inter_inter_distrib_right
code: theorem inter_inter_distrib_right (s t u : Set α) : s ∩ t ∩ u = s ∩ u ∩ (t ∩ u) 
goal: s ∩ t ∩ u = s ∩ u ∩ (t ∩ u)

full_name: Set.union_union_union_comm
code: theorem union_union_union_comm (s t u v : Set α) : s ∪ t ∪ (u ∪ v) = s ∪ u ∪ (t ∪ v) 
goal: s ∪ t ∪ (u ∪ v) = s ∪ u ∪ (t ∪ v)

full_name: Set.inter_inter_inter_comm
code: theorem inter_inter_inter_comm (s t u v : Set α) : s ∩ t ∩ (u ∩ v) = s ∩ u ∩ (t ∩ v) 
goal: s ∩ t ∩ (u ∩ v) = s ∩ u ∩ (t ∩ v)

full_name: Set.insert_def
code: theorem insert_def (x : α) (s : Set α) : insert x s = { y | y = x ∨ y ∈ s } 
goal: insert x s = {y | y = x ∨ y ∈ s}

full_name: Set.subset_insert
code: @[simp]
theorem subset_insert (x : α) (s : Set α) : s ⊆ insert x s 
goal: s ⊆ insert x s

full_name: Set.mem_insert
code: theorem mem_insert (x : α) (s : Set α) : x ∈ insert x s 
goal: x ∈ insert x s

full_name: Set.mem_insert_of_mem
code: theorem mem_insert_of_mem {x : α} {s : Set α} (y : α) : x ∈ s → x ∈ insert y s 
goal: x ∈ s → x ∈ insert y s

full_name: Set.eq_or_mem_of_mem_insert
code: theorem eq_or_mem_of_mem_insert {x a : α} {s : Set α} : x ∈ insert a s → x = a ∨ x ∈ s 
goal: x ∈ insert a s → x = a ∨ x ∈ s

full_name: Set.mem_of_mem_insert_of_ne
code: theorem mem_of_mem_insert_of_ne : b ∈ insert a s → b ≠ a → b ∈ s 
goal: b ∈ insert a s → b ≠ a → b ∈ s

full_name: Set.eq_of_not_mem_of_mem_insert
code: theorem eq_of_not_mem_of_mem_insert : b ∈ insert a s → b ∉ s → b = a 
goal: b ∈ insert a s → b ∉ s → b = a

full_name: Set.mem_insert_iff
code: @[simp]
theorem mem_insert_iff {x a : α} {s : Set α} : x ∈ insert a s ↔ x = a ∨ x ∈ s 
goal: x ∈ insert a s ↔ x = a ∨ x ∈ s

full_name: Set.insert_eq_of_mem
code: @[simp]
theorem insert_eq_of_mem {a : α} {s : Set α} (h : a ∈ s) : insert a s = s 
goal: insert a s = s

full_name: Set.ne_insert_of_not_mem
code: theorem ne_insert_of_not_mem {s : Set α} (t : Set α) {a : α} : a ∉ s → s ≠ insert a t 
goal: a ∉ s → s ≠ insert a t

full_name: Set.insert_eq_self
code: @[simp]
theorem insert_eq_self : insert a s = s ↔ a ∈ s 
goal: insert a s = s ↔ a ∈ s

full_name: Set.insert_ne_self
code: theorem insert_ne_self : insert a s ≠ s ↔ a ∉ s 
goal: insert a s ≠ s ↔ a ∉ s

full_name: Set.insert_subset_iff
code: theorem insert_subset_iff : insert a s ⊆ t ↔ a ∈ t ∧ s ⊆ t 
goal: insert a s ⊆ t ↔ a ∈ t ∧ s ⊆ t

full_name: Set.insert_subset
code: theorem insert_subset (ha : a ∈ t) (hs : s ⊆ t) : insert a s ⊆ t 
goal: insert a s ⊆ t

full_name: Set.insert_subset_insert
code: theorem insert_subset_insert (h : s ⊆ t) : insert a s ⊆ insert a t 
goal: insert a s ⊆ insert a t

full_name: Set.insert_subset_insert_iff
code: @[simp] theorem insert_subset_insert_iff (ha : a ∉ s) : insert a s ⊆ insert a t ↔ s ⊆ t 
goal: insert a s ⊆ insert a t ↔ s ⊆ t

full_name: Set.subset_insert_iff_of_not_mem
code: theorem subset_insert_iff_of_not_mem (ha : a ∉ s) : s ⊆ insert a t ↔ s ⊆ t 
goal: s ⊆ insert a t ↔ s ⊆ t

full_name: Set.ssubset_iff_insert
code: theorem ssubset_iff_insert {s t : Set α} : s ⊂ t ↔ ∃ a ∉ s, insert a s ⊆ t 
goal: s ⊂ t ↔ ∃ a ∉ s, insert a s ⊆ t

full_name: Set.ssubset_insert
code: theorem ssubset_insert {s : Set α} {a : α} (h : a ∉ s) : s ⊂ insert a s 
goal: s ⊂ insert a s

full_name: Set.insert_comm
code: theorem insert_comm (a b : α) (s : Set α) : insert a (insert b s) = insert b (insert a s) 
goal: insert a (insert b s) = insert b (insert a s)

full_name: Set.insert_idem
code: theorem insert_idem (a : α) (s : Set α) : insert a (insert a s) = insert a s 
goal: insert a (insert a s) = insert a s

full_name: Set.insert_union
code: theorem insert_union : insert a s ∪ t = insert a (s ∪ t) 
goal: insert a s ∪ t = insert a (s ∪ t)

full_name: Set.union_insert
code: @[simp]
theorem union_insert : s ∪ insert a t = insert a (s ∪ t) 
goal: s ∪ insert a t = insert a (s ∪ t)

full_name: Set.insert_nonempty
code: @[simp]
theorem insert_nonempty (a : α) (s : Set α) : (insert a s).Nonempty 
goal: (insert a s).Nonempty

full_name: Set.instNonemptyElemInsert
code: instance (a : α) (s : Set α) : Nonempty (insert a s : Set α) 
goal: Nonempty ↑(insert a s)

full_name: Set.insert_inter_distrib
code: theorem insert_inter_distrib (a : α) (s t : Set α) : insert a (s ∩ t) = insert a s ∩ insert a t 
goal: insert a (s ∩ t) = insert a s ∩ insert a t

full_name: Set.insert_union_distrib
code: theorem insert_union_distrib (a : α) (s t : Set α) : insert a (s ∪ t) = insert a s ∪ insert a t 
goal: insert a (s ∪ t) = insert a s ∪ insert a t

full_name: Set.insert_inj
code: theorem insert_inj (ha : a ∉ s) : insert a s = insert b s ↔ a = b 
goal: insert a s = insert b s ↔ a = b

full_name: Set.forall_of_forall_insert
code: theorem forall_of_forall_insert {P : α → Prop} {a : α} {s : Set α} (H : ∀ x, x ∈ insert a s → P x)
    (x) (h : x ∈ s) : P x 
goal: P x

full_name: Set.forall_insert_of_forall
code: theorem forall_insert_of_forall {P : α → Prop} {a : α} {s : Set α} (H : ∀ x, x ∈ s → P x) (ha : P a)
    (x) (h : x ∈ insert a s) : P x 
goal: P x

full_name: Set.exists_mem_insert
code: theorem exists_mem_insert {P : α → Prop} {a : α} {s : Set α} :
    (∃ x ∈ insert a s, P x) ↔ (P a ∨ ∃ x ∈ s, P x) 
goal: (∃ x ∈ insert a s, P x) ↔ P a ∨ ∃ x ∈ s, P x

full_name: Set.forall_mem_insert
code: theorem forall_mem_insert {P : α → Prop} {a : α} {s : Set α} :
    (∀ x ∈ insert a s, P x) ↔ P a ∧ ∀ x ∈ s, P x 
goal: (∀ x ∈ insert a s, P x) ↔ P a ∧ ∀ x ∈ s, P x

full_name: Set.instLawfulSingleton
code: instance : LawfulSingleton α (Set α) 
goal: LawfulSingleton α (Set α)

full_name: Set.singleton_def
code: theorem singleton_def (a : α) : ({a} : Set α) = insert a ∅ 
goal: {a} = insert a ∅

full_name: Set.mem_singleton_iff
code: @[simp]
theorem mem_singleton_iff {a b : α} : a ∈ ({b} : Set α) ↔ a = b 
goal: a ∈ {b} ↔ a = b

full_name: Set.not_mem_singleton_iff
code: theorem not_mem_singleton_iff {a b : α} : a ∉ ({b} : Set α) ↔ a ≠ b 
goal: a ∉ {b} ↔ a ≠ b

full_name: Set.setOf_eq_eq_singleton
code: @[simp]
theorem setOf_eq_eq_singleton {a : α} : { n | n = a } = {a} 
goal: {n | n = a} = {a}

full_name: Set.setOf_eq_eq_singleton'
code: @[simp]
theorem setOf_eq_eq_singleton' {a : α} : { x | a = x } = {a} 
goal: {x | a = x} = {a}

full_name: Set.mem_singleton
code: theorem mem_singleton (a : α) : a ∈ ({a} : Set α) 
goal: a ∈ {a}

full_name: Set.eq_of_mem_singleton
code: theorem eq_of_mem_singleton {x y : α} (h : x ∈ ({y} : Set α)) : x = y 
goal: x = y

full_name: Set.singleton_eq_singleton_iff
code: @[simp]
theorem singleton_eq_singleton_iff {x y : α} : {x} = ({y} : Set α) ↔ x = y 
goal: {x} = {y} ↔ x = y

full_name: Set.singleton_injective
code: theorem singleton_injective : Injective (singleton : α → Set α) 
goal: Function.Injective singleton

full_name: Set.mem_singleton_of_eq
code: theorem mem_singleton_of_eq {x y : α} (H : x = y) : x ∈ ({y} : Set α) 
goal: x ∈ {y}

full_name: Set.insert_eq
code: theorem insert_eq (x : α) (s : Set α) : insert x s = ({x} : Set α) ∪ s 
goal: insert x s = {x} ∪ s

full_name: Set.singleton_nonempty
code: @[simp]
theorem singleton_nonempty (a : α) : ({a} : Set α).Nonempty 
goal: {a}.Nonempty

full_name: Set.singleton_ne_empty
code: @[simp]
theorem singleton_ne_empty (a : α) : ({a} : Set α) ≠ ∅ 
goal: {a} ≠ ∅

full_name: Set.empty_ssubset_singleton
code: theorem empty_ssubset_singleton : (∅ : Set α) ⊂ {a} 
goal: ∅ ⊂ {a}

full_name: Set.singleton_subset_iff
code: @[simp]
theorem singleton_subset_iff {a : α} {s : Set α} : {a} ⊆ s ↔ a ∈ s 
goal: {a} ⊆ s ↔ a ∈ s

full_name: Set.singleton_subset_singleton
code: theorem singleton_subset_singleton : ({a} : Set α) ⊆ {b} ↔ a = b 
goal: {a} ⊆ {b} ↔ a = b

full_name: Set.set_compr_eq_eq_singleton
code: theorem set_compr_eq_eq_singleton {a : α} : { b | b = a } = {a} 
goal: {b | b = a} = {a}

full_name: Set.singleton_union
code: @[simp]
theorem singleton_union : {a} ∪ s = insert a s 
goal: {a} ∪ s = insert a s

full_name: Set.union_singleton
code: @[simp]
theorem union_singleton : s ∪ {a} = insert a s 
goal: s ∪ {a} = insert a s

full_name: Set.singleton_inter_nonempty
code: @[simp]
theorem singleton_inter_nonempty : ({a} ∩ s).Nonempty ↔ a ∈ s 
goal: ({a} ∩ s).Nonempty ↔ a ∈ s

full_name: Set.inter_singleton_nonempty
code: @[simp]
theorem inter_singleton_nonempty : (s ∩ {a}).Nonempty ↔ a ∈ s 
goal: (s ∩ {a}).Nonempty ↔ a ∈ s

full_name: Set.singleton_inter_eq_empty
code: @[simp]
theorem singleton_inter_eq_empty : {a} ∩ s = ∅ ↔ a ∉ s 
goal: {a} ∩ s = ∅ ↔ a ∉ s

full_name: Set.inter_singleton_eq_empty
code: @[simp]
theorem inter_singleton_eq_empty : s ∩ {a} = ∅ ↔ a ∉ s 
goal: s ∩ {a} = ∅ ↔ a ∉ s

full_name: Set.nmem_singleton_empty
code: theorem nmem_singleton_empty {s : Set α} : s ∉ ({∅} : Set (Set α)) ↔ s.Nonempty 
goal: s ∉ {∅} ↔ s.Nonempty

full_name: Set.uniqueSingleton
code: instance uniqueSingleton (a : α) : Unique (↥({a} : Set α)) 
goal: Unique ↑{a}

full_name: Set.eq_singleton_iff_unique_mem
code: theorem eq_singleton_iff_unique_mem : s = {a} ↔ a ∈ s ∧ ∀ x ∈ s, x = a 
goal: s = {a} ↔ a ∈ s ∧ ∀ x ∈ s, x = a

full_name: Set.eq_singleton_iff_nonempty_unique_mem
code: theorem eq_singleton_iff_nonempty_unique_mem : s = {a} ↔ s.Nonempty ∧ ∀ x ∈ s, x = a 
goal: s = {a} ↔ s.Nonempty ∧ ∀ x ∈ s, x = a

full_name: Set.default_coe_singleton
code: @[simp]
theorem default_coe_singleton (x : α) : (default : ({x} : Set α)) = ⟨x, rfl⟩ 
goal: default = ⟨x, ⋯⟩

full_name: Set.mem_sep
code: theorem mem_sep (xs : x ∈ s) (px : p x) : x ∈ { x ∈ s | p x } 
goal: x ∈ {x | x ∈ s ∧ p x}

full_name: Set.sep_mem_eq
code: @[simp]
theorem sep_mem_eq : { x ∈ s | x ∈ t } = s ∩ t 
goal: {x | x ∈ s ∧ x ∈ t} = s ∩ t

full_name: Set.mem_sep_iff
code: @[simp]
theorem mem_sep_iff : x ∈ { x ∈ s | p x } ↔ x ∈ s ∧ p x 
goal: x ∈ {x | x ∈ s ∧ p x} ↔ x ∈ s ∧ p x

full_name: Set.sep_ext_iff
code: theorem sep_ext_iff : { x ∈ s | p x } = { x ∈ s | q x } ↔ ∀ x ∈ s, p x ↔ q x 
goal: {x | x ∈ s ∧ p x} = {x | x ∈ s ∧ q x} ↔ ∀ x ∈ s, p x ↔ q x

full_name: Set.sep_eq_of_subset
code: theorem sep_eq_of_subset (h : s ⊆ t) : { x ∈ t | x ∈ s } = s 
goal: {x | x ∈ t ∧ x ∈ s} = s

full_name: Set.sep_subset
code: @[simp]
theorem sep_subset (s : Set α) (p : α → Prop) : { x ∈ s | p x } ⊆ s 
goal: {x | x ∈ s ∧ p x} ⊆ s

full_name: Set.sep_eq_self_iff_mem_true
code: @[simp]
theorem sep_eq_self_iff_mem_true : { x ∈ s | p x } = s ↔ ∀ x ∈ s, p x 
goal: {x | x ∈ s ∧ p x} = s ↔ ∀ x ∈ s, p x

full_name: Set.sep_eq_empty_iff_mem_false
code: @[simp]
theorem sep_eq_empty_iff_mem_false : { x ∈ s | p x } = ∅ ↔ ∀ x ∈ s, ¬p x 
goal: {x | x ∈ s ∧ p x} = ∅ ↔ ∀ x ∈ s, ¬p x

full_name: Set.sep_true
code: theorem sep_true : { x ∈ s | True } = s 
goal: {x | x ∈ s ∧ True} = s

full_name: Set.sep_false
code: theorem sep_false : { x ∈ s | False } = ∅ 
goal: {x | x ∈ s ∧ False} = ∅

full_name: Set.sep_empty
code: theorem sep_empty (p : α → Prop) : { x ∈ (∅ : Set α) | p x } = ∅ 
goal: {x | x ∈ ∅ ∧ p x} = ∅

full_name: Set.sep_univ
code: theorem sep_univ : { x ∈ (univ : Set α) | p x } = { x | p x } 
goal: {x | x ∈ Set.univ ∧ p x} = {x | p x}

full_name: Set.sep_union
code: @[simp]
theorem sep_union : { x | (x ∈ s ∨ x ∈ t) ∧ p x } = { x ∈ s | p x } ∪ { x ∈ t | p x } 
goal: {x | (x ∈ s ∨ x ∈ t) ∧ p x} = {x | x ∈ s ∧ p x} ∪ {x | x ∈ t ∧ p x}

full_name: Set.sep_inter
code: @[simp]
theorem sep_inter : { x | (x ∈ s ∧ x ∈ t) ∧ p x } = { x ∈ s | p x } ∩ { x ∈ t | p x } 
goal: {x | (x ∈ s ∧ x ∈ t) ∧ p x} = {x | x ∈ s ∧ p x} ∩ {x | x ∈ t ∧ p x}

full_name: Set.sep_and
code: @[simp]
theorem sep_and : { x ∈ s | p x ∧ q x } = { x ∈ s | p x } ∩ { x ∈ s | q x } 
goal: {x | x ∈ s ∧ p x ∧ q x} = {x | x ∈ s ∧ p x} ∩ {x | x ∈ s ∧ q x}

full_name: Set.sep_or
code: @[simp]
theorem sep_or : { x ∈ s | p x ∨ q x } = { x ∈ s | p x } ∪ { x ∈ s | q x } 
goal: {x | x ∈ s ∧ (p x ∨ q x)} = {x | x ∈ s ∧ p x} ∪ {x | x ∈ s ∧ q x}

full_name: Set.sep_setOf
code: @[simp]
theorem sep_setOf : { x ∈ { y | p y } | q x } = { x | p x ∧ q x } 
goal: {x | x ∈ {y | p y} ∧ q x} = {x | p x ∧ q x}

full_name: Set.subset_singleton_iff
code: @[simp]
theorem subset_singleton_iff {α : Type*} {s : Set α} {x : α} : s ⊆ {x} ↔ ∀ y ∈ s, y = x 
goal: s ⊆ {x} ↔ ∀ y ∈ s, y = x

full_name: Set.subset_singleton_iff_eq
code: theorem subset_singleton_iff_eq {s : Set α} {x : α} : s ⊆ {x} ↔ s = ∅ ∨ s = {x} 
goal: s ⊆ {x} ↔ s = ∅ ∨ s = {x}

full_name: Set.Nonempty.subset_singleton_iff
code: theorem Nonempty.subset_singleton_iff (h : s.Nonempty) : s ⊆ {a} ↔ s = {a} 
goal: s ⊆ {a} ↔ s = {a}

full_name: Set.ssubset_singleton_iff
code: theorem ssubset_singleton_iff {s : Set α} {x : α} : s ⊂ {x} ↔ s = ∅ 
goal: s ⊂ {x} ↔ s = ∅

full_name: Set.eq_empty_of_ssubset_singleton
code: theorem eq_empty_of_ssubset_singleton {s : Set α} {x : α} (hs : s ⊂ {x}) : s = ∅ 
goal: s = ∅

full_name: Set.eq_of_nonempty_of_subsingleton
code: theorem eq_of_nonempty_of_subsingleton {α} [Subsingleton α] (s t : Set α) [Nonempty s]
    [Nonempty t] : s = t 
goal: s = t

full_name: Set.eq_of_nonempty_of_subsingleton'
code: theorem eq_of_nonempty_of_subsingleton' {α} [Subsingleton α] {s : Set α} (t : Set α)
    (hs : s.Nonempty) [Nonempty t] : s = t 
goal: s = t

full_name: Set.Nonempty.eq_zero
code: theorem Nonempty.eq_zero [Subsingleton α] [Zero α] {s : Set α} (h : s.Nonempty) :
    s = {0} 
goal: s = {0}

full_name: Set.Nonempty.eq_one
code: theorem Nonempty.eq_one [Subsingleton α] [One α] {s : Set α} (h : s.Nonempty) :
    s = {1} 
goal: s = {1}

full_name: Set.disjoint_iff
code: protected theorem disjoint_iff : Disjoint s t ↔ s ∩ t ⊆ ∅ 
goal: Disjoint s t ↔ s ∩ t ⊆ ∅

full_name: Set.disjoint_iff_inter_eq_empty
code: theorem disjoint_iff_inter_eq_empty : Disjoint s t ↔ s ∩ t = ∅ 
goal: Disjoint s t ↔ s ∩ t = ∅

full_name: Disjoint.inter_eq
code: theorem _root_.Disjoint.inter_eq : Disjoint s t → s ∩ t = ∅ 
goal: Disjoint s t → s ∩ t = ∅

full_name: Set.disjoint_left
code: theorem disjoint_left : Disjoint s t ↔ ∀ ⦃a⦄, a ∈ s → a ∉ t 
goal: Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ s → a ∉ t

full_name: Set.disjoint_right
code: theorem disjoint_right : Disjoint s t ↔ ∀ ⦃a⦄, a ∈ t → a ∉ s 
goal: Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ t → a ∉ s

full_name: Set.not_disjoint_iff
code: lemma not_disjoint_iff : ¬Disjoint s t ↔ ∃ x, x ∈ s ∧ x ∈ t 
goal: ¬Disjoint s t ↔ ∃ x ∈ s, x ∈ t

full_name: Set.not_disjoint_iff_nonempty_inter
code: lemma not_disjoint_iff_nonempty_inter : ¬ Disjoint s t ↔ (s ∩ t).Nonempty 
goal: ¬Disjoint s t ↔ (s ∩ t).Nonempty

full_name: Set.disjoint_or_nonempty_inter
code: lemma disjoint_or_nonempty_inter (s t : Set α) : Disjoint s t ∨ (s ∩ t).Nonempty 
goal: Disjoint s t ∨ (s ∩ t).Nonempty

full_name: Set.disjoint_iff_forall_ne
code: lemma disjoint_iff_forall_ne : Disjoint s t ↔ ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ t → a ≠ b 
goal: Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ t → a ≠ b

full_name: Set.disjoint_of_subset_left
code: lemma disjoint_of_subset_left (h : s ⊆ u) (d : Disjoint u t) : Disjoint s t 
goal: Disjoint s t

full_name: Set.disjoint_of_subset_right
code: lemma disjoint_of_subset_right (h : t ⊆ u) (d : Disjoint s u) : Disjoint s t 
goal: Disjoint s t

full_name: Set.disjoint_of_subset
code: lemma disjoint_of_subset (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) (h : Disjoint s₂ t₂) : Disjoint s₁ t₁ 
goal: Disjoint s₁ t₁

full_name: Set.disjoint_union_left
code: @[simp]
lemma disjoint_union_left : Disjoint (s ∪ t) u ↔ Disjoint s u ∧ Disjoint t u 
goal: Disjoint (s ∪ t) u ↔ Disjoint s u ∧ Disjoint t u

full_name: Set.disjoint_union_right
code: @[simp]
lemma disjoint_union_right : Disjoint s (t ∪ u) ↔ Disjoint s t ∧ Disjoint s u 
goal: Disjoint s (t ∪ u) ↔ Disjoint s t ∧ Disjoint s u

full_name: Set.disjoint_empty
code: @[simp] lemma disjoint_empty (s : Set α) : Disjoint s ∅ 
goal: Disjoint s ∅

full_name: Set.empty_disjoint
code: @[simp] lemma empty_disjoint (s : Set α) : Disjoint ∅ s 
goal: Disjoint ∅ s

full_name: Set.univ_disjoint
code: @[simp] lemma univ_disjoint : Disjoint univ s ↔ s = ∅ 
goal: Disjoint Set.univ s ↔ s = ∅

full_name: Set.disjoint_univ
code: @[simp] lemma disjoint_univ : Disjoint s univ ↔ s = ∅ 
goal: Disjoint s Set.univ ↔ s = ∅

full_name: Set.disjoint_sdiff_left
code: lemma disjoint_sdiff_left : Disjoint (t \ s) s 
goal: Disjoint (t \ s) s

full_name: Set.disjoint_sdiff_right
code: lemma disjoint_sdiff_right : Disjoint s (t \ s) 
goal: Disjoint s (t \ s)

full_name: Set.disjoint_sdiff_inter
code: theorem disjoint_sdiff_inter : Disjoint (s \ t) (s ∩ t) 
goal: Disjoint (s \ t) (s ∩ t)

full_name: Set.diff_union_diff_cancel
code: theorem diff_union_diff_cancel (hts : t ⊆ s) (hut : u ⊆ t) : s \ t ∪ t \ u = s \ u 
goal: s \ t ∪ t \ u = s \ u

full_name: Set.diff_diff_eq_sdiff_union
code: theorem diff_diff_eq_sdiff_union (h : u ⊆ s) : s \ (t \ u) = s \ t ∪ u 
goal: s \ (t \ u) = s \ t ∪ u

full_name: Set.disjoint_singleton_left
code: @[simp default+1]
lemma disjoint_singleton_left : Disjoint {a} s ↔ a ∉ s 
goal: Disjoint {a} s ↔ a ∉ s

full_name: Set.disjoint_singleton_right
code: @[simp]
lemma disjoint_singleton_right : Disjoint s {a} ↔ a ∉ s 
goal: Disjoint s {a} ↔ a ∉ s

full_name: Set.disjoint_singleton
code: lemma disjoint_singleton : Disjoint ({a} : Set α) {b} ↔ a ≠ b 
goal: Disjoint {a} {b} ↔ a ≠ b

full_name: Set.subset_diff
code: lemma subset_diff : s ⊆ t \ u ↔ s ⊆ t ∧ Disjoint s u 
goal: s ⊆ t \ u ↔ s ⊆ t ∧ Disjoint s u

full_name: Set.ssubset_iff_sdiff_singleton
code: lemma ssubset_iff_sdiff_singleton : s ⊂ t ↔ ∃ a ∈ t, s ⊆ t \ {a} 
goal: s ⊂ t ↔ ∃ a ∈ t, s ⊆ t \ {a}

full_name: Set.inter_diff_distrib_left
code: theorem inter_diff_distrib_left (s t u : Set α) : s ∩ (t \ u) = (s ∩ t) \ (s ∩ u) 
goal: s ∩ (t \ u) = (s ∩ t) \ (s ∩ u)

full_name: Set.inter_diff_distrib_right
code: theorem inter_diff_distrib_right (s t u : Set α) : s \ t ∩ u = (s ∩ u) \ (t ∩ u) 
goal: s \ t ∩ u = (s ∩ u) \ (t ∩ u)

full_name: Set.compl_def
code: theorem compl_def (s : Set α) : sᶜ = { x | x ∉ s } 
goal: sᶜ = {x | x ∉ s}

full_name: Set.mem_compl
code: theorem mem_compl {s : Set α} {x : α} (h : x ∉ s) : x ∈ sᶜ 
goal: x ∈ sᶜ

full_name: Set.compl_setOf
code: theorem compl_setOf {α} (p : α → Prop) : { a | p a }ᶜ = { a | ¬p a } 
goal: {a | p a}ᶜ = {a | ¬p a}

full_name: Set.not_mem_of_mem_compl
code: theorem not_mem_of_mem_compl {s : Set α} {x : α} (h : x ∈ sᶜ) : x ∉ s 
goal: x ∉ s

full_name: Set.not_mem_compl_iff
code: theorem not_mem_compl_iff {x : α} : x ∉ sᶜ ↔ x ∈ s 
goal: x ∉ sᶜ ↔ x ∈ s

full_name: Set.inter_compl_self
code: @[simp]
theorem inter_compl_self (s : Set α) : s ∩ sᶜ = ∅ 
goal: s ∩ sᶜ = ∅

full_name: Set.compl_inter_self
code: @[simp]
theorem compl_inter_self (s : Set α) : sᶜ ∩ s = ∅ 
goal: sᶜ ∩ s = ∅

full_name: Set.compl_empty
code: @[simp]
theorem compl_empty : (∅ : Set α)ᶜ = univ 
goal: ∅ᶜ = Set.univ

full_name: Set.compl_union
code: @[simp]
theorem compl_union (s t : Set α) : (s ∪ t)ᶜ = sᶜ ∩ tᶜ 
goal: (s ∪ t)ᶜ = sᶜ ∩ tᶜ

full_name: Set.compl_inter
code: theorem compl_inter (s t : Set α) : (s ∩ t)ᶜ = sᶜ ∪ tᶜ 
goal: (s ∩ t)ᶜ = sᶜ ∪ tᶜ

full_name: Set.compl_univ
code: @[simp]
theorem compl_univ : (univ : Set α)ᶜ = ∅ 
goal: Set.univᶜ = ∅

full_name: Set.compl_empty_iff
code: @[simp]
theorem compl_empty_iff {s : Set α} : sᶜ = ∅ ↔ s = univ 
goal: sᶜ = ∅ ↔ s = Set.univ

full_name: Set.compl_univ_iff
code: @[simp]
theorem compl_univ_iff {s : Set α} : sᶜ = univ ↔ s = ∅ 
goal: sᶜ = Set.univ ↔ s = ∅

full_name: Set.compl_ne_univ
code: theorem compl_ne_univ : sᶜ ≠ univ ↔ s.Nonempty 
goal: sᶜ ≠ Set.univ ↔ s.Nonempty

full_name: Set.nonempty_compl
code: theorem nonempty_compl : sᶜ.Nonempty ↔ s ≠ univ 
goal: sᶜ.Nonempty ↔ s ≠ Set.univ

full_name: Set.nonempty_compl_of_nontrivial
code: @[simp] lemma nonempty_compl_of_nontrivial [Nontrivial α] (x : α) : Set.Nonempty {x}ᶜ 
goal: {x}ᶜ.Nonempty

full_name: Set.mem_compl_singleton_iff
code: theorem mem_compl_singleton_iff {a x : α} : x ∈ ({a} : Set α)ᶜ ↔ x ≠ a 
goal: x ∈ {a}ᶜ ↔ x ≠ a

full_name: Set.compl_singleton_eq
code: theorem compl_singleton_eq (a : α) : ({a} : Set α)ᶜ = { x | x ≠ a } 
goal: {a}ᶜ = {x | x ≠ a}

full_name: Set.compl_ne_eq_singleton
code: @[simp]
theorem compl_ne_eq_singleton (a : α) : ({ x | x ≠ a } : Set α)ᶜ = {a} 
goal: {x | x ≠ a}ᶜ = {a}

full_name: Set.union_eq_compl_compl_inter_compl
code: theorem union_eq_compl_compl_inter_compl (s t : Set α) : s ∪ t = (sᶜ ∩ tᶜ)ᶜ 
goal: s ∪ t = (sᶜ ∩ tᶜ)ᶜ

full_name: Set.inter_eq_compl_compl_union_compl
code: theorem inter_eq_compl_compl_union_compl (s t : Set α) : s ∩ t = (sᶜ ∪ tᶜ)ᶜ 
goal: s ∩ t = (sᶜ ∪ tᶜ)ᶜ

full_name: Set.union_compl_self
code: @[simp]
theorem union_compl_self (s : Set α) : s ∪ sᶜ = univ 
goal: s ∪ sᶜ = Set.univ

full_name: Set.compl_union_self
code: @[simp]
theorem compl_union_self (s : Set α) : sᶜ ∪ s = univ 
goal: sᶜ ∪ s = Set.univ

full_name: Set.compl_subset_comm
code: theorem compl_subset_comm : sᶜ ⊆ t ↔ tᶜ ⊆ s 
goal: sᶜ ⊆ t ↔ tᶜ ⊆ s

full_name: Set.subset_compl_comm
code: theorem subset_compl_comm : s ⊆ tᶜ ↔ t ⊆ sᶜ 
goal: s ⊆ tᶜ ↔ t ⊆ sᶜ

full_name: Set.compl_subset_compl
code: @[simp]
theorem compl_subset_compl : sᶜ ⊆ tᶜ ↔ t ⊆ s 
goal: sᶜ ⊆ tᶜ ↔ t ⊆ s

full_name: Set.compl_subset_compl_of_subset
code: @[gcongr] theorem compl_subset_compl_of_subset (h : t ⊆ s) : sᶜ ⊆ tᶜ 
goal: sᶜ ⊆ tᶜ

full_name: Set.subset_compl_iff_disjoint_left
code: theorem subset_compl_iff_disjoint_left : s ⊆ tᶜ ↔ Disjoint t s 
goal: s ⊆ tᶜ ↔ Disjoint t s

full_name: Set.subset_compl_iff_disjoint_right
code: theorem subset_compl_iff_disjoint_right : s ⊆ tᶜ ↔ Disjoint s t 
goal: s ⊆ tᶜ ↔ Disjoint s t

full_name: Set.disjoint_compl_left_iff_subset
code: theorem disjoint_compl_left_iff_subset : Disjoint sᶜ t ↔ t ⊆ s 
goal: Disjoint sᶜ t ↔ t ⊆ s

full_name: Set.disjoint_compl_right_iff_subset
code: theorem disjoint_compl_right_iff_subset : Disjoint s tᶜ ↔ s ⊆ t 
goal: Disjoint s tᶜ ↔ s ⊆ t

full_name: Set.subset_union_compl_iff_inter_subset
code: theorem subset_union_compl_iff_inter_subset {s t u : Set α} : s ⊆ t ∪ uᶜ ↔ s ∩ u ⊆ t 
goal: s ⊆ t ∪ uᶜ ↔ s ∩ u ⊆ t

full_name: Set.compl_subset_iff_union
code: theorem compl_subset_iff_union {s t : Set α} : sᶜ ⊆ t ↔ s ∪ t = univ 
goal: sᶜ ⊆ t ↔ s ∪ t = Set.univ

full_name: Set.subset_compl_singleton_iff
code: @[simp]
theorem subset_compl_singleton_iff {a : α} {s : Set α} : s ⊆ {a}ᶜ ↔ a ∉ s 
goal: s ⊆ {a}ᶜ ↔ a ∉ s

full_name: Set.inter_subset
code: theorem inter_subset (a b c : Set α) : a ∩ b ⊆ c ↔ a ⊆ bᶜ ∪ c 
goal: a ∩ b ⊆ c ↔ a ⊆ bᶜ ∪ c

full_name: Set.inter_compl_nonempty_iff
code: theorem inter_compl_nonempty_iff {s t : Set α} : (s ∩ tᶜ).Nonempty ↔ ¬s ⊆ t 
goal: (s ∩ tᶜ).Nonempty ↔ ¬s ⊆ t

full_name: Set.not_mem_diff_of_mem
code: theorem not_mem_diff_of_mem {s t : Set α} {x : α} (hx : x ∈ t) : x ∉ s \ t 
goal: x ∉ s \ t

full_name: Set.mem_of_mem_diff
code: theorem mem_of_mem_diff {s t : Set α} {x : α} (h : x ∈ s \ t) : x ∈ s 
goal: x ∈ s

full_name: Set.not_mem_of_mem_diff
code: theorem not_mem_of_mem_diff {s t : Set α} {x : α} (h : x ∈ s \ t) : x ∉ t 
goal: x ∉ t

full_name: Set.diff_eq_compl_inter
code: theorem diff_eq_compl_inter {s t : Set α} : s \ t = tᶜ ∩ s 
goal: s \ t = tᶜ ∩ s

full_name: Set.nonempty_diff
code: theorem nonempty_diff {s t : Set α} : (s \ t).Nonempty ↔ ¬s ⊆ t 
goal: (s \ t).Nonempty ↔ ¬s ⊆ t

full_name: Set.diff_subset
code: theorem diff_subset {s t : Set α} : s \ t ⊆ s 
goal: s \ t ⊆ s

full_name: Set.diff_subset_compl
code: theorem diff_subset_compl (s t : Set α) : s \ t ⊆ tᶜ 
goal: s \ t ⊆ tᶜ

full_name: Set.union_diff_cancel'
code: theorem union_diff_cancel' {s t u : Set α} (h₁ : s ⊆ t) (h₂ : t ⊆ u) : t ∪ u \ s = u 
goal: t ∪ u \ s = u

full_name: Set.union_diff_cancel
code: theorem union_diff_cancel {s t : Set α} (h : s ⊆ t) : s ∪ t \ s = t 
goal: s ∪ t \ s = t

full_name: Set.union_diff_cancel_left
code: theorem union_diff_cancel_left {s t : Set α} (h : s ∩ t ⊆ ∅) : (s ∪ t) \ s = t 
goal: (s ∪ t) \ s = t

full_name: Set.union_diff_cancel_right
code: theorem union_diff_cancel_right {s t : Set α} (h : s ∩ t ⊆ ∅) : (s ∪ t) \ t = s 
goal: (s ∪ t) \ t = s

full_name: Set.union_diff_left
code: @[simp]
theorem union_diff_left {s t : Set α} : (s ∪ t) \ s = t \ s 
goal: (s ∪ t) \ s = t \ s

full_name: Set.union_diff_right
code: @[simp]
theorem union_diff_right {s t : Set α} : (s ∪ t) \ t = s \ t 
goal: (s ∪ t) \ t = s \ t

full_name: Set.union_diff_distrib
code: theorem union_diff_distrib {s t u : Set α} : (s ∪ t) \ u = s \ u ∪ t \ u 
goal: (s ∪ t) \ u = s \ u ∪ t \ u

full_name: Set.inter_diff_assoc
code: theorem inter_diff_assoc (a b c : Set α) : (a ∩ b) \ c = a ∩ (b \ c) 
goal: (a ∩ b) \ c = a ∩ (b \ c)

full_name: Set.inter_diff_self
code: @[simp]
theorem inter_diff_self (a b : Set α) : a ∩ (b \ a) = ∅ 
goal: a ∩ (b \ a) = ∅

full_name: Set.inter_union_diff
code: @[simp]
theorem inter_union_diff (s t : Set α) : s ∩ t ∪ s \ t = s 
goal: s ∩ t ∪ s \ t = s

full_name: Set.diff_union_inter
code: @[simp]
theorem diff_union_inter (s t : Set α) : s \ t ∪ s ∩ t = s 
goal: s \ t ∪ s ∩ t = s

full_name: Set.inter_union_compl
code: @[simp]
theorem inter_union_compl (s t : Set α) : s ∩ t ∪ s ∩ tᶜ = s 
goal: s ∩ t ∪ s ∩ tᶜ = s

full_name: Set.diff_subset_diff
code: @[gcongr]
theorem diff_subset_diff {s₁ s₂ t₁ t₂ : Set α} : s₁ ⊆ s₂ → t₂ ⊆ t₁ → s₁ \ t₁ ⊆ s₂ \ t₂ 
goal: s₁ ⊆ s₂ → t₂ ⊆ t₁ → s₁ \ t₁ ⊆ s₂ \ t₂

full_name: Set.diff_subset_diff_left
code: @[gcongr]
theorem diff_subset_diff_left {s₁ s₂ t : Set α} (h : s₁ ⊆ s₂) : s₁ \ t ⊆ s₂ \ t 
goal: s₁ \ t ⊆ s₂ \ t

full_name: Set.diff_subset_diff_right
code: @[gcongr]
theorem diff_subset_diff_right {s t u : Set α} (h : t ⊆ u) : s \ u ⊆ s \ t 
goal: s \ u ⊆ s \ t

full_name: Set.compl_eq_univ_diff
code: theorem compl_eq_univ_diff (s : Set α) : sᶜ = univ \ s 
goal: sᶜ = Set.univ \ s

full_name: Set.empty_diff
code: @[simp]
theorem empty_diff (s : Set α) : (∅ \ s : Set α) = ∅ 
goal: ∅ \ s = ∅

full_name: Set.diff_eq_empty
code: theorem diff_eq_empty {s t : Set α} : s \ t = ∅ ↔ s ⊆ t 
goal: s \ t = ∅ ↔ s ⊆ t

full_name: Set.diff_empty
code: @[simp]
theorem diff_empty {s : Set α} : s \ ∅ = s 
goal: s \ ∅ = s

full_name: Set.diff_univ
code: @[simp]
theorem diff_univ (s : Set α) : s \ univ = ∅ 
goal: s \ Set.univ = ∅

full_name: Set.diff_diff
code: theorem diff_diff {u : Set α} : (s \ t) \ u = s \ (t ∪ u) 
goal: (s \ t) \ u = s \ (t ∪ u)

full_name: Set.diff_diff_comm
code: theorem diff_diff_comm {s t u : Set α} : (s \ t) \ u = (s \ u) \ t 
goal: (s \ t) \ u = (s \ u) \ t

full_name: Set.diff_subset_iff
code: theorem diff_subset_iff {s t u : Set α} : s \ t ⊆ u ↔ s ⊆ t ∪ u 
goal: s \ t ⊆ u ↔ s ⊆ t ∪ u

full_name: Set.subset_diff_union
code: theorem subset_diff_union (s t : Set α) : s ⊆ s \ t ∪ t 
goal: s ⊆ s \ t ∪ t

full_name: Set.diff_union_of_subset
code: theorem diff_union_of_subset {s t : Set α} (h : t ⊆ s) : s \ t ∪ t = s 
goal: s \ t ∪ t = s

full_name: Set.diff_singleton_subset_iff
code: @[simp]
theorem diff_singleton_subset_iff {x : α} {s t : Set α} : s \ {x} ⊆ t ↔ s ⊆ insert x t 
goal: s \ {x} ⊆ t ↔ s ⊆ insert x t

full_name: Set.subset_diff_singleton
code: theorem subset_diff_singleton {x : α} {s t : Set α} (h : s ⊆ t) (hx : x ∉ s) : s ⊆ t \ {x} 
goal: s ⊆ t \ {x}

full_name: Set.subset_insert_diff_singleton
code: theorem subset_insert_diff_singleton (x : α) (s : Set α) : s ⊆ insert x (s \ {x}) 
goal: s ⊆ insert x (s \ {x})

full_name: Set.diff_subset_comm
code: theorem diff_subset_comm {s t u : Set α} : s \ t ⊆ u ↔ s \ u ⊆ t 
goal: s \ t ⊆ u ↔ s \ u ⊆ t

full_name: Set.diff_inter
code: theorem diff_inter {s t u : Set α} : s \ (t ∩ u) = s \ t ∪ s \ u 
goal: s \ (t ∩ u) = s \ t ∪ s \ u

full_name: Set.diff_inter_diff
code: theorem diff_inter_diff {s t u : Set α} : s \ t ∩ (s \ u) = s \ (t ∪ u) 
goal: s \ t ∩ (s \ u) = s \ (t ∪ u)

full_name: Set.diff_compl
code: theorem diff_compl : s \ tᶜ = s ∩ t 
goal: s \ tᶜ = s ∩ t

full_name: Set.diff_diff_right
code: theorem diff_diff_right {s t u : Set α} : s \ (t \ u) = s \ t ∪ s ∩ u 
goal: s \ (t \ u) = s \ t ∪ s ∩ u

full_name: Set.insert_diff_of_mem
code: @[simp]
theorem insert_diff_of_mem (s) (h : a ∈ t) : insert a s \ t = s \ t 
goal: insert a s \ t = s \ t

full_name: Set.insert_diff_of_not_mem
code: theorem insert_diff_of_not_mem (s) (h : a ∉ t) : insert a s \ t = insert a (s \ t) 
goal: insert a s \ t = insert a (s \ t)

full_name: Set.insert_diff_self_of_not_mem
code: theorem insert_diff_self_of_not_mem {a : α} {s : Set α} (h : a ∉ s) : insert a s \ {a} = s 
goal: insert a s \ {a} = s

full_name: Set.insert_diff_eq_singleton
code: @[simp]
theorem insert_diff_eq_singleton {a : α} {s : Set α} (h : a ∉ s) : insert a s \ s = {a} 
goal: insert a s \ s = {a}

full_name: Set.inter_insert_of_mem
code: theorem inter_insert_of_mem (h : a ∈ s) : s ∩ insert a t = insert a (s ∩ t) 
goal: s ∩ insert a t = insert a (s ∩ t)

full_name: Set.insert_inter_of_mem
code: theorem insert_inter_of_mem (h : a ∈ t) : insert a s ∩ t = insert a (s ∩ t) 
goal: insert a s ∩ t = insert a (s ∩ t)

full_name: Set.inter_insert_of_not_mem
code: theorem inter_insert_of_not_mem (h : a ∉ s) : s ∩ insert a t = s ∩ t 
goal: s ∩ insert a t = s ∩ t

full_name: Set.insert_inter_of_not_mem
code: theorem insert_inter_of_not_mem (h : a ∉ t) : insert a s ∩ t = s ∩ t 
goal: insert a s ∩ t = s ∩ t

full_name: Set.union_diff_self
code: @[simp]
theorem union_diff_self {s t : Set α} : s ∪ t \ s = s ∪ t 
goal: s ∪ t \ s = s ∪ t

full_name: Set.diff_union_self
code: @[simp]
theorem diff_union_self {s t : Set α} : s \ t ∪ t = s ∪ t 
goal: s \ t ∪ t = s ∪ t

full_name: Set.diff_inter_self
code: @[simp]
theorem diff_inter_self {a b : Set α} : b \ a ∩ a = ∅ 
goal: b \ a ∩ a = ∅

full_name: Set.diff_inter_self_eq_diff
code: @[simp]
theorem diff_inter_self_eq_diff {s t : Set α} : s \ (t ∩ s) = s \ t 
goal: s \ (t ∩ s) = s \ t

full_name: Set.diff_self_inter
code: @[simp]
theorem diff_self_inter {s t : Set α} : s \ (s ∩ t) = s \ t 
goal: s \ (s ∩ t) = s \ t

full_name: Set.diff_singleton_eq_self
code: @[simp]
theorem diff_singleton_eq_self {a : α} {s : Set α} (h : a ∉ s) : s \ {a} = s 
goal: s \ {a} = s

full_name: Set.diff_singleton_sSubset
code: @[simp]
theorem diff_singleton_sSubset {s : Set α} {a : α} : s \ {a} ⊂ s ↔ a ∈ s 
goal: s \ {a} ⊂ s ↔ a ∈ s

full_name: Set.insert_diff_singleton
code: @[simp]
theorem insert_diff_singleton {a : α} {s : Set α} : insert a (s \ {a}) = insert a s 
goal: insert a (s \ {a}) = insert a s

full_name: Set.insert_diff_singleton_comm
code: theorem insert_diff_singleton_comm (hab : a ≠ b) (s : Set α) :
    insert a (s \ {b}) = insert a s \ {b} 
goal: insert a (s \ {b}) = insert a s \ {b}

full_name: Set.diff_self
code: theorem diff_self {s : Set α} : s \ s = ∅ 
goal: s \ s = ∅

full_name: Set.diff_diff_right_self
code: theorem diff_diff_right_self (s t : Set α) : s \ (s \ t) = s ∩ t 
goal: s \ (s \ t) = s ∩ t

full_name: Set.diff_diff_cancel_left
code: theorem diff_diff_cancel_left {s t : Set α} (h : s ⊆ t) : t \ (t \ s) = s 
goal: t \ (t \ s) = s

full_name: Set.mem_diff_singleton
code: theorem mem_diff_singleton {x y : α} {s : Set α} : x ∈ s \ {y} ↔ x ∈ s ∧ x ≠ y 
goal: x ∈ s \ {y} ↔ x ∈ s ∧ x ≠ y

full_name: Set.mem_diff_singleton_empty
code: theorem mem_diff_singleton_empty {t : Set (Set α)} : s ∈ t \ {∅} ↔ s ∈ t ∧ s.Nonempty 
goal: s ∈ t \ {∅} ↔ s ∈ t ∧ s.Nonempty

full_name: Set.subset_insert_iff
code: theorem subset_insert_iff {s t : Set α} {x : α} :
    s ⊆ insert x t ↔ s ⊆ t ∨ (x ∈ s ∧ s \ {x} ⊆ t) 
goal: s ⊆ insert x t ↔ s ⊆ t ∨ x ∈ s ∧ s \ {x} ⊆ t

full_name: Set.union_eq_diff_union_diff_union_inter
code: theorem union_eq_diff_union_diff_union_inter (s t : Set α) : s ∪ t = s \ t ∪ t \ s ∪ s ∩ t 
goal: s ∪ t = s \ t ∪ t \ s ∪ s ∩ t

full_name: Set.pair_eq_singleton
code: theorem pair_eq_singleton (a : α) : ({a, a} : Set α) = {a} 
goal: {a, a} = {a}

full_name: Set.pair_comm
code: theorem pair_comm (a b : α) : ({a, b} : Set α) = {b, a} 
goal: {a, b} = {b, a}

full_name: Set.pair_eq_pair_iff
code: theorem pair_eq_pair_iff {x y z w : α} :
    ({x, y} : Set α) = {z, w} ↔ x = z ∧ y = w ∨ x = w ∧ y = z 
goal: {x, y} = {z, w} ↔ x = z ∧ y = w ∨ x = w ∧ y = z

full_name: Set.pair_diff_left
code: theorem pair_diff_left (hne : a ≠ b) : ({a, b} : Set α) \ {a} = {b} 
goal: {a, b} \ {a} = {b}

full_name: Set.pair_diff_right
code: theorem pair_diff_right (hne : a ≠ b) : ({a, b} : Set α) \ {b} = {a} 
goal: {a, b} \ {b} = {a}

full_name: Set.pair_subset_iff
code: theorem pair_subset_iff : {a, b} ⊆ s ↔ a ∈ s ∧ b ∈ s 
goal: {a, b} ⊆ s ↔ a ∈ s ∧ b ∈ s

full_name: Set.pair_subset
code: theorem pair_subset (ha : a ∈ s) (hb : b ∈ s) : {a, b} ⊆ s 
goal: {a, b} ⊆ s

full_name: Set.subset_pair_iff
code: theorem subset_pair_iff : s ⊆ {a, b} ↔ ∀ x ∈ s, x = a ∨ x = b 
goal: s ⊆ {a, b} ↔ ∀ x ∈ s, x = a ∨ x = b

full_name: Set.subset_pair_iff_eq
code: theorem subset_pair_iff_eq {x y : α} : s ⊆ {x, y} ↔ s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y} 
goal: s ⊆ {x, y} ↔ s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y}

full_name: Set.Nonempty.subset_pair_iff_eq
code: theorem Nonempty.subset_pair_iff_eq (hs : s.Nonempty) :
    s ⊆ {a, b} ↔ s = {a} ∨ s = {b} ∨ s = {a, b} 
goal: s ⊆ {a, b} ↔ s = {a} ∨ s = {b} ∨ s = {a, b}

full_name: Set.mem_symmDiff
code: theorem mem_symmDiff : a ∈ s ∆ t ↔ a ∈ s ∧ a ∉ t ∨ a ∈ t ∧ a ∉ s 
goal: a ∈ symmDiff s t ↔ a ∈ s ∧ a ∉ t ∨ a ∈ t ∧ a ∉ s

full_name: Set.symmDiff_def
code: protected theorem symmDiff_def (s t : Set α) : s ∆ t = s \ t ∪ t \ s 
goal: symmDiff s t = s \ t ∪ t \ s

full_name: Set.symmDiff_subset_union
code: theorem symmDiff_subset_union : s ∆ t ⊆ s ∪ t 
goal: symmDiff s t ⊆ s ∪ t

full_name: Set.symmDiff_eq_empty
code: @[simp]
theorem symmDiff_eq_empty : s ∆ t = ∅ ↔ s = t 
goal: symmDiff s t = ∅ ↔ s = t

full_name: Set.symmDiff_nonempty
code: @[simp]
theorem symmDiff_nonempty : (s ∆ t).Nonempty ↔ s ≠ t 
goal: (symmDiff s t).Nonempty ↔ s ≠ t

full_name: Set.inter_symmDiff_distrib_left
code: theorem inter_symmDiff_distrib_left (s t u : Set α) : s ∩ t ∆ u = (s ∩ t) ∆ (s ∩ u) 
goal: s ∩ symmDiff t u = symmDiff (s ∩ t) (s ∩ u)

full_name: Set.inter_symmDiff_distrib_right
code: theorem inter_symmDiff_distrib_right (s t u : Set α) : s ∆ t ∩ u = (s ∩ u) ∆ (t ∩ u) 
goal: symmDiff s t ∩ u = symmDiff (s ∩ u) (t ∩ u)

full_name: Set.subset_symmDiff_union_symmDiff_left
code: theorem subset_symmDiff_union_symmDiff_left (h : Disjoint s t) : u ⊆ s ∆ u ∪ t ∆ u 
goal: u ⊆ symmDiff s u ∪ symmDiff t u

full_name: Set.subset_symmDiff_union_symmDiff_right
code: theorem subset_symmDiff_union_symmDiff_right (h : Disjoint t u) : s ⊆ s ∆ t ∪ s ∆ u 
goal: s ⊆ symmDiff s t ∪ symmDiff s u

full_name: Set.mem_powerset
code: theorem mem_powerset {x s : Set α} (h : x ⊆ s) : x ∈ 𝒫 s 
goal: x ∈ 𝒫 s

full_name: Set.subset_of_mem_powerset
code: theorem subset_of_mem_powerset {x s : Set α} (h : x ∈ 𝒫 s) : x ⊆ s 
goal: x ⊆ s

full_name: Set.mem_powerset_iff
code: @[simp]
theorem mem_powerset_iff (x s : Set α) : x ∈ 𝒫 s ↔ x ⊆ s 
goal: x ∈ 𝒫 s ↔ x ⊆ s

full_name: Set.powerset_inter
code: theorem powerset_inter (s t : Set α) : 𝒫(s ∩ t) = 𝒫 s ∩ 𝒫 t 
goal: 𝒫(s ∩ t) = 𝒫 s ∩ 𝒫 t

full_name: Set.powerset_mono
code: @[simp]
theorem powerset_mono : 𝒫 s ⊆ 𝒫 t ↔ s ⊆ t 
goal: 𝒫 s ⊆ 𝒫 t ↔ s ⊆ t

full_name: Set.monotone_powerset
code: theorem monotone_powerset : Monotone (powerset : Set α → Set (Set α)) 
goal: Monotone Set.powerset

full_name: Set.powerset_nonempty
code: @[simp]
theorem powerset_nonempty : (𝒫 s).Nonempty 
goal: (𝒫 s).Nonempty

full_name: Set.powerset_empty
code: @[simp]
theorem powerset_empty : 𝒫(∅ : Set α) = {∅} 
goal: 𝒫∅ = {∅}

full_name: Set.powerset_univ
code: @[simp]
theorem powerset_univ : 𝒫(univ : Set α) = univ 
goal: 𝒫 Set.univ = Set.univ

full_name: Set.powerset_singleton
code: /-- The powerset of a singleton contains only `∅` and the singleton itself. -/
theorem powerset_singleton (x : α) : 𝒫({x} : Set α) = {∅, {x}} 
goal: 𝒫{x} = {∅, {x}}

full_name: Set.mem_dite
code: theorem mem_dite (p : Prop) [Decidable p] (s : p → Set α) (t : ¬ p → Set α) (x : α) :
    (x ∈ if h : p then s h else t h) ↔ (∀ h : p, x ∈ s h) ∧ ∀ h : ¬p, x ∈ t h 
goal: (x ∈ if h : p then s h else t h) ↔ (∀ (h : p), x ∈ s h) ∧ ∀ (h : ¬p), x ∈ t h

full_name: Set.mem_dite_univ_right
code: theorem mem_dite_univ_right (p : Prop) [Decidable p] (t : p → Set α) (x : α) :
    (x ∈ if h : p then t h else univ) ↔ ∀ h : p, x ∈ t h 
goal: (x ∈ if h : p then t h else Set.univ) ↔ ∀ (h : p), x ∈ t h

full_name: Set.mem_ite_univ_right
code: @[simp]
theorem mem_ite_univ_right (p : Prop) [Decidable p] (t : Set α) (x : α) :
    x ∈ ite p t Set.univ ↔ p → x ∈ t 
goal: (x ∈ if p then t else Set.univ) ↔ p → x ∈ t

full_name: Set.mem_dite_univ_left
code: theorem mem_dite_univ_left (p : Prop) [Decidable p] (t : ¬p → Set α) (x : α) :
    (x ∈ if h : p then univ else t h) ↔ ∀ h : ¬p, x ∈ t h 
goal: (x ∈ if h : p then Set.univ else t h) ↔ ∀ (h : ¬p), x ∈ t h

full_name: Set.mem_ite_univ_left
code: @[simp]
theorem mem_ite_univ_left (p : Prop) [Decidable p] (t : Set α) (x : α) :
    x ∈ ite p Set.univ t ↔ ¬p → x ∈ t 
goal: (x ∈ if p then Set.univ else t) ↔ ¬p → x ∈ t

full_name: Set.mem_dite_empty_right
code: theorem mem_dite_empty_right (p : Prop) [Decidable p] (t : p → Set α) (x : α) :
    (x ∈ if h : p then t h else ∅) ↔ ∃ h : p, x ∈ t h 
goal: (x ∈ if h : p then t h else ∅) ↔ ∃ (h : p), x ∈ t h

full_name: Set.mem_ite_empty_right
code: @[simp]
theorem mem_ite_empty_right (p : Prop) [Decidable p] (t : Set α) (x : α) :
    x ∈ ite p t ∅ ↔ p ∧ x ∈ t 
goal: (x ∈ if p then t else ∅) ↔ p ∧ x ∈ t

full_name: Set.mem_dite_empty_left
code: theorem mem_dite_empty_left (p : Prop) [Decidable p] (t : ¬p → Set α) (x : α) :
    (x ∈ if h : p then ∅ else t h) ↔ ∃ h : ¬p, x ∈ t h 
goal: (x ∈ if h : p then ∅ else t h) ↔ ∃ (h : ¬p), x ∈ t h

full_name: Set.mem_ite_empty_left
code: @[simp]
theorem mem_ite_empty_left (p : Prop) [Decidable p] (t : Set α) (x : α) :
    x ∈ ite p ∅ t ↔ ¬p ∧ x ∈ t 
goal: (x ∈ if p then ∅ else t) ↔ ¬p ∧ x ∈ t

full_name: Set.ite
code: /-- `ite` for sets: `Set.ite t s s' ∩ t = s ∩ t`, `Set.ite t s s' ∩ tᶜ = s' ∩ tᶜ`.
Defined as `s ∩ t ∪ s' \ t`. -/
protected def ite (t s s' : Set α) : Set α 
goal: Set α

full_name: Set.ite_inter_self
code: @[simp]
theorem ite_inter_self (t s s' : Set α) : t.ite s s' ∩ t = s ∩ t 
goal: t.ite s s' ∩ t = s ∩ t

full_name: Set.ite_compl
code: @[simp]
theorem ite_compl (t s s' : Set α) : tᶜ.ite s s' = t.ite s' s 
goal: tᶜ.ite s s' = t.ite s' s

full_name: Set.ite_inter_compl_self
code: @[simp]
theorem ite_inter_compl_self (t s s' : Set α) : t.ite s s' ∩ tᶜ = s' ∩ tᶜ 
goal: t.ite s s' ∩ tᶜ = s' ∩ tᶜ

full_name: Set.ite_diff_self
code: @[simp]
theorem ite_diff_self (t s s' : Set α) : t.ite s s' \ t = s' \ t 
goal: t.ite s s' \ t = s' \ t

full_name: Set.ite_same
code: @[simp]
theorem ite_same (t s : Set α) : t.ite s s = s 
goal: t.ite s s = s

full_name: Set.ite_left
code: @[simp]
theorem ite_left (s t : Set α) : s.ite s t = s ∪ t 
goal: s.ite s t = s ∪ t

full_name: Set.ite_right
code: @[simp]
theorem ite_right (s t : Set α) : s.ite t s = t ∩ s 
goal: s.ite t s = t ∩ s

full_name: Set.ite_empty
code: @[simp]
theorem ite_empty (s s' : Set α) : Set.ite ∅ s s' = s' 
goal: ∅.ite s s' = s'

full_name: Set.ite_univ
code: @[simp]
theorem ite_univ (s s' : Set α) : Set.ite univ s s' = s 
goal: Set.univ.ite s s' = s

full_name: Set.ite_empty_left
code: @[simp]
theorem ite_empty_left (t s : Set α) : t.ite ∅ s = s \ t 
goal: t.ite ∅ s = s \ t

full_name: Set.ite_empty_right
code: @[simp]
theorem ite_empty_right (t s : Set α) : t.ite s ∅ = s ∩ t 
goal: t.ite s ∅ = s ∩ t

full_name: Set.ite_mono
code: theorem ite_mono (t : Set α) {s₁ s₁' s₂ s₂' : Set α} (h : s₁ ⊆ s₂) (h' : s₁' ⊆ s₂') :
    t.ite s₁ s₁' ⊆ t.ite s₂ s₂' 
goal: t.ite s₁ s₁' ⊆ t.ite s₂ s₂'

full_name: Set.ite_subset_union
code: theorem ite_subset_union (t s s' : Set α) : t.ite s s' ⊆ s ∪ s' 
goal: t.ite s s' ⊆ s ∪ s'

full_name: Set.inter_subset_ite
code: theorem inter_subset_ite (t s s' : Set α) : s ∩ s' ⊆ t.ite s s' 
goal: s ∩ s' ⊆ t.ite s s'

full_name: Set.ite_inter_inter
code: theorem ite_inter_inter (t s₁ s₂ s₁' s₂' : Set α) :
    t.ite (s₁ ∩ s₂) (s₁' ∩ s₂') = t.ite s₁ s₁' ∩ t.ite s₂ s₂' 
goal: t.ite (s₁ ∩ s₂) (s₁' ∩ s₂') = t.ite s₁ s₁' ∩ t.ite s₂ s₂'

full_name: Set.ite_inter
code: theorem ite_inter (t s₁ s₂ s : Set α) : t.ite (s₁ ∩ s) (s₂ ∩ s) = t.ite s₁ s₂ ∩ s 
goal: t.ite (s₁ ∩ s) (s₂ ∩ s) = t.ite s₁ s₂ ∩ s

full_name: Set.ite_inter_of_inter_eq
code: theorem ite_inter_of_inter_eq (t : Set α) {s₁ s₂ s : Set α} (h : s₁ ∩ s = s₂ ∩ s) :
    t.ite s₁ s₂ ∩ s = s₁ ∩ s 
goal: t.ite s₁ s₂ ∩ s = s₁ ∩ s

full_name: Set.subset_ite
code: theorem subset_ite {t s s' u : Set α} : u ⊆ t.ite s s' ↔ u ∩ t ⊆ s ∧ u \ t ⊆ s' 
goal: u ⊆ t.ite s s' ↔ u ∩ t ⊆ s ∧ u \ t ⊆ s'

full_name: Set.ite_eq_of_subset_left
code: theorem ite_eq_of_subset_left (t : Set α) {s₁ s₂ : Set α} (h : s₁ ⊆ s₂) :
    t.ite s₁ s₂ = s₁ ∪ (s₂ \ t) 
goal: t.ite s₁ s₂ = s₁ ∪ s₂ \ t

full_name: Set.ite_eq_of_subset_right
code: theorem ite_eq_of_subset_right (t : Set α) {s₁ s₂ : Set α} (h : s₂ ⊆ s₁) :
    t.ite s₁ s₂ = (s₁ ∩ t) ∪ s₂ 
goal: t.ite s₁ s₂ = s₁ ∩ t ∪ s₂

full_name: Set.monotoneOn_iff_monotone
code: theorem monotoneOn_iff_monotone : MonotoneOn f s ↔
    Monotone fun a : s => f a 
goal: MonotoneOn f s ↔ Monotone fun a => f ↑a

full_name: Set.antitoneOn_iff_antitone
code: theorem antitoneOn_iff_antitone : AntitoneOn f s ↔
    Antitone fun a : s => f a 
goal: AntitoneOn f s ↔ Antitone fun a => f ↑a

full_name: Set.strictMonoOn_iff_strictMono
code: theorem strictMonoOn_iff_strictMono : StrictMonoOn f s ↔
    StrictMono fun a : s => f a 
goal: StrictMonoOn f s ↔ StrictMono fun a => f ↑a

full_name: Set.strictAntiOn_iff_strictAnti
code: theorem strictAntiOn_iff_strictAnti : StrictAntiOn f s ↔
    StrictAnti fun a : s => f a 
goal: StrictAntiOn f s ↔ StrictAnti fun a => f ↑a

full_name: Set.not_monotoneOn_not_antitoneOn_iff_exists_le_le
code: /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
downright. -/
theorem not_monotoneOn_not_antitoneOn_iff_exists_le_le :
    ¬MonotoneOn f s ∧ ¬AntitoneOn f s ↔
      ∃ᵉ (a ∈ s) (b ∈ s) (c ∈ s), a ≤ b ∧ b ≤ c ∧
        (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c) 
goal: ¬MonotoneOn f s ∧ ¬AntitoneOn f s ↔
  ∃ a ∈ s, ∃ b ∈ s, ∃ c ∈ s, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)

full_name: Set.not_monotoneOn_not_antitoneOn_iff_exists_lt_lt
code: /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
downright. -/
theorem not_monotoneOn_not_antitoneOn_iff_exists_lt_lt :
    ¬MonotoneOn f s ∧ ¬AntitoneOn f s ↔
      ∃ᵉ (a ∈ s) (b ∈ s) (c ∈ s), a < b ∧ b < c ∧
        (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c) 
goal: ¬MonotoneOn f s ∧ ¬AntitoneOn f s ↔
  ∃ a ∈ s, ∃ b ∈ s, ∃ c ∈ s, a < b ∧ b < c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)

full_name: Function.Injective.nonempty_apply_iff
code: theorem Injective.nonempty_apply_iff {f : Set α → Set β} (hf : Injective f) (h2 : f ∅ = ∅)
    {s : Set α} : (f s).Nonempty ↔ s.Nonempty 
goal: (f s).Nonempty ↔ s.Nonempty

full_name: Set.inclusion
code: /-- `inclusion` is the "identity" function between two subsets `s` and `t`, where `s ⊆ t` -/
def inclusion (h : s ⊆ t) : s → t 
goal: ↑s → ↑t

full_name: Set.inclusion_self
code: @[simp]
theorem inclusion_self (x : s) : inclusion Subset.rfl x = x 
goal: Set.inclusion ⋯ x = x

full_name: Set.inclusion_eq_id
code: theorem inclusion_eq_id (h : s ⊆ s) : inclusion h = id 
goal: Set.inclusion h = id

full_name: Set.inclusion_mk
code: @[simp]
theorem inclusion_mk {h : s ⊆ t} (a : α) (ha : a ∈ s) : inclusion h ⟨a, ha⟩ = ⟨a, h ha⟩ 
goal: Set.inclusion h ⟨a, ha⟩ = ⟨a, ⋯⟩

full_name: Set.inclusion_right
code: theorem inclusion_right (h : s ⊆ t) (x : t) (m : (x : α) ∈ s) : inclusion h ⟨x, m⟩ = x 
goal: Set.inclusion h ⟨↑x, m⟩ = x

full_name: Set.inclusion_inclusion
code: @[simp]
theorem inclusion_inclusion (hst : s ⊆ t) (htu : t ⊆ u) (x : s) :
    inclusion htu (inclusion hst x) = inclusion (hst.trans htu) x 
goal: Set.inclusion htu (Set.inclusion hst x) = Set.inclusion ⋯ x

full_name: Set.inclusion_comp_inclusion
code: @[simp]
theorem inclusion_comp_inclusion {α} {s t u : Set α} (hst : s ⊆ t) (htu : t ⊆ u) :
    inclusion htu ∘ inclusion hst = inclusion (hst.trans htu) 
goal: Set.inclusion htu ∘ Set.inclusion hst = Set.inclusion ⋯

full_name: Set.coe_inclusion
code: @[simp]
theorem coe_inclusion (h : s ⊆ t) (x : s) : (inclusion h x : α) = (x : α) 
goal: ↑(Set.inclusion h x) = ↑x

full_name: Set.val_comp_inclusion
code: theorem val_comp_inclusion (h : s ⊆ t) : Subtype.val ∘ inclusion h = Subtype.val 
goal: Subtype.val ∘ Set.inclusion h = Subtype.val

full_name: Set.inclusion_injective
code: theorem inclusion_injective (h : s ⊆ t) : Injective (inclusion h)
  
goal: Function.Injective (Set.inclusion h)

full_name: Set.inclusion_inj
code: @[simp]
theorem inclusion_inj (h : s ⊆ t) {x y : s} : inclusion h x = inclusion h y ↔ x = y 
goal: Set.inclusion h x = Set.inclusion h y ↔ x = y

full_name: Set.eq_of_inclusion_surjective
code: theorem eq_of_inclusion_surjective {s t : Set α} {h : s ⊆ t}
    (h_surj : Function.Surjective (inclusion h)) : s = t 
goal: s = t

full_name: Set.inclusion_le_inclusion
code: @[simp]
theorem inclusion_le_inclusion [Preorder α] {s t : Set α} (h : s ⊆ t) {x y : s} :
    inclusion h x ≤ inclusion h y ↔ x ≤ y 
goal: Set.inclusion h x ≤ Set.inclusion h y ↔ x ≤ y

full_name: Set.inclusion_lt_inclusion
code: @[simp]
theorem inclusion_lt_inclusion [Preorder α] {s t : Set α} (h : s ⊆ t) {x y : s} :
    inclusion h x < inclusion h y ↔ x < y 
goal: Set.inclusion h x < Set.inclusion h y ↔ x < y

full_name: Subsingleton.eq_univ_of_nonempty
code: theorem eq_univ_of_nonempty {s : Set α} : s.Nonempty → s = univ 
goal: s.Nonempty → s = Set.univ

full_name: Subsingleton.set_cases
code: @[elab_as_elim]
theorem set_cases {p : Set α → Prop} (h0 : p ∅) (h1 : p univ) (s) : p s 
goal: p s

full_name: Subsingleton.mem_iff_nonempty
code: theorem mem_iff_nonempty {α : Type*} [Subsingleton α] {s : Set α} {x : α} : x ∈ s ↔ s.Nonempty 
goal: x ∈ s ↔ s.Nonempty

full_name: Set.decidableSdiff
code: instance decidableSdiff [Decidable (a ∈ s)] [Decidable (a ∈ t)] : Decidable (a ∈ s \ t) 
goal: Decidable (a ∈ s \ t)

full_name: Set.decidableInter
code: instance decidableInter [Decidable (a ∈ s)] [Decidable (a ∈ t)] : Decidable (a ∈ s ∩ t) 
goal: Decidable (a ∈ s ∩ t)

full_name: Set.decidableUnion
code: instance decidableUnion [Decidable (a ∈ s)] [Decidable (a ∈ t)] : Decidable (a ∈ s ∪ t) 
goal: Decidable (a ∈ s ∪ t)

full_name: Set.decidableCompl
code: instance decidableCompl [Decidable (a ∈ s)] : Decidable (a ∈ sᶜ) 
goal: Decidable (a ∈ sᶜ)

full_name: Set.decidableEmptyset
code: instance decidableEmptyset : Decidable (a ∈ (∅ : Set α)) 
goal: Decidable (a ∈ ∅)

full_name: Set.decidableUniv
code: instance decidableUniv : Decidable (a ∈ univ) 
goal: Decidable (a ∈ Set.univ)

full_name: Set.decidableInsert
code: instance decidableInsert [Decidable (a = b)] [Decidable (a ∈ s)] : Decidable (a ∈ insert b s) 
goal: Decidable (a ∈ insert b s)

full_name: Set.decidableSingleton
code: instance decidableSingleton [Decidable (a = b)] : Decidable (a ∈ ({b} : Set α)) 
goal: Decidable (a ∈ {b})

full_name: Set.decidableSetOf
code: instance decidableSetOf (p : α → Prop) [Decidable (p a)] : Decidable (a ∈ { a | p a }) 
goal: Decidable (a ∈ {a | p a})

full_name: Monotone.inter
code: theorem Monotone.inter [Preorder β] {f g : β → Set α} (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x ∩ g x 
goal: Monotone fun x => f x ∩ g x

full_name: MonotoneOn.inter
code: theorem MonotoneOn.inter [Preorder β] {f g : β → Set α} {s : Set β} (hf : MonotoneOn f s)
    (hg : MonotoneOn g s) : MonotoneOn (fun x => f x ∩ g x) s 
goal: MonotoneOn (fun x => f x ∩ g x) s

full_name: Antitone.inter
code: theorem Antitone.inter [Preorder β] {f g : β → Set α} (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x => f x ∩ g x 
goal: Antitone fun x => f x ∩ g x

full_name: AntitoneOn.inter
code: theorem AntitoneOn.inter [Preorder β] {f g : β → Set α} {s : Set β} (hf : AntitoneOn f s)
    (hg : AntitoneOn g s) : AntitoneOn (fun x => f x ∩ g x) s 
goal: AntitoneOn (fun x => f x ∩ g x) s

full_name: Monotone.union
code: theorem Monotone.union [Preorder β] {f g : β → Set α} (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x ∪ g x 
goal: Monotone fun x => f x ∪ g x

full_name: MonotoneOn.union
code: theorem MonotoneOn.union [Preorder β] {f g : β → Set α} {s : Set β} (hf : MonotoneOn f s)
    (hg : MonotoneOn g s) : MonotoneOn (fun x => f x ∪ g x) s 
goal: MonotoneOn (fun x => f x ∪ g x) s

full_name: Antitone.union
code: theorem Antitone.union [Preorder β] {f g : β → Set α} (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x => f x ∪ g x 
goal: Antitone fun x => f x ∪ g x

full_name: AntitoneOn.union
code: theorem AntitoneOn.union [Preorder β] {f g : β → Set α} {s : Set β} (hf : AntitoneOn f s)
    (hg : AntitoneOn g s) : AntitoneOn (fun x => f x ∪ g x) s 
goal: AntitoneOn (fun x => f x ∪ g x) s

full_name: Set.monotone_setOf
code: theorem monotone_setOf [Preorder α] {p : α → β → Prop} (hp : ∀ b, Monotone fun a => p a b) :
    Monotone fun a => { b | p a b } 
goal: Monotone fun a => {b | p a b}

full_name: Set.antitone_setOf
code: theorem antitone_setOf [Preorder α] {p : α → β → Prop} (hp : ∀ b, Antitone fun a => p a b) :
    Antitone fun a => { b | p a b } 
goal: Antitone fun a => {b | p a b}

full_name: Set.antitone_bforall
code: /-- Quantifying over a set is antitone in the set -/
theorem antitone_bforall {P : α → Prop} : Antitone fun s : Set α => ∀ x ∈ s, P x 
goal: Antitone fun s => ∀ x ∈ s, P x

full_name: Disjoint.union_left
code: theorem union_left (hs : Disjoint s u) (ht : Disjoint t u) : Disjoint (s ∪ t) u 
goal: Disjoint (s ∪ t) u

full_name: Disjoint.union_right
code: theorem union_right (ht : Disjoint s t) (hu : Disjoint s u) : Disjoint s (t ∪ u) 
goal: Disjoint s (t ∪ u)

full_name: Disjoint.inter_left
code: theorem inter_left (u : Set α) (h : Disjoint s t) : Disjoint (s ∩ u) t 
goal: Disjoint (s ∩ u) t

full_name: Disjoint.inter_left'
code: theorem inter_left' (u : Set α) (h : Disjoint s t) : Disjoint (u ∩ s) t 
goal: Disjoint (u ∩ s) t

full_name: Disjoint.inter_right
code: theorem inter_right (u : Set α) (h : Disjoint s t) : Disjoint s (t ∩ u) 
goal: Disjoint s (t ∩ u)

full_name: Disjoint.inter_right'
code: theorem inter_right' (u : Set α) (h : Disjoint s t) : Disjoint s (u ∩ t) 
goal: Disjoint s (u ∩ t)

full_name: Disjoint.subset_left_of_subset_union
code: theorem subset_left_of_subset_union (h : s ⊆ t ∪ u) (hac : Disjoint s u) : s ⊆ t 
goal: s ⊆ t

full_name: Disjoint.subset_right_of_subset_union
code: theorem subset_right_of_subset_union (h : s ⊆ t ∪ u) (hab : Disjoint s t) : s ⊆ u 
goal: s ⊆ u

full_name: Prop.compl_singleton
code: @[simp] theorem Prop.compl_singleton (p : Prop) : ({p}ᶜ : Set Prop) = {¬p} 
goal: {p}ᶜ = {¬p}