ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.iInf_sets_eq
theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
    (iInf f).sets = ⋃ i, (f i).sets 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} (h : Directed (fun x x_1 => x ≥ x_1) f) [ne : Nonempty ι]
Goal: (iInf f).sets = ⋃ i, (f i).sets
-- Filter.mem_iInf_of_directed
theorem mem_iInf_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f) [Nonempty ι] (s) :
    s ∈ iInf f ↔ ∃ i, s ∈ f i 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} (h : Directed (fun x x_1 => x ≥ x_1) f) [Nonempty ι] (s : Set α)
Goal: s ∈ iInf f ↔ ∃ i, s ∈ f i
-- Filter.mem_biInf_of_directed
theorem mem_biInf_of_directed {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
    (ne : s.Nonempty) {t : Set α} : (t ∈ ⨅ i ∈ s, f i) ↔ ∃ i ∈ s, t ∈ f i 
Arguments: {α : Type u} {β : Type v} {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s) (ne : s.Nonempty) {t : Set α}
Goal: t ∈ ⨅ i ∈ s, f i ↔ ∃ i ∈ s, t ∈ f i
-- Filter.biInf_sets_eq
theorem biInf_sets_eq {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o (· ≥ ·)) s)
    (ne : s.Nonempty) : (⨅ i ∈ s, f i).sets = ⋃ i ∈ s, (f i).sets 
Arguments: {α : Type u} {β : Type v} {f : β → Filter α} {s : Set β} (h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) s) (ne : s.Nonempty)
Goal: (⨅ i ∈ s, f i).sets = ⋃ i ∈ s, (f i).sets
-- Filter.iInf_sets_eq_finite
theorem iInf_sets_eq_finite {ι : Type*} (f : ι → Filter α) :
    (⨅ i, f i).sets = ⋃ t : Finset ι, (⨅ i ∈ t, f i).sets 
Arguments: {α : Type u} {ι : Type u_2} (f : ι → Filter α)
Goal: (⨅ i, f i).sets = ⋃ t, (⨅ i ∈ t, f i).sets
-- Filter.iInf_sets_eq_finite'
theorem iInf_sets_eq_finite' (f : ι → Filter α) :
    (⨅ i, f i).sets = ⋃ t : Finset (PLift ι), (⨅ i ∈ t, f (PLift.down i)).sets 
Arguments: {α : Type u} {ι : Sort x} (f : ι → Filter α)
Goal: (⨅ i, f i).sets = ⋃ t, (⨅ i ∈ t, f i.down).sets
-- Filter.mem_iInf_finite
theorem mem_iInf_finite {ι : Type*} {f : ι → Filter α} (s) :
    s ∈ iInf f ↔ ∃ t : Finset ι, s ∈ ⨅ i ∈ t, f i 
Arguments: {α : Type u} {ι : Type u_2} {f : ι → Filter α} (s : Set α)
Goal: s ∈ iInf f ↔ ∃ t, s ∈ ⨅ i ∈ t, f i
-- Filter.mem_iInf_finite'
theorem mem_iInf_finite' {f : ι → Filter α} (s) :
    s ∈ iInf f ↔ ∃ t : Finset (PLift ι), s ∈ ⨅ i ∈ t, f (PLift.down i) 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} (s : Set α)
Goal: s ∈ iInf f ↔ ∃ t, s ∈ ⨅ i ∈ t, f i.down
-- Filter.sup_join
@[simp]
theorem sup_join {f₁ f₂ : Filter (Filter α)} : join f₁ ⊔ join f₂ = join (f₁ ⊔ f₂) 
Arguments: {α : Type u} {f₁ f₂ : Filter (Filter α)}
Goal: f₁.join ⊔ f₂.join = (f₁ ⊔ f₂).join
-- Filter.iSup_join
@[simp]
theorem iSup_join {ι : Sort w} {f : ι → Filter (Filter α)} : ⨆ x, join (f x) = join (⨆ x, f x) 
Arguments: {α : Type u} {ι : Sort w} {f : ι → Filter (Filter α)}
Goal: ⨆ x, (f x).join = (⨆ x, f x).join
-- Filter.mem_iInf_finset
theorem mem_iInf_finset {s : Finset α} {f : α → Filter β} {t : Set β} :
    (t ∈ ⨅ a ∈ s, f a) ↔ ∃ p : α → Set β, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a 
Arguments: {α : Type u} {β : Type v} {s : Finset α} {f : α → Filter β} {t : Set β}
Goal: t ∈ ⨅ a ∈ s, f a ↔ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a
-- Filter.iInf_neBot_of_directed'
theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
    (∀ i, NeBot (f i)) → NeBot (iInf f) 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} [Nonempty ι] (hd : Directed (fun x x_1 => x ≥ x_1) f)
Goal: (∀ (i : ι), (f i).NeBot) → (iInf f).NeBot
-- Filter.iInf_neBot_of_directed
theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : Directed (· ≥ ·) f)
    (hb : ∀ i, NeBot (f i)) : NeBot (iInf f) 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} [hn : Nonempty α] (hd : Directed (fun x x_1 => x ≥ x_1) f) (hb : ∀ (i : ι), (f i).NeBot)
Goal: (iInf f).NeBot
-- Filter.sInf_neBot_of_directed'
theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (· ≥ ·) s)
    (hbot : ⊥ ∉ s) : NeBot (sInf s) 
Arguments: {α : Type u} {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (fun x x_1 => x ≥ x_1) s) (hbot : ⊥ ∉ s)
Goal: (sInf s).NeBot
-- Filter.sInf_neBot_of_directed
theorem sInf_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (· ≥ ·) s)
    (hbot : ⊥ ∉ s) : NeBot (sInf s) 
Arguments: {α : Type u} [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (fun x x_1 => x ≥ x_1) s) (hbot : ⊥ ∉ s)
Goal: (sInf s).NeBot
-- Filter.iInf_neBot_iff_of_directed'
theorem iInf_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
    NeBot (iInf f) ↔ ∀ i, NeBot (f i) 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} [Nonempty ι] (hd : Directed (fun x x_1 => x ≥ x_1) f)
Goal: (iInf f).NeBot ↔ ∀ (i : ι), (f i).NeBot
-- Filter.iInf_neBot_iff_of_directed
theorem iInf_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Directed (· ≥ ·) f) :
    NeBot (iInf f) ↔ ∀ i, NeBot (f i) 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} [Nonempty α] (hd : Directed (fun x x_1 => x ≥ x_1) f)
Goal: (iInf f).NeBot ↔ ∀ (i : ι), (f i).NeBot
-- Filter.iInf_sets_induct
@[elab_as_elim]
theorem iInf_sets_induct {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f) {p : Set α → Prop}
    (uni : p univ) (ins : ∀ {i s₁ s₂}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)) : p s 
Arguments: {α : Type u} {ι : Sort x} {f : ι → Filter α} {s : Set α} (hs : s ∈ iInf f) {p : Set α → Prop} (uni : p Set.univ) (ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂))
Goal: p s
-- Filter.inf_principal
@[simp]
theorem inf_principal {s t : Set α} : 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t) 
Arguments: {α : Type u} {s t : Set α}
Goal: 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t)
-- Filter.sup_principal
@[simp]
theorem sup_principal {s t : Set α} : 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t) 
Arguments: {α : Type u} {s t : Set α}
Goal: 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t)
-- Filter.iSup_principal
@[simp]
theorem iSup_principal {ι : Sort w} {s : ι → Set α} : ⨆ x, 𝓟 (s x) = 𝓟 (⋃ i, s i) 
Arguments: {α : Type u} {ι : Sort w} {s : ι → Set α}
Goal: ⨆ x, 𝓟 (s x) = 𝓟 (⋃ i, s i)
-- Filter.principal_eq_bot_iff
@[simp]
theorem principal_eq_bot_iff {s : Set α} : 𝓟 s = ⊥ ↔ s = ∅ 
Arguments: {α : Type u} {s : Set α}
Goal: 𝓟 s = ⊥ ↔ s = ∅
-- Filter.principal_neBot_iff
@[simp]
theorem principal_neBot_iff {s : Set α} : NeBot (𝓟 s) ↔ s.Nonempty 
Arguments: {α : Type u} {s : Set α}
Goal: (𝓟 s).NeBot ↔ s.Nonempty
-- Filter.isCompl_principal
theorem isCompl_principal (s : Set α) : IsCompl (𝓟 s) (𝓟 sᶜ) 
Arguments: {α : Type u} (s : Set α)
Goal: IsCompl (𝓟 s) (𝓟 sᶜ)
-- Filter.mem_inf_principal'
theorem mem_inf_principal' {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f 
Arguments: {α : Type u} {f : Filter α} {s t : Set α}
Goal: s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f
-- Filter.mem_inf_principal
lemma mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ { x | x ∈ t → x ∈ s } ∈ f 
Arguments: {α : Type u} {f : Filter α} {s t : Set α}
Goal: s ∈ f ⊓ 𝓟 t ↔ {x | x ∈ t → x ∈ s} ∈ f
-- Filter.iSup_inf_principal
lemma iSup_inf_principal (f : ι → Filter α) (s : Set α) : ⨆ i, f i ⊓ 𝓟 s = (⨆ i, f i) ⊓ 𝓟 s 
Arguments: {α : Type u} {ι : Sort x} (f : ι → Filter α) (s : Set α)
Goal: ⨆ i, f i ⊓ 𝓟 s = (⨆ i, f i) ⊓ 𝓟 s
-- Filter.inf_principal_eq_bot
theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f 
Arguments: {α : Type u} {f : Filter α} {s : Set α}
Goal: f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f
-- Filter.mem_of_eq_bot
theorem mem_of_eq_bot {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 sᶜ = ⊥) : s ∈ f 
Arguments: {α : Type u} {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 sᶜ = ⊥)
Goal: s ∈ f
-- Filter.diff_mem_inf_principal_compl
theorem diff_mem_inf_principal_compl {f : Filter α} {s : Set α} (hs : s ∈ f) (t : Set α) :
    s \ t ∈ f ⊓ 𝓟 tᶜ 
Arguments: {α : Type u} {f : Filter α} {s : Set α} (hs : s ∈ f) (t : Set α)
Goal: s \ t ∈ f ⊓ 𝓟 tᶜ
-- Filter.principal_le_iff
theorem principal_le_iff {s : Set α} {f : Filter α} : 𝓟 s ≤ f ↔ ∀ V ∈ f, s ⊆ V 
Arguments: {α : Type u} {s : Set α} {f : Filter α}
Goal: 𝓟 s ≤ f ↔ ∀ V ∈ f, s ⊆ V
-- Filter.iInf_principal_finset
@[simp]
theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α) :
    ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i) 
Arguments: {α : Type u} {ι : Type w} (s : Finset ι) (f : ι → Set α)
Goal: ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i)
-- Filter.iInf_principal
theorem iInf_principal {ι : Sort w} [Finite ι] (f : ι → Set α) : ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i) 
Arguments: {α : Type u} {ι : Sort w} [Finite ι] (f : ι → Set α)
Goal: ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i)
-- Filter.iInf_principal'
@[simp]
theorem iInf_principal' {ι : Type w} [Finite ι] (f : ι → Set α) : ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i) 
Arguments: {α : Type u} {ι : Type w} [Finite ι] (f : ι → Set α)
Goal: ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i)
-- Filter.iInf_principal_finite
theorem iInf_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α) :
    ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i) 
Arguments: {α : Type u} {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α)
Goal: ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i)
-- Filter.join_mono
@[mono, gcongr]
theorem join_mono {f₁ f₂ : Filter (Filter α)} (h : f₁ ≤ f₂) : join f₁ ≤ join f₂ 
Arguments: {α : Type u} {f₁ f₂ : Filter (Filter α)} (h : f₁ ≤ f₂)
Goal: f₁.join ≤ f₂.join
-- Filter.eventually_iff
theorem eventually_iff {f : Filter α} {P : α → Prop} : (∀ᶠ x in f, P x) ↔ { x | P x } ∈ f 
Arguments: {α : Type u} {f : Filter α} {P : α → Prop}
Goal: (∀ᶠ (x : α) in f, P x) ↔ {x | P x} ∈ f
-- Filter.eventually_mem_set
@[simp]
theorem eventually_mem_set {s : Set α} {l : Filter α} : (∀ᶠ x in l, x ∈ s) ↔ s ∈ l 
Arguments: {α : Type u} {s : Set α} {l : Filter α}
Goal: (∀ᶠ (x : α) in l, x ∈ s) ↔ s ∈ l
-- Filter.ext'
protected theorem ext' {f₁ f₂ : Filter α}
    (h : ∀ p : α → Prop, (∀ᶠ x in f₁, p x) ↔ ∀ᶠ x in f₂, p x) : f₁ = f₂ 
Arguments: {α : Type u} {f₁ f₂ : Filter α} (h : ∀ (p : α → Prop), (∀ᶠ (x : α) in f₁, p x) ↔ ∀ᶠ (x : α) in f₂, p x)
Goal: f₁ = f₂
-- Filter.Eventually.filter_mono
theorem Eventually.filter_mono {f₁ f₂ : Filter α} (h : f₁ ≤ f₂) {p : α → Prop}
    (hp : ∀ᶠ x in f₂, p x) : ∀ᶠ x in f₁, p x 
Arguments: {α : Type u} {f₁ f₂ : Filter α} (h : f₁ ≤ f₂) {p : α → Prop} (hp : ∀ᶠ (x : α) in f₂, p x)
Goal: ∀ᶠ (x : α) in f₁, p x
-- Filter.eventually_of_mem
theorem eventually_of_mem {f : Filter α} {P : α → Prop} {U : Set α} (hU : U ∈ f)
    (h : ∀ x ∈ U, P x) : ∀ᶠ x in f, P x 
Arguments: {α : Type u} {f : Filter α} {P : α → Prop} {U : Set α} (hU : U ∈ f) (h : ∀ x ∈ U, P x)
Goal: ∀ᶠ (x : α) in f, P x
-- Filter.Eventually.and
protected theorem Eventually.and {p q : α → Prop} {f : Filter α} :
    f.Eventually p → f.Eventually q → ∀ᶠ x in f, p x ∧ q x 
Arguments: {α : Type u} {p q : α → Prop} {f : Filter α}
Goal: Filter.Eventually p f → Filter.Eventually q f → ∀ᶠ (x : α) in f, p x ∧ q x
-- Filter.eventually_true
@[simp] theorem eventually_true (f : Filter α) : ∀ᶠ _ in f, True 
Arguments: {α : Type u} (f : Filter α)
Goal: ∀ᶠ (x : α) in f, True
-- Filter.eventually_of_forall
theorem eventually_of_forall {p : α → Prop} {f : Filter α} (hp : ∀ x, p x) : ∀ᶠ x in f, p x 
Arguments: {α : Type u} {p : α → Prop} {f : Filter α} (hp : ∀ (x : α), p x)
Goal: ∀ᶠ (x : α) in f, p x
-- Filter.eventually_false_iff_eq_bot
@[simp]
theorem eventually_false_iff_eq_bot {f : Filter α} : (∀ᶠ _ in f, False) ↔ f = ⊥ 
Arguments: {α : Type u} {f : Filter α}
Goal: (∀ᶠ (x : α) in f, False) ↔ f = ⊥
-- Filter.eventually_const
@[simp]
theorem eventually_const {f : Filter α} [t : NeBot f] {p : Prop} : (∀ᶠ _ in f, p) ↔ p 
Arguments: {α : Type u} {f : Filter α} [t : f.NeBot] {p : Prop}
Goal: (∀ᶠ (x : α) in f, p) ↔ p
-- Filter.eventually_iff_exists_mem
theorem eventually_iff_exists_mem {p : α → Prop} {f : Filter α} :
    (∀ᶠ x in f, p x) ↔ ∃ v ∈ f, ∀ y ∈ v, p y 
Arguments: {α : Type u} {p : α → Prop} {f : Filter α}
Goal: (∀ᶠ (x : α) in f, p x) ↔ ∃ v ∈ f, ∀ y ∈ v, p y
-- Filter.Eventually.exists_mem
theorem Eventually.exists_mem {p : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f, p x) :
    ∃ v ∈ f, ∀ y ∈ v, p y 
Arguments: {α : Type u} {p : α → Prop} {f : Filter α} (hp : ∀ᶠ (x : α) in f, p x)
Goal: ∃ v ∈ f, ∀ y ∈ v, p y
-- Filter.Eventually.mp
theorem Eventually.mp {p q : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f, p x)
    (hq : ∀ᶠ x in f, p x → q x) : ∀ᶠ x in f, q x 
Arguments: {α : Type u} {p q : α → Prop} {f : Filter α} (hp : ∀ᶠ (x : α) in f, p x) (hq : ∀ᶠ (x : α) in f, p x → q x)
Goal: ∀ᶠ (x : α) in f, q x
-- Filter.Eventually.mono
theorem Eventually.mono {p q : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f, p x)
    (hq : ∀ x, p x → q x) : ∀ᶠ x in f, q x 
Arguments: {α : Type u} {p q : α → Prop} {f : Filter α} (hp : ∀ᶠ (x : α) in f, p x) (hq : ∀ (x : α), p x → q x)
Goal: ∀ᶠ (x : α) in f, q x
-- Filter.forall_eventually_of_eventually_forall
theorem forall_eventually_of_eventually_forall {f : Filter α} {p : α → β → Prop}
    (h : ∀ᶠ x in f, ∀ y, p x y) : ∀ y, ∀ᶠ x in f, p x y 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {p : α → β → Prop} (h : ∀ᶠ (x : α) in f, ∀ (y : β), p x y) (y : β)
Goal: ∀ᶠ (x : α) in f, p x y
-- Filter.eventually_and
@[simp]
theorem eventually_and {p q : α → Prop} {f : Filter α} :
    (∀ᶠ x in f, p x ∧ q x) ↔ (∀ᶠ x in f, p x) ∧ ∀ᶠ x in f, q x 
Arguments: {α : Type u} {p q : α → Prop} {f : Filter α}
Goal: (∀ᶠ (x : α) in f, p x ∧ q x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x
-- Filter.Eventually.congr
theorem Eventually.congr {f : Filter α} {p q : α → Prop} (h' : ∀ᶠ x in f, p x)
    (h : ∀ᶠ x in f, p x ↔ q x) : ∀ᶠ x in f, q x 
Arguments: {α : Type u} {f : Filter α} {p q : α → Prop} (h' : ∀ᶠ (x : α) in f, p x) (h : ∀ᶠ (x : α) in f, p x ↔ q x)
Goal: ∀ᶠ (x : α) in f, q x
-- Filter.eventually_congr
theorem eventually_congr {f : Filter α} {p q : α → Prop} (h : ∀ᶠ x in f, p x ↔ q x) :
    (∀ᶠ x in f, p x) ↔ ∀ᶠ x in f, q x 
Arguments: {α : Type u} {f : Filter α} {p q : α → Prop} (h : ∀ᶠ (x : α) in f, p x ↔ q x)
Goal: (∀ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, q x
-- Filter.eventually_all
@[simp]
theorem eventually_all {ι : Sort*} [Finite ι] {l} {p : ι → α → Prop} :
    (∀ᶠ x in l, ∀ i, p i x) ↔ ∀ i, ∀ᶠ x in l, p i x 
Arguments: {α : Type u} {ι : Sort u_2} [Finite ι] {l : Filter α} {p : ι → α → Prop}
Goal: (∀ᶠ (x : α) in l, ∀ (i : ι), p i x) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p i x
-- Filter.eventually_all_finite
@[simp]
theorem eventually_all_finite {ι} {I : Set ι} (hI : I.Finite) {l} {p : ι → α → Prop} :
    (∀ᶠ x in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ x in l, p i x 
Arguments: {α : Type u} {ι : Type u_2} {I : Set ι} (hI : I.Finite) {l : Filter α} {p : ι → α → Prop}
Goal: (∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x
-- Filter.eventually_all_finset
@[simp] theorem eventually_all_finset {ι} (I : Finset ι) {l} {p : ι → α → Prop} :
    (∀ᶠ x in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ x in l, p i x 
Arguments: {α : Type u} {ι : Type u_2} (I : Finset ι) {l : Filter α} {p : ι → α → Prop}
Goal: (∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x
-- Filter.eventually_or_distrib_left
@[simp]
theorem eventually_or_distrib_left {f : Filter α} {p : Prop} {q : α → Prop} :
    (∀ᶠ x in f, p ∨ q x) ↔ p ∨ ∀ᶠ x in f, q x 
Arguments: {α : Type u} {f : Filter α} {p : Prop} {q : α → Prop}
Goal: (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x
-- Filter.eventually_or_distrib_right
@[simp]
theorem eventually_or_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :
    (∀ᶠ x in f, p x ∨ q) ↔ (∀ᶠ x in f, p x) ∨ q 
Arguments: {α : Type u} {f : Filter α} {p : α → Prop} {q : Prop}
Goal: (∀ᶠ (x : α) in f, p x ∨ q) ↔ (∀ᶠ (x : α) in f, p x) ∨ q
-- Filter.eventually_imp_distrib_left
theorem eventually_imp_distrib_left {f : Filter α} {p : Prop} {q : α → Prop} :
    (∀ᶠ x in f, p → q x) ↔ p → ∀ᶠ x in f, q x 
Arguments: {α : Type u} {f : Filter α} {p : Prop} {q : α → Prop}
Goal: (∀ᶠ (x : α) in f, p → q x) ↔ p → ∀ᶠ (x : α) in f, q x
-- Filter.eventually_bot
@[simp]
theorem eventually_bot {p : α → Prop} : ∀ᶠ x in ⊥, p x 
Arguments: {α : Type u} {p : α → Prop}
Goal: ∀ᶠ (x : α) in ⊥, p x
-- Filter.eventually_top
@[simp]
theorem eventually_top {p : α → Prop} : (∀ᶠ x in ⊤, p x) ↔ ∀ x, p x 
Arguments: {α : Type u} {p : α → Prop}
Goal: (∀ᶠ (x : α) in ⊤, p x) ↔ ∀ (x : α), p x
-- Filter.eventually_sup
@[simp]
theorem eventually_sup {p : α → Prop} {f g : Filter α} :
    (∀ᶠ x in f ⊔ g, p x) ↔ (∀ᶠ x in f, p x) ∧ ∀ᶠ x in g, p x 
Arguments: {α : Type u} {p : α → Prop} {f g : Filter α}
Goal: (∀ᶠ (x : α) in f ⊔ g, p x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in g, p x
-- Filter.eventually_sSup
@[simp]
theorem eventually_sSup {p : α → Prop} {fs : Set (Filter α)} :
    (∀ᶠ x in sSup fs, p x) ↔ ∀ f ∈ fs, ∀ᶠ x in f, p x 
Arguments: {α : Type u} {p : α → Prop} {fs : Set (Filter α)}
Goal: (∀ᶠ (x : α) in sSup fs, p x) ↔ ∀ f ∈ fs, ∀ᶠ (x : α) in f, p x
-- Filter.eventually_iSup
@[simp]
theorem eventually_iSup {p : α → Prop} {fs : ι → Filter α} :
    (∀ᶠ x in ⨆ b, fs b, p x) ↔ ∀ b, ∀ᶠ x in fs b, p x 
Arguments: {α : Type u} {ι : Sort x} {p : α → Prop} {fs : ι → Filter α}
Goal: (∀ᶠ (x : α) in ⨆ b, fs b, p x) ↔ ∀ (b : ι), ∀ᶠ (x : α) in fs b, p x
-- Filter.eventually_principal
@[simp]
theorem eventually_principal {a : Set α} {p : α → Prop} : (∀ᶠ x in 𝓟 a, p x) ↔ ∀ x ∈ a, p x 
Arguments: {α : Type u} {a : Set α} {p : α → Prop}
Goal: (∀ᶠ (x : α) in 𝓟 a, p x) ↔ ∀ x ∈ a, p x
-- Filter.Eventually.forall_mem
theorem Eventually.forall_mem {α : Type*} {f : Filter α} {s : Set α} {P : α → Prop}
    (hP : ∀ᶠ x in f, P x) (hf : 𝓟 s ≤ f) : ∀ x ∈ s, P x 
Arguments: {α : Type u_2} {f : Filter α} {s : Set α} {P : α → Prop} (hP : ∀ᶠ (x : α) in f, P x) (hf : 𝓟 s ≤ f) (x : α)
Goal: x ∈ s → P x
-- Filter.eventually_inf
theorem eventually_inf {f g : Filter α} {p : α → Prop} :
    (∀ᶠ x in f ⊓ g, p x) ↔ ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x 
Arguments: {α : Type u} {f g : Filter α} {p : α → Prop}
Goal: (∀ᶠ (x : α) in f ⊓ g, p x) ↔ ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x
-- Filter.eventually_inf_principal
theorem eventually_inf_principal {f : Filter α} {p : α → Prop} {s : Set α} :
    (∀ᶠ x in f ⊓ 𝓟 s, p x) ↔ ∀ᶠ x in f, x ∈ s → p x 
Arguments: {α : Type u} {f : Filter α} {p : α → Prop} {s : Set α}
Goal: (∀ᶠ (x : α) in f ⊓ 𝓟 s, p x) ↔ ∀ᶠ (x : α) in f, x ∈ s → p x
-- Filter.Eventually.frequently
theorem Eventually.frequently {f : Filter α} [NeBot f] {p : α → Prop} (h : ∀ᶠ x in f, p x) :
    ∃ᶠ x in f, p x 
Arguments: {α : Type u} {f : Filter α} [f.NeBot] {p : α → Prop} (h : ∀ᶠ (x : α) in f, p x)
Goal: ∃ᶠ (x : α) in f, p x
-- Filter.frequently_of_forall
theorem frequently_of_forall {f : Filter α} [NeBot f] {p : α → Prop} (h : ∀ x, p x) :
    ∃ᶠ x in f, p x 
Arguments: {α : Type u} {f : Filter α} [f.NeBot] {p : α → Prop} (h : ∀ (x : α), p x)
Goal: ∃ᶠ (x : α) in f, p x
-- Filter.Frequently.mp
theorem Frequently.mp {p q : α → Prop} {f : Filter α} (h : ∃ᶠ x in f, p x)
    (hpq : ∀ᶠ x in f, p x → q x) : ∃ᶠ x in f, q x 
Arguments: {α : Type u} {p q : α → Prop} {f : Filter α} (h : ∃ᶠ (x : α) in f, p x) (hpq : ∀ᶠ (x : α) in f, p x → q x)
Goal: ∃ᶠ (x : α) in f, q x
-- Filter.Frequently.filter_mono
theorem Frequently.filter_mono {p : α → Prop} {f g : Filter α} (h : ∃ᶠ x in f, p x) (hle : f ≤ g) :
    ∃ᶠ x in g, p x 
Arguments: {α : Type u} {p : α → Prop} {f g : Filter α} (h : ∃ᶠ (x : α) in f, p x) (hle : f ≤ g)
Goal: ∃ᶠ (x : α) in g, p x
-- Filter.Frequently.mono
theorem Frequently.mono {p q : α → Prop} {f : Filter α} (h : ∃ᶠ x in f, p x)
    (hpq : ∀ x, p x → q x) : ∃ᶠ x in f, q x 
Arguments: {α : Type u} {p q : α → Prop} {f : Filter α} (h : ∃ᶠ (x : α) in f, p x) (hpq : ∀ (x : α), p x → q x)
Goal: ∃ᶠ (x : α) in f, q x
-- Filter.Frequently.and_eventually
theorem Frequently.and_eventually {p q : α → Prop} {f : Filter α} (hp : ∃ᶠ x in f, p x)
    (hq : ∀ᶠ x in f, q x) : ∃ᶠ x in f, p x ∧ q x 
Arguments: {α : Type u} {p q : α → Prop} {f : Filter α} (hp : ∃ᶠ (x : α) in f, p x) (hq : ∀ᶠ (x : α) in f, q x)
Goal: ∃ᶠ (x : α) in f, p x ∧ q x
-- Filter.Eventually.and_frequently
theorem Eventually.and_frequently {p q : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f, p x)
    (hq : ∃ᶠ x in f, q x) : ∃ᶠ x in f, p x ∧ q x 
Arguments: {α : Type u} {p q : α → Prop} {f : Filter α} (hp : ∀ᶠ (x : α) in f, p x) (hq : ∃ᶠ (x : α) in f, q x)
Goal: ∃ᶠ (x : α) in f, p x ∧ q x
-- Filter.Frequently.exists
theorem Frequently.exists {p : α → Prop} {f : Filter α} (hp : ∃ᶠ x in f, p x) : ∃ x, p x 
Arguments: {α : Type u} {p : α → Prop} {f : Filter α} (hp : ∃ᶠ (x : α) in f, p x)
Goal: ∃ x, p x
-- Filter.Eventually.exists
theorem Eventually.exists {p : α → Prop} {f : Filter α} [NeBot f] (hp : ∀ᶠ x in f, p x) :
    ∃ x, p x 
Arguments: {α : Type u} {p : α → Prop} {f : Filter α} [f.NeBot] (hp : ∀ᶠ (x : α) in f, p x)
Goal: ∃ x, p x
-- Filter.frequently_iff_neBot
lemma frequently_iff_neBot {l : Filter α} {p : α → Prop} :
    (∃ᶠ x in l, p x) ↔ NeBot (l ⊓ 𝓟 {x | p x}) 
Arguments: {α : Type u} {l : Filter α} {p : α → Prop}
Goal: (∃ᶠ (x : α) in l, p x) ↔ (l ⊓ 𝓟 {x | p x}).NeBot
-- Filter.frequently_mem_iff_neBot
lemma frequently_mem_iff_neBot {l : Filter α} {s : Set α} : (∃ᶠ x in l, x ∈ s) ↔ NeBot (l ⊓ 𝓟 s) 
Arguments: {α : Type u} {l : Filter α} {s : Set α}
Goal: (∃ᶠ (x : α) in l, x ∈ s) ↔ (l ⊓ 𝓟 s).NeBot
-- Filter.frequently_iff_forall_eventually_exists_and
theorem frequently_iff_forall_eventually_exists_and {p : α → Prop} {f : Filter α} :
    (∃ᶠ x in f, p x) ↔ ∀ {q : α → Prop}, (∀ᶠ x in f, q x) → ∃ x, p x ∧ q x 
Arguments: {α : Type u} {p : α → Prop} {f : Filter α}
Goal: (∃ᶠ (x : α) in f, p x) ↔ ∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, p x ∧ q x
-- Filter.frequently_iff
theorem frequently_iff {f : Filter α} {P : α → Prop} :
    (∃ᶠ x in f, P x) ↔ ∀ {U}, U ∈ f → ∃ x ∈ U, P x 
Arguments: {α : Type u} {f : Filter α} {P : α → Prop}
Goal: (∃ᶠ (x : α) in f, P x) ↔ ∀ {U : Set α}, U ∈ f → ∃ x ∈ U, P x
-- Filter.not_eventually
@[simp]
theorem not_eventually {p : α → Prop} {f : Filter α} : (¬∀ᶠ x in f, p x) ↔ ∃ᶠ x in f, ¬p x 
Arguments: {α : Type u} {p : α → Prop} {f : Filter α}
Goal: (¬∀ᶠ (x : α) in f, p x) ↔ ∃ᶠ (x : α) in f, ¬p x
-- Filter.not_frequently
@[simp]
theorem not_frequently {p : α → Prop} {f : Filter α} : (¬∃ᶠ x in f, p x) ↔ ∀ᶠ x in f, ¬p x 
Arguments: {α : Type u} {p : α → Prop} {f : Filter α}
Goal: (¬∃ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, ¬p x
-- Filter.frequently_true_iff_neBot
@[simp]
theorem frequently_true_iff_neBot (f : Filter α) : (∃ᶠ _ in f, True) ↔ NeBot f 
Arguments: {α : Type u} (f : Filter α)
Goal: (∃ᶠ (x : α) in f, True) ↔ f.NeBot
-- Filter.frequently_false
@[simp]
theorem frequently_false (f : Filter α) : ¬∃ᶠ _ in f, False 
Arguments: {α : Type u} (f : Filter α)
Goal: ¬∃ᶠ (x : α) in f, False
-- Filter.frequently_const
@[simp]
theorem frequently_const {f : Filter α} [NeBot f] {p : Prop} : (∃ᶠ _ in f, p) ↔ p 
Arguments: {α : Type u} {f : Filter α} [f.NeBot] {p : Prop}
Goal: (∃ᶠ (x : α) in f, p) ↔ p
-- Filter.frequently_or_distrib
@[simp]
theorem frequently_or_distrib {f : Filter α} {p q : α → Prop} :
    (∃ᶠ x in f, p x ∨ q x) ↔ (∃ᶠ x in f, p x) ∨ ∃ᶠ x in f, q x 
Arguments: {α : Type u} {f : Filter α} {p q : α → Prop}
Goal: (∃ᶠ (x : α) in f, p x ∨ q x) ↔ (∃ᶠ (x : α) in f, p x) ∨ ∃ᶠ (x : α) in f, q x
-- Filter.frequently_or_distrib_left
theorem frequently_or_distrib_left {f : Filter α} [NeBot f] {p : Prop} {q : α → Prop} :
    (∃ᶠ x in f, p ∨ q x) ↔ p ∨ ∃ᶠ x in f, q x 
Arguments: {α : Type u} {f : Filter α} [f.NeBot] {p : Prop} {q : α → Prop}
Goal: (∃ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∃ᶠ (x : α) in f, q x
-- Filter.frequently_or_distrib_right
theorem frequently_or_distrib_right {f : Filter α} [NeBot f] {p : α → Prop} {q : Prop} :
    (∃ᶠ x in f, p x ∨ q) ↔ (∃ᶠ x in f, p x) ∨ q 
Arguments: {α : Type u} {f : Filter α} [f.NeBot] {p : α → Prop} {q : Prop}
Goal: (∃ᶠ (x : α) in f, p x ∨ q) ↔ (∃ᶠ (x : α) in f, p x) ∨ q
-- Filter.frequently_imp_distrib
theorem frequently_imp_distrib {f : Filter α} {p q : α → Prop} :
    (∃ᶠ x in f, p x → q x) ↔ (∀ᶠ x in f, p x) → ∃ᶠ x in f, q x 
Arguments: {α : Type u} {f : Filter α} {p q : α → Prop}
Goal: (∃ᶠ (x : α) in f, p x → q x) ↔ (∀ᶠ (x : α) in f, p x) → ∃ᶠ (x : α) in f, q x
-- Filter.frequently_imp_distrib_left
theorem frequently_imp_distrib_left {f : Filter α} [NeBot f] {p : Prop} {q : α → Prop} :
    (∃ᶠ x in f, p → q x) ↔ p → ∃ᶠ x in f, q x 
Arguments: {α : Type u} {f : Filter α} [f.NeBot] {p : Prop} {q : α → Prop}
Goal: (∃ᶠ (x : α) in f, p → q x) ↔ p → ∃ᶠ (x : α) in f, q x