ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.subtype_coe_map_comap
theorem subtype_coe_map_comap (s : Set α) (f : Filter α) :
    map ((↑) : s → α) (comap ((↑) : s → α) f) = f ⊓ 𝓟 s 
Arguments: {α : Type u} (s : Set α) (f : Filter α)
Goal: Filter.map Subtype.val (Filter.comap Subtype.val f) = f ⊓ 𝓟 s
-- Filter.image_mem_of_mem_comap
theorem image_mem_of_mem_comap {f : Filter α} {c : β → α} (h : range c ∈ f) {W : Set β}
    (W_in : W ∈ comap c f) : c '' W ∈ f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {c : β → α} (h : Set.range c ∈ f) {W : Set β} (W_in : W ∈ Filter.comap c f)
Goal: c '' W ∈ f
-- Filter.image_coe_mem_of_mem_comap
theorem image_coe_mem_of_mem_comap {f : Filter α} {U : Set α} (h : U ∈ f) {W : Set U}
    (W_in : W ∈ comap ((↑) : U → α) f) : (↑) '' W ∈ f 
Arguments: {α : Type u} {f : Filter α} {U : Set α} (h : U ∈ f) {W : Set ↑U} (W_in : W ∈ Filter.comap Subtype.val f)
Goal: Subtype.val '' W ∈ f
-- Filter.comap_map
theorem comap_map {f : Filter α} {m : α → β} (h : Injective m) : comap m (map m f) = f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} (h : Function.Injective m)
Goal: Filter.comap m (Filter.map m f) = f
-- Filter.mem_comap_iff
theorem mem_comap_iff {f : Filter β} {m : α → β} (inj : Injective m) (large : Set.range m ∈ f)
    {S : Set α} : S ∈ comap m f ↔ m '' S ∈ f 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β} (inj : Function.Injective m) (large : Set.range m ∈ f) {S : Set α}
Goal: S ∈ Filter.comap m f ↔ m '' S ∈ f
-- Filter.map_le_map_iff_of_injOn
theorem map_le_map_iff_of_injOn {l₁ l₂ : Filter α} {f : α → β} {s : Set α} (h₁ : s ∈ l₁)
    (h₂ : s ∈ l₂) (hinj : InjOn f s) : map f l₁ ≤ map f l₂ ↔ l₁ ≤ l₂ 
Arguments: {α : Type u} {β : Type v} {l₁ l₂ : Filter α} {f : α → β} {s : Set α} (h₁ : s ∈ l₁) (h₂ : s ∈ l₂) (hinj : Set.InjOn f s)
Goal: Filter.map f l₁ ≤ Filter.map f l₂ ↔ l₁ ≤ l₂
-- Filter.map_le_map_iff
theorem map_le_map_iff {f g : Filter α} {m : α → β} (hm : Injective m) :
    map m f ≤ map m g ↔ f ≤ g 
Arguments: {α : Type u} {β : Type v} {f g : Filter α} {m : α → β} (hm : Function.Injective m)
Goal: Filter.map m f ≤ Filter.map m g ↔ f ≤ g
-- Filter.map_eq_map_iff_of_injOn
theorem map_eq_map_iff_of_injOn {f g : Filter α} {m : α → β} {s : Set α} (hsf : s ∈ f) (hsg : s ∈ g)
    (hm : InjOn m s) : map m f = map m g ↔ f = g 
Arguments: {α : Type u} {β : Type v} {f g : Filter α} {m : α → β} {s : Set α} (hsf : s ∈ f) (hsg : s ∈ g) (hm : Set.InjOn m s)
Goal: Filter.map m f = Filter.map m g ↔ f = g
-- Filter.map_inj
theorem map_inj {f g : Filter α} {m : α → β} (hm : Injective m) : map m f = map m g ↔ f = g 
Arguments: {α : Type u} {β : Type v} {f g : Filter α} {m : α → β} (hm : Function.Injective m)
Goal: Filter.map m f = Filter.map m g ↔ f = g
-- Filter.map_injective
theorem map_injective {m : α → β} (hm : Injective m) : Injective (map m) 
Arguments: {α : Type u} {β : Type v} {m : α → β} (hm : Function.Injective m)
Goal: Function.Injective (Filter.map m)
-- Filter.comap_neBot_iff
theorem comap_neBot_iff {f : Filter β} {m : α → β} : NeBot (comap m f) ↔ ∀ t ∈ f, ∃ a, m a ∈ t 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β}
Goal: (Filter.comap m f).NeBot ↔ ∀ t ∈ f, ∃ a, m a ∈ t
-- Filter.comap_neBot
theorem comap_neBot {f : Filter β} {m : α → β} (hm : ∀ t ∈ f, ∃ a, m a ∈ t) : NeBot (comap m f) 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β} (hm : ∀ t ∈ f, ∃ a, m a ∈ t)
Goal: (Filter.comap m f).NeBot
-- Filter.comap_neBot_iff_frequently
theorem comap_neBot_iff_frequently {f : Filter β} {m : α → β} :
    NeBot (comap m f) ↔ ∃ᶠ y in f, y ∈ range m 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β}
Goal: (Filter.comap m f).NeBot ↔ ∃ᶠ (y : β) in f, y ∈ Set.range m
-- Filter.comap_neBot_iff_compl_range
theorem comap_neBot_iff_compl_range {f : Filter β} {m : α → β} :
    NeBot (comap m f) ↔ (range m)ᶜ ∉ f 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β}
Goal: (Filter.comap m f).NeBot ↔ (Set.range m)ᶜ ∉ f
-- Filter.comap_eq_bot_iff_compl_range
theorem comap_eq_bot_iff_compl_range {f : Filter β} {m : α → β} : comap m f = ⊥ ↔ (range m)ᶜ ∈ f 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β}
Goal: Filter.comap m f = ⊥ ↔ (Set.range m)ᶜ ∈ f
-- Filter.comap_surjective_eq_bot
theorem comap_surjective_eq_bot {f : Filter β} {m : α → β} (hm : Surjective m) :
    comap m f = ⊥ ↔ f = ⊥ 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β} (hm : Function.Surjective m)
Goal: Filter.comap m f = ⊥ ↔ f = ⊥
-- Filter.disjoint_comap_iff
theorem disjoint_comap_iff (h : Surjective m) :
    Disjoint (comap m g₁) (comap m g₂) ↔ Disjoint g₁ g₂ 
Arguments: {α : Type u} {β : Type v} {g₁ g₂ : Filter β} {m : α → β} (h : Function.Surjective m)
Goal: Disjoint (Filter.comap m g₁) (Filter.comap m g₂) ↔ Disjoint g₁ g₂
-- Filter.NeBot.comap_of_range_mem
theorem NeBot.comap_of_range_mem {f : Filter β} {m : α → β} (_ : NeBot f) (hm : range m ∈ f) :
    NeBot (comap m f) 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β}
Goal: f.NeBot → Set.range m ∈ f → (Filter.comap m f).NeBot
-- Filter.comap_fst_neBot_iff
@[simp]
theorem comap_fst_neBot_iff {f : Filter α} :
    (f.comap (Prod.fst : α × β → α)).NeBot ↔ f.NeBot ∧ Nonempty β 
Arguments: {α : Type u} {β : Type v} {f : Filter α}
Goal: (Filter.comap Prod.fst f).NeBot ↔ f.NeBot ∧ Nonempty β
-- Filter.comap_fst_neBot
@[instance]
theorem comap_fst_neBot [Nonempty β] {f : Filter α} [NeBot f] :
    (f.comap (Prod.fst : α × β → α)).NeBot 
Arguments: {α : Type u} {β : Type v} [Nonempty β] {f : Filter α} [f.NeBot]
Goal: (Filter.comap Prod.fst f).NeBot
-- Filter.comap_snd_neBot_iff
@[simp]
theorem comap_snd_neBot_iff {f : Filter β} :
    (f.comap (Prod.snd : α × β → β)).NeBot ↔ Nonempty α ∧ f.NeBot 
Arguments: {α : Type u} {β : Type v} {f : Filter β}
Goal: (Filter.comap Prod.snd f).NeBot ↔ Nonempty α ∧ f.NeBot
-- Filter.comap_snd_neBot
@[instance]
theorem comap_snd_neBot [Nonempty α] {f : Filter β} [NeBot f] :
    (f.comap (Prod.snd : α × β → β)).NeBot 
Arguments: {α : Type u} {β : Type v} [Nonempty α] {f : Filter β} [f.NeBot]
Goal: (Filter.comap Prod.snd f).NeBot
-- Filter.comap_eval_neBot_iff'
theorem comap_eval_neBot_iff' {ι : Type*} {α : ι → Type*} {i : ι} {f : Filter (α i)} :
    (comap (eval i) f).NeBot ↔ (∀ j, Nonempty (α j)) ∧ NeBot f 
Arguments: {ι : Type u_2} {α : ι → Type u_3} {i : ι} {f : Filter (α i)}
Goal: (Filter.comap (Function.eval i) f).NeBot ↔ (∀ (j : ι), Nonempty (α j)) ∧ f.NeBot
-- Filter.comap_eval_neBot_iff
@[simp]
theorem comap_eval_neBot_iff {ι : Type*} {α : ι → Type*} [∀ j, Nonempty (α j)] {i : ι}
    {f : Filter (α i)} : (comap (eval i) f).NeBot ↔ NeBot f 
Arguments: {ι : Type u_2} {α : ι → Type u_3} [∀ (j : ι), Nonempty (α j)] {i : ι} {f : Filter (α i)}
Goal: (Filter.comap (Function.eval i) f).NeBot ↔ f.NeBot
-- Filter.comap_eval_neBot
@[instance]
theorem comap_eval_neBot {ι : Type*} {α : ι → Type*} [∀ j, Nonempty (α j)] (i : ι)
    (f : Filter (α i)) [NeBot f] : (comap (eval i) f).NeBot 
Arguments: {ι : Type u_2} {α : ι → Type u_3} [∀ (j : ι), Nonempty (α j)] (i : ι) (f : Filter (α i)) [f.NeBot]
Goal: (Filter.comap (Function.eval i) f).NeBot
-- Filter.comap_inf_principal_neBot_of_image_mem
theorem comap_inf_principal_neBot_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f) {s : Set α}
    (hs : m '' s ∈ f) : NeBot (comap m f ⊓ 𝓟 s) 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β} (hf : f.NeBot) {s : Set α} (hs : m '' s ∈ f)
Goal: (Filter.comap m f ⊓ 𝓟 s).NeBot
-- Filter.comap_coe_neBot_of_le_principal
theorem comap_coe_neBot_of_le_principal {s : Set γ} {l : Filter γ} [h : NeBot l] (h' : l ≤ 𝓟 s) :
    NeBot (comap ((↑) : s → γ) l) 
Arguments: {γ : Type w} {s : Set γ} {l : Filter γ} [h : l.NeBot] (h' : l ≤ 𝓟 s)
Goal: (Filter.comap Subtype.val l).NeBot
-- Filter.NeBot.comap_of_surj
theorem NeBot.comap_of_surj {f : Filter β} {m : α → β} (hf : NeBot f) (hm : Surjective m) :
    NeBot (comap m f) 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β} (hf : f.NeBot) (hm : Function.Surjective m)
Goal: (Filter.comap m f).NeBot
-- Filter.NeBot.comap_of_image_mem
theorem NeBot.comap_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f) {s : Set α}
    (hs : m '' s ∈ f) : NeBot (comap m f) 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β} (hf : f.NeBot) {s : Set α} (hs : m '' s ∈ f)
Goal: (Filter.comap m f).NeBot
-- Filter.map_eq_bot_iff
@[simp]
theorem map_eq_bot_iff : map m f = ⊥ ↔ f = ⊥ 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β}
Goal: Filter.map m f = ⊥ ↔ f = ⊥
-- Filter.map_neBot_iff
theorem map_neBot_iff (f : α → β) {F : Filter α} : NeBot (map f F) ↔ NeBot F 
Arguments: {α : Type u} {β : Type v} (f : α → β) {F : Filter α}
Goal: (Filter.map f F).NeBot ↔ F.NeBot
-- Filter.NeBot.map
theorem NeBot.map (hf : NeBot f) (m : α → β) : NeBot (map m f) 
Arguments: {α : Type u} {β : Type v} {f : Filter α} (hf : f.NeBot) (m : α → β)
Goal: (Filter.map m f).NeBot
-- Filter.NeBot.of_map
theorem NeBot.of_map : NeBot (f.map m) → NeBot f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β}
Goal: (Filter.map m f).NeBot → f.NeBot
-- Filter.sInter_comap_sets
theorem sInter_comap_sets (f : α → β) (F : Filter β) : ⋂₀ (comap f F).sets = ⋂ U ∈ F, f ⁻¹' U 
Arguments: {α : Type u} {β : Type v} (f : α → β) (F : Filter β)
Goal: ⋂₀ (Filter.comap f F).sets = ⋂ U ∈ F, f ⁻¹' U
-- Filter.map_iInf_le
theorem map_iInf_le {f : ι → Filter α} {m : α → β} : map m (iInf f) ≤ ⨅ i, map m (f i) 
Arguments: {α : Type u} {β : Type v} {ι : Sort x} {f : ι → Filter α} {m : α → β}
Goal: Filter.map m (iInf f) ≤ ⨅ i, Filter.map m (f i)
-- Filter.map_iInf_eq
theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
    map m (iInf f) = ⨅ i, map m (f i) 
Arguments: {α : Type u} {β : Type v} {ι : Sort x} {f : ι → Filter α} {m : α → β} (hf : Directed (fun x x_1 => x ≥ x_1) f) [Nonempty ι]
Goal: Filter.map m (iInf f) = ⨅ i, Filter.map m (f i)
-- Filter.map_biInf_eq
theorem map_biInf_eq {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop}
    (h : DirectedOn (f ⁻¹'o (· ≥ ·)) { x | p x }) (ne : ∃ i, p i) :
    map m (⨅ (i) (_ : p i), f i) = ⨅ (i) (_ : p i), map m (f i) 
Arguments: {α : Type u} {β : Type v} {ι : Type w} {f : ι → Filter α} {m : α → β} {p : ι → Prop} (h : DirectedOn (f ⁻¹'o fun x x_1 => x ≥ x_1) {x | p x}) (ne : ∃ i, p i)
Goal: Filter.map m (⨅ i, ⨅ (_ : p i), f i) = ⨅ i, ⨅ (_ : p i), Filter.map m (f i)
-- Filter.map_inf_le
theorem map_inf_le {f g : Filter α} {m : α → β} : map m (f ⊓ g) ≤ map m f ⊓ map m g 
Arguments: {α : Type u} {β : Type v} {f g : Filter α} {m : α → β}
Goal: Filter.map m (f ⊓ g) ≤ Filter.map m f ⊓ Filter.map m g
-- Filter.map_inf
theorem map_inf {f g : Filter α} {m : α → β} (h : Injective m) :
    map m (f ⊓ g) = map m f ⊓ map m g 
Arguments: {α : Type u} {β : Type v} {f g : Filter α} {m : α → β} (h : Function.Injective m)
Goal: Filter.map m (f ⊓ g) = Filter.map m f ⊓ Filter.map m g
-- Filter.map_inf'
theorem map_inf' {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f) (htg : t ∈ g)
    (h : InjOn m t) : map m (f ⊓ g) = map m f ⊓ map m g 
Arguments: {α : Type u} {β : Type v} {f g : Filter α} {m : α → β} {t : Set α} (htf : t ∈ f) (htg : t ∈ g) (h : Set.InjOn m t)
Goal: Filter.map m (f ⊓ g) = Filter.map m f ⊓ Filter.map m g
-- Filter.disjoint_of_map
lemma disjoint_of_map {α β : Type*} {F G : Filter α} {f : α → β}
    (h : Disjoint (map f F) (map f G)) : Disjoint F G 
Arguments: {α : Type u_2} {β : Type u_3} {F G : Filter α} {f : α → β} (h : Disjoint (Filter.map f F) (Filter.map f G))
Goal: Disjoint F G
-- Filter.disjoint_map
theorem disjoint_map {m : α → β} (hm : Injective m) {f₁ f₂ : Filter α} :
    Disjoint (map m f₁) (map m f₂) ↔ Disjoint f₁ f₂ 
Arguments: {α : Type u} {β : Type v} {m : α → β} (hm : Function.Injective m) {f₁ f₂ : Filter α}
Goal: Disjoint (Filter.map m f₁) (Filter.map m f₂) ↔ Disjoint f₁ f₂
-- Filter.map_equiv_symm
theorem map_equiv_symm (e : α ≃ β) (f : Filter β) : map e.symm f = comap e f 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) (f : Filter β)
Goal: Filter.map (⇑e.symm) f = Filter.comap (⇑e) f
-- Filter.map_eq_comap_of_inverse
theorem map_eq_comap_of_inverse {f : Filter α} {m : α → β} {n : β → α} (h₁ : m ∘ n = id)
    (h₂ : n ∘ m = id) : map m f = comap n f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {n : β → α} (h₁ : m ∘ n = id) (h₂ : n ∘ m = id)
Goal: Filter.map m f = Filter.comap n f
-- Filter.comap_equiv_symm
theorem comap_equiv_symm (e : α ≃ β) (f : Filter α) : comap e.symm f = map e f 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) (f : Filter α)
Goal: Filter.comap (⇑e.symm) f = Filter.map (⇑e) f
-- Filter.map_swap_eq_comap_swap
theorem map_swap_eq_comap_swap {f : Filter (α × β)} : Prod.swap <$> f = comap Prod.swap f 
Arguments: {α : Type u} {β : Type v} {f : Filter (α × β)}
Goal: Prod.swap <$> f = Filter.comap Prod.swap f
-- Filter.map_swap4_eq_comap
theorem map_swap4_eq_comap {f : Filter ((α × β) × γ × δ)} :
    map (fun p : (α × β) × γ × δ => ((p.1.1, p.2.1), (p.1.2, p.2.2))) f =
      comap (fun p : (α × γ) × β × δ => ((p.1.1, p.2.1), (p.1.2, p.2.2))) f 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_1} {f : Filter ((α × β) × γ × δ)}
Goal: Filter.map (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) f = Filter.comap (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) f
-- Filter.le_map
theorem le_map {f : Filter α} {m : α → β} {g : Filter β} (h : ∀ s ∈ f, m '' s ∈ g) : g ≤ f.map m 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {g : Filter β} (h : ∀ s ∈ f, m '' s ∈ g)
Goal: g ≤ Filter.map m f
-- Filter.le_map_iff
theorem le_map_iff {f : Filter α} {m : α → β} {g : Filter β} : g ≤ f.map m ↔ ∀ s ∈ f, m '' s ∈ g 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {g : Filter β}
Goal: g ≤ Filter.map m f ↔ ∀ s ∈ f, m '' s ∈ g
-- Filter.push_pull
protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
    map f (F ⊓ comap f G) = map f F ⊓ G 
Arguments: {α : Type u} {β : Type v} (f : α → β) (F : Filter α) (G : Filter β)
Goal: Filter.map f (F ⊓ Filter.comap f G) = Filter.map f F ⊓ G
-- Filter.push_pull'
protected theorem push_pull' (f : α → β) (F : Filter α) (G : Filter β) :
    map f (comap f G ⊓ F) = G ⊓ map f F 
Arguments: {α : Type u} {β : Type v} (f : α → β) (F : Filter α) (G : Filter β)
Goal: Filter.map f (Filter.comap f G ⊓ F) = G ⊓ Filter.map f F
-- Filter.principal_eq_map_coe_top
theorem principal_eq_map_coe_top (s : Set α) : 𝓟 s = map ((↑) : s → α) ⊤ 
Arguments: {α : Type u} (s : Set α)
Goal: 𝓟 s = Filter.map Subtype.val ⊤
-- Filter.inf_principal_eq_bot_iff_comap
theorem inf_principal_eq_bot_iff_comap {F : Filter α} {s : Set α} :
    F ⊓ 𝓟 s = ⊥ ↔ comap ((↑) : s → α) F = ⊥ 
Arguments: {α : Type u} {F : Filter α} {s : Set α}
Goal: F ⊓ 𝓟 s = ⊥ ↔ Filter.comap Subtype.val F = ⊥
-- Filter.singleton_mem_pure
theorem singleton_mem_pure {a : α} : {a} ∈ (pure a : Filter α) 
Arguments: {α : Type u} {a : α}
Goal: {a} ∈ pure a
-- Filter.pure_injective
theorem pure_injective : Injective (pure : α → Filter α) 
Arguments: {α : Type u}
Goal: Function.Injective pure
-- Filter.le_pure_iff
@[simp]
theorem le_pure_iff {f : Filter α} {a : α} : f ≤ pure a ↔ {a} ∈ f 
Arguments: {α : Type u} {f : Filter α} {a : α}
Goal: f ≤ pure a ↔ {a} ∈ f
-- Filter.mem_seq_def
theorem mem_seq_def {f : Filter (α → β)} {g : Filter α} {s : Set β} :
    s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, ∀ x ∈ u, ∀ y ∈ t, (x : α → β) y ∈ s 
Arguments: {α : Type u} {β : Type v} {f : Filter (α → β)} {g : Filter α} {s : Set β}
Goal: s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, ∀ x ∈ u, ∀ y ∈ t, x y ∈ s
-- Filter.mem_seq_iff
theorem mem_seq_iff {f : Filter (α → β)} {g : Filter α} {s : Set β} :
    s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, Set.seq u t ⊆ s 
Arguments: {α : Type u} {β : Type v} {f : Filter (α → β)} {g : Filter α} {s : Set β}
Goal: s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, u.seq t ⊆ s
-- Filter.mem_map_seq_iff
theorem mem_map_seq_iff {f : Filter α} {g : Filter β} {m : α → β → γ} {s : Set γ} :
    s ∈ (f.map m).seq g ↔ ∃ t u, t ∈ g ∧ u ∈ f ∧ ∀ x ∈ u, ∀ y ∈ t, m x y ∈ s 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {f : Filter α} {g : Filter β} {m : α → β → γ} {s : Set γ}
Goal: s ∈ (Filter.map m f).seq g ↔ ∃ t u, t ∈ g ∧ u ∈ f ∧ ∀ x ∈ u, ∀ y ∈ t, m x y ∈ s
-- Filter.seq_mem_seq
theorem seq_mem_seq {f : Filter (α → β)} {g : Filter α} {s : Set (α → β)} {t : Set α} (hs : s ∈ f)
    (ht : t ∈ g) : s.seq t ∈ f.seq g 
Arguments: {α : Type u} {β : Type v} {f : Filter (α → β)} {g : Filter α} {s : Set (α → β)} {t : Set α} (hs : s ∈ f) (ht : t ∈ g)
Goal: s.seq t ∈ f.seq g
-- Filter.le_seq
theorem le_seq {f : Filter (α → β)} {g : Filter α} {h : Filter β}
    (hh : ∀ t ∈ f, ∀ u ∈ g, Set.seq t u ∈ h) : h ≤ seq f g 
Arguments: {α : Type u} {β : Type v} {f : Filter (α → β)} {g : Filter α} {h : Filter β} (hh : ∀ t ∈ f, ∀ u ∈ g, t.seq u ∈ h)
Goal: h ≤ f.seq g
-- Filter.seq_mono
@[mono]
theorem seq_mono {f₁ f₂ : Filter (α → β)} {g₁ g₂ : Filter α} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
    f₁.seq g₁ ≤ f₂.seq g₂ 
Arguments: {α : Type u} {β : Type v} {f₁ f₂ : Filter (α → β)} {g₁ g₂ : Filter α} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂)
Goal: f₁.seq g₁ ≤ f₂.seq g₂
-- Filter.pure_seq_eq_map
@[simp]
theorem pure_seq_eq_map (g : α → β) (f : Filter α) : seq (pure g) f = f.map g 
Arguments: {α : Type u} {β : Type v} (g : α → β) (f : Filter α)
Goal: (pure g).seq f = Filter.map g f
-- Filter.seq_pure
@[simp]
theorem seq_pure (f : Filter (α → β)) (a : α) : seq f (pure a) = map (fun g : α → β => g a) f 
Arguments: {α : Type u} {β : Type v} (f : Filter (α → β)) (a : α)
Goal: f.seq (pure a) = Filter.map (fun g => g a) f
-- Filter.seq_assoc
@[simp]
theorem seq_assoc (x : Filter α) (g : Filter (α → β)) (h : Filter (β → γ)) :
    seq h (seq g x) = seq (seq (map (· ∘ ·) h) g) x 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (x : Filter α) (g : Filter (α → β)) (h : Filter (β → γ))
Goal: h.seq (g.seq x) = ((Filter.map (fun x x_1 => x ∘ x_1) h).seq g).seq x
-- Filter.prod_map_seq_comm
theorem prod_map_seq_comm (f : Filter α) (g : Filter β) :
    (map Prod.mk f).seq g = seq (map (fun b a => (a, b)) g) f 
Arguments: {α : Type u} {β : Type v} (f : Filter α) (g : Filter β)
Goal: (Filter.map Prod.mk f).seq g = (Filter.map (fun b a => (a, b)) g).seq f
-- Filter.seq_eq_filter_seq
theorem seq_eq_filter_seq {α β : Type u} (f : Filter (α → β)) (g : Filter α) :
    f <*> g = seq f g 
Arguments: {α β : Type u} (f : Filter (α → β)) (g : Filter α)
Goal: (Seq.seq f fun x => g) = f.seq g
-- Filter.eventually_bind
@[simp]
theorem eventually_bind {f : Filter α} {m : α → Filter β} {p : β → Prop} :
    (∀ᶠ y in bind f m, p y) ↔ ∀ᶠ x in f, ∀ᶠ y in m x, p y 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → Filter β} {p : β → Prop}
Goal: (∀ᶠ (y : β) in f.bind m, p y) ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in m x, p y
-- Filter.eventuallyEq_bind
@[simp]
theorem eventuallyEq_bind {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ} :
    g₁ =ᶠ[bind f m] g₂ ↔ ∀ᶠ x in f, g₁ =ᶠ[m x] g₂ 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ}
Goal: g₁ =ᶠ[f.bind m] g₂ ↔ ∀ᶠ (x : α) in f, g₁ =ᶠ[m x] g₂
-- Filter.eventuallyLE_bind
@[simp]
theorem eventuallyLE_bind [LE γ] {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ} :
    g₁ ≤ᶠ[bind f m] g₂ ↔ ∀ᶠ x in f, g₁ ≤ᶠ[m x] g₂ 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [LE γ] {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ}
Goal: g₁ ≤ᶠ[f.bind m] g₂ ↔ ∀ᶠ (x : α) in f, g₁ ≤ᶠ[m x] g₂
-- Filter.mem_bind'
theorem mem_bind' {s : Set β} {f : Filter α} {m : α → Filter β} :
    s ∈ bind f m ↔ { a | s ∈ m a } ∈ f 
Arguments: {α : Type u} {β : Type v} {s : Set β} {f : Filter α} {m : α → Filter β}
Goal: s ∈ f.bind m ↔ {a | s ∈ m a} ∈ f
-- Filter.mem_bind
@[simp]
theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
    s ∈ bind f m ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x 
Arguments: {α : Type u} {β : Type v} {s : Set β} {f : Filter α} {m : α → Filter β}
Goal: s ∈ f.bind m ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x
-- Filter.bind_le
theorem bind_le {f : Filter α} {g : α → Filter β} {l : Filter β} (h : ∀ᶠ x in f, g x ≤ l) :
    f.bind g ≤ l 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {g : α → Filter β} {l : Filter β} (h : ∀ᶠ (x : α) in f, g x ≤ l)
Goal: f.bind g ≤ l
-- Filter.bind_mono
@[mono]
theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ᶠ[f₁] g₂) :
    bind f₁ g₁ ≤ bind f₂ g₂ 
Arguments: {α : Type u} {β : Type v} {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ᶠ[f₁] g₂)
Goal: f₁.bind g₁ ≤ f₂.bind g₂
-- Filter.bind_inf_principal
theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
    (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {g : α → Filter β} {s : Set β}
Goal: (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s
-- Filter.sup_bind
theorem sup_bind {f g : Filter α} {h : α → Filter β} : bind (f ⊔ g) h = bind f h ⊔ bind g h 
Arguments: {α : Type u} {β : Type v} {f g : Filter α} {h : α → Filter β}
Goal: (f ⊔ g).bind h = f.bind h ⊔ g.bind h
-- Filter.principal_bind
theorem principal_bind {s : Set α} {f : α → Filter β} : bind (𝓟 s) f = ⨆ x ∈ s, f x 
Arguments: {α : Type u} {β : Type v} {s : Set α} {f : α → Filter β}
Goal: (𝓟 s).bind f = ⨆ x ∈ s, f x
-- Filter.tendsto_def
theorem tendsto_def {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β}
Goal: Filter.Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁
-- Filter.tendsto_iff_eventually
theorem tendsto_iff_eventually {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    Tendsto f l₁ l₂ ↔ ∀ ⦃p : β → Prop⦄, (∀ᶠ y in l₂, p y) → ∀ᶠ x in l₁, p (f x) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β}
Goal: Filter.Tendsto f l₁ l₂ ↔ ∀ ⦃p : β → Prop⦄, (∀ᶠ (y : β) in l₂, p y) → ∀ᶠ (x : α) in l₁, p (f x)
-- Filter.tendsto_iff_forall_eventually_mem
theorem tendsto_iff_forall_eventually_mem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, ∀ᶠ x in l₁, f x ∈ s 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β}
Goal: Filter.Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, ∀ᶠ (x : α) in l₁, f x ∈ s
-- Filter.Tendsto.eventually_mem
lemma Tendsto.eventually_mem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {s : Set β}
    (hf : Tendsto f l₁ l₂) (h : s ∈ l₂) : ∀ᶠ x in l₁, f x ∈ s 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {s : Set β} (hf : Filter.Tendsto f l₁ l₂) (h : s ∈ l₂)
Goal: ∀ᶠ (x : α) in l₁, f x ∈ s
-- Filter.Tendsto.eventually
theorem Tendsto.eventually {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop}
    (hf : Tendsto f l₁ l₂) (h : ∀ᶠ y in l₂, p y) : ∀ᶠ x in l₁, p (f x) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop} (hf : Filter.Tendsto f l₁ l₂) (h : ∀ᶠ (y : β) in l₂, p y)
Goal: ∀ᶠ (x : α) in l₁, p (f x)
-- Filter.not_tendsto_iff_exists_frequently_nmem
theorem not_tendsto_iff_exists_frequently_nmem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    ¬Tendsto f l₁ l₂ ↔ ∃ s ∈ l₂, ∃ᶠ x in l₁, f x ∉ s 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β}
Goal: ¬Filter.Tendsto f l₁ l₂ ↔ ∃ s ∈ l₂, ∃ᶠ (x : α) in l₁, f x ∉ s
-- Filter.Tendsto.frequently
theorem Tendsto.frequently {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop}
    (hf : Tendsto f l₁ l₂) (h : ∃ᶠ x in l₁, p (f x)) : ∃ᶠ y in l₂, p y 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l₁ : Filter α} {l₂ : Filter β} {p : β → Prop} (hf : Filter.Tendsto f l₁ l₂) (h : ∃ᶠ (x : α) in l₁, p (f x))
Goal: ∃ᶠ (y : β) in l₂, p y
-- Filter.Tendsto.frequently_map
theorem Tendsto.frequently_map {l₁ : Filter α} {l₂ : Filter β} {p : α → Prop} {q : β → Prop}
    (f : α → β) (c : Filter.Tendsto f l₁ l₂) (w : ∀ x, p x → q (f x)) (h : ∃ᶠ x in l₁, p x) :
    ∃ᶠ y in l₂, q y 
Arguments: {α : Type u} {β : Type v} {l₁ : Filter α} {l₂ : Filter β} {p : α → Prop} {q : β → Prop} (f : α → β) (c : Filter.Tendsto f l₁ l₂) (w : ∀ (x : α), p x → q (f x)) (h : ∃ᶠ (x : α) in l₁, p x)
Goal: ∃ᶠ (y : β) in l₂, q y
-- Filter.tendsto_bot
@[simp]
theorem tendsto_bot {f : α → β} {l : Filter β} : Tendsto f ⊥ l 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : Filter β}
Goal: Filter.Tendsto f ⊥ l