ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ULift.up_lt
@[simp] theorem up_lt [LT α] {a b : α} : up a < up b ↔ a < b 
Arguments: {α : Type u} [LT α] {a b : α}
Goal: { down := a } < { down := b } ↔ a < b
-- ULift.down_lt
@[simp] theorem down_lt [LT α] {a b : ULift α} : down a < down b ↔ a < b 
Arguments: {α : Type u} [LT α] {a b : ULift.{u_1, u} α}
Goal: a.down < b.down ↔ a < b
-- ULift.up_compare
@[simp] theorem up_compare [Ord α] (a b : α) : compare (up a) (up b) = compare a b 
Arguments: {α : Type u} [Ord α] (a b : α)
Goal: compare { down := a } { down := b } = compare a b
-- ULift.down_compare
@[simp] theorem down_compare [Ord α] (a b : ULift α) :
  compare (down a) (down b) = compare a b 
Arguments: {α : Type u} [Ord α] (a b : ULift.{u_1, u} α)
Goal: compare a.down b.down = compare a b
-- ULift.up_sup
@[simp] theorem up_sup [Sup α] (a b : α) : up (a ⊔ b) = up a ⊔ up b 
Arguments: {α : Type u} [Sup α] (a b : α)
Goal: { down := a ⊔ b } = { down := a } ⊔ { down := b }
-- ULift.down_sup
@[simp] theorem down_sup [Sup α] (a b : ULift α) : down (a ⊔ b) = down a ⊔ down b 
Arguments: {α : Type u} [Sup α] (a b : ULift.{u_1, u} α)
Goal: (a ⊔ b).down = a.down ⊔ b.down
-- ULift.up_inf
@[simp] theorem up_inf [Inf α] (a b : α) : up (a ⊓ b) = up a ⊓ up b 
Arguments: {α : Type u} [Inf α] (a b : α)
Goal: { down := a ⊓ b } = { down := a } ⊓ { down := b }
-- ULift.down_inf
@[simp] theorem down_inf [Inf α] (a b : ULift α) : down (a ⊓ b) = down a ⊓ down b 
Arguments: {α : Type u} [Inf α] (a b : ULift.{u_1, u} α)
Goal: (a ⊓ b).down = a.down ⊓ b.down
-- ULift.up_sdiff
@[simp] theorem up_sdiff [SDiff α] (a b : α) : up (a \ b) = up a \ up b 
Arguments: {α : Type u} [SDiff α] (a b : α)
Goal: { down := a \ b } = { down := a } \ { down := b }
-- ULift.down_sdiff
@[simp] theorem down_sdiff [SDiff α] (a b : ULift α) : down (a \ b) = down a \ down b 
Arguments: {α : Type u} [SDiff α] (a b : ULift.{u_1, u} α)
Goal: (a \ b).down = a.down \ b.down
-- ULift.up_compl
@[simp] theorem up_compl [HasCompl α] (a : α) : up (aᶜ) = (up a)ᶜ 
Arguments: {α : Type u} [HasCompl α] (a : α)
Goal: { down := aᶜ } = { down := a }ᶜ
-- ULift.down_compl
@[simp] theorem down_compl [HasCompl α] (a : ULift α) : down aᶜ = (down a)ᶜ 
Arguments: {α : Type u} [HasCompl α] (a : ULift.{u_1, u} α)
Goal: aᶜ.down = a.downᶜ
-- Filter.sets_of_superset
structure Filter (α : Type*) where
    sets : Set (Set α)
    univ_sets : Set.univ ∈ sets
    sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets
    inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets
Arguments: {α : Type u_1} (self : Filter α) {x y : Set α}
Goal: x ∈ self.sets → x ⊆ y → y ∈ self.sets
-- Filter.inter_sets
structure Filter (α : Type*) where
    sets : Set (Set α)
    univ_sets : Set.univ ∈ sets
    sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets
    inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets
Arguments: {α : Type u_1} (self : Filter α) {x y : Set α}
Goal: x ∈ self.sets → y ∈ self.sets → x ∩ y ∈ self.sets
-- Filter.univ_sets
structure Filter (α : Type*) where
    sets : Set (Set α)
    univ_sets : Set.univ ∈ sets
    sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets
    inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets
Arguments: {α : Type u_1} (self : Filter α)
Goal: Set.univ ∈ self.sets
-- Filter.mem_mk
@[simp]
protected theorem mem_mk {t : Set (Set α)} {h₁ h₂ h₃} : s ∈ mk t h₁ h₂ h₃ ↔ s ∈ t 
Arguments: {α : Type u} {s : Set α} {t : Set (Set α)} {h₁ : Set.univ ∈ t} {h₂ : ∀ {x y : Set α}, x ∈ t → x ⊆ y → y ∈ t} {h₃ : ∀ {x y : Set α}, x ∈ t → y ∈ t → x ∩ y ∈ t}
Goal: s ∈ { sets := t, univ_sets := h₁, sets_of_superset := h₂, inter_sets := h₃ } ↔ s ∈ t
-- Filter.mem_sets
@[simp]
protected theorem mem_sets : s ∈ f.sets ↔ s ∈ f 
Arguments: {α : Type u} {f : Filter α} {s : Set α}
Goal: s ∈ f.sets ↔ s ∈ f
-- Filter.filter_eq
theorem filter_eq : ∀ {f g : Filter α}, f.sets = g.sets → f = g
  
Arguments: {α : Type u} {f g : Filter α}
Goal: f.sets = g.sets → f = g
-- Filter.filter_eq_iff
theorem filter_eq_iff : f = g ↔ f.sets = g.sets 
Arguments: {α : Type u} {f g : Filter α}
Goal: f = g ↔ f.sets = g.sets
-- Filter.ext
@[ext]
protected theorem ext (h : ∀ s, s ∈ f ↔ s ∈ g) : f = g 
Arguments: {α : Type u} {f g : Filter α} (h : ∀ (s : Set α), s ∈ f ↔ s ∈ g)
Goal: f = g
-- Filter.ext_iff
protected theorem ext_iff : f = g ↔ ∀ s, s ∈ f ↔ s ∈ g 
Arguments: {α : Type u} {f g : Filter α}
Goal: f = g ↔ ∀ (s : Set α), s ∈ f ↔ s ∈ g
-- Filter.coext
protected theorem coext (h : ∀ s, sᶜ ∈ f ↔ sᶜ ∈ g) : f = g 
Arguments: {α : Type u} {f g : Filter α} (h : ∀ (s : Set α), sᶜ ∈ f ↔ sᶜ ∈ g)
Goal: f = g
-- Filter.univ_mem
@[simp]
theorem univ_mem : univ ∈ f 
Arguments: {α : Type u} {f : Filter α}
Goal: Set.univ ∈ f
-- Filter.mem_of_superset
theorem mem_of_superset {x y : Set α} (hx : x ∈ f) (hxy : x ⊆ y) : y ∈ f 
Arguments: {α : Type u} {f : Filter α} {x y : Set α} (hx : x ∈ f) (hxy : x ⊆ y)
Goal: y ∈ f
-- Filter.inter_mem
theorem inter_mem {s t : Set α} (hs : s ∈ f) (ht : t ∈ f) : s ∩ t ∈ f 
Arguments: {α : Type u} {f : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ f)
Goal: s ∩ t ∈ f
-- Filter.inter_mem_iff
@[simp]
theorem inter_mem_iff {s t : Set α} : s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f 
Arguments: {α : Type u} {f : Filter α} {s t : Set α}
Goal: s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f
-- Filter.diff_mem
theorem diff_mem {s t : Set α} (hs : s ∈ f) (ht : tᶜ ∈ f) : s \ t ∈ f 
Arguments: {α : Type u} {f : Filter α} {s t : Set α} (hs : s ∈ f) (ht : tᶜ ∈ f)
Goal: s \ t ∈ f
-- Filter.univ_mem'
theorem univ_mem' (h : ∀ a, a ∈ s) : s ∈ f 
Arguments: {α : Type u} {f : Filter α} {s : Set α} (h : ∀ (a : α), a ∈ s)
Goal: s ∈ f
-- Filter.mp_mem
theorem mp_mem (hs : s ∈ f) (h : { x | x ∈ s → x ∈ t } ∈ f) : t ∈ f 
Arguments: {α : Type u} {f : Filter α} {s t : Set α} (hs : s ∈ f) (h : {x | x ∈ s → x ∈ t} ∈ f)
Goal: t ∈ f
-- Filter.congr_sets
theorem congr_sets (h : { x | x ∈ s ↔ x ∈ t } ∈ f) : s ∈ f ↔ t ∈ f 
Arguments: {α : Type u} {f : Filter α} {s t : Set α} (h : {x | x ∈ s ↔ x ∈ t} ∈ f)
Goal: s ∈ f ↔ t ∈ f
-- Filter.copy_eq
lemma copy_eq {S} (hmem : ∀ s, s ∈ S ↔ s ∈ f) : f.copy S hmem = f 
Arguments: {α : Type u} {f : Filter α} {S : Set (Set α)} (hmem : ∀ (s : Set α), s ∈ S ↔ s ∈ f)
Goal: f.copy S hmem = f
-- Filter.mem_copy
@[simp] lemma mem_copy {S hmem} : s ∈ f.copy S hmem ↔ s ∈ S 
Arguments: {α : Type u} {f : Filter α} {s : Set α} {S : Set (Set α)} {hmem : ∀ (s : Set α), s ∈ S ↔ s ∈ f}
Goal: s ∈ f.copy S hmem ↔ s ∈ S
-- Filter.biInter_mem
@[simp]
theorem biInter_mem {β : Type v} {s : β → Set α} {is : Set β} (hf : is.Finite) :
    (⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f 
Arguments: {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} {is : Set β} (hf : is.Finite)
Goal: ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f
-- Filter.biInter_finset_mem
@[simp]
theorem biInter_finset_mem {β : Type v} {s : β → Set α} (is : Finset β) :
    (⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f 
Arguments: {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} (is : Finset β)
Goal: ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f
-- Filter.sInter_mem
@[simp]
theorem sInter_mem {s : Set (Set α)} (hfin : s.Finite) : ⋂₀ s ∈ f ↔ ∀ U ∈ s, U ∈ f 
Arguments: {α : Type u} {f : Filter α} {s : Set (Set α)} (hfin : s.Finite)
Goal: ⋂₀ s ∈ f ↔ ∀ U ∈ s, U ∈ f
-- Filter.iInter_mem
@[simp]
theorem iInter_mem {β : Sort v} {s : β → Set α} [Finite β] : (⋂ i, s i) ∈ f ↔ ∀ i, s i ∈ f 
Arguments: {α : Type u} {f : Filter α} {β : Sort v} {s : β → Set α} [Finite β]
Goal: ⋂ i, s i ∈ f ↔ ∀ (i : β), s i ∈ f
-- Filter.exists_mem_subset_iff
theorem exists_mem_subset_iff : (∃ t ∈ f, t ⊆ s) ↔ s ∈ f 
Arguments: {α : Type u} {f : Filter α} {s : Set α}
Goal: (∃ t ∈ f, t ⊆ s) ↔ s ∈ f
-- Filter.monotone_mem
theorem monotone_mem {f : Filter α} : Monotone fun s => s ∈ f 
Arguments: {α : Type u} {f : Filter α}
Goal: Monotone fun s => s ∈ f
-- Filter.exists_mem_and_iff
theorem exists_mem_and_iff {P : Set α → Prop} {Q : Set α → Prop} (hP : Antitone P)
    (hQ : Antitone Q) : ((∃ u ∈ f, P u) ∧ ∃ u ∈ f, Q u) ↔ ∃ u ∈ f, P u ∧ Q u 
Arguments: {α : Type u} {f : Filter α} {P Q : Set α → Prop} (hP : Antitone P) (hQ : Antitone Q)
Goal: ((∃ u ∈ f, P u) ∧ ∃ u ∈ f, Q u) ↔ ∃ u ∈ f, P u ∧ Q u
-- Filter.forall_in_swap
theorem forall_in_swap {β : Type*} {p : Set α → β → Prop} :
    (∀ a ∈ f, ∀ (b), p a b) ↔ ∀ (b), ∀ a ∈ f, p a b 
Arguments: {α : Type u} {f : Filter α} {β : Type u_1} {p : Set α → β → Prop}
Goal: (∀ a ∈ f, ∀ (b : β), p a b) ↔ ∀ (b : β), ∀ a ∈ f, p a b
-- Filter.mem_principal
@[simp] theorem mem_principal {s t : Set α} : s ∈ 𝓟 t ↔ t ⊆ s 
Arguments: {α : Type u} {s t : Set α}
Goal: s ∈ 𝓟 t ↔ t ⊆ s
-- Filter.mem_principal_self
theorem mem_principal_self (s : Set α) : s ∈ 𝓟 s 
Arguments: {α : Type u} (s : Set α)
Goal: s ∈ 𝓟 s
-- Filter.mem_join
@[simp]
theorem mem_join {s : Set α} {f : Filter (Filter α)} : s ∈ join f ↔ { t | s ∈ t } ∈ f 
Arguments: {α : Type u} {s : Set α} {f : Filter (Filter α)}
Goal: s ∈ f.join ↔ {t | s ∈ t} ∈ f
-- Filter.le_def
theorem le_def : f ≤ g ↔ ∀ x ∈ g, x ∈ f 
Arguments: {α : Type u} {f g : Filter α}
Goal: f ≤ g ↔ ∀ x ∈ g, x ∈ f
-- Filter.not_le
protected theorem not_le : ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f 
Arguments: {α : Type u} {f g : Filter α}
Goal: ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f
-- Filter.mem_generate_of_mem
lemma mem_generate_of_mem {s : Set <| Set α} {U : Set α} (h : U ∈ s) :
    U ∈ generate s 
Arguments: {α : Type u} {s : Set (Set α)} {U : Set α} (h : U ∈ s)
Goal: U ∈ Filter.generate s
-- Filter.le_generate_iff
theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ generate s ↔ s ⊆ f.sets 
Arguments: {α : Type u} {s : Set (Set α)} {f : Filter α}
Goal: f ≤ Filter.generate s ↔ s ⊆ f.sets
-- Filter.mem_generate_iff
theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
    U ∈ generate s ↔ ∃ t ⊆ s, Set.Finite t ∧ ⋂₀ t ⊆ U 
Arguments: {α : Type u} {s : Set (Set α)} {U : Set α}
Goal: U ∈ Filter.generate s ↔ ∃ t ⊆ s, t.Finite ∧ ⋂₀ t ⊆ U
-- Filter.generate_singleton
@[simp] lemma generate_singleton (s : Set α) : generate {s} = 𝓟 s 
Arguments: {α : Type u} (s : Set α)
Goal: Filter.generate {s} = 𝓟 s
-- Filter.mkOfClosure_sets
theorem mkOfClosure_sets {s : Set (Set α)} {hs : (generate s).sets = s} :
    Filter.mkOfClosure s hs = generate s 
Arguments: {α : Type u} {s : Set (Set α)} {hs : (Filter.generate s).sets = s}
Goal: Filter.mkOfClosure s hs = Filter.generate s
-- Filter.mem_inf_iff
theorem mem_inf_iff {f g : Filter α} {s : Set α} : s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂ 
Arguments: {α : Type u} {f g : Filter α} {s : Set α}
Goal: s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂
-- Filter.mem_inf_of_left
theorem mem_inf_of_left {f g : Filter α} {s : Set α} (h : s ∈ f) : s ∈ f ⊓ g 
Arguments: {α : Type u} {f g : Filter α} {s : Set α} (h : s ∈ f)
Goal: s ∈ f ⊓ g
-- Filter.mem_inf_of_right
theorem mem_inf_of_right {f g : Filter α} {s : Set α} (h : s ∈ g) : s ∈ f ⊓ g 
Arguments: {α : Type u} {f g : Filter α} {s : Set α} (h : s ∈ g)
Goal: s ∈ f ⊓ g
-- Filter.inter_mem_inf
theorem inter_mem_inf {α : Type u} {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) :
    s ∩ t ∈ f ⊓ g 
Arguments: {α : Type u} {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g)
Goal: s ∩ t ∈ f ⊓ g
-- Filter.mem_inf_of_inter
theorem mem_inf_of_inter {f g : Filter α} {s t u : Set α} (hs : s ∈ f) (ht : t ∈ g)
    (h : s ∩ t ⊆ u) : u ∈ f ⊓ g 
Arguments: {α : Type u} {f g : Filter α} {s t u : Set α} (hs : s ∈ f) (ht : t ∈ g) (h : s ∩ t ⊆ u)
Goal: u ∈ f ⊓ g
-- Filter.mem_inf_iff_superset
theorem mem_inf_iff_superset {f g : Filter α} {s : Set α} :
    s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ∩ t₂ ⊆ s 
Arguments: {α : Type u} {f g : Filter α} {s : Set α}
Goal: s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ∩ t₂ ⊆ s
-- Filter.mem_top_iff_forall
theorem mem_top_iff_forall {s : Set α} : s ∈ (⊤ : Filter α) ↔ ∀ x, x ∈ s 
Arguments: {α : Type u} {s : Set α}
Goal: s ∈ ⊤ ↔ ∀ (x : α), x ∈ s
-- Filter.mem_top
@[simp]
theorem mem_top {s : Set α} : s ∈ (⊤ : Filter α) ↔ s = univ 
Arguments: {α : Type u} {s : Set α}
Goal: s ∈ ⊤ ↔ s = Set.univ
-- Filter.NeBot.ne'
class NeBot (f : Filter α) : Prop where
    ne' : f ≠ ⊥
Arguments: {α : Type u} {f : Filter α} [self : f.NeBot]
Goal: f ≠ ⊥
-- Filter.neBot_iff
theorem neBot_iff {f : Filter α} : NeBot f ↔ f ≠ ⊥ 
Arguments: {α : Type u} {f : Filter α}
Goal: f.NeBot ↔ f ≠ ⊥
-- Filter.NeBot.ne
theorem NeBot.ne {f : Filter α} (hf : NeBot f) : f ≠ ⊥ 
Arguments: {α : Type u} {f : Filter α} (hf : f.NeBot)
Goal: f ≠ ⊥
-- Filter.not_neBot
@[simp] theorem not_neBot {f : Filter α} : ¬f.NeBot ↔ f = ⊥ 
Arguments: {α : Type u} {f : Filter α}
Goal: ¬f.NeBot ↔ f = ⊥
-- Filter.NeBot.mono
theorem NeBot.mono {f g : Filter α} (hf : NeBot f) (hg : f ≤ g) : NeBot g 
Arguments: {α : Type u} {f g : Filter α} (hf : f.NeBot) (hg : f ≤ g)
Goal: g.NeBot
-- Filter.neBot_of_le
theorem neBot_of_le {f g : Filter α} [hf : NeBot f] (hg : f ≤ g) : NeBot g 
Arguments: {α : Type u} {f g : Filter α} [hf : f.NeBot] (hg : f ≤ g)
Goal: g.NeBot
-- Filter.sup_neBot
@[simp] theorem sup_neBot {f g : Filter α} : NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g 
Arguments: {α : Type u} {f g : Filter α}
Goal: (f ⊔ g).NeBot ↔ f.NeBot ∨ g.NeBot
-- Filter.not_disjoint_self_iff
theorem not_disjoint_self_iff : ¬Disjoint f f ↔ f.NeBot 
Arguments: {α : Type u} {f : Filter α}
Goal: ¬Disjoint f f ↔ f.NeBot
-- Filter.bot_sets_eq
theorem bot_sets_eq : (⊥ : Filter α).sets = univ 
Arguments: {α : Type u}
Goal: ⊥.sets = Set.univ
-- Filter.eq_or_neBot
theorem eq_or_neBot (f : Filter α) : f = ⊥ ∨ NeBot f 
Arguments: {α : Type u} (f : Filter α)
Goal: f = ⊥ ∨ f.NeBot
-- Filter.sup_sets_eq
theorem sup_sets_eq {f g : Filter α} : (f ⊔ g).sets = f.sets ∩ g.sets 
Arguments: {α : Type u} {f g : Filter α}
Goal: (f ⊔ g).sets = f.sets ∩ g.sets
-- Filter.sSup_sets_eq
theorem sSup_sets_eq {s : Set (Filter α)} : (sSup s).sets = ⋂ f ∈ s, (f : Filter α).sets 
Arguments: {α : Type u} {s : Set (Filter α)}
Goal: (sSup s).sets = ⋂ f ∈ s, f.sets
-- Filter.iSup_sets_eq
theorem iSup_sets_eq {f : ι → Filter α} : (iSup f).sets = ⋂ i, (f i).sets 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α}
Goal: (iSup f).sets = ⋂ i, (f i).sets
-- Filter.generate_empty
theorem generate_empty : Filter.generate ∅ = (⊤ : Filter α) 
Arguments: {α : Type u}
Goal: Filter.generate ∅ = ⊤
-- Filter.generate_univ
theorem generate_univ : Filter.generate univ = (⊥ : Filter α) 
Arguments: {α : Type u}
Goal: Filter.generate Set.univ = ⊥
-- Filter.generate_union
theorem generate_union {s t : Set (Set α)} :
    Filter.generate (s ∪ t) = Filter.generate s ⊓ Filter.generate t 
Arguments: {α : Type u} {s t : Set (Set α)}
Goal: Filter.generate (s ∪ t) = Filter.generate s ⊓ Filter.generate t
-- Filter.generate_iUnion
theorem generate_iUnion {s : ι → Set (Set α)} :
    Filter.generate (⋃ i, s i) = ⨅ i, Filter.generate (s i) 
Arguments: {α : Type u} {ι : Sort x} {s : ι → Set (Set α)}
Goal: Filter.generate (⋃ i, s i) = ⨅ i, Filter.generate (s i)
-- Filter.mem_bot
@[simp]
theorem mem_bot {s : Set α} : s ∈ (⊥ : Filter α) 
Arguments: {α : Type u} {s : Set α}
Goal: s ∈ ⊥
-- Filter.mem_sup
@[simp]
theorem mem_sup {f g : Filter α} {s : Set α} : s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g 
Arguments: {α : Type u} {f g : Filter α} {s : Set α}
Goal: s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g
-- Filter.union_mem_sup
theorem union_mem_sup {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) : s ∪ t ∈ f ⊔ g 
Arguments: {α : Type u} {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g)
Goal: s ∪ t ∈ f ⊔ g
-- Filter.mem_sSup
@[simp]
theorem mem_sSup {x : Set α} {s : Set (Filter α)} : x ∈ sSup s ↔ ∀ f ∈ s, x ∈ (f : Filter α) 
Arguments: {α : Type u} {x : Set α} {s : Set (Filter α)}
Goal: x ∈ sSup s ↔ ∀ f ∈ s, x ∈ f
-- Filter.mem_iSup
@[simp]
theorem mem_iSup {x : Set α} {f : ι → Filter α} : x ∈ iSup f ↔ ∀ i, x ∈ f i 
Arguments: {α : Type u} {ι : Sort x} {x : Set α} {f : ι → Filter α}
Goal: x ∈ iSup f ↔ ∀ (i : ι), x ∈ f i
-- Filter.iSup_neBot
@[simp]
theorem iSup_neBot {f : ι → Filter α} : (⨆ i, f i).NeBot ↔ ∃ i, (f i).NeBot 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α}
Goal: (⨆ i, f i).NeBot ↔ ∃ i, (f i).NeBot
-- Filter.iInf_eq_generate
theorem iInf_eq_generate (s : ι → Filter α) : iInf s = generate (⋃ i, (s i).sets) 
Arguments: {α : Type u} {ι : Sort x} (s : ι → Filter α)
Goal: iInf s = Filter.generate (⋃ i, (s i).sets)
-- Filter.mem_iInf_of_mem
theorem mem_iInf_of_mem {f : ι → Filter α} (i : ι) {s} (hs : s ∈ f i) : s ∈ ⨅ i, f i 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} (i : ι) {s : Set α} (hs : s ∈ f i)
Goal: s ∈ ⨅ i, f i
-- Filter.mem_iInf_of_iInter
theorem mem_iInf_of_iInter {ι} {s : ι → Filter α} {U : Set α} {I : Set ι} (I_fin : I.Finite)
    {V : I → Set α} (hV : ∀ i, V i ∈ s i) (hU : ⋂ i, V i ⊆ U) : U ∈ ⨅ i, s i 
Arguments: {α : Type u} {ι : Type u_2} {s : ι → Filter α} {U : Set α} {I : Set ι} (I_fin : I.Finite) {V : ↑I → Set α} (hV : ∀ (i : ↑I), V i ∈ s ↑i) (hU : ⋂ i, V i ⊆ U)
Goal: U ∈ ⨅ i, s i
-- Filter.mem_iInf
theorem mem_iInf {ι} {s : ι → Filter α} {U : Set α} :
    (U ∈ ⨅ i, s i) ↔ ∃ I : Set ι, I.Finite ∧ ∃ V : I → Set α, (∀ i, V i ∈ s i) ∧ U = ⋂ i, V i 
Arguments: {α : Type u} {ι : Type u_2} {s : ι → Filter α} {U : Set α}
Goal: U ∈ ⨅ i, s i ↔ ∃ I, I.Finite ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ i, V i
-- Filter.mem_iInf'
theorem mem_iInf' {ι} {s : ι → Filter α} {U : Set α} :
    (U ∈ ⨅ i, s i) ↔
      ∃ I : Set ι, I.Finite ∧ ∃ V : ι → Set α, (∀ i, V i ∈ s i) ∧
        (∀ i ∉ I, V i = univ) ∧ (U = ⋂ i ∈ I, V i) ∧ U = ⋂ i, V i 
Arguments: {α : Type u} {ι : Type u_2} {s : ι → Filter α} {U : Set α}
Goal: U ∈ ⨅ i, s i ↔ ∃ I, I.Finite ∧ ∃ V, (∀ (i : ι), V i ∈ s i) ∧ (∀ i ∉ I, V i = Set.univ) ∧ U = ⋂ i ∈ I, V i ∧ U = ⋂ i, V i
-- Filter.exists_iInter_of_mem_iInf
theorem exists_iInter_of_mem_iInf {ι : Type*} {α : Type*} {f : ι → Filter α} {s}
    (hs : s ∈ ⨅ i, f i) : ∃ t : ι → Set α, (∀ i, t i ∈ f i) ∧ s = ⋂ i, t i 
Arguments: {ι : Type u_2} {α : Type u_3} {f : ι → Filter α} {s : Set α} (hs : s ∈ ⨅ i, f i)
Goal: ∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ i, t i
-- Filter.mem_iInf_of_finite
theorem mem_iInf_of_finite {ι : Type*} [Finite ι] {α : Type*} {f : ι → Filter α} (s) :
    (s ∈ ⨅ i, f i) ↔ ∃ t : ι → Set α, (∀ i, t i ∈ f i) ∧ s = ⋂ i, t i 
Arguments: {ι : Type u_2} [Finite ι] {α : Type u_3} {f : ι → Filter α} (s : Set α)
Goal: s ∈ ⨅ i, f i ↔ ∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ i, t i
-- Filter.le_principal_iff
@[simp]
theorem le_principal_iff {s : Set α} {f : Filter α} : f ≤ 𝓟 s ↔ s ∈ f 
Arguments: {α : Type u} {s : Set α} {f : Filter α}
Goal: f ≤ 𝓟 s ↔ s ∈ f
-- Filter.Iic_principal
theorem Iic_principal (s : Set α) : Iic (𝓟 s) = { l | s ∈ l } 
Arguments: {α : Type u} (s : Set α)
Goal: Set.Iic (𝓟 s) = {l | s ∈ l}
-- Filter.principal_mono
theorem principal_mono {s t : Set α} : 𝓟 s ≤ 𝓟 t ↔ s ⊆ t 
Arguments: {α : Type u} {s t : Set α}
Goal: 𝓟 s ≤ 𝓟 t ↔ s ⊆ t
-- Filter.monotone_principal
@[mono]
theorem monotone_principal : Monotone (𝓟 : Set α → Filter α) 
Arguments: {α : Type u}
Goal: Monotone 𝓟
-- Filter.principal_eq_iff_eq
@[simp] theorem principal_eq_iff_eq {s t : Set α} : 𝓟 s = 𝓟 t ↔ s = t 
Arguments: {α : Type u} {s t : Set α}
Goal: 𝓟 s = 𝓟 t ↔ s = t
-- Filter.join_principal_eq_sSup
@[simp] theorem join_principal_eq_sSup {s : Set (Filter α)} : join (𝓟 s) = sSup s 
Arguments: {α : Type u} {s : Set (Filter α)}
Goal: (𝓟 s).join = sSup s
-- Filter.principal_univ
@[simp] theorem principal_univ : 𝓟 (univ : Set α) = ⊤ 
Arguments: {α : Type u}
Goal: 𝓟 Set.univ = ⊤
-- Filter.principal_empty
@[simp]
theorem principal_empty : 𝓟 (∅ : Set α) = ⊥ 
Arguments: {α : Type u}
Goal: 𝓟 ∅ = ⊥
-- Filter.generate_eq_biInf
theorem generate_eq_biInf (S : Set (Set α)) : generate S = ⨅ s ∈ S, 𝓟 s 
Arguments: {α : Type u} (S : Set (Set α))
Goal: Filter.generate S = ⨅ s ∈ S, 𝓟 s
-- Filter.empty_mem_iff_bot
theorem empty_mem_iff_bot {f : Filter α} : ∅ ∈ f ↔ f = ⊥ 
Arguments: {α : Type u} {f : Filter α}
Goal: ∅ ∈ f ↔ f = ⊥
-- Filter.nonempty_of_mem
theorem nonempty_of_mem {f : Filter α} [hf : NeBot f] {s : Set α} (hs : s ∈ f) : s.Nonempty 
Arguments: {α : Type u} {f : Filter α} [hf : f.NeBot] {s : Set α} (hs : s ∈ f)
Goal: s.Nonempty
-- Filter.NeBot.nonempty_of_mem
theorem NeBot.nonempty_of_mem {f : Filter α} (hf : NeBot f) {s : Set α} (hs : s ∈ f) : s.Nonempty 
Arguments: {α : Type u} {f : Filter α} (hf : f.NeBot) {s : Set α} (hs : s ∈ f)
Goal: s.Nonempty
-- Filter.empty_not_mem
@[simp]
theorem empty_not_mem (f : Filter α) [NeBot f] : ¬∅ ∈ f 
Arguments: {α : Type u} (f : Filter α) [f.NeBot]
Goal: ∅ ∉ f
-- Filter.nonempty_of_neBot
theorem nonempty_of_neBot (f : Filter α) [NeBot f] : Nonempty α 
Arguments: {α : Type u} (f : Filter α) [f.NeBot]
Goal: Nonempty α
-- Filter.compl_not_mem
theorem compl_not_mem {f : Filter α} {s : Set α} [NeBot f] (h : s ∈ f) : sᶜ ∉ f 
Arguments: {α : Type u} {f : Filter α} {s : Set α} [f.NeBot] (h : s ∈ f)
Goal: sᶜ ∉ f
-- Filter.filter_eq_bot_of_isEmpty
theorem filter_eq_bot_of_isEmpty [IsEmpty α] (f : Filter α) : f = ⊥ 
Arguments: {α : Type u} [IsEmpty α] (f : Filter α)
Goal: f = ⊥
-- Filter.disjoint_iff
protected lemma disjoint_iff {f g : Filter α} : Disjoint f g ↔ ∃ s ∈ f, ∃ t ∈ g, Disjoint s t 
Arguments: {α : Type u} {f g : Filter α}
Goal: Disjoint f g ↔ ∃ s ∈ f, ∃ t ∈ g, Disjoint s t
-- Filter.disjoint_of_disjoint_of_mem
theorem disjoint_of_disjoint_of_mem {f g : Filter α} {s t : Set α} (h : Disjoint s t) (hs : s ∈ f)
    (ht : t ∈ g) : Disjoint f g 
Arguments: {α : Type u} {f g : Filter α} {s t : Set α} (h : Disjoint s t) (hs : s ∈ f) (ht : t ∈ g)
Goal: Disjoint f g
-- Filter.NeBot.not_disjoint
theorem NeBot.not_disjoint (hf : f.NeBot) (hs : s ∈ f) (ht : t ∈ f) : ¬Disjoint s t 
Arguments: {α : Type u} {f : Filter α} {s t : Set α} (hf : f.NeBot) (hs : s ∈ f) (ht : t ∈ f)
Goal: ¬Disjoint s t
-- Filter.inf_eq_bot_iff
theorem inf_eq_bot_iff {f g : Filter α} : f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V ∈ g, U ∩ V = ∅ 
Arguments: {α : Type u} {f g : Filter α}
Goal: f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V ∈ g, U ∩ V = ∅
-- Pairwise.exists_mem_filter_of_disjoint
theorem _root_.Pairwise.exists_mem_filter_of_disjoint {ι : Type*} [Finite ι] {l : ι → Filter α}
    (hd : Pairwise (Disjoint on l)) :
    ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ Pairwise (Disjoint on s) 
Arguments: {α : Type u} {ι : Type u_2} [Finite ι] {l : ι → Filter α} (hd : Pairwise (Disjoint on l))
Goal: ∃ s, (∀ (i : ι), s i ∈ l i) ∧ Pairwise (Disjoint on s)
-- Set.PairwiseDisjoint.exists_mem_filter
theorem _root_.Set.PairwiseDisjoint.exists_mem_filter {ι : Type*} {l : ι → Filter α} {t : Set ι}
    (hd : t.PairwiseDisjoint l) (ht : t.Finite) :
    ∃ s : ι → Set α, (∀ i, s i ∈ l i) ∧ t.PairwiseDisjoint s 
Arguments: {α : Type u} {ι : Type u_2} {l : ι → Filter α} {t : Set ι} (hd : t.PairwiseDisjoint l) (ht : t.Finite)
Goal: ∃ s, (∀ (i : ι), s i ∈ l i) ∧ t.PairwiseDisjoint s
-- Filter.NeBot.nonempty
theorem NeBot.nonempty (f : Filter α) [hf : f.NeBot] : Nonempty α 
Arguments: {α : Type u} (f : Filter α) [hf : f.NeBot]
Goal: Nonempty α
-- Filter.eq_top_of_neBot
theorem eq_top_of_neBot [Subsingleton α] (l : Filter α) [NeBot l] : l = ⊤ 
Arguments: {α : Type u} [Subsingleton α] (l : Filter α) [l.NeBot]
Goal: l = ⊤
-- Filter.forall_mem_nonempty_iff_neBot
theorem forall_mem_nonempty_iff_neBot {f : Filter α} :
    (∀ s : Set α, s ∈ f → s.Nonempty) ↔ NeBot f 
Arguments: {α : Type u} {f : Filter α}
Goal: (∀ s ∈ f, s.Nonempty) ↔ f.NeBot
-- Filter.nontrivial_iff_nonempty
theorem nontrivial_iff_nonempty : Nontrivial (Filter α) ↔ Nonempty α 
Arguments: {α : Type u}
Goal: Nontrivial (Filter α) ↔ Nonempty α
-- Filter.eq_sInf_of_mem_iff_exists_mem
theorem eq_sInf_of_mem_iff_exists_mem {S : Set (Filter α)} {l : Filter α}
    (h : ∀ {s}, s ∈ l ↔ ∃ f ∈ S, s ∈ f) : l = sInf S 
Arguments: {α : Type u} {S : Set (Filter α)} {l : Filter α} (h : ∀ {s : Set α}, s ∈ l ↔ ∃ f ∈ S, s ∈ f)
Goal: l = sInf S
-- Filter.eq_iInf_of_mem_iff_exists_mem
theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
    (h : ∀ {s}, s ∈ l ↔ ∃ i, s ∈ f i) : l = iInf f 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} {l : Filter α} (h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, s ∈ f i)
Goal: l = iInf f
-- Filter.eq_biInf_of_mem_iff_exists_mem
theorem eq_biInf_of_mem_iff_exists_mem {f : ι → Filter α} {p : ι → Prop} {l : Filter α}
    (h : ∀ {s}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i) : l = ⨅ (i) (_ : p i), f i 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} {p : ι → Prop} {l : Filter α} (h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i)
Goal: l = ⨅ i, ⨅ (_ : p i), f i