ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.EventuallyLE.compl
@[mono]
theorem EventuallyLE.compl {s t : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) :
    (tᶜ : Set α) ≤ᶠ[l] (sᶜ : Set α) 
Arguments: {α : Type u} {s t : Set α} {l : Filter α} (h : s ≤ᶠ[l] t)
Goal: tᶜ ≤ᶠ[l] sᶜ
-- Filter.EventuallyLE.diff
@[mono]
theorem EventuallyLE.diff {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : t' ≤ᶠ[l] s') :
    (s \ s' : Set α) ≤ᶠ[l] (t \ t' : Set α) 
Arguments: {α : Type u} {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : t' ≤ᶠ[l] s')
Goal: s \ s' ≤ᶠ[l] t \ t'
-- Filter.set_eventuallyLE_iff_mem_inf_principal
theorem set_eventuallyLE_iff_mem_inf_principal {s t : Set α} {l : Filter α} :
    s ≤ᶠ[l] t ↔ t ∈ l ⊓ 𝓟 s 
Arguments: {α : Type u} {s t : Set α} {l : Filter α}
Goal: s ≤ᶠ[l] t ↔ t ∈ l ⊓ 𝓟 s
-- Filter.set_eventuallyLE_iff_inf_principal_le
theorem set_eventuallyLE_iff_inf_principal_le {s t : Set α} {l : Filter α} :
    s ≤ᶠ[l] t ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t 
Arguments: {α : Type u} {s t : Set α} {l : Filter α}
Goal: s ≤ᶠ[l] t ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t
-- Filter.set_eventuallyEq_iff_inf_principal
theorem set_eventuallyEq_iff_inf_principal {s t : Set α} {l : Filter α} :
    s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t 
Arguments: {α : Type u} {s t : Set α} {l : Filter α}
Goal: s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t
-- Filter.EventuallyLE.sup
theorem EventuallyLE.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂)
    (hg : g₁ ≤ᶠ[l] g₂) : f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂ 
Arguments: {α : Type u} {β : Type v} [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂) (hg : g₁ ≤ᶠ[l] g₂)
Goal: f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂
-- Filter.EventuallyLE.sup_le
theorem EventuallyLE.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h)
    (hg : g ≤ᶠ[l] h) : f ⊔ g ≤ᶠ[l] h 
Arguments: {α : Type u} {β : Type v} [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h) (hg : g ≤ᶠ[l] h)
Goal: f ⊔ g ≤ᶠ[l] h
-- Filter.EventuallyLE.le_sup_of_le_left
theorem EventuallyLE.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g h : α → β}
    (hf : h ≤ᶠ[l] f) : h ≤ᶠ[l] f ⊔ g 
Arguments: {α : Type u} {β : Type v} [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : h ≤ᶠ[l] f)
Goal: h ≤ᶠ[l] f ⊔ g
-- Filter.EventuallyLE.le_sup_of_le_right
theorem EventuallyLE.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
    (hg : h ≤ᶠ[l] g) : h ≤ᶠ[l] f ⊔ g 
Arguments: {α : Type u} {β : Type v} [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hg : h ≤ᶠ[l] g)
Goal: h ≤ᶠ[l] f ⊔ g
-- Filter.join_le
theorem join_le {f : Filter (Filter α)} {l : Filter α} (h : ∀ᶠ m in f, m ≤ l) : join f ≤ l 
Arguments: {α : Type u} {f : Filter (Filter α)} {l : Filter α} (h : ∀ᶠ (m : Filter α) in f, m ≤ l)
Goal: f.join ≤ l
-- Filter.map_principal
@[simp]
theorem map_principal {s : Set α} {f : α → β} : map f (𝓟 s) = 𝓟 (Set.image f s) 
Arguments: {α : Type u} {β : Type v} {s : Set α} {f : α → β}
Goal: Filter.map f (𝓟 s) = 𝓟 (f '' s)
-- Filter.eventually_map
@[simp]
theorem eventually_map {P : β → Prop} : (∀ᶠ b in map m f, P b) ↔ ∀ᶠ a in f, P (m a) 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {P : β → Prop}
Goal: (∀ᶠ (b : β) in Filter.map m f, P b) ↔ ∀ᶠ (a : α) in f, P (m a)
-- Filter.frequently_map
@[simp]
theorem frequently_map {P : β → Prop} : (∃ᶠ b in map m f, P b) ↔ ∃ᶠ a in f, P (m a) 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {P : β → Prop}
Goal: (∃ᶠ (b : β) in Filter.map m f, P b) ↔ ∃ᶠ (a : α) in f, P (m a)
-- Filter.mem_map
@[simp]
theorem mem_map : t ∈ map m f ↔ m ⁻¹' t ∈ f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {t : Set β}
Goal: t ∈ Filter.map m f ↔ m ⁻¹' t ∈ f
-- Filter.mem_map'
theorem mem_map' : t ∈ map m f ↔ { x | m x ∈ t } ∈ f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {t : Set β}
Goal: t ∈ Filter.map m f ↔ {x | m x ∈ t} ∈ f
-- Filter.image_mem_map
theorem image_mem_map (hs : s ∈ f) : m '' s ∈ map m f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {s : Set α} (hs : s ∈ f)
Goal: m '' s ∈ Filter.map m f
-- Filter.image_mem_map_iff
@[simp 1100, nolint simpNF]
theorem image_mem_map_iff (hf : Injective m) : m '' s ∈ map m f ↔ s ∈ f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {s : Set α} (hf : Function.Injective m)
Goal: m '' s ∈ Filter.map m f ↔ s ∈ f
-- Filter.range_mem_map
theorem range_mem_map : range m ∈ map m f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β}
Goal: Set.range m ∈ Filter.map m f
-- Filter.mem_map_iff_exists_image
theorem mem_map_iff_exists_image : t ∈ map m f ↔ ∃ s ∈ f, m '' s ⊆ t 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β} {t : Set β}
Goal: t ∈ Filter.map m f ↔ ∃ s ∈ f, m '' s ⊆ t
-- Filter.map_id
@[simp]
theorem map_id : Filter.map id f = f 
Arguments: {α : Type u} {f : Filter α}
Goal: Filter.map id f = f
-- Filter.map_id'
@[simp]
theorem map_id' : Filter.map (fun x => x) f = f 
Arguments: {α : Type u} {f : Filter α}
Goal: Filter.map (fun x => x) f = f
-- Filter.map_compose
@[simp]
theorem map_compose : Filter.map m' ∘ Filter.map m = Filter.map (m' ∘ m) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {m : α → β} {m' : β → γ}
Goal: Filter.map m' ∘ Filter.map m = Filter.map (m' ∘ m)
-- Filter.map_map
@[simp]
theorem map_map : Filter.map m' (Filter.map m f) = Filter.map (m' ∘ m) f 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {f : Filter α} {m : α → β} {m' : β → γ}
Goal: Filter.map m' (Filter.map m f) = Filter.map (m' ∘ m) f
-- Filter.map_congr
theorem map_congr {m₁ m₂ : α → β} {f : Filter α} (h : m₁ =ᶠ[f] m₂) : map m₁ f = map m₂ f 
Arguments: {α : Type u} {β : Type v} {m₁ m₂ : α → β} {f : Filter α} (h : m₁ =ᶠ[f] m₂)
Goal: Filter.map m₁ f = Filter.map m₂ f
-- Filter.mem_comap'
theorem mem_comap' : s ∈ comap f l ↔ { y | ∀ ⦃x⦄, f x = y → x ∈ s } ∈ l 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : Filter β} {s : Set α}
Goal: s ∈ Filter.comap f l ↔ {y | ∀ ⦃x : α⦄, f x = y → x ∈ s} ∈ l
-- Filter.mem_comap''
theorem mem_comap'' : s ∈ comap f l ↔ kernImage f s ∈ l 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : Filter β} {s : Set α}
Goal: s ∈ Filter.comap f l ↔ Set.kernImage f s ∈ l
-- Filter.mem_comap_prod_mk
lemma mem_comap_prod_mk {x : α} {s : Set β} {F : Filter (α × β)} :
    s ∈ comap (Prod.mk x) F ↔ {p : α × β | p.fst = x → p.snd ∈ s} ∈ F 
Arguments: {α : Type u} {β : Type v} {x : α} {s : Set β} {F : Filter (α × β)}
Goal: s ∈ Filter.comap (Prod.mk x) F ↔ {p | p.1 = x → p.2 ∈ s} ∈ F
-- Filter.eventually_comap
@[simp]
theorem eventually_comap : (∀ᶠ a in comap f l, p a) ↔ ∀ᶠ b in l, ∀ a, f a = b → p a 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : Filter β} {p : α → Prop}
Goal: (∀ᶠ (a : α) in Filter.comap f l, p a) ↔ ∀ᶠ (b : β) in l, ∀ (a : α), f a = b → p a
-- Filter.frequently_comap
@[simp]
theorem frequently_comap : (∃ᶠ a in comap f l, p a) ↔ ∃ᶠ b in l, ∃ a, f a = b ∧ p a 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : Filter β} {p : α → Prop}
Goal: (∃ᶠ (a : α) in Filter.comap f l, p a) ↔ ∃ᶠ (b : β) in l, ∃ a, f a = b ∧ p a
-- Filter.mem_comap_iff_compl
theorem mem_comap_iff_compl : s ∈ comap f l ↔ (f '' sᶜ)ᶜ ∈ l 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : Filter β} {s : Set α}
Goal: s ∈ Filter.comap f l ↔ (f '' sᶜ)ᶜ ∈ l
-- Filter.compl_mem_comap
theorem compl_mem_comap : sᶜ ∈ comap f l ↔ (f '' s)ᶜ ∈ l 
Arguments: {α : Type u} {β : Type v} {f : α → β} {l : Filter β} {s : Set α}
Goal: sᶜ ∈ Filter.comap f l ↔ (f '' s)ᶜ ∈ l
-- Filter.mem_kernMap
theorem mem_kernMap {s : Set β} : s ∈ kernMap m f ↔ ∃ t ∈ f, kernImage m t = s 
Arguments: {α : Type u} {β : Type v} {m : α → β} {f : Filter α} {s : Set β}
Goal: s ∈ Filter.kernMap m f ↔ ∃ t ∈ f, Set.kernImage m t = s
-- Filter.mem_kernMap_iff_compl
theorem mem_kernMap_iff_compl {s : Set β} : s ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ 
Arguments: {α : Type u} {β : Type v} {m : α → β} {f : Filter α} {s : Set β}
Goal: s ∈ Filter.kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ
-- Filter.compl_mem_kernMap
theorem compl_mem_kernMap {s : Set β} : sᶜ ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = s 
Arguments: {α : Type u} {β : Type v} {m : α → β} {f : Filter α} {s : Set β}
Goal: sᶜ ∈ Filter.kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = s
-- Filter.pure_sets
theorem pure_sets (a : α) : (pure a : Filter α).sets = { s | a ∈ s } 
Arguments: {α : Type u} (a : α)
Goal: (pure a).sets = {s | a ∈ s}
-- Filter.mem_pure
@[simp]
theorem mem_pure {a : α} {s : Set α} : s ∈ (pure a : Filter α) ↔ a ∈ s 
Arguments: {α : Type u} {a : α} {s : Set α}
Goal: s ∈ pure a ↔ a ∈ s
-- Filter.eventually_pure
@[simp]
theorem eventually_pure {a : α} {p : α → Prop} : (∀ᶠ x in pure a, p x) ↔ p a 
Arguments: {α : Type u} {a : α} {p : α → Prop}
Goal: (∀ᶠ (x : α) in pure a, p x) ↔ p a
-- Filter.principal_singleton
@[simp]
theorem principal_singleton (a : α) : 𝓟 {a} = pure a 
Arguments: {α : Type u} (a : α)
Goal: 𝓟 {a} = pure a
-- Filter.map_pure
@[simp]
theorem map_pure (f : α → β) (a : α) : map f (pure a) = pure (f a) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (a : α)
Goal: Filter.map f (pure a) = pure (f a)
-- Filter.pure_le_principal
theorem pure_le_principal {s : Set α} (a : α) : pure a ≤ 𝓟 s ↔ a ∈ s 
Arguments: {α : Type u} {s : Set α} (a : α)
Goal: pure a ≤ 𝓟 s ↔ a ∈ s
-- Filter.join_pure
@[simp] theorem join_pure (f : Filter α) : join (pure f) = f 
Arguments: {α : Type u} (f : Filter α)
Goal: (pure f).join = f
-- Filter.pure_bind
@[simp]
theorem pure_bind (a : α) (m : α → Filter β) : bind (pure a) m = m a 
Arguments: {α : Type u} {β : Type v} (a : α) (m : α → Filter β)
Goal: (pure a).bind m = m a
-- Filter.map_bind
theorem map_bind {α β} (m : β → γ) (f : Filter α) (g : α → Filter β) :
    map m (bind f g) = bind f (map m ∘ g) 
Arguments: {γ : Type w} {α : Type u_2} {β : Type u_3} (m : β → γ) (f : Filter α) (g : α → Filter β)
Goal: Filter.map m (f.bind g) = f.bind (Filter.map m ∘ g)
-- Filter.bind_map
theorem bind_map {α β} (m : α → β) (f : Filter α) (g : β → Filter γ) :
    (bind (map m f) g) = bind f (g ∘ m) 
Arguments: {γ : Type w} {α : Type u_2} {β : Type u_3} (m : α → β) (f : Filter α) (g : β → Filter γ)
Goal: (Filter.map m f).bind g = f.bind (g ∘ m)
-- Filter.lawfulMonad
protected theorem lawfulMonad : LawfulMonad Filter 
Goal: LawfulMonad Filter
-- Filter.map_def
@[simp]
theorem map_def {α β} (m : α → β) (f : Filter α) : m <$> f = map m f 
Arguments: {α β : Type u_2} (m : α → β) (f : Filter α)
Goal: m <$> f = Filter.map m f
-- Filter.bind_def
@[simp]
theorem bind_def {α β} (f : Filter α) (m : α → Filter β) : f >>= m = bind f m 
Arguments: {α β : Type u_2} (f : Filter α) (m : α → Filter β)
Goal: f >>= m = f.bind m
-- Filter.mem_comap
@[simp] theorem mem_comap : s ∈ comap m g ↔ ∃ t ∈ g, m ⁻¹' t ⊆ s 
Arguments: {α : Type u} {β : Type v} {g : Filter β} {m : α → β} {s : Set α}
Goal: s ∈ Filter.comap m g ↔ ∃ t ∈ g, m ⁻¹' t ⊆ s
-- Filter.preimage_mem_comap
theorem preimage_mem_comap (ht : t ∈ g) : m ⁻¹' t ∈ comap m g 
Arguments: {α : Type u} {β : Type v} {g : Filter β} {m : α → β} {t : Set β} (ht : t ∈ g)
Goal: m ⁻¹' t ∈ Filter.comap m g
-- Filter.Eventually.comap
theorem Eventually.comap {p : β → Prop} (hf : ∀ᶠ b in g, p b) (f : α → β) :
    ∀ᶠ a in comap f g, p (f a) 
Arguments: {α : Type u} {β : Type v} {g : Filter β} {p : β → Prop} (hf : ∀ᶠ (b : β) in g, p b) (f : α → β)
Goal: ∀ᶠ (a : α) in Filter.comap f g, p (f a)
-- Filter.comap_id
theorem comap_id : comap id f = f 
Arguments: {α : Type u} {f : Filter α}
Goal: Filter.comap id f = f
-- Filter.comap_id'
theorem comap_id' : comap (fun x => x) f = f 
Arguments: {α : Type u} {f : Filter α}
Goal: Filter.comap (fun x => x) f = f
-- Filter.comap_const_of_not_mem
theorem comap_const_of_not_mem {x : β} (ht : t ∈ g) (hx : x ∉ t) : comap (fun _ : α => x) g = ⊥ 
Arguments: {α : Type u} {β : Type v} {g : Filter β} {t : Set β} {x : β} (ht : t ∈ g) (hx : x ∉ t)
Goal: Filter.comap (fun x_1 => x) g = ⊥
-- Filter.comap_const_of_mem
theorem comap_const_of_mem {x : β} (h : ∀ t ∈ g, x ∈ t) : comap (fun _ : α => x) g = ⊤ 
Arguments: {α : Type u} {β : Type v} {g : Filter β} {x : β} (h : ∀ t ∈ g, x ∈ t)
Goal: Filter.comap (fun x_1 => x) g = ⊤
-- Filter.map_const
theorem map_const [NeBot f] {c : β} : (f.map fun _ => c) = pure c 
Arguments: {α : Type u} {β : Type v} {f : Filter α} [f.NeBot] {c : β}
Goal: Filter.map (fun x => c) f = pure c
-- Filter.comap_comap
theorem comap_comap {m : γ → β} {n : β → α} : comap m (comap n f) = comap (n ∘ m) f 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {f : Filter α} {m : γ → β} {n : β → α}
Goal: Filter.comap m (Filter.comap n f) = Filter.comap (n ∘ m) f
-- Filter.map_comm
theorem map_comm (H : ψ ∘ φ = ρ ∘ θ) (F : Filter α) :
    map ψ (map φ F) = map ρ (map θ F) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_1} {φ : α → β} {θ : α → γ} {ψ : β → δ} {ρ : γ → δ} (H : ψ ∘ φ = ρ ∘ θ) (F : Filter α)
Goal: Filter.map ψ (Filter.map φ F) = Filter.map ρ (Filter.map θ F)
-- Filter.comap_comm
theorem comap_comm (H : ψ ∘ φ = ρ ∘ θ) (G : Filter δ) :
    comap φ (comap ψ G) = comap θ (comap ρ G) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_1} {φ : α → β} {θ : α → γ} {ψ : β → δ} {ρ : γ → δ} (H : ψ ∘ φ = ρ ∘ θ) (G : Filter δ)
Goal: Filter.comap φ (Filter.comap ψ G) = Filter.comap θ (Filter.comap ρ G)
-- Function.Semiconj.filter_map
theorem _root_.Function.Semiconj.filter_map {f : α → β} {ga : α → α} {gb : β → β}
    (h : Function.Semiconj f ga gb) : Function.Semiconj (map f) (map ga) (map gb) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {ga : α → α} {gb : β → β} (h : Function.Semiconj f ga gb)
Goal: Function.Semiconj (Filter.map f) (Filter.map ga) (Filter.map gb)
-- Function.Commute.filter_map
theorem _root_.Function.Commute.filter_map {f g : α → α} (h : Function.Commute f g) :
    Function.Commute (map f) (map g) 
Arguments: {α : Type u} {f g : α → α} (h : Function.Commute f g)
Goal: Function.Commute (Filter.map f) (Filter.map g)
-- Function.Semiconj.filter_comap
theorem _root_.Function.Semiconj.filter_comap {f : α → β} {ga : α → α} {gb : β → β}
    (h : Function.Semiconj f ga gb) : Function.Semiconj (comap f) (comap gb) (comap ga) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {ga : α → α} {gb : β → β} (h : Function.Semiconj f ga gb)
Goal: Function.Semiconj (Filter.comap f) (Filter.comap gb) (Filter.comap ga)
-- Function.Commute.filter_comap
theorem _root_.Function.Commute.filter_comap {f g : α → α} (h : Function.Commute f g) :
    Function.Commute (comap f) (comap g) 
Arguments: {α : Type u} {f g : α → α} (h : Function.Commute f g)
Goal: Function.Commute (Filter.comap f) (Filter.comap g)
-- Function.LeftInverse.filter_map
theorem _root_.Function.LeftInverse.filter_map {f : α → β} {g : β → α} (hfg : LeftInverse g f) :
    LeftInverse (map g) (map f) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {g : β → α} (hfg : Function.LeftInverse g f)
Goal: Function.LeftInverse (Filter.map g) (Filter.map f)
-- Function.LeftInverse.filter_comap
theorem _root_.Function.LeftInverse.filter_comap {f : α → β} {g : β → α} (hfg : LeftInverse g f) :
    RightInverse (comap g) (comap f) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {g : β → α} (hfg : Function.LeftInverse g f)
Goal: Function.RightInverse (Filter.comap g) (Filter.comap f)
-- Function.RightInverse.filter_map
nonrec theorem _root_.Function.RightInverse.filter_map {f : α → β} {g : β → α}
    (hfg : RightInverse g f) : RightInverse (map g) (map f) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {g : β → α} (hfg : Function.RightInverse g f)
Goal: Function.RightInverse (Filter.map g) (Filter.map f)
-- Function.RightInverse.filter_comap
nonrec theorem _root_.Function.RightInverse.filter_comap {f : α → β} {g : β → α}
    (hfg : RightInverse g f) : LeftInverse (comap g) (comap f) 
Arguments: {α : Type u} {β : Type v} {f : α → β} {g : β → α} (hfg : Function.RightInverse g f)
Goal: Function.LeftInverse (Filter.comap g) (Filter.comap f)
-- Set.LeftInvOn.filter_map_Iic
theorem _root_.Set.LeftInvOn.filter_map_Iic {f : α → β} {g : β → α} (hfg : LeftInvOn g f s) :
    LeftInvOn (map g) (map f) (Iic <| 𝓟 s) 
Arguments: {α : Type u} {β : Type v} {s : Set α} {f : α → β} {g : β → α} (hfg : Set.LeftInvOn g f s)
Goal: Set.LeftInvOn (Filter.map g) (Filter.map f) (Set.Iic (𝓟 s))
-- Set.RightInvOn.filter_map_Iic
nonrec theorem _root_.Set.RightInvOn.filter_map_Iic {f : α → β} {g : β → α}
    (hfg : RightInvOn g f t) : RightInvOn (map g) (map f) (Iic <| 𝓟 t) 
Arguments: {α : Type u} {β : Type v} {t : Set β} {f : α → β} {g : β → α} (hfg : Set.RightInvOn g f t)
Goal: Set.RightInvOn (Filter.map g) (Filter.map f) (Set.Iic (𝓟 t))
-- Filter.comap_principal
@[simp]
theorem comap_principal {t : Set β} : comap m (𝓟 t) = 𝓟 (m ⁻¹' t) 
Arguments: {α : Type u} {β : Type v} {m : α → β} {t : Set β}
Goal: Filter.comap m (𝓟 t) = 𝓟 (m ⁻¹' t)
-- Filter.principal_subtype
theorem principal_subtype {α : Type*} (s : Set α) (t : Set s) :
    𝓟 t = comap (↑) (𝓟 (((↑) : s → α) '' t)) 
Arguments: {α : Type u_2} (s : Set α) (t : Set ↑s)
Goal: 𝓟 t = Filter.comap Subtype.val (𝓟 (Subtype.val '' t))
-- Filter.comap_pure
@[simp]
theorem comap_pure {b : β} : comap m (pure b) = 𝓟 (m ⁻¹' {b}) 
Arguments: {α : Type u} {β : Type v} {m : α → β} {b : β}
Goal: Filter.comap m (pure b) = 𝓟 (m ⁻¹' {b})
-- Filter.map_le_iff_le_comap
theorem map_le_iff_le_comap : map m f ≤ g ↔ f ≤ comap m g 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {g : Filter β} {m : α → β}
Goal: Filter.map m f ≤ g ↔ f ≤ Filter.comap m g
-- Filter.gc_map_comap
theorem gc_map_comap (m : α → β) : GaloisConnection (map m) (comap m) 
Arguments: {α : Type u} {β : Type v} (m : α → β)
Goal: GaloisConnection (Filter.map m) (Filter.comap m)
-- Filter.comap_le_iff_le_kernMap
theorem comap_le_iff_le_kernMap : comap m g ≤ f ↔ g ≤ kernMap m f 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {g : Filter β} {m : α → β}
Goal: Filter.comap m g ≤ f ↔ g ≤ Filter.kernMap m f
-- Filter.gc_comap_kernMap
theorem gc_comap_kernMap (m : α → β) : GaloisConnection (comap m) (kernMap m) 
Arguments: {α : Type u} {β : Type v} (m : α → β)
Goal: GaloisConnection (Filter.comap m) (Filter.kernMap m)
-- Filter.kernMap_principal
theorem kernMap_principal {s : Set α} : kernMap m (𝓟 s) = 𝓟 (kernImage m s) 
Arguments: {α : Type u} {β : Type v} {m : α → β} {s : Set α}
Goal: Filter.kernMap m (𝓟 s) = 𝓟 (Set.kernImage m s)
-- Filter.map_mono
@[mono]
theorem map_mono : Monotone (map m) 
Arguments: {α : Type u} {β : Type v} {m : α → β}
Goal: Monotone (Filter.map m)
-- Filter.comap_mono
@[mono]
theorem comap_mono : Monotone (comap m) 
Arguments: {α : Type u} {β : Type v} {m : α → β}
Goal: Monotone (Filter.comap m)
-- GCongr.Filter.map_le_map
@[gcongr] theorem _root_.GCongr.Filter.map_le_map {F G : Filter α} (h : F ≤ G) :
    map m F ≤ map m G 
Arguments: {α : Type u} {β : Type v} {m : α → β} {F G : Filter α} (h : F ≤ G)
Goal: Filter.map m F ≤ Filter.map m G
-- GCongr.Filter.comap_le_comap
@[gcongr]
theorem _root_.GCongr.Filter.comap_le_comap {F G : Filter β} (h : F ≤ G) :
    comap m F ≤ comap m G 
Arguments: {α : Type u} {β : Type v} {m : α → β} {F G : Filter β} (h : F ≤ G)
Goal: Filter.comap m F ≤ Filter.comap m G
-- Filter.map_bot
@[simp] theorem map_bot : map m ⊥ = ⊥ 
Arguments: {α : Type u} {β : Type v} {m : α → β}
Goal: Filter.map m ⊥ = ⊥
-- Filter.map_sup
@[simp] theorem map_sup : map m (f₁ ⊔ f₂) = map m f₁ ⊔ map m f₂ 
Arguments: {α : Type u} {β : Type v} {f₁ f₂ : Filter α} {m : α → β}
Goal: Filter.map m (f₁ ⊔ f₂) = Filter.map m f₁ ⊔ Filter.map m f₂
-- Filter.map_iSup
@[simp]
theorem map_iSup {f : ι → Filter α} : map m (⨆ i, f i) = ⨆ i, map m (f i) 
Arguments: {α : Type u} {β : Type v} {ι : Sort x} {m : α → β} {f : ι → Filter α}
Goal: Filter.map m (⨆ i, f i) = ⨆ i, Filter.map m (f i)
-- Filter.map_top
@[simp]
theorem map_top (f : α → β) : map f ⊤ = 𝓟 (range f) 
Arguments: {α : Type u} {β : Type v} (f : α → β)
Goal: Filter.map f ⊤ = 𝓟 (Set.range f)
-- Filter.comap_top
@[simp] theorem comap_top : comap m ⊤ = ⊤ 
Arguments: {α : Type u} {β : Type v} {m : α → β}
Goal: Filter.comap m ⊤ = ⊤
-- Filter.comap_inf
@[simp] theorem comap_inf : comap m (g₁ ⊓ g₂) = comap m g₁ ⊓ comap m g₂ 
Arguments: {α : Type u} {β : Type v} {g₁ g₂ : Filter β} {m : α → β}
Goal: Filter.comap m (g₁ ⊓ g₂) = Filter.comap m g₁ ⊓ Filter.comap m g₂
-- Filter.comap_iInf
@[simp]
theorem comap_iInf {f : ι → Filter β} : comap m (⨅ i, f i) = ⨅ i, comap m (f i) 
Arguments: {α : Type u} {β : Type v} {ι : Sort x} {m : α → β} {f : ι → Filter β}
Goal: Filter.comap m (⨅ i, f i) = ⨅ i, Filter.comap m (f i)
-- Filter.le_comap_top
theorem le_comap_top (f : α → β) (l : Filter α) : l ≤ comap f ⊤ 
Arguments: {α : Type u} {β : Type v} (f : α → β) (l : Filter α)
Goal: l ≤ Filter.comap f ⊤
-- Filter.map_comap_le
theorem map_comap_le : map m (comap m g) ≤ g 
Arguments: {α : Type u} {β : Type v} {g : Filter β} {m : α → β}
Goal: Filter.map m (Filter.comap m g) ≤ g
-- Filter.le_comap_map
theorem le_comap_map : f ≤ comap m (map m f) 
Arguments: {α : Type u} {β : Type v} {f : Filter α} {m : α → β}
Goal: f ≤ Filter.comap m (Filter.map m f)
-- Filter.comap_bot
@[simp]
theorem comap_bot : comap m ⊥ = ⊥ 
Arguments: {α : Type u} {β : Type v} {m : α → β}
Goal: Filter.comap m ⊥ = ⊥
-- Filter.neBot_of_comap
theorem neBot_of_comap (h : (comap m g).NeBot) : g.NeBot 
Arguments: {α : Type u} {β : Type v} {g : Filter β} {m : α → β} (h : (Filter.comap m g).NeBot)
Goal: g.NeBot
-- Filter.comap_inf_principal_range
theorem comap_inf_principal_range : comap m (g ⊓ 𝓟 (range m)) = comap m g 
Arguments: {α : Type u} {β : Type v} {g : Filter β} {m : α → β}
Goal: Filter.comap m (g ⊓ 𝓟 (Set.range m)) = Filter.comap m g
-- Filter.disjoint_comap
theorem disjoint_comap (h : Disjoint g₁ g₂) : Disjoint (comap m g₁) (comap m g₂) 
Arguments: {α : Type u} {β : Type v} {g₁ g₂ : Filter β} {m : α → β} (h : Disjoint g₁ g₂)
Goal: Disjoint (Filter.comap m g₁) (Filter.comap m g₂)
-- Filter.comap_iSup
theorem comap_iSup {ι} {f : ι → Filter β} {m : α → β} : comap m (iSup f) = ⨆ i, comap m (f i) 
Arguments: {α : Type u} {β : Type v} {ι : Sort u_2} {f : ι → Filter β} {m : α → β}
Goal: Filter.comap m (iSup f) = ⨆ i, Filter.comap m (f i)
-- Filter.comap_sSup
theorem comap_sSup {s : Set (Filter β)} {m : α → β} : comap m (sSup s) = ⨆ f ∈ s, comap m f 
Arguments: {α : Type u} {β : Type v} {s : Set (Filter β)} {m : α → β}
Goal: Filter.comap m (sSup s) = ⨆ f ∈ s, Filter.comap m f
-- Filter.comap_sup
theorem comap_sup : comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂ 
Arguments: {α : Type u} {β : Type v} {g₁ g₂ : Filter β} {m : α → β}
Goal: Filter.comap m (g₁ ⊔ g₂) = Filter.comap m g₁ ⊔ Filter.comap m g₂
-- Filter.map_comap
theorem map_comap (f : Filter β) (m : α → β) : (f.comap m).map m = f ⊓ 𝓟 (range m) 
Arguments: {α : Type u} {β : Type v} (f : Filter β) (m : α → β)
Goal: Filter.map m (Filter.comap m f) = f ⊓ 𝓟 (Set.range m)
-- Filter.map_comap_setCoe_val
theorem map_comap_setCoe_val (f : Filter β) (s : Set β) :
    (f.comap ((↑) : s → β)).map (↑) = f ⊓ 𝓟 s 
Arguments: {β : Type v} (f : Filter β) (s : Set β)
Goal: Filter.map Subtype.val (Filter.comap Subtype.val f) = f ⊓ 𝓟 s
-- Filter.map_comap_of_mem
theorem map_comap_of_mem {f : Filter β} {m : α → β} (hf : range m ∈ f) : (f.comap m).map m = f 
Arguments: {α : Type u} {β : Type v} {f : Filter β} {m : α → β} (hf : Set.range m ∈ f)
Goal: Filter.map m (Filter.comap m f) = f
-- Filter.comap_le_comap_iff
theorem comap_le_comap_iff {f g : Filter β} {m : α → β} (hf : range m ∈ f) :
    comap m f ≤ comap m g ↔ f ≤ g 
Arguments: {α : Type u} {β : Type v} {f g : Filter β} {m : α → β} (hf : Set.range m ∈ f)
Goal: Filter.comap m f ≤ Filter.comap m g ↔ f ≤ g
-- Filter.map_comap_of_surjective
theorem map_comap_of_surjective {f : α → β} (hf : Surjective f) (l : Filter β) :
    map f (comap f l) = l 
Arguments: {α : Type u} {β : Type v} {f : α → β} (hf : Function.Surjective f) (l : Filter β)
Goal: Filter.map f (Filter.comap f l) = l
-- Filter.comap_injective
theorem comap_injective {f : α → β} (hf : Surjective f) : Injective (comap f) 
Arguments: {α : Type u} {β : Type v} {f : α → β} (hf : Function.Surjective f)
Goal: Function.Injective (Filter.comap f)
-- Function.Surjective.filter_map_top
theorem _root_.Function.Surjective.filter_map_top {f : α → β} (hf : Surjective f) : map f ⊤ = ⊤ 
Arguments: {α : Type u} {β : Type v} {f : α → β} (hf : Function.Surjective f)
Goal: Filter.map f ⊤ = ⊤