File: Mathlib/Order/Filter/Basic.lean

full_name: Filter
code: /-- A filter `F` on a type `α` is a collection of sets of `α` which contains the whole `α`,
is upwards-closed, and is stable under intersection. We do not forbid this collection to be
all sets of `α`. -/
structure Filter (α : Type*) where
  /-- The set of sets that belong to the filter. -/
  sets : Set (Set α)
  /-- The set `Set.univ` belongs to any filter. -/
  univ_sets : Set.univ ∈ sets
  /-- If a set belongs to a filter, then its superset belongs to the filter as well. -/
  sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets
  /-- If two sets belong to a filter, then their intersection belongs to the filter as well. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets
goal: Type u_1

full_name: Filter.sets
code: /-- A filter `F` on a type `α` is a collection of sets of `α` which contains the whole `α`,
is upwards-closed, and is stable under intersection. We do not forbid this collection to be
all sets of `α`. -/
structure Filter (α : Type*) where
  /-- The set of sets that belong to the filter. -/
  sets : Set (Set α)
  /-- The set `Set.univ` belongs to any filter. -/
  univ_sets : Set.univ ∈ sets
  /-- If a set belongs to a filter, then its superset belongs to the filter as well. -/
  sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets
  /-- If two sets belong to a filter, then their intersection belongs to the filter as well. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets
goal: Set (Set α)

full_name: Filter.sets_of_superset
code: /-- A filter `F` on a type `α` is a collection of sets of `α` which contains the whole `α`,
is upwards-closed, and is stable under intersection. We do not forbid this collection to be
all sets of `α`. -/
structure Filter (α : Type*) where
  /-- The set of sets that belong to the filter. -/
  sets : Set (Set α)
  /-- The set `Set.univ` belongs to any filter. -/
  univ_sets : Set.univ ∈ sets
  /-- If a set belongs to a filter, then its superset belongs to the filter as well. -/
  sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets
  /-- If two sets belong to a filter, then their intersection belongs to the filter as well. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets
goal: x ∈ self.sets → x ⊆ y → y ∈ self.sets

full_name: Filter.inter_sets
code: /-- A filter `F` on a type `α` is a collection of sets of `α` which contains the whole `α`,
is upwards-closed, and is stable under intersection. We do not forbid this collection to be
all sets of `α`. -/
structure Filter (α : Type*) where
  /-- The set of sets that belong to the filter. -/
  sets : Set (Set α)
  /-- The set `Set.univ` belongs to any filter. -/
  univ_sets : Set.univ ∈ sets
  /-- If a set belongs to a filter, then its superset belongs to the filter as well. -/
  sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets
  /-- If two sets belong to a filter, then their intersection belongs to the filter as well. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets
goal: x ∈ self.sets → y ∈ self.sets → x ∩ y ∈ self.sets

full_name: Filter.univ_sets
code: /-- A filter `F` on a type `α` is a collection of sets of `α` which contains the whole `α`,
is upwards-closed, and is stable under intersection. We do not forbid this collection to be
all sets of `α`. -/
structure Filter (α : Type*) where
  /-- The set of sets that belong to the filter. -/
  sets : Set (Set α)
  /-- The set `Set.univ` belongs to any filter. -/
  univ_sets : Set.univ ∈ sets
  /-- If a set belongs to a filter, then its superset belongs to the filter as well. -/
  sets_of_superset {x y} : x ∈ sets → x ⊆ y → y ∈ sets
  /-- If two sets belong to a filter, then their intersection belongs to the filter as well. -/
  inter_sets {x y} : x ∈ sets → y ∈ sets → x ∩ y ∈ sets
goal: Set.univ ∈ self.sets

full_name: instMembershipSetFilter
code: /-- If `F` is a filter on `α`, and `U` a subset of `α` then we can write `U ∈ F` as on paper. -/
instance {α : Type*} : Membership (Set α) (Filter α) 
goal: Membership (Set α) (Filter α)

full_name: Filter.mem_mk
code: @[simp]
protected theorem mem_mk {t : Set (Set α)} {h₁ h₂ h₃} : s ∈ mk t h₁ h₂ h₃ ↔ s ∈ t 
goal: s ∈ { sets := t, univ_sets := h₁, sets_of_superset := h₂, inter_sets := h₃ } ↔ s ∈ t

full_name: Filter.mem_sets
code: @[simp]
protected theorem mem_sets : s ∈ f.sets ↔ s ∈ f 
goal: s ∈ f.sets ↔ s ∈ f

full_name: Filter.inhabitedMem
code: instance inhabitedMem : Inhabited { s : Set α // s ∈ f } 
goal: Inhabited { s // s ∈ f }

full_name: Filter.filter_eq
code: theorem filter_eq : ∀ {f g : Filter α}, f.sets = g.sets → f = g
  
goal: f.sets = g.sets → f = g

full_name: Filter.filter_eq_iff
code: theorem filter_eq_iff : f = g ↔ f.sets = g.sets 
goal: f = g ↔ f.sets = g.sets

full_name: Filter.ext
code: @[ext]
protected theorem ext (h : ∀ s, s ∈ f ↔ s ∈ g) : f = g 
goal: f = g

full_name: Filter.ext_iff
code: protected theorem ext_iff : f = g ↔ ∀ s, s ∈ f ↔ s ∈ g 
goal: f = g ↔ ∀ (s : Set α), s ∈ f ↔ s ∈ g

full_name: Filter.coext
code: /-- An extensionality lemma that is useful for filters with good lemmas about `sᶜ ∈ f` (e.g.,
`Filter.comap`, `Filter.coprod`, `Filter.Coprod`, `Filter.cofinite`). -/
protected theorem coext (h : ∀ s, sᶜ ∈ f ↔ sᶜ ∈ g) : f = g 
goal: f = g

full_name: Filter.univ_mem
code: @[simp]
theorem univ_mem : univ ∈ f 
goal: Set.univ ∈ f

full_name: Filter.mem_of_superset
code: theorem mem_of_superset {x y : Set α} (hx : x ∈ f) (hxy : x ⊆ y) : y ∈ f 
goal: y ∈ f

full_name: Filter.instTransSetSupersetMem
code: instance : Trans (· ⊇ ·) ((· ∈ ·) : Set α → Filter α → Prop) (· ∈ ·) 
goal: Trans (fun x x_1 => x ⊇ x_1) (fun x x_1 => x ∈ x_1) fun x x_1 => x ∈ x_1

full_name: Filter.inter_mem
code: theorem inter_mem {s t : Set α} (hs : s ∈ f) (ht : t ∈ f) : s ∩ t ∈ f 
goal: s ∩ t ∈ f

full_name: Filter.inter_mem_iff
code: @[simp]
theorem inter_mem_iff {s t : Set α} : s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f 
goal: s ∩ t ∈ f ↔ s ∈ f ∧ t ∈ f

full_name: Filter.diff_mem
code: theorem diff_mem {s t : Set α} (hs : s ∈ f) (ht : tᶜ ∈ f) : s \ t ∈ f 
goal: s \ t ∈ f

full_name: Filter.univ_mem'
code: theorem univ_mem' (h : ∀ a, a ∈ s) : s ∈ f 
goal: s ∈ f

full_name: Filter.mp_mem
code: theorem mp_mem (hs : s ∈ f) (h : { x | x ∈ s → x ∈ t } ∈ f) : t ∈ f 
goal: t ∈ f

full_name: Filter.congr_sets
code: theorem congr_sets (h : { x | x ∈ s ↔ x ∈ t } ∈ f) : s ∈ f ↔ t ∈ f 
goal: s ∈ f ↔ t ∈ f

full_name: Filter.copy
code: /-- Override `sets` field of a filter to provide better definitional equality. -/
protected def copy (f : Filter α) (S : Set (Set α)) (hmem : ∀ s, s ∈ S ↔ s ∈ f) : Filter α 
goal: Filter α

full_name: Filter.copy_eq
code: lemma copy_eq {S} (hmem : ∀ s, s ∈ S ↔ s ∈ f) : f.copy S hmem = f 
goal: f.copy S hmem = f

full_name: Filter.mem_copy
code: @[simp] lemma mem_copy {S hmem} : s ∈ f.copy S hmem ↔ s ∈ S 
goal: s ∈ f.copy S hmem ↔ s ∈ S

full_name: Filter.biInter_mem
code: @[simp]
theorem biInter_mem {β : Type v} {s : β → Set α} {is : Set β} (hf : is.Finite) :
    (⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f 
goal: ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f

full_name: Filter.biInter_finset_mem
code: @[simp]
theorem biInter_finset_mem {β : Type v} {s : β → Set α} (is : Finset β) :
    (⋂ i ∈ is, s i) ∈ f ↔ ∀ i ∈ is, s i ∈ f 
goal: ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f

full_name: Filter.sInter_mem
code: @[simp]
theorem sInter_mem {s : Set (Set α)} (hfin : s.Finite) : ⋂₀ s ∈ f ↔ ∀ U ∈ s, U ∈ f 
goal: ⋂₀ s ∈ f ↔ ∀ U ∈ s, U ∈ f

full_name: Filter.iInter_mem
code: @[simp]
theorem iInter_mem {β : Sort v} {s : β → Set α} [Finite β] : (⋂ i, s i) ∈ f ↔ ∀ i, s i ∈ f 
goal: ⋂ i, s i ∈ f ↔ ∀ (i : β), s i ∈ f

full_name: Filter.exists_mem_subset_iff
code: theorem exists_mem_subset_iff : (∃ t ∈ f, t ⊆ s) ↔ s ∈ f 
goal: (∃ t ∈ f, t ⊆ s) ↔ s ∈ f

full_name: Filter.monotone_mem
code: theorem monotone_mem {f : Filter α} : Monotone fun s => s ∈ f 
goal: Monotone fun s => s ∈ f

full_name: Filter.exists_mem_and_iff
code: 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 
goal: ((∃ u ∈ f, P u) ∧ ∃ u ∈ f, Q u) ↔ ∃ u ∈ f, P u ∧ Q u

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

full_name: Mathlib.Tactic.filterUpwards
code: /--
`filter_upwards [h₁, ⋯, hₙ]` replaces a goal of the form `s ∈ f` and terms
`h₁ : t₁ ∈ f, ⋯, hₙ : tₙ ∈ f` with `∀ x, x ∈ t₁ → ⋯ → x ∈ tₙ → x ∈ s`.
The list is an optional parameter, `[]` being its default value.

`filter_upwards [h₁, ⋯, hₙ] with a₁ a₂ ⋯ aₖ` is a short form for
`{ filter_upwards [h₁, ⋯, hₙ], intros a₁ a₂ ⋯ aₖ }`.

`filter_upwards [h₁, ⋯, hₙ] using e` is a short form for
`{ filter_upwards [h1, ⋯, hn], exact e }`.

Combining both shortcuts is done by writing `filter_upwards [h₁, ⋯, hₙ] with a₁ a₂ ⋯ aₖ using e`.
Note that in this case, the `aᵢ` terms can be used in `e`.
-/
syntax (name := filterUpwards) "filter_upwards" (" [" term,* "]")?
  (" with" (ppSpace colGt term:max)*)? (" using " term)? : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic._aux_Mathlib_Order_Filter_Basic___elabRules_Mathlib_Tactic_filterUpwards_1
code: elab_rules : tactic
| `(tactic| filter_upwards $[[$[$args],*]]? $[with $wth*]? $[using $usingArg]?) => do
  let config : ApplyConfig := {newGoals := ApplyNewGoals.nonDependentOnly}
  for e in args.getD #[] |>.reverse do
    let goal ← getMainGoal
    replaceMainGoal <| ← goal.withContext <| runTermElab do
      let m ← mkFreshExprMVar none
      let lem ← Term.elabTermEnsuringType
        (← ``(Filter.mp_mem $e $(← Term.exprToSyntax m))) (← goal.getType)
      goal.assign lem
      return [m.mvarId!]
  liftMetaTactic fun goal => do
    goal.apply (← mkConstWithFreshMVarLevels ``Filter.univ_mem') config
  evalTactic <|← `(tactic| dsimp (config := {zeta := false}) only [Set.mem_setOf_eq])
  if let some l := wth then
    evalTactic <|← `(tactic| intro $[$l]*)
  if let some e := usingArg then
    evalTactic <|← `(tactic| exact $e)
goal: Lean.Elab.Tactic.Tactic

full_name: Filter.principal
code: /-- The principal filter of `s` is the collection of all supersets of `s`. -/
def principal (s : Set α) : Filter α 
goal: Filter α

full_name: Filter._aux_Mathlib_Order_Filter_Basic___macroRules_Filter_term𝓟_1
code: @[inherit_doc]
scoped notation "𝓟" => Filter.principal
goal: Lean.Macro

full_name: Filter._aux_Mathlib_Order_Filter_Basic___unexpand_Filter_principal_1
code: @[inherit_doc]
scoped notation "𝓟" => Filter.principal
goal: Lean.PrettyPrinter.Unexpander

full_name: Filter.mem_principal
code: @[simp] theorem mem_principal {s t : Set α} : s ∈ 𝓟 t ↔ t ⊆ s 
goal: s ∈ 𝓟 t ↔ t ⊆ s

full_name: Filter.mem_principal_self
code: theorem mem_principal_self (s : Set α) : s ∈ 𝓟 s 
goal: s ∈ 𝓟 s

full_name: Filter.join
code: /-- The join of a filter of filters is defined by the relation `s ∈ join f ↔ {t | s ∈ t} ∈ f`. -/
def join (f : Filter (Filter α)) : Filter α 
goal: Filter α

full_name: Filter.mem_join
code: @[simp]
theorem mem_join {s : Set α} {f : Filter (Filter α)} : s ∈ join f ↔ { t | s ∈ t } ∈ f 
goal: s ∈ f.join ↔ {t | s ∈ t} ∈ f

full_name: Filter.instPartialOrder
code: instance : PartialOrder (Filter α) 
goal: PartialOrder (Filter α)

full_name: Filter.le_def
code: theorem le_def : f ≤ g ↔ ∀ x ∈ g, x ∈ f 
goal: f ≤ g ↔ ∀ x ∈ g, x ∈ f

full_name: Filter.not_le
code: protected theorem not_le : ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f 
goal: ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f

full_name: Filter.GenerateSets.superset
code: /-- `GenerateSets g s`: `s` is in the filter closure of `g`. -/
inductive GenerateSets (g : Set (Set α)) : Set α → Prop
  | basic {s : Set α} : s ∈ g → GenerateSets g s
  | univ : GenerateSets g univ
  | superset {s t : Set α} : GenerateSets g s → s ⊆ t → GenerateSets g t
  | inter {s t : Set α} : GenerateSets g s → GenerateSets g t → GenerateSets g (s ∩ t)
goal: Filter.GenerateSets g s → s ⊆ t → Filter.GenerateSets g t

full_name: Filter.GenerateSets.basic
code: /-- `GenerateSets g s`: `s` is in the filter closure of `g`. -/
inductive GenerateSets (g : Set (Set α)) : Set α → Prop
  | basic {s : Set α} : s ∈ g → GenerateSets g s
  | univ : GenerateSets g univ
  | superset {s t : Set α} : GenerateSets g s → s ⊆ t → GenerateSets g t
  | inter {s t : Set α} : GenerateSets g s → GenerateSets g t → GenerateSets g (s ∩ t)
goal: s ∈ g → Filter.GenerateSets g s

full_name: Filter.GenerateSets.inter
code: /-- `GenerateSets g s`: `s` is in the filter closure of `g`. -/
inductive GenerateSets (g : Set (Set α)) : Set α → Prop
  | basic {s : Set α} : s ∈ g → GenerateSets g s
  | univ : GenerateSets g univ
  | superset {s t : Set α} : GenerateSets g s → s ⊆ t → GenerateSets g t
  | inter {s t : Set α} : GenerateSets g s → GenerateSets g t → GenerateSets g (s ∩ t)
goal: Filter.GenerateSets g s → Filter.GenerateSets g t → Filter.GenerateSets g (s ∩ t)

full_name: Filter.GenerateSets.univ
code: /-- `GenerateSets g s`: `s` is in the filter closure of `g`. -/
inductive GenerateSets (g : Set (Set α)) : Set α → Prop
  | basic {s : Set α} : s ∈ g → GenerateSets g s
  | univ : GenerateSets g univ
  | superset {s t : Set α} : GenerateSets g s → s ⊆ t → GenerateSets g t
  | inter {s t : Set α} : GenerateSets g s → GenerateSets g t → GenerateSets g (s ∩ t)
goal: Filter.GenerateSets g Set.univ

full_name: Filter.GenerateSets
code: /-- `GenerateSets g s`: `s` is in the filter closure of `g`. -/
inductive GenerateSets (g : Set (Set α)) : Set α → Prop
  | basic {s : Set α} : s ∈ g → GenerateSets g s
  | univ : GenerateSets g univ
  | superset {s t : Set α} : GenerateSets g s → s ⊆ t → GenerateSets g t
  | inter {s t : Set α} : GenerateSets g s → GenerateSets g t → GenerateSets g (s ∩ t)
goal: Set α → Prop

full_name: Filter.generate
code: /-- `generate g` is the largest filter containing the sets `g`. -/
def generate (g : Set (Set α)) : Filter α 
goal: Filter α

full_name: Filter.mem_generate_of_mem
code: lemma mem_generate_of_mem {s : Set <| Set α} {U : Set α} (h : U ∈ s) :
    U ∈ generate s 
goal: U ∈ Filter.generate s

full_name: Filter.le_generate_iff
code: theorem le_generate_iff {s : Set (Set α)} {f : Filter α} : f ≤ generate s ↔ s ⊆ f.sets 
goal: f ≤ Filter.generate s ↔ s ⊆ f.sets

full_name: Filter.mem_generate_iff
code: theorem mem_generate_iff {s : Set <| Set α} {U : Set α} :
    U ∈ generate s ↔ ∃ t ⊆ s, Set.Finite t ∧ ⋂₀ t ⊆ U 
goal: U ∈ Filter.generate s ↔ ∃ t ⊆ s, t.Finite ∧ ⋂₀ t ⊆ U

full_name: Filter.generate_singleton
code: @[simp] lemma generate_singleton (s : Set α) : generate {s} = 𝓟 s 
goal: Filter.generate {s} = 𝓟 s

full_name: Filter.mkOfClosure
code: /-- `mkOfClosure s hs` constructs a filter on `α` whose elements set is exactly
`s : Set (Set α)`, provided one gives the assumption `hs : (generate s).sets = s`. -/
protected def mkOfClosure (s : Set (Set α)) (hs : (generate s).sets = s) : Filter α 
goal: Filter α

full_name: Filter.mkOfClosure_sets
code: theorem mkOfClosure_sets {s : Set (Set α)} {hs : (generate s).sets = s} :
    Filter.mkOfClosure s hs = generate s 
goal: Filter.mkOfClosure s hs = Filter.generate s

full_name: Filter.giGenerate
code: /-- Galois insertion from sets of sets into filters. -/
def giGenerate (α : Type*) :
    @GaloisInsertion (Set (Set α)) (Filter α)ᵒᵈ _ _ Filter.generate Filter.sets 
goal: GaloisInsertion Filter.generate Filter.sets

full_name: Filter.instInf
code: /-- The infimum of filters is the filter generated by intersections
  of elements of the two filters. -/
instance : Inf (Filter α) 
goal: Inf (Filter α)

full_name: Filter.mem_inf_iff
code: theorem mem_inf_iff {f g : Filter α} {s : Set α} : s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂ 
goal: s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, s = t₁ ∩ t₂

full_name: Filter.mem_inf_of_left
code: theorem mem_inf_of_left {f g : Filter α} {s : Set α} (h : s ∈ f) : s ∈ f ⊓ g 
goal: s ∈ f ⊓ g

full_name: Filter.mem_inf_of_right
code: theorem mem_inf_of_right {f g : Filter α} {s : Set α} (h : s ∈ g) : s ∈ f ⊓ g 
goal: s ∈ f ⊓ g

full_name: Filter.inter_mem_inf
code: theorem inter_mem_inf {α : Type u} {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) :
    s ∩ t ∈ f ⊓ g 
goal: s ∩ t ∈ f ⊓ g

full_name: Filter.mem_inf_of_inter
code: 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 
goal: u ∈ f ⊓ g

full_name: Filter.mem_inf_iff_superset
code: theorem mem_inf_iff_superset {f g : Filter α} {s : Set α} :
    s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ∩ t₂ ⊆ s 
goal: s ∈ f ⊓ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ∩ t₂ ⊆ s

full_name: Filter.instTop
code: instance : Top (Filter α) 
goal: Top (Filter α)

full_name: Filter.mem_top_iff_forall
code: theorem mem_top_iff_forall {s : Set α} : s ∈ (⊤ : Filter α) ↔ ∀ x, x ∈ s 
goal: s ∈ ⊤ ↔ ∀ (x : α), x ∈ s

full_name: Filter.mem_top
code: @[simp]
theorem mem_top {s : Set α} : s ∈ (⊤ : Filter α) ↔ s = univ 
goal: s ∈ ⊤ ↔ s = Set.univ

full_name: Filter.instCompleteLatticeFilter
code: instance instCompleteLatticeFilter : CompleteLattice (Filter α) 
goal: CompleteLattice (Filter α)

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

full_name: Filter.NeBot
code: /-- A filter is `NeBot` if it is not equal to `⊥`, or equivalently the empty set does not belong to
the filter. Bourbaki include this assumption in the definition of a filter but we prefer to have a
`CompleteLattice` structure on `Filter _`, so we use a typeclass argument in lemmas instead. -/
class NeBot (f : Filter α) : Prop where
  /-- The filter is nontrivial: `f ≠ ⊥` or equivalently, `∅ ∉ f`. -/
  ne' : f ≠ ⊥
goal: Prop

full_name: Filter.NeBot.ne'
code: /-- A filter is `NeBot` if it is not equal to `⊥`, or equivalently the empty set does not belong to
the filter. Bourbaki include this assumption in the definition of a filter but we prefer to have a
`CompleteLattice` structure on `Filter _`, so we use a typeclass argument in lemmas instead. -/
class NeBot (f : Filter α) : Prop where
  /-- The filter is nontrivial: `f ≠ ⊥` or equivalently, `∅ ∉ f`. -/
  ne' : f ≠ ⊥
goal: f ≠ ⊥

full_name: Filter.neBot_iff
code: theorem neBot_iff {f : Filter α} : NeBot f ↔ f ≠ ⊥ 
goal: f.NeBot ↔ f ≠ ⊥

full_name: Filter.NeBot.ne
code: theorem NeBot.ne {f : Filter α} (hf : NeBot f) : f ≠ ⊥ 
goal: f ≠ ⊥

full_name: Filter.not_neBot
code: @[simp] theorem not_neBot {f : Filter α} : ¬f.NeBot ↔ f = ⊥ 
goal: ¬f.NeBot ↔ f = ⊥

full_name: Filter.NeBot.mono
code: theorem NeBot.mono {f g : Filter α} (hf : NeBot f) (hg : f ≤ g) : NeBot g 
goal: g.NeBot

full_name: Filter.neBot_of_le
code: theorem neBot_of_le {f g : Filter α} [hf : NeBot f] (hg : f ≤ g) : NeBot g 
goal: g.NeBot

full_name: Filter.sup_neBot
code: @[simp] theorem sup_neBot {f g : Filter α} : NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g 
goal: (f ⊔ g).NeBot ↔ f.NeBot ∨ g.NeBot

full_name: Filter.not_disjoint_self_iff
code: theorem not_disjoint_self_iff : ¬Disjoint f f ↔ f.NeBot 
goal: ¬Disjoint f f ↔ f.NeBot

full_name: Filter.bot_sets_eq
code: theorem bot_sets_eq : (⊥ : Filter α).sets = univ 
goal: ⊥.sets = Set.univ

full_name: Filter.eq_or_neBot
code: /-- Either `f = ⊥` or `Filter.NeBot f`. This is a version of `eq_or_ne` that uses `Filter.NeBot`
as the second alternative, to be used as an instance. -/
theorem eq_or_neBot (f : Filter α) : f = ⊥ ∨ NeBot f 
goal: f = ⊥ ∨ f.NeBot

full_name: Filter.sup_sets_eq
code: theorem sup_sets_eq {f g : Filter α} : (f ⊔ g).sets = f.sets ∩ g.sets 
goal: (f ⊔ g).sets = f.sets ∩ g.sets

full_name: Filter.sSup_sets_eq
code: theorem sSup_sets_eq {s : Set (Filter α)} : (sSup s).sets = ⋂ f ∈ s, (f : Filter α).sets 
goal: (sSup s).sets = ⋂ f ∈ s, f.sets

full_name: Filter.iSup_sets_eq
code: theorem iSup_sets_eq {f : ι → Filter α} : (iSup f).sets = ⋂ i, (f i).sets 
goal: (iSup f).sets = ⋂ i, (f i).sets

full_name: Filter.generate_empty
code: theorem generate_empty : Filter.generate ∅ = (⊤ : Filter α) 
goal: Filter.generate ∅ = ⊤

full_name: Filter.generate_univ
code: theorem generate_univ : Filter.generate univ = (⊥ : Filter α) 
goal: Filter.generate Set.univ = ⊥

full_name: Filter.generate_union
code: theorem generate_union {s t : Set (Set α)} :
    Filter.generate (s ∪ t) = Filter.generate s ⊓ Filter.generate t 
goal: Filter.generate (s ∪ t) = Filter.generate s ⊓ Filter.generate t

full_name: Filter.generate_iUnion
code: theorem generate_iUnion {s : ι → Set (Set α)} :
    Filter.generate (⋃ i, s i) = ⨅ i, Filter.generate (s i) 
goal: Filter.generate (⋃ i, s i) = ⨅ i, Filter.generate (s i)

full_name: Filter.mem_bot
code: @[simp]
theorem mem_bot {s : Set α} : s ∈ (⊥ : Filter α) 
goal: s ∈ ⊥

full_name: Filter.mem_sup
code: @[simp]
theorem mem_sup {f g : Filter α} {s : Set α} : s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g 
goal: s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g

full_name: Filter.union_mem_sup
code: theorem union_mem_sup {f g : Filter α} {s t : Set α} (hs : s ∈ f) (ht : t ∈ g) : s ∪ t ∈ f ⊔ g 
goal: s ∪ t ∈ f ⊔ g

full_name: Filter.mem_sSup
code: @[simp]
theorem mem_sSup {x : Set α} {s : Set (Filter α)} : x ∈ sSup s ↔ ∀ f ∈ s, x ∈ (f : Filter α) 
goal: x ∈ sSup s ↔ ∀ f ∈ s, x ∈ f

full_name: Filter.mem_iSup
code: @[simp]
theorem mem_iSup {x : Set α} {f : ι → Filter α} : x ∈ iSup f ↔ ∀ i, x ∈ f i 
goal: x ∈ iSup f ↔ ∀ (i : ι), x ∈ f i

full_name: Filter.iSup_neBot
code: @[simp]
theorem iSup_neBot {f : ι → Filter α} : (⨆ i, f i).NeBot ↔ ∃ i, (f i).NeBot 
goal: (⨆ i, f i).NeBot ↔ ∃ i, (f i).NeBot

full_name: Filter.iInf_eq_generate
code: theorem iInf_eq_generate (s : ι → Filter α) : iInf s = generate (⋃ i, (s i).sets) 
goal: iInf s = Filter.generate (⋃ i, (s i).sets)

full_name: Filter.mem_iInf_of_mem
code: theorem mem_iInf_of_mem {f : ι → Filter α} (i : ι) {s} (hs : s ∈ f i) : s ∈ ⨅ i, f i 
goal: s ∈ ⨅ i, f i

full_name: Filter.mem_iInf_of_iInter
code: 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 
goal: U ∈ ⨅ i, s i

full_name: Filter.mem_iInf
code: 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 
goal: U ∈ ⨅ i, s i ↔ ∃ I, I.Finite ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ i, V i

full_name: Filter.mem_iInf'
code: 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 
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

full_name: Filter.exists_iInter_of_mem_iInf
code: 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 
goal: ∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ i, t i

full_name: Filter.mem_iInf_of_finite
code: 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 
goal: s ∈ ⨅ i, f i ↔ ∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ i, t i

full_name: Filter.le_principal_iff
code: @[simp]
theorem le_principal_iff {s : Set α} {f : Filter α} : f ≤ 𝓟 s ↔ s ∈ f 
goal: f ≤ 𝓟 s ↔ s ∈ f

full_name: Filter.Iic_principal
code: theorem Iic_principal (s : Set α) : Iic (𝓟 s) = { l | s ∈ l } 
goal: Set.Iic (𝓟 s) = {l | s ∈ l}

full_name: Filter.principal_mono
code: theorem principal_mono {s t : Set α} : 𝓟 s ≤ 𝓟 t ↔ s ⊆ t 
goal: 𝓟 s ≤ 𝓟 t ↔ s ⊆ t

full_name: Filter.monotone_principal
code: @[mono]
theorem monotone_principal : Monotone (𝓟 : Set α → Filter α) 
goal: Monotone 𝓟

full_name: Filter.principal_eq_iff_eq
code: @[simp] theorem principal_eq_iff_eq {s t : Set α} : 𝓟 s = 𝓟 t ↔ s = t 
goal: 𝓟 s = 𝓟 t ↔ s = t

full_name: Filter.join_principal_eq_sSup
code: @[simp] theorem join_principal_eq_sSup {s : Set (Filter α)} : join (𝓟 s) = sSup s 
goal: (𝓟 s).join = sSup s

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

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

full_name: Filter.generate_eq_biInf
code: theorem generate_eq_biInf (S : Set (Set α)) : generate S = ⨅ s ∈ S, 𝓟 s 
goal: Filter.generate S = ⨅ s ∈ S, 𝓟 s

full_name: Filter.empty_mem_iff_bot
code: theorem empty_mem_iff_bot {f : Filter α} : ∅ ∈ f ↔ f = ⊥ 
goal: ∅ ∈ f ↔ f = ⊥

full_name: Filter.nonempty_of_mem
code: theorem nonempty_of_mem {f : Filter α} [hf : NeBot f] {s : Set α} (hs : s ∈ f) : s.Nonempty 
goal: s.Nonempty

full_name: Filter.NeBot.nonempty_of_mem
code: theorem NeBot.nonempty_of_mem {f : Filter α} (hf : NeBot f) {s : Set α} (hs : s ∈ f) : s.Nonempty 
goal: s.Nonempty

full_name: Filter.empty_not_mem
code: @[simp]
theorem empty_not_mem (f : Filter α) [NeBot f] : ¬∅ ∈ f 
goal: ∅ ∉ f

full_name: Filter.nonempty_of_neBot
code: theorem nonempty_of_neBot (f : Filter α) [NeBot f] : Nonempty α 
goal: Nonempty α

full_name: Filter.compl_not_mem
code: theorem compl_not_mem {f : Filter α} {s : Set α} [NeBot f] (h : s ∈ f) : sᶜ ∉ f 
goal: sᶜ ∉ f

full_name: Filter.filter_eq_bot_of_isEmpty
code: theorem filter_eq_bot_of_isEmpty [IsEmpty α] (f : Filter α) : f = ⊥ 
goal: f = ⊥

full_name: Filter.disjoint_iff
code: protected lemma disjoint_iff {f g : Filter α} : Disjoint f g ↔ ∃ s ∈ f, ∃ t ∈ g, Disjoint s t 
goal: Disjoint f g ↔ ∃ s ∈ f, ∃ t ∈ g, Disjoint s t

full_name: Filter.disjoint_of_disjoint_of_mem
code: 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 
goal: Disjoint f g

full_name: Filter.NeBot.not_disjoint
code: theorem NeBot.not_disjoint (hf : f.NeBot) (hs : s ∈ f) (ht : t ∈ f) : ¬Disjoint s t 
goal: ¬Disjoint s t

full_name: Filter.inf_eq_bot_iff
code: theorem inf_eq_bot_iff {f g : Filter α} : f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V ∈ g, U ∩ V = ∅ 
goal: f ⊓ g = ⊥ ↔ ∃ U ∈ f, ∃ V ∈ g, U ∩ V = ∅

full_name: Pairwise.exists_mem_filter_of_disjoint
code: 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) 
goal: ∃ s, (∀ (i : ι), s i ∈ l i) ∧ Pairwise (Disjoint on s)

full_name: Set.PairwiseDisjoint.exists_mem_filter
code: 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 
goal: ∃ s, (∀ (i : ι), s i ∈ l i) ∧ t.PairwiseDisjoint s

full_name: Filter.unique
code: /-- There is exactly one filter on an empty type. -/
instance unique [IsEmpty α] : Unique (Filter α) 
goal: Unique (Filter α)

full_name: Filter.NeBot.nonempty
code: theorem NeBot.nonempty (f : Filter α) [hf : f.NeBot] : Nonempty α 
goal: Nonempty α

full_name: Filter.eq_top_of_neBot
code: /-- There are only two filters on a `Subsingleton`: `⊥` and `⊤`. If the type is empty, then they are
equal. -/
theorem eq_top_of_neBot [Subsingleton α] (l : Filter α) [NeBot l] : l = ⊤ 
goal: l = ⊤

full_name: Filter.forall_mem_nonempty_iff_neBot
code: theorem forall_mem_nonempty_iff_neBot {f : Filter α} :
    (∀ s : Set α, s ∈ f → s.Nonempty) ↔ NeBot f 
goal: (∀ s ∈ f, s.Nonempty) ↔ f.NeBot

full_name: Filter.instNontrivialFilter
code: instance instNontrivialFilter [Nonempty α] : Nontrivial (Filter α) 
goal: Nontrivial (Filter α)

full_name: Filter.nontrivial_iff_nonempty
code: theorem nontrivial_iff_nonempty : Nontrivial (Filter α) ↔ Nonempty α 
goal: Nontrivial (Filter α) ↔ Nonempty α

full_name: Filter.eq_sInf_of_mem_iff_exists_mem
code: theorem eq_sInf_of_mem_iff_exists_mem {S : Set (Filter α)} {l : Filter α}
    (h : ∀ {s}, s ∈ l ↔ ∃ f ∈ S, s ∈ f) : l = sInf S 
goal: l = sInf S

full_name: Filter.eq_iInf_of_mem_iff_exists_mem
code: theorem eq_iInf_of_mem_iff_exists_mem {f : ι → Filter α} {l : Filter α}
    (h : ∀ {s}, s ∈ l ↔ ∃ i, s ∈ f i) : l = iInf f 
goal: l = iInf f

full_name: Filter.eq_biInf_of_mem_iff_exists_mem
code: 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 
goal: l = ⨅ i, ⨅ (_ : p i), f i

full_name: Filter.iInf_sets_eq
code: theorem iInf_sets_eq {f : ι → Filter α} (h : Directed (· ≥ ·) f) [ne : Nonempty ι] :
    (iInf f).sets = ⋃ i, (f i).sets 
goal: (iInf f).sets = ⋃ i, (f i).sets

full_name: Filter.mem_iInf_of_directed
code: theorem mem_iInf_of_directed {f : ι → Filter α} (h : Directed (· ≥ ·) f) [Nonempty ι] (s) :
    s ∈ iInf f ↔ ∃ i, s ∈ f i 
goal: s ∈ iInf f ↔ ∃ i, s ∈ f i

full_name: Filter.mem_biInf_of_directed
code: 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 
goal: t ∈ ⨅ i ∈ s, f i ↔ ∃ i ∈ s, t ∈ f i

full_name: Filter.biInf_sets_eq
code: 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 
goal: (⨅ i ∈ s, f i).sets = ⋃ i ∈ s, (f i).sets

full_name: Filter.iInf_sets_eq_finite
code: theorem iInf_sets_eq_finite {ι : Type*} (f : ι → Filter α) :
    (⨅ i, f i).sets = ⋃ t : Finset ι, (⨅ i ∈ t, f i).sets 
goal: (⨅ i, f i).sets = ⋃ t, (⨅ i ∈ t, f i).sets

full_name: Filter.iInf_sets_eq_finite'
code: theorem iInf_sets_eq_finite' (f : ι → Filter α) :
    (⨅ i, f i).sets = ⋃ t : Finset (PLift ι), (⨅ i ∈ t, f (PLift.down i)).sets 
goal: (⨅ i, f i).sets = ⋃ t, (⨅ i ∈ t, f i.down).sets

full_name: Filter.mem_iInf_finite
code: theorem mem_iInf_finite {ι : Type*} {f : ι → Filter α} (s) :
    s ∈ iInf f ↔ ∃ t : Finset ι, s ∈ ⨅ i ∈ t, f i 
goal: s ∈ iInf f ↔ ∃ t, s ∈ ⨅ i ∈ t, f i

full_name: Filter.mem_iInf_finite'
code: theorem mem_iInf_finite' {f : ι → Filter α} (s) :
    s ∈ iInf f ↔ ∃ t : Finset (PLift ι), s ∈ ⨅ i ∈ t, f (PLift.down i) 
goal: s ∈ iInf f ↔ ∃ t, s ∈ ⨅ i ∈ t, f i.down

full_name: Filter.sup_join
code: @[simp]
theorem sup_join {f₁ f₂ : Filter (Filter α)} : join f₁ ⊔ join f₂ = join (f₁ ⊔ f₂) 
goal: f₁.join ⊔ f₂.join = (f₁ ⊔ f₂).join

full_name: Filter.iSup_join
code: @[simp]
theorem iSup_join {ι : Sort w} {f : ι → Filter (Filter α)} : ⨆ x, join (f x) = join (⨆ x, f x) 
goal: ⨆ x, (f x).join = (⨆ x, f x).join

full_name: Filter.instDistribLattice
code: instance : DistribLattice (Filter α) 
goal: DistribLattice (Filter α)

full_name: Filter.coframeMinimalAxioms
code: /-- The dual version does not hold! `Filter α` is not a `CompleteDistribLattice`. -/
def coframeMinimalAxioms : Coframe.MinimalAxioms (Filter α) 
goal: Order.Coframe.MinimalAxioms (Filter α)

full_name: Filter.instCoframe
code: instance instCoframe : Coframe (Filter α) 
goal: Order.Coframe (Filter α)

full_name: Filter.mem_iInf_finset
code: 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 
goal: t ∈ ⨅ a ∈ s, f a ↔ ∃ p, (∀ a ∈ s, p a ∈ f a) ∧ t = ⋂ a ∈ s, p a

full_name: Filter.iInf_neBot_of_directed'
code: /-- If `f : ι → Filter α` is directed, `ι` is not empty, and `∀ i, f i ≠ ⊥`, then `iInf f ≠ ⊥`.
See also `iInf_neBot_of_directed` for a version assuming `Nonempty α` instead of `Nonempty ι`. -/
theorem iInf_neBot_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
    (∀ i, NeBot (f i)) → NeBot (iInf f) 
goal: (∀ (i : ι), (f i).NeBot) → (iInf f).NeBot

full_name: Filter.iInf_neBot_of_directed
code: /-- If `f : ι → Filter α` is directed, `α` is not empty, and `∀ i, f i ≠ ⊥`, then `iInf f ≠ ⊥`.
See also `iInf_neBot_of_directed'` for a version assuming `Nonempty ι` instead of `Nonempty α`. -/
theorem iInf_neBot_of_directed {f : ι → Filter α} [hn : Nonempty α] (hd : Directed (· ≥ ·) f)
    (hb : ∀ i, NeBot (f i)) : NeBot (iInf f) 
goal: (iInf f).NeBot

full_name: Filter.sInf_neBot_of_directed'
code: theorem sInf_neBot_of_directed' {s : Set (Filter α)} (hne : s.Nonempty) (hd : DirectedOn (· ≥ ·) s)
    (hbot : ⊥ ∉ s) : NeBot (sInf s) 
goal: (sInf s).NeBot

full_name: Filter.sInf_neBot_of_directed
code: theorem sInf_neBot_of_directed [Nonempty α] {s : Set (Filter α)} (hd : DirectedOn (· ≥ ·) s)
    (hbot : ⊥ ∉ s) : NeBot (sInf s) 
goal: (sInf s).NeBot

full_name: Filter.iInf_neBot_iff_of_directed'
code: theorem iInf_neBot_iff_of_directed' {f : ι → Filter α} [Nonempty ι] (hd : Directed (· ≥ ·) f) :
    NeBot (iInf f) ↔ ∀ i, NeBot (f i) 
goal: (iInf f).NeBot ↔ ∀ (i : ι), (f i).NeBot

full_name: Filter.iInf_neBot_iff_of_directed
code: theorem iInf_neBot_iff_of_directed {f : ι → Filter α} [Nonempty α] (hd : Directed (· ≥ ·) f) :
    NeBot (iInf f) ↔ ∀ i, NeBot (f i) 
goal: (iInf f).NeBot ↔ ∀ (i : ι), (f i).NeBot

full_name: Filter.iInf_sets_induct
code: @[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 
goal: p s

full_name: Filter.inf_principal
code: @[simp]
theorem inf_principal {s t : Set α} : 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t) 
goal: 𝓟 s ⊓ 𝓟 t = 𝓟 (s ∩ t)

full_name: Filter.sup_principal
code: @[simp]
theorem sup_principal {s t : Set α} : 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t) 
goal: 𝓟 s ⊔ 𝓟 t = 𝓟 (s ∪ t)

full_name: Filter.iSup_principal
code: @[simp]
theorem iSup_principal {ι : Sort w} {s : ι → Set α} : ⨆ x, 𝓟 (s x) = 𝓟 (⋃ i, s i) 
goal: ⨆ x, 𝓟 (s x) = 𝓟 (⋃ i, s i)

full_name: Filter.principal_eq_bot_iff
code: @[simp]
theorem principal_eq_bot_iff {s : Set α} : 𝓟 s = ⊥ ↔ s = ∅ 
goal: 𝓟 s = ⊥ ↔ s = ∅

full_name: Filter.principal_neBot_iff
code: @[simp]
theorem principal_neBot_iff {s : Set α} : NeBot (𝓟 s) ↔ s.Nonempty 
goal: (𝓟 s).NeBot ↔ s.Nonempty

full_name: Filter.isCompl_principal
code: theorem isCompl_principal (s : Set α) : IsCompl (𝓟 s) (𝓟 sᶜ) 
goal: IsCompl (𝓟 s) (𝓟 sᶜ)

full_name: Filter.mem_inf_principal'
code: theorem mem_inf_principal' {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f 
goal: s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f

full_name: Filter.mem_inf_principal
code: lemma mem_inf_principal {f : Filter α} {s t : Set α} : s ∈ f ⊓ 𝓟 t ↔ { x | x ∈ t → x ∈ s } ∈ f 
goal: s ∈ f ⊓ 𝓟 t ↔ {x | x ∈ t → x ∈ s} ∈ f

full_name: Filter.iSup_inf_principal
code: lemma iSup_inf_principal (f : ι → Filter α) (s : Set α) : ⨆ i, f i ⊓ 𝓟 s = (⨆ i, f i) ⊓ 𝓟 s 
goal: ⨆ i, f i ⊓ 𝓟 s = (⨆ i, f i) ⊓ 𝓟 s

full_name: Filter.inf_principal_eq_bot
code: theorem inf_principal_eq_bot {f : Filter α} {s : Set α} : f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f 
goal: f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f

full_name: Filter.mem_of_eq_bot
code: theorem mem_of_eq_bot {f : Filter α} {s : Set α} (h : f ⊓ 𝓟 sᶜ = ⊥) : s ∈ f 
goal: s ∈ f

full_name: Filter.diff_mem_inf_principal_compl
code: theorem diff_mem_inf_principal_compl {f : Filter α} {s : Set α} (hs : s ∈ f) (t : Set α) :
    s \ t ∈ f ⊓ 𝓟 tᶜ 
goal: s \ t ∈ f ⊓ 𝓟 tᶜ

full_name: Filter.principal_le_iff
code: theorem principal_le_iff {s : Set α} {f : Filter α} : 𝓟 s ≤ f ↔ ∀ V ∈ f, s ⊆ V 
goal: 𝓟 s ≤ f ↔ ∀ V ∈ f, s ⊆ V

full_name: Filter.iInf_principal_finset
code: @[simp]
theorem iInf_principal_finset {ι : Type w} (s : Finset ι) (f : ι → Set α) :
    ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i) 
goal: ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i)

full_name: Filter.iInf_principal
code: theorem iInf_principal {ι : Sort w} [Finite ι] (f : ι → Set α) : ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i) 
goal: ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i)

full_name: Filter.iInf_principal'
code: /-- A special case of `iInf_principal` that is safe to mark `simp`. -/
@[simp]
theorem iInf_principal' {ι : Type w} [Finite ι] (f : ι → Set α) : ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i) 
goal: ⨅ i, 𝓟 (f i) = 𝓟 (⋂ i, f i)

full_name: Filter.iInf_principal_finite
code: theorem iInf_principal_finite {ι : Type w} {s : Set ι} (hs : s.Finite) (f : ι → Set α) :
    ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i) 
goal: ⨅ i ∈ s, 𝓟 (f i) = 𝓟 (⋂ i ∈ s, f i)

full_name: Filter.join_mono
code: @[mono, gcongr]
theorem join_mono {f₁ f₂ : Filter (Filter α)} (h : f₁ ≤ f₂) : join f₁ ≤ join f₂ 
goal: f₁.join ≤ f₂.join

full_name: Filter.Eventually
code: /-- `f.Eventually p` or `∀ᶠ x in f, p x` mean that `{x | p x} ∈ f`. E.g., `∀ᶠ x in atTop, p x`
means that `p` holds true for sufficiently large `x`. -/
protected def Eventually (p : α → Prop) (f : Filter α) : Prop 
goal: Prop

full_name: Filter.«_aux_Mathlib_Order_Filter_Basic___macroRules_Filter_term∀ᶠ_In_,__1»
code: @[inherit_doc Filter.Eventually]
notation3 "∀ᶠ "(...)" in "f", "r:(scoped p => Filter.Eventually p f) => r
goal: Lean.Macro

full_name: Filter.eventually_iff
code: theorem eventually_iff {f : Filter α} {P : α → Prop} : (∀ᶠ x in f, P x) ↔ { x | P x } ∈ f 
goal: (∀ᶠ (x : α) in f, P x) ↔ {x | P x} ∈ f

full_name: Filter.eventually_mem_set
code: @[simp]
theorem eventually_mem_set {s : Set α} {l : Filter α} : (∀ᶠ x in l, x ∈ s) ↔ s ∈ l 
goal: (∀ᶠ (x : α) in l, x ∈ s) ↔ s ∈ l

full_name: Filter.ext'
code: protected theorem ext' {f₁ f₂ : Filter α}
    (h : ∀ p : α → Prop, (∀ᶠ x in f₁, p x) ↔ ∀ᶠ x in f₂, p x) : f₁ = f₂ 
goal: f₁ = f₂

full_name: Filter.Eventually.filter_mono
code: theorem Eventually.filter_mono {f₁ f₂ : Filter α} (h : f₁ ≤ f₂) {p : α → Prop}
    (hp : ∀ᶠ x in f₂, p x) : ∀ᶠ x in f₁, p x 
goal: ∀ᶠ (x : α) in f₁, p x

full_name: Filter.eventually_of_mem
code: theorem eventually_of_mem {f : Filter α} {P : α → Prop} {U : Set α} (hU : U ∈ f)
    (h : ∀ x ∈ U, P x) : ∀ᶠ x in f, P x 
goal: ∀ᶠ (x : α) in f, P x

full_name: Filter.Eventually.and
code: protected theorem Eventually.and {p q : α → Prop} {f : Filter α} :
    f.Eventually p → f.Eventually q → ∀ᶠ x in f, p x ∧ q x 
goal: Filter.Eventually p f → Filter.Eventually q f → ∀ᶠ (x : α) in f, p x ∧ q x

full_name: Filter.eventually_true
code: @[simp] theorem eventually_true (f : Filter α) : ∀ᶠ _ in f, True 
goal: ∀ᶠ (x : α) in f, True

full_name: Filter.eventually_of_forall
code: theorem eventually_of_forall {p : α → Prop} {f : Filter α} (hp : ∀ x, p x) : ∀ᶠ x in f, p x 
goal: ∀ᶠ (x : α) in f, p x

full_name: Filter.eventually_false_iff_eq_bot
code: @[simp]
theorem eventually_false_iff_eq_bot {f : Filter α} : (∀ᶠ _ in f, False) ↔ f = ⊥ 
goal: (∀ᶠ (x : α) in f, False) ↔ f = ⊥

full_name: Filter.eventually_const
code: @[simp]
theorem eventually_const {f : Filter α} [t : NeBot f] {p : Prop} : (∀ᶠ _ in f, p) ↔ p 
goal: (∀ᶠ (x : α) in f, p) ↔ p

full_name: Filter.eventually_iff_exists_mem
code: theorem eventually_iff_exists_mem {p : α → Prop} {f : Filter α} :
    (∀ᶠ x in f, p x) ↔ ∃ v ∈ f, ∀ y ∈ v, p y 
goal: (∀ᶠ (x : α) in f, p x) ↔ ∃ v ∈ f, ∀ y ∈ v, p y

full_name: Filter.Eventually.exists_mem
code: theorem Eventually.exists_mem {p : α → Prop} {f : Filter α} (hp : ∀ᶠ x in f, p x) :
    ∃ v ∈ f, ∀ y ∈ v, p y 
goal: ∃ v ∈ f, ∀ y ∈ v, p y

full_name: Filter.Eventually.mp
code: 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 
goal: ∀ᶠ (x : α) in f, q x

full_name: Filter.Eventually.mono
code: 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 
goal: ∀ᶠ (x : α) in f, q x

full_name: Filter.forall_eventually_of_eventually_forall
code: 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 
goal: ∀ᶠ (x : α) in f, p x y

full_name: Filter.eventually_and
code: @[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 
goal: (∀ᶠ (x : α) in f, p x ∧ q x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x

full_name: Filter.Eventually.congr
code: 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 
goal: ∀ᶠ (x : α) in f, q x

full_name: Filter.eventually_congr
code: 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 
goal: (∀ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, q x

full_name: Filter.eventually_all
code: @[simp]
theorem eventually_all {ι : Sort*} [Finite ι] {l} {p : ι → α → Prop} :
    (∀ᶠ x in l, ∀ i, p i x) ↔ ∀ i, ∀ᶠ x in l, p i x 
goal: (∀ᶠ (x : α) in l, ∀ (i : ι), p i x) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p i x

full_name: Filter.eventually_all_finite
code: @[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 
goal: (∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x

full_name: Filter.eventually_all_finset
code: @[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 
goal: (∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) ↔ ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x

full_name: Filter.eventually_or_distrib_left
code: @[simp]
theorem eventually_or_distrib_left {f : Filter α} {p : Prop} {q : α → Prop} :
    (∀ᶠ x in f, p ∨ q x) ↔ p ∨ ∀ᶠ x in f, q x 
goal: (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x

full_name: Filter.eventually_or_distrib_right
code: @[simp]
theorem eventually_or_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :
    (∀ᶠ x in f, p x ∨ q) ↔ (∀ᶠ x in f, p x) ∨ q 
goal: (∀ᶠ (x : α) in f, p x ∨ q) ↔ (∀ᶠ (x : α) in f, p x) ∨ q

full_name: Filter.eventually_imp_distrib_left
code: theorem eventually_imp_distrib_left {f : Filter α} {p : Prop} {q : α → Prop} :
    (∀ᶠ x in f, p → q x) ↔ p → ∀ᶠ x in f, q x 
goal: (∀ᶠ (x : α) in f, p → q x) ↔ p → ∀ᶠ (x : α) in f, q x

full_name: Filter.eventually_bot
code: @[simp]
theorem eventually_bot {p : α → Prop} : ∀ᶠ x in ⊥, p x 
goal: ∀ᶠ (x : α) in ⊥, p x

full_name: Filter.eventually_top
code: @[simp]
theorem eventually_top {p : α → Prop} : (∀ᶠ x in ⊤, p x) ↔ ∀ x, p x 
goal: (∀ᶠ (x : α) in ⊤, p x) ↔ ∀ (x : α), p x

full_name: Filter.eventually_sup
code: @[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 
goal: (∀ᶠ (x : α) in f ⊔ g, p x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in g, p x

full_name: Filter.eventually_sSup
code: @[simp]
theorem eventually_sSup {p : α → Prop} {fs : Set (Filter α)} :
    (∀ᶠ x in sSup fs, p x) ↔ ∀ f ∈ fs, ∀ᶠ x in f, p x 
goal: (∀ᶠ (x : α) in sSup fs, p x) ↔ ∀ f ∈ fs, ∀ᶠ (x : α) in f, p x

full_name: Filter.eventually_iSup
code: @[simp]
theorem eventually_iSup {p : α → Prop} {fs : ι → Filter α} :
    (∀ᶠ x in ⨆ b, fs b, p x) ↔ ∀ b, ∀ᶠ x in fs b, p x 
goal: (∀ᶠ (x : α) in ⨆ b, fs b, p x) ↔ ∀ (b : ι), ∀ᶠ (x : α) in fs b, p x

full_name: Filter.eventually_principal
code: @[simp]
theorem eventually_principal {a : Set α} {p : α → Prop} : (∀ᶠ x in 𝓟 a, p x) ↔ ∀ x ∈ a, p x 
goal: (∀ᶠ (x : α) in 𝓟 a, p x) ↔ ∀ x ∈ a, p x

full_name: Filter.Eventually.forall_mem
code: theorem Eventually.forall_mem {α : Type*} {f : Filter α} {s : Set α} {P : α → Prop}
    (hP : ∀ᶠ x in f, P x) (hf : 𝓟 s ≤ f) : ∀ x ∈ s, P x 
goal: x ∈ s → P x

full_name: Filter.eventually_inf
code: theorem eventually_inf {f g : Filter α} {p : α → Prop} :
    (∀ᶠ x in f ⊓ g, p x) ↔ ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x 
goal: (∀ᶠ (x : α) in f ⊓ g, p x) ↔ ∃ s ∈ f, ∃ t ∈ g, ∀ x ∈ s ∩ t, p x

full_name: Filter.eventually_inf_principal
code: theorem eventually_inf_principal {f : Filter α} {p : α → Prop} {s : Set α} :
    (∀ᶠ x in f ⊓ 𝓟 s, p x) ↔ ∀ᶠ x in f, x ∈ s → p x 
goal: (∀ᶠ (x : α) in f ⊓ 𝓟 s, p x) ↔ ∀ᶠ (x : α) in f, x ∈ s → p x

full_name: Filter.Frequently
code: /-- `f.Frequently p` or `∃ᶠ x in f, p x` mean that `{x | ¬p x} ∉ f`. E.g., `∃ᶠ x in atTop, p x`
means that there exist arbitrarily large `x` for which `p` holds true. -/
protected def Frequently (p : α → Prop) (f : Filter α) : Prop 
goal: Prop

full_name: Filter.«_aux_Mathlib_Order_Filter_Basic___macroRules_Filter_term∃ᶠ_In_,__1»
code: @[inherit_doc Filter.Frequently]
notation3 "∃ᶠ "(...)" in "f", "r:(scoped p => Filter.Frequently p f) => r
goal: Lean.Macro

full_name: Filter.Eventually.frequently
code: theorem Eventually.frequently {f : Filter α} [NeBot f] {p : α → Prop} (h : ∀ᶠ x in f, p x) :
    ∃ᶠ x in f, p x 
goal: ∃ᶠ (x : α) in f, p x

full_name: Filter.frequently_of_forall
code: theorem frequently_of_forall {f : Filter α} [NeBot f] {p : α → Prop} (h : ∀ x, p x) :
    ∃ᶠ x in f, p x 
goal: ∃ᶠ (x : α) in f, p x

full_name: Filter.Frequently.mp
code: 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 
goal: ∃ᶠ (x : α) in f, q x

full_name: Filter.Frequently.filter_mono
code: theorem Frequently.filter_mono {p : α → Prop} {f g : Filter α} (h : ∃ᶠ x in f, p x) (hle : f ≤ g) :
    ∃ᶠ x in g, p x 
goal: ∃ᶠ (x : α) in g, p x

full_name: Filter.Frequently.mono
code: 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 
goal: ∃ᶠ (x : α) in f, q x

full_name: Filter.Frequently.and_eventually
code: 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 
goal: ∃ᶠ (x : α) in f, p x ∧ q x

full_name: Filter.Eventually.and_frequently
code: 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 
goal: ∃ᶠ (x : α) in f, p x ∧ q x

full_name: Filter.Frequently.exists
code: theorem Frequently.exists {p : α → Prop} {f : Filter α} (hp : ∃ᶠ x in f, p x) : ∃ x, p x 
goal: ∃ x, p x

full_name: Filter.Eventually.exists
code: theorem Eventually.exists {p : α → Prop} {f : Filter α} [NeBot f] (hp : ∀ᶠ x in f, p x) :
    ∃ x, p x 
goal: ∃ x, p x

full_name: Filter.frequently_iff_neBot
code: lemma frequently_iff_neBot {l : Filter α} {p : α → Prop} :
    (∃ᶠ x in l, p x) ↔ NeBot (l ⊓ 𝓟 {x | p x}) 
goal: (∃ᶠ (x : α) in l, p x) ↔ (l ⊓ 𝓟 {x | p x}).NeBot

full_name: Filter.frequently_mem_iff_neBot
code: lemma frequently_mem_iff_neBot {l : Filter α} {s : Set α} : (∃ᶠ x in l, x ∈ s) ↔ NeBot (l ⊓ 𝓟 s) 
goal: (∃ᶠ (x : α) in l, x ∈ s) ↔ (l ⊓ 𝓟 s).NeBot

full_name: Filter.frequently_iff_forall_eventually_exists_and
code: 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 
goal: (∃ᶠ (x : α) in f, p x) ↔ ∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, p x ∧ q x

full_name: Filter.frequently_iff
code: theorem frequently_iff {f : Filter α} {P : α → Prop} :
    (∃ᶠ x in f, P x) ↔ ∀ {U}, U ∈ f → ∃ x ∈ U, P x 
goal: (∃ᶠ (x : α) in f, P x) ↔ ∀ {U : Set α}, U ∈ f → ∃ x ∈ U, P x

full_name: Filter.not_eventually
code: @[simp]
theorem not_eventually {p : α → Prop} {f : Filter α} : (¬∀ᶠ x in f, p x) ↔ ∃ᶠ x in f, ¬p x 
goal: (¬∀ᶠ (x : α) in f, p x) ↔ ∃ᶠ (x : α) in f, ¬p x

full_name: Filter.not_frequently
code: @[simp]
theorem not_frequently {p : α → Prop} {f : Filter α} : (¬∃ᶠ x in f, p x) ↔ ∀ᶠ x in f, ¬p x 
goal: (¬∃ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, ¬p x

full_name: Filter.frequently_true_iff_neBot
code: @[simp]
theorem frequently_true_iff_neBot (f : Filter α) : (∃ᶠ _ in f, True) ↔ NeBot f 
goal: (∃ᶠ (x : α) in f, True) ↔ f.NeBot

full_name: Filter.frequently_false
code: @[simp]
theorem frequently_false (f : Filter α) : ¬∃ᶠ _ in f, False 
goal: ¬∃ᶠ (x : α) in f, False

full_name: Filter.frequently_const
code: @[simp]
theorem frequently_const {f : Filter α} [NeBot f] {p : Prop} : (∃ᶠ _ in f, p) ↔ p 
goal: (∃ᶠ (x : α) in f, p) ↔ p

full_name: Filter.frequently_or_distrib
code: @[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 
goal: (∃ᶠ (x : α) in f, p x ∨ q x) ↔ (∃ᶠ (x : α) in f, p x) ∨ ∃ᶠ (x : α) in f, q x

full_name: Filter.frequently_or_distrib_left
code: 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 
goal: (∃ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∃ᶠ (x : α) in f, q x

full_name: Filter.frequently_or_distrib_right
code: 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 
goal: (∃ᶠ (x : α) in f, p x ∨ q) ↔ (∃ᶠ (x : α) in f, p x) ∨ q

full_name: Filter.frequently_imp_distrib
code: 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 
goal: (∃ᶠ (x : α) in f, p x → q x) ↔ (∀ᶠ (x : α) in f, p x) → ∃ᶠ (x : α) in f, q x

full_name: Filter.frequently_imp_distrib_left
code: 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 
goal: (∃ᶠ (x : α) in f, p → q x) ↔ p → ∃ᶠ (x : α) in f, q x

full_name: Filter.frequently_imp_distrib_right
code: theorem frequently_imp_distrib_right {f : Filter α} [NeBot f] {p : α → Prop} {q : Prop} :
    (∃ᶠ x in f, p x → q) ↔ (∀ᶠ x in f, p x) → q 
goal: (∃ᶠ (x : α) in f, p x → q) ↔ (∀ᶠ (x : α) in f, p x) → q

full_name: Filter.eventually_imp_distrib_right
code: theorem eventually_imp_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :
    (∀ᶠ x in f, p x → q) ↔ (∃ᶠ x in f, p x) → q 
goal: (∀ᶠ (x : α) in f, p x → q) ↔ (∃ᶠ (x : α) in f, p x) → q

full_name: Filter.frequently_and_distrib_left
code: @[simp]
theorem frequently_and_distrib_left {f : Filter α} {p : Prop} {q : α → Prop} :
    (∃ᶠ x in f, p ∧ q x) ↔ p ∧ ∃ᶠ x in f, q x 
goal: (∃ᶠ (x : α) in f, p ∧ q x) ↔ p ∧ ∃ᶠ (x : α) in f, q x

full_name: Filter.frequently_and_distrib_right
code: @[simp]
theorem frequently_and_distrib_right {f : Filter α} {p : α → Prop} {q : Prop} :
    (∃ᶠ x in f, p x ∧ q) ↔ (∃ᶠ x in f, p x) ∧ q 
goal: (∃ᶠ (x : α) in f, p x ∧ q) ↔ (∃ᶠ (x : α) in f, p x) ∧ q

full_name: Filter.frequently_bot
code: @[simp]
theorem frequently_bot {p : α → Prop} : ¬∃ᶠ x in ⊥, p x 
goal: ¬∃ᶠ (x : α) in ⊥, p x

full_name: Filter.frequently_top
code: @[simp]
theorem frequently_top {p : α → Prop} : (∃ᶠ x in ⊤, p x) ↔ ∃ x, p x 
goal: (∃ᶠ (x : α) in ⊤, p x) ↔ ∃ x, p x

full_name: Filter.frequently_principal
code: @[simp]
theorem frequently_principal {a : Set α} {p : α → Prop} : (∃ᶠ x in 𝓟 a, p x) ↔ ∃ x ∈ a, p x 
goal: (∃ᶠ (x : α) in 𝓟 a, p x) ↔ ∃ x ∈ a, p x

full_name: Filter.frequently_inf_principal
code: theorem frequently_inf_principal {f : Filter α} {s : Set α} {p : α → Prop} :
    (∃ᶠ x in f ⊓ 𝓟 s, p x) ↔ ∃ᶠ x in f, x ∈ s ∧ p x 
goal: (∃ᶠ (x : α) in f ⊓ 𝓟 s, p x) ↔ ∃ᶠ (x : α) in f, x ∈ s ∧ p x

full_name: Filter.frequently_sup
code: theorem frequently_sup {p : α → Prop} {f g : Filter α} :
    (∃ᶠ x in f ⊔ g, p x) ↔ (∃ᶠ x in f, p x) ∨ ∃ᶠ x in g, p x 
goal: (∃ᶠ (x : α) in f ⊔ g, p x) ↔ (∃ᶠ (x : α) in f, p x) ∨ ∃ᶠ (x : α) in g, p x

full_name: Filter.frequently_sSup
code: @[simp]
theorem frequently_sSup {p : α → Prop} {fs : Set (Filter α)} :
    (∃ᶠ x in sSup fs, p x) ↔ ∃ f ∈ fs, ∃ᶠ x in f, p x 
goal: (∃ᶠ (x : α) in sSup fs, p x) ↔ ∃ f ∈ fs, ∃ᶠ (x : α) in f, p x

full_name: Filter.frequently_iSup
code: @[simp]
theorem frequently_iSup {p : α → Prop} {fs : β → Filter α} :
    (∃ᶠ x in ⨆ b, fs b, p x) ↔ ∃ b, ∃ᶠ x in fs b, p x 
goal: (∃ᶠ (x : α) in ⨆ b, fs b, p x) ↔ ∃ b, ∃ᶠ (x : α) in fs b, p x

full_name: Filter.Eventually.choice
code: theorem Eventually.choice {r : α → β → Prop} {l : Filter α} [l.NeBot] (h : ∀ᶠ x in l, ∃ y, r x y) :
    ∃ f : α → β, ∀ᶠ x in l, r x (f x) 
goal: ∃ f, ∀ᶠ (x : α) in l, r x (f x)

full_name: Filter.EventuallyEq
code: /-- Two functions `f` and `g` are *eventually equal* along a filter `l` if the set of `x` such that
`f x = g x` belongs to `l`. -/
def EventuallyEq (l : Filter α) (f g : α → β) : Prop 
goal: Prop

full_name: Filter.«_aux_Mathlib_Order_Filter_Basic___macroRules_Filter_term_=ᶠ[_]__1»
code: @[inherit_doc]
notation:50 f " =ᶠ[" l:50 "] " g:50 => EventuallyEq l f g
goal: Lean.Macro

full_name: Filter._aux_Mathlib_Order_Filter_Basic___unexpand_Filter_EventuallyEq_1
code: @[inherit_doc]
notation:50 f " =ᶠ[" l:50 "] " g:50 => EventuallyEq l f g
goal: Lean.PrettyPrinter.Unexpander

full_name: Filter.EventuallyEq.eventually
code: theorem EventuallyEq.eventually {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) :
    ∀ᶠ x in l, f x = g x 
goal: ∀ᶠ (x : α) in l, f x = g x

full_name: Filter.EventuallyEq.rw
code: theorem EventuallyEq.rw {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) (p : α → β → Prop)
    (hf : ∀ᶠ x in l, p x (f x)) : ∀ᶠ x in l, p x (g x) 
goal: ∀ᶠ (x : α) in l, p x (g x)

full_name: Filter.eventuallyEq_set
code: theorem eventuallyEq_set {s t : Set α} {l : Filter α} : s =ᶠ[l] t ↔ ∀ᶠ x in l, x ∈ s ↔ x ∈ t 
goal: s =ᶠ[l] t ↔ ∀ᶠ (x : α) in l, x ∈ s ↔ x ∈ t

full_name: Filter.eventuallyEq_univ
code: @[simp]
theorem eventuallyEq_univ {s : Set α} {l : Filter α} : s =ᶠ[l] univ ↔ s ∈ l 
goal: s =ᶠ[l] Set.univ ↔ s ∈ l

full_name: Filter.EventuallyEq.exists_mem
code: theorem EventuallyEq.exists_mem {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) :
    ∃ s ∈ l, EqOn f g s 
goal: ∃ s ∈ l, Set.EqOn f g s

full_name: Filter.eventuallyEq_of_mem
code: theorem eventuallyEq_of_mem {l : Filter α} {f g : α → β} {s : Set α} (hs : s ∈ l) (h : EqOn f g s) :
    f =ᶠ[l] g 
goal: f =ᶠ[l] g

full_name: Filter.eventuallyEq_iff_exists_mem
code: theorem eventuallyEq_iff_exists_mem {l : Filter α} {f g : α → β} :
    f =ᶠ[l] g ↔ ∃ s ∈ l, EqOn f g s 
goal: f =ᶠ[l] g ↔ ∃ s ∈ l, Set.EqOn f g s

full_name: Filter.EventuallyEq.filter_mono
code: theorem EventuallyEq.filter_mono {l l' : Filter α} {f g : α → β} (h₁ : f =ᶠ[l] g) (h₂ : l' ≤ l) :
    f =ᶠ[l'] g 
goal: f =ᶠ[l'] g

full_name: Filter.EventuallyEq.refl
code: @[refl, simp]
theorem EventuallyEq.refl (l : Filter α) (f : α → β) : f =ᶠ[l] f 
goal: f =ᶠ[l] f

full_name: Filter.EventuallyEq.rfl
code: protected theorem EventuallyEq.rfl {l : Filter α} {f : α → β} : f =ᶠ[l] f 
goal: f =ᶠ[l] f

full_name: Filter.EventuallyEq.symm
code: @[symm]
theorem EventuallyEq.symm {f g : α → β} {l : Filter α} (H : f =ᶠ[l] g) : g =ᶠ[l] f 
goal: g =ᶠ[l] f

full_name: Filter.EventuallyEq.trans
code: @[trans]
theorem EventuallyEq.trans {l : Filter α} {f g h : α → β} (H₁ : f =ᶠ[l] g) (H₂ : g =ᶠ[l] h) :
    f =ᶠ[l] h 
goal: f =ᶠ[l] h

full_name: Filter.EventuallyEq.congr_left
code: theorem EventuallyEq.congr_left {l : Filter α} {f g h : α → β} (H : f =ᶠ[l] g) :
    f =ᶠ[l] h ↔ g =ᶠ[l] h 
goal: f =ᶠ[l] h ↔ g =ᶠ[l] h

full_name: Filter.EventuallyEq.congr_right
code: theorem EventuallyEq.congr_right {l : Filter α} {f g h : α → β} (H : g =ᶠ[l] h) :
    f =ᶠ[l] g ↔ f =ᶠ[l] h 
goal: f =ᶠ[l] g ↔ f =ᶠ[l] h

full_name: Filter.instTransForallEventuallyEq
code: instance {l : Filter α} :
    Trans ((· =ᶠ[l] ·) : (α → β) → (α → β) → Prop) (· =ᶠ[l] ·) (· =ᶠ[l] ·) 
goal: Trans (fun x x_1 => x =ᶠ[l] x_1) (fun x x_1 => x =ᶠ[l] x_1) fun x x_1 => x =ᶠ[l] x_1

full_name: Filter.EventuallyEq.prod_mk
code: theorem EventuallyEq.prod_mk {l} {f f' : α → β} (hf : f =ᶠ[l] f') {g g' : α → γ} (hg : g =ᶠ[l] g') :
    (fun x => (f x, g x)) =ᶠ[l] fun x => (f' x, g' x) 
goal: (fun x => (f x, g x)) =ᶠ[l] fun x => (f' x, g' x)

full_name: Filter.EventuallyEq.fun_comp
code: theorem EventuallyEq.fun_comp {f g : α → β} {l : Filter α} (H : f =ᶠ[l] g) (h : β → γ) :
    h ∘ f =ᶠ[l] h ∘ g 
goal: h ∘ f =ᶠ[l] h ∘ g

full_name: Filter.EventuallyEq.comp₂
code: theorem EventuallyEq.comp₂ {δ} {f f' : α → β} {g g' : α → γ} {l} (Hf : f =ᶠ[l] f') (h : β → γ → δ)
    (Hg : g =ᶠ[l] g') : (fun x => h (f x) (g x)) =ᶠ[l] fun x => h (f' x) (g' x) 
goal: (fun x => h (f x) (g x)) =ᶠ[l] fun x => h (f' x) (g' x)

full_name: Filter.EventuallyEq.add
code: @[to_additive]
theorem EventuallyEq.mul [Mul β] {f f' g g' : α → β} {l : Filter α} (h : f =ᶠ[l] g)
    (h' : f' =ᶠ[l] g') : (fun x => f x * f' x) =ᶠ[l] fun x => g x * g' x 
goal: (fun x => f x + f' x) =ᶠ[l] fun x => g x + g' x

full_name: Filter.EventuallyEq.mul
code: @[to_additive]
theorem EventuallyEq.mul [Mul β] {f f' g g' : α → β} {l : Filter α} (h : f =ᶠ[l] g)
    (h' : f' =ᶠ[l] g') : (fun x => f x * f' x) =ᶠ[l] fun x => g x * g' x 
goal: (fun x => f x * f' x) =ᶠ[l] fun x => g x * g' x

full_name: Filter.EventuallyEq.pow_const
code: @[to_additive const_smul]
theorem EventuallyEq.pow_const {γ} [Pow β γ] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) (c : γ) :
    (fun x => f x ^ c) =ᶠ[l] fun x => g x ^ c 
goal: (fun x => f x ^ c) =ᶠ[l] fun x => g x ^ c

full_name: Filter.EventuallyEq.const_smul
code: @[to_additive const_smul]
theorem EventuallyEq.pow_const {γ} [Pow β γ] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) (c : γ) :
    (fun x => f x ^ c) =ᶠ[l] fun x => g x ^ c 
goal: (fun x => c • f x) =ᶠ[l] fun x => c • g x

full_name: Filter.EventuallyEq.neg
code: @[to_additive]
theorem EventuallyEq.inv [Inv β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
    (fun x => (f x)⁻¹) =ᶠ[l] fun x => (g x)⁻¹ 
goal: (fun x => -f x) =ᶠ[l] fun x => -g x

full_name: Filter.EventuallyEq.inv
code: @[to_additive]
theorem EventuallyEq.inv [Inv β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
    (fun x => (f x)⁻¹) =ᶠ[l] fun x => (g x)⁻¹ 
goal: (fun x => (f x)⁻¹) =ᶠ[l] fun x => (g x)⁻¹

full_name: Filter.EventuallyEq.sub
code: @[to_additive]
theorem EventuallyEq.div [Div β] {f f' g g' : α → β} {l : Filter α} (h : f =ᶠ[l] g)
    (h' : f' =ᶠ[l] g') : (fun x => f x / f' x) =ᶠ[l] fun x => g x / g' x 
goal: (fun x => f x - f' x) =ᶠ[l] fun x => g x - g' x

full_name: Filter.EventuallyEq.div
code: @[to_additive]
theorem EventuallyEq.div [Div β] {f f' g g' : α → β} {l : Filter α} (h : f =ᶠ[l] g)
    (h' : f' =ᶠ[l] g') : (fun x => f x / f' x) =ᶠ[l] fun x => g x / g' x 
goal: (fun x => f x / f' x) =ᶠ[l] fun x => g x / g' x

full_name: Filter.EventuallyEq.vadd
code: @[to_additive]
theorem EventuallyEq.smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f f' : α → 𝕜} {g g' : α → β}
    (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') : (fun x => f x • g x) =ᶠ[l] fun x => f' x • g' x 
goal: (fun x => f x +ᵥ g x) =ᶠ[l] fun x => f' x +ᵥ g' x

full_name: Filter.EventuallyEq.smul
code: @[to_additive]
theorem EventuallyEq.smul {𝕜} [SMul 𝕜 β] {l : Filter α} {f f' : α → 𝕜} {g g' : α → β}
    (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') : (fun x => f x • g x) =ᶠ[l] fun x => f' x • g' x 
goal: (fun x => f x • g x) =ᶠ[l] fun x => f' x • g' x

full_name: Filter.EventuallyEq.sup
code: theorem EventuallyEq.sup [Sup β] {l : Filter α} {f f' g g' : α → β} (hf : f =ᶠ[l] f')
    (hg : g =ᶠ[l] g') : (fun x => f x ⊔ g x) =ᶠ[l] fun x => f' x ⊔ g' x 
goal: (fun x => f x ⊔ g x) =ᶠ[l] fun x => f' x ⊔ g' x

full_name: Filter.EventuallyEq.inf
code: theorem EventuallyEq.inf [Inf β] {l : Filter α} {f f' g g' : α → β} (hf : f =ᶠ[l] f')
    (hg : g =ᶠ[l] g') : (fun x => f x ⊓ g x) =ᶠ[l] fun x => f' x ⊓ g' x 
goal: (fun x => f x ⊓ g x) =ᶠ[l] fun x => f' x ⊓ g' x

full_name: Filter.EventuallyEq.preimage
code: theorem EventuallyEq.preimage {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) (s : Set β) :
    f ⁻¹' s =ᶠ[l] g ⁻¹' s 
goal: f ⁻¹' s =ᶠ[l] g ⁻¹' s

full_name: Filter.EventuallyEq.inter
code: theorem EventuallyEq.inter {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
    (s ∩ s' : Set α) =ᶠ[l] (t ∩ t' : Set α) 
goal: s ∩ s' =ᶠ[l] t ∩ t'

full_name: Filter.EventuallyEq.union
code: theorem EventuallyEq.union {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
    (s ∪ s' : Set α) =ᶠ[l] (t ∪ t' : Set α) 
goal: s ∪ s' =ᶠ[l] t ∪ t'

full_name: Filter.EventuallyEq.compl
code: theorem EventuallyEq.compl {s t : Set α} {l : Filter α} (h : s =ᶠ[l] t) :
    (sᶜ : Set α) =ᶠ[l] (tᶜ : Set α) 
goal: sᶜ =ᶠ[l] tᶜ

full_name: Filter.EventuallyEq.diff
code: theorem EventuallyEq.diff {s t s' t' : Set α} {l : Filter α} (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') :
    (s \ s' : Set α) =ᶠ[l] (t \ t' : Set α) 
goal: s \ s' =ᶠ[l] t \ t'

full_name: Filter.EventuallyEq.symmDiff
code: protected theorem EventuallyEq.symmDiff {s t s' t' : Set α} {l : Filter α}
    (h : s =ᶠ[l] t) (h' : s' =ᶠ[l] t') : (s ∆ s' : Set α) =ᶠ[l] (t ∆ t' : Set α) 
goal: s ∆ s' =ᶠ[l] t ∆ t'

full_name: Filter.eventuallyEq_empty
code: theorem eventuallyEq_empty {s : Set α} {l : Filter α} : s =ᶠ[l] (∅ : Set α) ↔ ∀ᶠ x in l, x ∉ s 
goal: s =ᶠ[l] ∅ ↔ ∀ᶠ (x : α) in l, x ∉ s

full_name: Filter.inter_eventuallyEq_left
code: theorem inter_eventuallyEq_left {s t : Set α} {l : Filter α} :
    (s ∩ t : Set α) =ᶠ[l] s ↔ ∀ᶠ x in l, x ∈ s → x ∈ t 
goal: s ∩ t =ᶠ[l] s ↔ ∀ᶠ (x : α) in l, x ∈ s → x ∈ t

full_name: Filter.inter_eventuallyEq_right
code: theorem inter_eventuallyEq_right {s t : Set α} {l : Filter α} :
    (s ∩ t : Set α) =ᶠ[l] t ↔ ∀ᶠ x in l, x ∈ t → x ∈ s 
goal: s ∩ t =ᶠ[l] t ↔ ∀ᶠ (x : α) in l, x ∈ t → x ∈ s

full_name: Filter.eventuallyEq_principal
code: @[simp]
theorem eventuallyEq_principal {s : Set α} {f g : α → β} : f =ᶠ[𝓟 s] g ↔ EqOn f g s 
goal: f =ᶠ[𝓟 s] g ↔ Set.EqOn f g s

full_name: Filter.eventuallyEq_inf_principal_iff
code: theorem eventuallyEq_inf_principal_iff {F : Filter α} {s : Set α} {f g : α → β} :
    f =ᶠ[F ⊓ 𝓟 s] g ↔ ∀ᶠ x in F, x ∈ s → f x = g x 
goal: f =ᶠ[F ⊓ 𝓟 s] g ↔ ∀ᶠ (x : α) in F, x ∈ s → f x = g x

full_name: Filter.EventuallyEq.sub_eq
code: theorem EventuallyEq.sub_eq [AddGroup β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
    f - g =ᶠ[l] 0 
goal: f - g =ᶠ[l] 0

full_name: Filter.eventuallyEq_iff_sub
code: theorem eventuallyEq_iff_sub [AddGroup β] {f g : α → β} {l : Filter α} :
    f =ᶠ[l] g ↔ f - g =ᶠ[l] 0 
goal: f =ᶠ[l] g ↔ f - g =ᶠ[l] 0

full_name: Filter.EventuallyLE
code: /-- A function `f` is eventually less than or equal to a function `g` at a filter `l`. -/
def EventuallyLE (l : Filter α) (f g : α → β) : Prop 
goal: Prop

full_name: Filter._aux_Mathlib_Order_Filter_Basic___unexpand_Filter_EventuallyLE_1
code: @[inherit_doc]
notation:50 f " ≤ᶠ[" l:50 "] " g:50 => EventuallyLE l f g
goal: Lean.PrettyPrinter.Unexpander

full_name: Filter.«_aux_Mathlib_Order_Filter_Basic___macroRules_Filter_term_≤ᶠ[_]__1»
code: @[inherit_doc]
notation:50 f " ≤ᶠ[" l:50 "] " g:50 => EventuallyLE l f g
goal: Lean.Macro

full_name: Filter.EventuallyLE.congr
code: theorem EventuallyLE.congr {f f' g g' : α → β} (H : f ≤ᶠ[l] g) (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') :
    f' ≤ᶠ[l] g' 
goal: f' ≤ᶠ[l] g'

full_name: Filter.eventuallyLE_congr
code: theorem eventuallyLE_congr {f f' g g' : α → β} (hf : f =ᶠ[l] f') (hg : g =ᶠ[l] g') :
    f ≤ᶠ[l] g ↔ f' ≤ᶠ[l] g' 
goal: f ≤ᶠ[l] g ↔ f' ≤ᶠ[l] g'

full_name: Filter.EventuallyEq.le
code: theorem EventuallyEq.le (h : f =ᶠ[l] g) : f ≤ᶠ[l] g 
goal: f ≤ᶠ[l] g

full_name: Filter.EventuallyLE.refl
code: @[refl]
theorem EventuallyLE.refl (l : Filter α) (f : α → β) : f ≤ᶠ[l] f 
goal: f ≤ᶠ[l] f

full_name: Filter.EventuallyLE.rfl
code: theorem EventuallyLE.rfl : f ≤ᶠ[l] f 
goal: f ≤ᶠ[l] f

full_name: Filter.EventuallyLE.trans
code: @[trans]
theorem EventuallyLE.trans (H₁ : f ≤ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h 
goal: f ≤ᶠ[l] h

full_name: Filter.instTransForallEventuallyLE
code: instance : Trans ((· ≤ᶠ[l] ·) : (α → β) → (α → β) → Prop) (· ≤ᶠ[l] ·) (· ≤ᶠ[l] ·) 
goal: Trans (fun x x_1 => x ≤ᶠ[l] x_1) (fun x x_1 => x ≤ᶠ[l] x_1) fun x x_1 => x ≤ᶠ[l] x_1

full_name: Filter.EventuallyEq.trans_le
code: @[trans]
theorem EventuallyEq.trans_le (H₁ : f =ᶠ[l] g) (H₂ : g ≤ᶠ[l] h) : f ≤ᶠ[l] h 
goal: f ≤ᶠ[l] h

full_name: Filter.instTransForallEventuallyEqEventuallyLE
code: instance : Trans ((· =ᶠ[l] ·) : (α → β) → (α → β) → Prop) (· ≤ᶠ[l] ·) (· ≤ᶠ[l] ·) 
goal: Trans (fun x x_1 => x =ᶠ[l] x_1) (fun x x_1 => x ≤ᶠ[l] x_1) fun x x_1 => x ≤ᶠ[l] x_1

full_name: Filter.EventuallyLE.trans_eq
code: @[trans]
theorem EventuallyLE.trans_eq (H₁ : f ≤ᶠ[l] g) (H₂ : g =ᶠ[l] h) : f ≤ᶠ[l] h 
goal: f ≤ᶠ[l] h

full_name: Filter.instTransForallEventuallyLEEventuallyEq
code: instance : Trans ((· ≤ᶠ[l] ·) : (α → β) → (α → β) → Prop) (· =ᶠ[l] ·) (· ≤ᶠ[l] ·) 
goal: Trans (fun x x_1 => x ≤ᶠ[l] x_1) (fun x x_1 => x =ᶠ[l] x_1) fun x x_1 => x ≤ᶠ[l] x_1

full_name: Filter.EventuallyLE.antisymm
code: theorem EventuallyLE.antisymm [PartialOrder β] {l : Filter α} {f g : α → β} (h₁ : f ≤ᶠ[l] g)
    (h₂ : g ≤ᶠ[l] f) : f =ᶠ[l] g 
goal: f =ᶠ[l] g

full_name: Filter.eventuallyLE_antisymm_iff
code: theorem eventuallyLE_antisymm_iff [PartialOrder β] {l : Filter α} {f g : α → β} :
    f =ᶠ[l] g ↔ f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f 
goal: f =ᶠ[l] g ↔ f ≤ᶠ[l] g ∧ g ≤ᶠ[l] f

full_name: Filter.EventuallyLE.le_iff_eq
code: theorem EventuallyLE.le_iff_eq [PartialOrder β] {l : Filter α} {f g : α → β} (h : f ≤ᶠ[l] g) :
    g ≤ᶠ[l] f ↔ g =ᶠ[l] f 
goal: g ≤ᶠ[l] f ↔ g =ᶠ[l] f

full_name: Filter.Eventually.ne_of_lt
code: theorem Eventually.ne_of_lt [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ᶠ x in l, f x < g x) :
    ∀ᶠ x in l, f x ≠ g x 
goal: ∀ᶠ (x : α) in l, f x ≠ g x

full_name: Filter.Eventually.ne_top_of_lt
code: theorem Eventually.ne_top_of_lt [PartialOrder β] [OrderTop β] {l : Filter α} {f g : α → β}
    (h : ∀ᶠ x in l, f x < g x) : ∀ᶠ x in l, f x ≠ ⊤ 
goal: ∀ᶠ (x : α) in l, f x ≠ ⊤

full_name: Filter.Eventually.lt_top_of_ne
code: theorem Eventually.lt_top_of_ne [PartialOrder β] [OrderTop β] {l : Filter α} {f : α → β}
    (h : ∀ᶠ x in l, f x ≠ ⊤) : ∀ᶠ x in l, f x < ⊤ 
goal: ∀ᶠ (x : α) in l, f x < ⊤

full_name: Filter.Eventually.lt_top_iff_ne_top
code: theorem Eventually.lt_top_iff_ne_top [PartialOrder β] [OrderTop β] {l : Filter α} {f : α → β} :
    (∀ᶠ x in l, f x < ⊤) ↔ ∀ᶠ x in l, f x ≠ ⊤ 
goal: (∀ᶠ (x : α) in l, f x < ⊤) ↔ ∀ᶠ (x : α) in l, f x ≠ ⊤

full_name: Filter.EventuallyLE.inter
code: @[mono]
theorem EventuallyLE.inter {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
    (s ∩ s' : Set α) ≤ᶠ[l] (t ∩ t' : Set α) 
goal: s ∩ s' ≤ᶠ[l] t ∩ t'

full_name: Filter.EventuallyLE.union
code: @[mono]
theorem EventuallyLE.union {s t s' t' : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) (h' : s' ≤ᶠ[l] t') :
    (s ∪ s' : Set α) ≤ᶠ[l] (t ∪ t' : Set α) 
goal: s ∪ s' ≤ᶠ[l] t ∪ t'

full_name: Filter.EventuallyLE.iUnion
code: protected lemma EventuallyLE.iUnion [Finite ι] {s t : ι → Set α}
    (h : ∀ i, s i ≤ᶠ[l] t i) : (⋃ i, s i) ≤ᶠ[l] ⋃ i, t i 
goal: ⋃ i, s i ≤ᶠ[l] ⋃ i, t i

full_name: Filter.EventuallyEq.iUnion
code: protected lemma EventuallyEq.iUnion [Finite ι] {s t : ι → Set α}
    (h : ∀ i, s i =ᶠ[l] t i) : (⋃ i, s i) =ᶠ[l] ⋃ i, t i 
goal: ⋃ i, s i =ᶠ[l] ⋃ i, t i

full_name: Filter.EventuallyLE.iInter
code: protected lemma EventuallyLE.iInter [Finite ι] {s t : ι → Set α}
    (h : ∀ i, s i ≤ᶠ[l] t i) : (⋂ i, s i) ≤ᶠ[l] ⋂ i, t i 
goal: ⋂ i, s i ≤ᶠ[l] ⋂ i, t i

full_name: Filter.EventuallyEq.iInter
code: protected lemma EventuallyEq.iInter [Finite ι] {s t : ι → Set α}
    (h : ∀ i, s i =ᶠ[l] t i) : (⋂ i, s i) =ᶠ[l] ⋂ i, t i 
goal: ⋂ i, s i =ᶠ[l] ⋂ i, t i

full_name: Set.Finite.eventuallyLE_iUnion
code: lemma _root_.Set.Finite.eventuallyLE_iUnion {ι : Type*} {s : Set ι} (hs : s.Finite)
    {f g : ι → Set α} (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋃ i ∈ s, f i) ≤ᶠ[l] (⋃ i ∈ s, g i) 
goal: ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i

full_name: Set.Finite.eventuallyEq_iUnion
code: lemma _root_.Set.Finite.eventuallyEq_iUnion {ι : Type*} {s : Set ι} (hs : s.Finite)
    {f g : ι → Set α} (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋃ i ∈ s, f i) =ᶠ[l] (⋃ i ∈ s, g i) 
goal: ⋃ i ∈ s, f i =ᶠ[l] ⋃ i ∈ s, g i

full_name: Set.Finite.eventuallyLE_iInter
code: lemma _root_.Set.Finite.eventuallyLE_iInter {ι : Type*} {s : Set ι} (hs : s.Finite)
    {f g : ι → Set α} (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋂ i ∈ s, f i) ≤ᶠ[l] (⋂ i ∈ s, g i) 
goal: ⋂ i ∈ s, f i ≤ᶠ[l] ⋂ i ∈ s, g i

full_name: Set.Finite.eventuallyEq_iInter
code: lemma _root_.Set.Finite.eventuallyEq_iInter {ι : Type*} {s : Set ι} (hs : s.Finite)
    {f g : ι → Set α} (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋂ i ∈ s, f i) =ᶠ[l] (⋂ i ∈ s, g i) 
goal: ⋂ i ∈ s, f i =ᶠ[l] ⋂ i ∈ s, g i

full_name: Finset.eventuallyLE_iUnion
code: lemma _root_.Finset.eventuallyLE_iUnion {ι : Type*} (s : Finset ι) {f g : ι → Set α}
    (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋃ i ∈ s, f i) ≤ᶠ[l] (⋃ i ∈ s, g i) 
goal: ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i

full_name: Finset.eventuallyEq_iUnion
code: lemma _root_.Finset.eventuallyEq_iUnion {ι : Type*} (s : Finset ι) {f g : ι → Set α}
    (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋃ i ∈ s, f i) =ᶠ[l] (⋃ i ∈ s, g i) 
goal: ⋃ i ∈ s, f i =ᶠ[l] ⋃ i ∈ s, g i

full_name: Finset.eventuallyLE_iInter
code: lemma _root_.Finset.eventuallyLE_iInter {ι : Type*} (s : Finset ι) {f g : ι → Set α}
    (hle : ∀ i ∈ s, f i ≤ᶠ[l] g i) : (⋂ i ∈ s, f i) ≤ᶠ[l] (⋂ i ∈ s, g i) 
goal: ⋂ i ∈ s, f i ≤ᶠ[l] ⋂ i ∈ s, g i

full_name: Finset.eventuallyEq_iInter
code: lemma _root_.Finset.eventuallyEq_iInter {ι : Type*} (s : Finset ι) {f g : ι → Set α}
    (heq : ∀ i ∈ s, f i =ᶠ[l] g i) : (⋂ i ∈ s, f i) =ᶠ[l] (⋂ i ∈ s, g i) 
goal: ⋂ i ∈ s, f i =ᶠ[l] ⋂ i ∈ s, g i

full_name: Filter.EventuallyLE.compl
code: @[mono]
theorem EventuallyLE.compl {s t : Set α} {l : Filter α} (h : s ≤ᶠ[l] t) :
    (tᶜ : Set α) ≤ᶠ[l] (sᶜ : Set α) 
goal: tᶜ ≤ᶠ[l] sᶜ

full_name: Filter.EventuallyLE.diff
code: @[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 α) 
goal: s \ s' ≤ᶠ[l] t \ t'

full_name: Filter.set_eventuallyLE_iff_mem_inf_principal
code: theorem set_eventuallyLE_iff_mem_inf_principal {s t : Set α} {l : Filter α} :
    s ≤ᶠ[l] t ↔ t ∈ l ⊓ 𝓟 s 
goal: s ≤ᶠ[l] t ↔ t ∈ l ⊓ 𝓟 s

full_name: Filter.set_eventuallyLE_iff_inf_principal_le
code: theorem set_eventuallyLE_iff_inf_principal_le {s t : Set α} {l : Filter α} :
    s ≤ᶠ[l] t ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t 
goal: s ≤ᶠ[l] t ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t

full_name: Filter.set_eventuallyEq_iff_inf_principal
code: theorem set_eventuallyEq_iff_inf_principal {s t : Set α} {l : Filter α} :
    s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t 
goal: s =ᶠ[l] t ↔ l ⊓ 𝓟 s = l ⊓ 𝓟 t

full_name: Filter.EventuallyLE.sup
code: theorem EventuallyLE.sup [SemilatticeSup β] {l : Filter α} {f₁ f₂ g₁ g₂ : α → β} (hf : f₁ ≤ᶠ[l] f₂)
    (hg : g₁ ≤ᶠ[l] g₂) : f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂ 
goal: f₁ ⊔ g₁ ≤ᶠ[l] f₂ ⊔ g₂

full_name: Filter.EventuallyLE.sup_le
code: theorem EventuallyLE.sup_le [SemilatticeSup β] {l : Filter α} {f g h : α → β} (hf : f ≤ᶠ[l] h)
    (hg : g ≤ᶠ[l] h) : f ⊔ g ≤ᶠ[l] h 
goal: f ⊔ g ≤ᶠ[l] h

full_name: Filter.EventuallyLE.le_sup_of_le_left
code: theorem EventuallyLE.le_sup_of_le_left [SemilatticeSup β] {l : Filter α} {f g h : α → β}
    (hf : h ≤ᶠ[l] f) : h ≤ᶠ[l] f ⊔ g 
goal: h ≤ᶠ[l] f ⊔ g

full_name: Filter.EventuallyLE.le_sup_of_le_right
code: theorem EventuallyLE.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
    (hg : h ≤ᶠ[l] g) : h ≤ᶠ[l] f ⊔ g 
goal: h ≤ᶠ[l] f ⊔ g

full_name: Filter.join_le
code: theorem join_le {f : Filter (Filter α)} {l : Filter α} (h : ∀ᶠ m in f, m ≤ l) : join f ≤ l 
goal: f.join ≤ l

full_name: Filter.map
code: /-- The forward map of a filter -/
def map (m : α → β) (f : Filter α) : Filter β 
goal: Filter β

full_name: Filter.map_principal
code: @[simp]
theorem map_principal {s : Set α} {f : α → β} : map f (𝓟 s) = 𝓟 (Set.image f s) 
goal: Filter.map f (𝓟 s) = 𝓟 (f '' s)

full_name: Filter.eventually_map
code: @[simp]
theorem eventually_map {P : β → Prop} : (∀ᶠ b in map m f, P b) ↔ ∀ᶠ a in f, P (m a) 
goal: (∀ᶠ (b : β) in Filter.map m f, P b) ↔ ∀ᶠ (a : α) in f, P (m a)

full_name: Filter.frequently_map
code: @[simp]
theorem frequently_map {P : β → Prop} : (∃ᶠ b in map m f, P b) ↔ ∃ᶠ a in f, P (m a) 
goal: (∃ᶠ (b : β) in Filter.map m f, P b) ↔ ∃ᶠ (a : α) in f, P (m a)

full_name: Filter.mem_map
code: @[simp]
theorem mem_map : t ∈ map m f ↔ m ⁻¹' t ∈ f 
goal: t ∈ Filter.map m f ↔ m ⁻¹' t ∈ f

full_name: Filter.mem_map'
code: theorem mem_map' : t ∈ map m f ↔ { x | m x ∈ t } ∈ f 
goal: t ∈ Filter.map m f ↔ {x | m x ∈ t} ∈ f

full_name: Filter.image_mem_map
code: theorem image_mem_map (hs : s ∈ f) : m '' s ∈ map m f 
goal: m '' s ∈ Filter.map m f

full_name: Filter.image_mem_map_iff
code: @[simp 1100, nolint simpNF]
theorem image_mem_map_iff (hf : Injective m) : m '' s ∈ map m f ↔ s ∈ f 
goal: m '' s ∈ Filter.map m f ↔ s ∈ f

full_name: Filter.range_mem_map
code: theorem range_mem_map : range m ∈ map m f 
goal: Set.range m ∈ Filter.map m f

full_name: Filter.mem_map_iff_exists_image
code: theorem mem_map_iff_exists_image : t ∈ map m f ↔ ∃ s ∈ f, m '' s ⊆ t 
goal: t ∈ Filter.map m f ↔ ∃ s ∈ f, m '' s ⊆ t

full_name: Filter.map_id
code: @[simp]
theorem map_id : Filter.map id f = f 
goal: Filter.map id f = f

full_name: Filter.map_id'
code: @[simp]
theorem map_id' : Filter.map (fun x => x) f = f 
goal: Filter.map (fun x => x) f = f

full_name: Filter.map_compose
code: @[simp]
theorem map_compose : Filter.map m' ∘ Filter.map m = Filter.map (m' ∘ m) 
goal: Filter.map m' ∘ Filter.map m = Filter.map (m' ∘ m)

full_name: Filter.map_map
code: @[simp]
theorem map_map : Filter.map m' (Filter.map m f) = Filter.map (m' ∘ m) f 
goal: Filter.map m' (Filter.map m f) = Filter.map (m' ∘ m) f

full_name: Filter.map_congr
code: /-- If functions `m₁` and `m₂` are eventually equal at a filter `f`, then
they map this filter to the same filter. -/
theorem map_congr {m₁ m₂ : α → β} {f : Filter α} (h : m₁ =ᶠ[f] m₂) : map m₁ f = map m₂ f 
goal: Filter.map m₁ f = Filter.map m₂ f

full_name: Filter.comap
code: /-- The inverse map of a filter. A set `s` belongs to `Filter.comap m f` if either of the following
equivalent conditions hold.

1. There exists a set `t ∈ f` such that `m ⁻¹' t ⊆ s`. This is used as a definition.
2. The set `kernImage m s = {y | ∀ x, m x = y → x ∈ s}` belongs to `f`, see `Filter.mem_comap'`.
3. The set `(m '' sᶜ)ᶜ` belongs to `f`, see `Filter.mem_comap_iff_compl` and
`Filter.compl_mem_comap`. -/
def comap (m : α → β) (f : Filter β) : Filter α 
goal: Filter α

full_name: Filter.mem_comap'
code: theorem mem_comap' : s ∈ comap f l ↔ { y | ∀ ⦃x⦄, f x = y → x ∈ s } ∈ l 
goal: s ∈ Filter.comap f l ↔ {y | ∀ ⦃x : α⦄, f x = y → x ∈ s} ∈ l

full_name: Filter.mem_comap''
code: theorem mem_comap'' : s ∈ comap f l ↔ kernImage f s ∈ l 
goal: s ∈ Filter.comap f l ↔ Set.kernImage f s ∈ l

full_name: Filter.mem_comap_prod_mk
code: /-- RHS form is used, e.g., in the definition of `UniformSpace`. -/
lemma mem_comap_prod_mk {x : α} {s : Set β} {F : Filter (α × β)} :
    s ∈ comap (Prod.mk x) F ↔ {p : α × β | p.fst = x → p.snd ∈ s} ∈ F 
goal: s ∈ Filter.comap (Prod.mk x) F ↔ {p | p.1 = x → p.2 ∈ s} ∈ F

full_name: Filter.eventually_comap
code: @[simp]
theorem eventually_comap : (∀ᶠ a in comap f l, p a) ↔ ∀ᶠ b in l, ∀ a, f a = b → p a 
goal: (∀ᶠ (a : α) in Filter.comap f l, p a) ↔ ∀ᶠ (b : β) in l, ∀ (a : α), f a = b → p a

full_name: Filter.frequently_comap
code: @[simp]
theorem frequently_comap : (∃ᶠ a in comap f l, p a) ↔ ∃ᶠ b in l, ∃ a, f a = b ∧ p a 
goal: (∃ᶠ (a : α) in Filter.comap f l, p a) ↔ ∃ᶠ (b : β) in l, ∃ a, f a = b ∧ p a

full_name: Filter.mem_comap_iff_compl
code: theorem mem_comap_iff_compl : s ∈ comap f l ↔ (f '' sᶜ)ᶜ ∈ l 
goal: s ∈ Filter.comap f l ↔ (f '' sᶜ)ᶜ ∈ l

full_name: Filter.compl_mem_comap
code: theorem compl_mem_comap : sᶜ ∈ comap f l ↔ (f '' s)ᶜ ∈ l 
goal: sᶜ ∈ Filter.comap f l ↔ (f '' s)ᶜ ∈ l

full_name: Filter.kernMap
code: /-- The analog of `kernImage` for filters. A set `s` belongs to `Filter.kernMap m f` if either of
the following equivalent conditions hold.

1. There exists a set `t ∈ f` such that `s = kernImage m t`. This is used as a definition.
2. There exists a set `t` such that `tᶜ ∈ f` and `sᶜ = m '' t`, see `Filter.mem_kernMap_iff_compl`
and `Filter.compl_mem_kernMap`.

This definition because it gives a right adjoint to `Filter.comap`, and because it has a nice
interpretation when working with `co-` filters (`Filter.cocompact`, `Filter.cofinite`, ...).
For example, `kernMap m (cocompact α)` is the filter generated by the complements of the sets
`m '' K` where `K` is a compact subset of `α`. -/
def kernMap (m : α → β) (f : Filter α) : Filter β 
goal: Filter β

full_name: Filter.mem_kernMap
code: theorem mem_kernMap {s : Set β} : s ∈ kernMap m f ↔ ∃ t ∈ f, kernImage m t = s 
goal: s ∈ Filter.kernMap m f ↔ ∃ t ∈ f, Set.kernImage m t = s

full_name: Filter.mem_kernMap_iff_compl
code: theorem mem_kernMap_iff_compl {s : Set β} : s ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ 
goal: s ∈ Filter.kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ

full_name: Filter.compl_mem_kernMap
code: theorem compl_mem_kernMap {s : Set β} : sᶜ ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = s 
goal: sᶜ ∈ Filter.kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = s

full_name: Filter.bind
code: /-- The monadic bind operation on filter is defined the usual way in terms of `map` and `join`.

Unfortunately, this `bind` does not result in the expected applicative. See `Filter.seq` for the
applicative instance. -/
def bind (f : Filter α) (m : α → Filter β) : Filter β 
goal: Filter β

full_name: Filter.seq
code: /-- The applicative sequentiation operation. This is not induced by the bind operation. -/
def seq (f : Filter (α → β)) (g : Filter α) : Filter β 
goal: Filter β

full_name: Filter.instPure
code: /-- `pure x` is the set of sets that contain `x`. It is equal to `𝓟 {x}` but
with this definition we have `s ∈ pure a` defeq `a ∈ s`. -/
instance : Pure Filter 
goal: Pure Filter

full_name: Filter.instBind
code: instance : Bind Filter 
goal: Bind Filter

full_name: Filter.instFunctor
code: instance : Functor Filter 
goal: Functor Filter

full_name: Filter.instLawfulFunctor
code: instance : LawfulFunctor (Filter : Type u → Type u) 
goal: LawfulFunctor Filter

full_name: Filter.pure_sets
code: theorem pure_sets (a : α) : (pure a : Filter α).sets = { s | a ∈ s } 
goal: (pure a).sets = {s | a ∈ s}

full_name: Filter.mem_pure
code: @[simp]
theorem mem_pure {a : α} {s : Set α} : s ∈ (pure a : Filter α) ↔ a ∈ s 
goal: s ∈ pure a ↔ a ∈ s

full_name: Filter.eventually_pure
code: @[simp]
theorem eventually_pure {a : α} {p : α → Prop} : (∀ᶠ x in pure a, p x) ↔ p a 
goal: (∀ᶠ (x : α) in pure a, p x) ↔ p a

full_name: Filter.principal_singleton
code: @[simp]
theorem principal_singleton (a : α) : 𝓟 {a} = pure a 
goal: 𝓟 {a} = pure a

full_name: Filter.map_pure
code: @[simp]
theorem map_pure (f : α → β) (a : α) : map f (pure a) = pure (f a) 
goal: Filter.map f (pure a) = pure (f a)

full_name: Filter.pure_le_principal
code: theorem pure_le_principal {s : Set α} (a : α) : pure a ≤ 𝓟 s ↔ a ∈ s 
goal: pure a ≤ 𝓟 s ↔ a ∈ s

full_name: Filter.join_pure
code: @[simp] theorem join_pure (f : Filter α) : join (pure f) = f 
goal: (pure f).join = f

full_name: Filter.pure_bind
code: @[simp]
theorem pure_bind (a : α) (m : α → Filter β) : bind (pure a) m = m a 
goal: (pure a).bind m = m a

full_name: Filter.map_bind
code: theorem map_bind {α β} (m : β → γ) (f : Filter α) (g : α → Filter β) :
    map m (bind f g) = bind f (map m ∘ g) 
goal: Filter.map m (f.bind g) = f.bind (Filter.map m ∘ g)

full_name: Filter.bind_map
code: theorem bind_map {α β} (m : α → β) (f : Filter α) (g : β → Filter γ) :
    (bind (map m f) g) = bind f (g ∘ m) 
goal: (Filter.map m f).bind g = f.bind (g ∘ m)

full_name: Filter.monad
code: /-- The monad structure on filters. -/
protected def monad : Monad Filter 
goal: Monad Filter

full_name: Filter.lawfulMonad
code: protected theorem lawfulMonad : LawfulMonad Filter 
goal: LawfulMonad Filter

full_name: Filter.instAlternative
code: instance : Alternative Filter 
goal: Alternative Filter

full_name: Filter.map_def
code: @[simp]
theorem map_def {α β} (m : α → β) (f : Filter α) : m <$> f = map m f 
goal: m <$> f = Filter.map m f

full_name: Filter.bind_def
code: @[simp]
theorem bind_def {α β} (f : Filter α) (m : α → Filter β) : f >>= m = bind f m 
goal: f >>= m = f.bind m

full_name: Filter.mem_comap
code: @[simp] theorem mem_comap : s ∈ comap m g ↔ ∃ t ∈ g, m ⁻¹' t ⊆ s 
goal: s ∈ Filter.comap m g ↔ ∃ t ∈ g, m ⁻¹' t ⊆ s

full_name: Filter.preimage_mem_comap
code: theorem preimage_mem_comap (ht : t ∈ g) : m ⁻¹' t ∈ comap m g 
goal: m ⁻¹' t ∈ Filter.comap m g

full_name: Filter.Eventually.comap
code: theorem Eventually.comap {p : β → Prop} (hf : ∀ᶠ b in g, p b) (f : α → β) :
    ∀ᶠ a in comap f g, p (f a) 
goal: ∀ᶠ (a : α) in Filter.comap f g, p (f a)

full_name: Filter.comap_id
code: theorem comap_id : comap id f = f 
goal: Filter.comap id f = f

full_name: Filter.comap_id'
code: theorem comap_id' : comap (fun x => x) f = f 
goal: Filter.comap (fun x => x) f = f

full_name: Filter.comap_const_of_not_mem
code: theorem comap_const_of_not_mem {x : β} (ht : t ∈ g) (hx : x ∉ t) : comap (fun _ : α => x) g = ⊥ 
goal: Filter.comap (fun x_1 => x) g = ⊥

full_name: Filter.comap_const_of_mem
code: theorem comap_const_of_mem {x : β} (h : ∀ t ∈ g, x ∈ t) : comap (fun _ : α => x) g = ⊤ 
goal: Filter.comap (fun x_1 => x) g = ⊤

full_name: Filter.map_const
code: theorem map_const [NeBot f] {c : β} : (f.map fun _ => c) = pure c 
goal: Filter.map (fun x => c) f = pure c

full_name: Filter.comap_comap
code: theorem comap_comap {m : γ → β} {n : β → α} : comap m (comap n f) = comap (n ∘ m) f 
goal: Filter.comap m (Filter.comap n f) = Filter.comap (n ∘ m) f

full_name: Filter.map_comm
code: theorem map_comm (H : ψ ∘ φ = ρ ∘ θ) (F : Filter α) :
    map ψ (map φ F) = map ρ (map θ F) 
goal: Filter.map ψ (Filter.map φ F) = Filter.map ρ (Filter.map θ F)

full_name: Filter.comap_comm
code: theorem comap_comm (H : ψ ∘ φ = ρ ∘ θ) (G : Filter δ) :
    comap φ (comap ψ G) = comap θ (comap ρ G) 
goal: Filter.comap φ (Filter.comap ψ G) = Filter.comap θ (Filter.comap ρ G)

full_name: Function.Semiconj.filter_map
code: theorem _root_.Function.Semiconj.filter_map {f : α → β} {ga : α → α} {gb : β → β}
    (h : Function.Semiconj f ga gb) : Function.Semiconj (map f) (map ga) (map gb) 
goal: Function.Semiconj (Filter.map f) (Filter.map ga) (Filter.map gb)

full_name: Function.Commute.filter_map
code: theorem _root_.Function.Commute.filter_map {f g : α → α} (h : Function.Commute f g) :
    Function.Commute (map f) (map g) 
goal: Function.Commute (Filter.map f) (Filter.map g)

full_name: Function.Semiconj.filter_comap
code: theorem _root_.Function.Semiconj.filter_comap {f : α → β} {ga : α → α} {gb : β → β}
    (h : Function.Semiconj f ga gb) : Function.Semiconj (comap f) (comap gb) (comap ga) 
goal: Function.Semiconj (Filter.comap f) (Filter.comap gb) (Filter.comap ga)

full_name: Function.Commute.filter_comap
code: theorem _root_.Function.Commute.filter_comap {f g : α → α} (h : Function.Commute f g) :
    Function.Commute (comap f) (comap g) 
goal: Function.Commute (Filter.comap f) (Filter.comap g)

full_name: Function.LeftInverse.filter_map
code: theorem _root_.Function.LeftInverse.filter_map {f : α → β} {g : β → α} (hfg : LeftInverse g f) :
    LeftInverse (map g) (map f) 
goal: Function.LeftInverse (Filter.map g) (Filter.map f)

full_name: Function.LeftInverse.filter_comap
code: theorem _root_.Function.LeftInverse.filter_comap {f : α → β} {g : β → α} (hfg : LeftInverse g f) :
    RightInverse (comap g) (comap f) 
goal: Function.RightInverse (Filter.comap g) (Filter.comap f)

full_name: Function.RightInverse.filter_map
code: nonrec theorem _root_.Function.RightInverse.filter_map {f : α → β} {g : β → α}
    (hfg : RightInverse g f) : RightInverse (map g) (map f) 
goal: Function.RightInverse (Filter.map g) (Filter.map f)

full_name: Function.RightInverse.filter_comap
code: nonrec theorem _root_.Function.RightInverse.filter_comap {f : α → β} {g : β → α}
    (hfg : RightInverse g f) : LeftInverse (comap g) (comap f) 
goal: Function.LeftInverse (Filter.comap g) (Filter.comap f)

full_name: Set.LeftInvOn.filter_map_Iic
code: theorem _root_.Set.LeftInvOn.filter_map_Iic {f : α → β} {g : β → α} (hfg : LeftInvOn g f s) :
    LeftInvOn (map g) (map f) (Iic <| 𝓟 s) 
goal: Set.LeftInvOn (Filter.map g) (Filter.map f) (Set.Iic (𝓟 s))

full_name: Set.RightInvOn.filter_map_Iic
code: nonrec theorem _root_.Set.RightInvOn.filter_map_Iic {f : α → β} {g : β → α}
    (hfg : RightInvOn g f t) : RightInvOn (map g) (map f) (Iic <| 𝓟 t) 
goal: Set.RightInvOn (Filter.map g) (Filter.map f) (Set.Iic (𝓟 t))

full_name: Filter.comap_principal
code: @[simp]
theorem comap_principal {t : Set β} : comap m (𝓟 t) = 𝓟 (m ⁻¹' t) 
goal: Filter.comap m (𝓟 t) = 𝓟 (m ⁻¹' t)

full_name: Filter.principal_subtype
code: theorem principal_subtype {α : Type*} (s : Set α) (t : Set s) :
    𝓟 t = comap (↑) (𝓟 (((↑) : s → α) '' t)) 
goal: 𝓟 t = Filter.comap Subtype.val (𝓟 (Subtype.val '' t))

full_name: Filter.comap_pure
code: @[simp]
theorem comap_pure {b : β} : comap m (pure b) = 𝓟 (m ⁻¹' {b}) 
goal: Filter.comap m (pure b) = 𝓟 (m ⁻¹' {b})

full_name: Filter.map_le_iff_le_comap
code: theorem map_le_iff_le_comap : map m f ≤ g ↔ f ≤ comap m g 
goal: Filter.map m f ≤ g ↔ f ≤ Filter.comap m g

full_name: Filter.gc_map_comap
code: theorem gc_map_comap (m : α → β) : GaloisConnection (map m) (comap m) 
goal: GaloisConnection (Filter.map m) (Filter.comap m)

full_name: Filter.comap_le_iff_le_kernMap
code: theorem comap_le_iff_le_kernMap : comap m g ≤ f ↔ g ≤ kernMap m f 
goal: Filter.comap m g ≤ f ↔ g ≤ Filter.kernMap m f

full_name: Filter.gc_comap_kernMap
code: theorem gc_comap_kernMap (m : α → β) : GaloisConnection (comap m) (kernMap m) 
goal: GaloisConnection (Filter.comap m) (Filter.kernMap m)

full_name: Filter.kernMap_principal
code: theorem kernMap_principal {s : Set α} : kernMap m (𝓟 s) = 𝓟 (kernImage m s) 
goal: Filter.kernMap m (𝓟 s) = 𝓟 (Set.kernImage m s)

full_name: Filter.map_mono
code: @[mono]
theorem map_mono : Monotone (map m) 
goal: Monotone (Filter.map m)

full_name: Filter.comap_mono
code: @[mono]
theorem comap_mono : Monotone (comap m) 
goal: Monotone (Filter.comap m)

full_name: GCongr.Filter.map_le_map
code: /-- Temporary lemma that we can tag with `gcongr` -/
@[gcongr] theorem _root_.GCongr.Filter.map_le_map {F G : Filter α} (h : F ≤ G) :
    map m F ≤ map m G 
goal: Filter.map m F ≤ Filter.map m G

full_name: GCongr.Filter.comap_le_comap
code: /-- Temporary lemma that we can tag with `gcongr` -/
@[gcongr]
theorem _root_.GCongr.Filter.comap_le_comap {F G : Filter β} (h : F ≤ G) :
    comap m F ≤ comap m G 
goal: Filter.comap m F ≤ Filter.comap m G

full_name: Filter.map_bot
code: @[simp] theorem map_bot : map m ⊥ = ⊥ 
goal: Filter.map m ⊥ = ⊥

full_name: Filter.map_sup
code: @[simp] theorem map_sup : map m (f₁ ⊔ f₂) = map m f₁ ⊔ map m f₂ 
goal: Filter.map m (f₁ ⊔ f₂) = Filter.map m f₁ ⊔ Filter.map m f₂

full_name: Filter.map_iSup
code: @[simp]
theorem map_iSup {f : ι → Filter α} : map m (⨆ i, f i) = ⨆ i, map m (f i) 
goal: Filter.map m (⨆ i, f i) = ⨆ i, Filter.map m (f i)

full_name: Filter.map_top
code: @[simp]
theorem map_top (f : α → β) : map f ⊤ = 𝓟 (range f) 
goal: Filter.map f ⊤ = 𝓟 (Set.range f)

full_name: Filter.comap_top
code: @[simp] theorem comap_top : comap m ⊤ = ⊤ 
goal: Filter.comap m ⊤ = ⊤

full_name: Filter.comap_inf
code: @[simp] theorem comap_inf : comap m (g₁ ⊓ g₂) = comap m g₁ ⊓ comap m g₂ 
goal: Filter.comap m (g₁ ⊓ g₂) = Filter.comap m g₁ ⊓ Filter.comap m g₂

full_name: Filter.comap_iInf
code: @[simp]
theorem comap_iInf {f : ι → Filter β} : comap m (⨅ i, f i) = ⨅ i, comap m (f i) 
goal: Filter.comap m (⨅ i, f i) = ⨅ i, Filter.comap m (f i)

full_name: Filter.le_comap_top
code: theorem le_comap_top (f : α → β) (l : Filter α) : l ≤ comap f ⊤ 
goal: l ≤ Filter.comap f ⊤

full_name: Filter.map_comap_le
code: theorem map_comap_le : map m (comap m g) ≤ g 
goal: Filter.map m (Filter.comap m g) ≤ g

full_name: Filter.le_comap_map
code: theorem le_comap_map : f ≤ comap m (map m f) 
goal: f ≤ Filter.comap m (Filter.map m f)

full_name: Filter.comap_bot
code: @[simp]
theorem comap_bot : comap m ⊥ = ⊥ 
goal: Filter.comap m ⊥ = ⊥

full_name: Filter.neBot_of_comap
code: theorem neBot_of_comap (h : (comap m g).NeBot) : g.NeBot 
goal: g.NeBot

full_name: Filter.comap_inf_principal_range
code: theorem comap_inf_principal_range : comap m (g ⊓ 𝓟 (range m)) = comap m g 
goal: Filter.comap m (g ⊓ 𝓟 (Set.range m)) = Filter.comap m g

full_name: Filter.disjoint_comap
code: theorem disjoint_comap (h : Disjoint g₁ g₂) : Disjoint (comap m g₁) (comap m g₂) 
goal: Disjoint (Filter.comap m g₁) (Filter.comap m g₂)

full_name: Filter.comap_iSup
code: theorem comap_iSup {ι} {f : ι → Filter β} {m : α → β} : comap m (iSup f) = ⨆ i, comap m (f i) 
goal: Filter.comap m (iSup f) = ⨆ i, Filter.comap m (f i)

full_name: Filter.comap_sSup
code: theorem comap_sSup {s : Set (Filter β)} {m : α → β} : comap m (sSup s) = ⨆ f ∈ s, comap m f 
goal: Filter.comap m (sSup s) = ⨆ f ∈ s, Filter.comap m f

full_name: Filter.comap_sup
code: theorem comap_sup : comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂ 
goal: Filter.comap m (g₁ ⊔ g₂) = Filter.comap m g₁ ⊔ Filter.comap m g₂

full_name: Filter.map_comap
code: theorem map_comap (f : Filter β) (m : α → β) : (f.comap m).map m = f ⊓ 𝓟 (range m) 
goal: Filter.map m (Filter.comap m f) = f ⊓ 𝓟 (Set.range m)

full_name: Filter.map_comap_setCoe_val
code: theorem map_comap_setCoe_val (f : Filter β) (s : Set β) :
    (f.comap ((↑) : s → β)).map (↑) = f ⊓ 𝓟 s 
goal: Filter.map Subtype.val (Filter.comap Subtype.val f) = f ⊓ 𝓟 s

full_name: Filter.map_comap_of_mem
code: theorem map_comap_of_mem {f : Filter β} {m : α → β} (hf : range m ∈ f) : (f.comap m).map m = f 
goal: Filter.map m (Filter.comap m f) = f

full_name: Filter.canLift
code: instance canLift (c) (p) [CanLift α β c p] :
    CanLift (Filter α) (Filter β) (map c) fun f => ∀ᶠ x : α in f, p x 
goal: CanLift (Filter α) (Filter β) (Filter.map c) fun f => ∀ᶠ (x : α) in f, p x

full_name: Filter.comap_le_comap_iff
code: theorem comap_le_comap_iff {f g : Filter β} {m : α → β} (hf : range m ∈ f) :
    comap m f ≤ comap m g ↔ f ≤ g 
goal: Filter.comap m f ≤ Filter.comap m g ↔ f ≤ g

full_name: Filter.map_comap_of_surjective
code: theorem map_comap_of_surjective {f : α → β} (hf : Surjective f) (l : Filter β) :
    map f (comap f l) = l 
goal: Filter.map f (Filter.comap f l) = l

full_name: Filter.comap_injective
code: theorem comap_injective {f : α → β} (hf : Surjective f) : Injective (comap f) 
goal: Function.Injective (Filter.comap f)

full_name: Function.Surjective.filter_map_top
code: theorem _root_.Function.Surjective.filter_map_top {f : α → β} (hf : Surjective f) : map f ⊤ = ⊤ 
goal: Filter.map f ⊤ = ⊤

full_name: Filter.subtype_coe_map_comap
code: theorem subtype_coe_map_comap (s : Set α) (f : Filter α) :
    map ((↑) : s → α) (comap ((↑) : s → α) f) = f ⊓ 𝓟 s 
goal: Filter.map Subtype.val (Filter.comap Subtype.val f) = f ⊓ 𝓟 s

full_name: Filter.image_mem_of_mem_comap
code: theorem image_mem_of_mem_comap {f : Filter α} {c : β → α} (h : range c ∈ f) {W : Set β}
    (W_in : W ∈ comap c f) : c '' W ∈ f 
goal: c '' W ∈ f

full_name: Filter.image_coe_mem_of_mem_comap
code: 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 
goal: Subtype.val '' W ∈ f

full_name: Filter.comap_map
code: theorem comap_map {f : Filter α} {m : α → β} (h : Injective m) : comap m (map m f) = f 
goal: Filter.comap m (Filter.map m f) = f

full_name: Filter.mem_comap_iff
code: theorem mem_comap_iff {f : Filter β} {m : α → β} (inj : Injective m) (large : Set.range m ∈ f)
    {S : Set α} : S ∈ comap m f ↔ m '' S ∈ f 
goal: S ∈ Filter.comap m f ↔ m '' S ∈ f

full_name: Filter.map_le_map_iff_of_injOn
code: 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₂ 
goal: Filter.map f l₁ ≤ Filter.map f l₂ ↔ l₁ ≤ l₂

full_name: Filter.map_le_map_iff
code: theorem map_le_map_iff {f g : Filter α} {m : α → β} (hm : Injective m) :
    map m f ≤ map m g ↔ f ≤ g 
goal: Filter.map m f ≤ Filter.map m g ↔ f ≤ g

full_name: Filter.map_eq_map_iff_of_injOn
code: 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 
goal: Filter.map m f = Filter.map m g ↔ f = g

full_name: Filter.map_inj
code: theorem map_inj {f g : Filter α} {m : α → β} (hm : Injective m) : map m f = map m g ↔ f = g 
goal: Filter.map m f = Filter.map m g ↔ f = g

full_name: Filter.map_injective
code: theorem map_injective {m : α → β} (hm : Injective m) : Injective (map m) 
goal: Function.Injective (Filter.map m)

full_name: Filter.comap_neBot_iff
code: theorem comap_neBot_iff {f : Filter β} {m : α → β} : NeBot (comap m f) ↔ ∀ t ∈ f, ∃ a, m a ∈ t 
goal: (Filter.comap m f).NeBot ↔ ∀ t ∈ f, ∃ a, m a ∈ t

full_name: Filter.comap_neBot
code: theorem comap_neBot {f : Filter β} {m : α → β} (hm : ∀ t ∈ f, ∃ a, m a ∈ t) : NeBot (comap m f) 
goal: (Filter.comap m f).NeBot

full_name: Filter.comap_neBot_iff_frequently
code: theorem comap_neBot_iff_frequently {f : Filter β} {m : α → β} :
    NeBot (comap m f) ↔ ∃ᶠ y in f, y ∈ range m 
goal: (Filter.comap m f).NeBot ↔ ∃ᶠ (y : β) in f, y ∈ Set.range m

full_name: Filter.comap_neBot_iff_compl_range
code: theorem comap_neBot_iff_compl_range {f : Filter β} {m : α → β} :
    NeBot (comap m f) ↔ (range m)ᶜ ∉ f 
goal: (Filter.comap m f).NeBot ↔ (Set.range m)ᶜ ∉ f

full_name: Filter.comap_eq_bot_iff_compl_range
code: theorem comap_eq_bot_iff_compl_range {f : Filter β} {m : α → β} : comap m f = ⊥ ↔ (range m)ᶜ ∈ f 
goal: Filter.comap m f = ⊥ ↔ (Set.range m)ᶜ ∈ f

full_name: Filter.comap_surjective_eq_bot
code: theorem comap_surjective_eq_bot {f : Filter β} {m : α → β} (hm : Surjective m) :
    comap m f = ⊥ ↔ f = ⊥ 
goal: Filter.comap m f = ⊥ ↔ f = ⊥

full_name: Filter.disjoint_comap_iff
code: theorem disjoint_comap_iff (h : Surjective m) :
    Disjoint (comap m g₁) (comap m g₂) ↔ Disjoint g₁ g₂ 
goal: Disjoint (Filter.comap m g₁) (Filter.comap m g₂) ↔ Disjoint g₁ g₂

full_name: Filter.NeBot.comap_of_range_mem
code: theorem NeBot.comap_of_range_mem {f : Filter β} {m : α → β} (_ : NeBot f) (hm : range m ∈ f) :
    NeBot (comap m f) 
goal: f.NeBot → Set.range m ∈ f → (Filter.comap m f).NeBot

full_name: Filter.comap_fst_neBot_iff
code: @[simp]
theorem comap_fst_neBot_iff {f : Filter α} :
    (f.comap (Prod.fst : α × β → α)).NeBot ↔ f.NeBot ∧ Nonempty β 
goal: (Filter.comap Prod.fst f).NeBot ↔ f.NeBot ∧ Nonempty β

full_name: Filter.comap_fst_neBot
code: @[instance]
theorem comap_fst_neBot [Nonempty β] {f : Filter α} [NeBot f] :
    (f.comap (Prod.fst : α × β → α)).NeBot 
goal: (Filter.comap Prod.fst f).NeBot

full_name: Filter.comap_snd_neBot_iff
code: @[simp]
theorem comap_snd_neBot_iff {f : Filter β} :
    (f.comap (Prod.snd : α × β → β)).NeBot ↔ Nonempty α ∧ f.NeBot 
goal: (Filter.comap Prod.snd f).NeBot ↔ Nonempty α ∧ f.NeBot

full_name: Filter.comap_snd_neBot
code: @[instance]
theorem comap_snd_neBot [Nonempty α] {f : Filter β} [NeBot f] :
    (f.comap (Prod.snd : α × β → β)).NeBot 
goal: (Filter.comap Prod.snd f).NeBot

full_name: Filter.comap_eval_neBot_iff'
code: theorem comap_eval_neBot_iff' {ι : Type*} {α : ι → Type*} {i : ι} {f : Filter (α i)} :
    (comap (eval i) f).NeBot ↔ (∀ j, Nonempty (α j)) ∧ NeBot f 
goal: (Filter.comap (Function.eval i) f).NeBot ↔ (∀ (j : ι), Nonempty (α j)) ∧ f.NeBot

full_name: Filter.comap_eval_neBot_iff
code: @[simp]
theorem comap_eval_neBot_iff {ι : Type*} {α : ι → Type*} [∀ j, Nonempty (α j)] {i : ι}
    {f : Filter (α i)} : (comap (eval i) f).NeBot ↔ NeBot f 
goal: (Filter.comap (Function.eval i) f).NeBot ↔ f.NeBot

full_name: Filter.comap_eval_neBot
code: @[instance]
theorem comap_eval_neBot {ι : Type*} {α : ι → Type*} [∀ j, Nonempty (α j)] (i : ι)
    (f : Filter (α i)) [NeBot f] : (comap (eval i) f).NeBot 
goal: (Filter.comap (Function.eval i) f).NeBot

full_name: Filter.comap_inf_principal_neBot_of_image_mem
code: 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) 
goal: (Filter.comap m f ⊓ 𝓟 s).NeBot

full_name: Filter.comap_coe_neBot_of_le_principal
code: theorem comap_coe_neBot_of_le_principal {s : Set γ} {l : Filter γ} [h : NeBot l] (h' : l ≤ 𝓟 s) :
    NeBot (comap ((↑) : s → γ) l) 
goal: (Filter.comap Subtype.val l).NeBot

full_name: Filter.NeBot.comap_of_surj
code: theorem NeBot.comap_of_surj {f : Filter β} {m : α → β} (hf : NeBot f) (hm : Surjective m) :
    NeBot (comap m f) 
goal: (Filter.comap m f).NeBot

full_name: Filter.NeBot.comap_of_image_mem
code: theorem NeBot.comap_of_image_mem {f : Filter β} {m : α → β} (hf : NeBot f) {s : Set α}
    (hs : m '' s ∈ f) : NeBot (comap m f) 
goal: (Filter.comap m f).NeBot

full_name: Filter.map_eq_bot_iff
code: @[simp]
theorem map_eq_bot_iff : map m f = ⊥ ↔ f = ⊥ 
goal: Filter.map m f = ⊥ ↔ f = ⊥

full_name: Filter.map_neBot_iff
code: theorem map_neBot_iff (f : α → β) {F : Filter α} : NeBot (map f F) ↔ NeBot F 
goal: (Filter.map f F).NeBot ↔ F.NeBot

full_name: Filter.NeBot.map
code: theorem NeBot.map (hf : NeBot f) (m : α → β) : NeBot (map m f) 
goal: (Filter.map m f).NeBot

full_name: Filter.NeBot.of_map
code: theorem NeBot.of_map : NeBot (f.map m) → NeBot f 
goal: (Filter.map m f).NeBot → f.NeBot

full_name: Filter.map_neBot
code: instance map_neBot [hf : NeBot f] : NeBot (f.map m) 
goal: (Filter.map m f).NeBot

full_name: Filter.sInter_comap_sets
code: theorem sInter_comap_sets (f : α → β) (F : Filter β) : ⋂₀ (comap f F).sets = ⋂ U ∈ F, f ⁻¹' U 
goal: ⋂₀ (Filter.comap f F).sets = ⋂ U ∈ F, f ⁻¹' U

full_name: Filter.map_iInf_le
code: theorem map_iInf_le {f : ι → Filter α} {m : α → β} : map m (iInf f) ≤ ⨅ i, map m (f i) 
goal: Filter.map m (iInf f) ≤ ⨅ i, Filter.map m (f i)

full_name: Filter.map_iInf_eq
code: theorem map_iInf_eq {f : ι → Filter α} {m : α → β} (hf : Directed (· ≥ ·) f) [Nonempty ι] :
    map m (iInf f) = ⨅ i, map m (f i) 
goal: Filter.map m (iInf f) = ⨅ i, Filter.map m (f i)

full_name: Filter.map_biInf_eq
code: 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) 
goal: Filter.map m (⨅ i, ⨅ (_ : p i), f i) = ⨅ i, ⨅ (_ : p i), Filter.map m (f i)

full_name: Filter.map_inf_le
code: theorem map_inf_le {f g : Filter α} {m : α → β} : map m (f ⊓ g) ≤ map m f ⊓ map m g 
goal: Filter.map m (f ⊓ g) ≤ Filter.map m f ⊓ Filter.map m g

full_name: Filter.map_inf
code: theorem map_inf {f g : Filter α} {m : α → β} (h : Injective m) :
    map m (f ⊓ g) = map m f ⊓ map m g 
goal: Filter.map m (f ⊓ g) = Filter.map m f ⊓ Filter.map m g

full_name: Filter.map_inf'
code: 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 
goal: Filter.map m (f ⊓ g) = Filter.map m f ⊓ Filter.map m g

full_name: Filter.disjoint_of_map
code: lemma disjoint_of_map {α β : Type*} {F G : Filter α} {f : α → β}
    (h : Disjoint (map f F) (map f G)) : Disjoint F G 
goal: Disjoint F G

full_name: Filter.disjoint_map
code: theorem disjoint_map {m : α → β} (hm : Injective m) {f₁ f₂ : Filter α} :
    Disjoint (map m f₁) (map m f₂) ↔ Disjoint f₁ f₂ 
goal: Disjoint (Filter.map m f₁) (Filter.map m f₂) ↔ Disjoint f₁ f₂

full_name: Filter.map_equiv_symm
code: theorem map_equiv_symm (e : α ≃ β) (f : Filter β) : map e.symm f = comap e f 
goal: Filter.map (⇑e.symm) f = Filter.comap (⇑e) f

full_name: Filter.map_eq_comap_of_inverse
code: theorem map_eq_comap_of_inverse {f : Filter α} {m : α → β} {n : β → α} (h₁ : m ∘ n = id)
    (h₂ : n ∘ m = id) : map m f = comap n f 
goal: Filter.map m f = Filter.comap n f

full_name: Filter.comap_equiv_symm
code: theorem comap_equiv_symm (e : α ≃ β) (f : Filter α) : comap e.symm f = map e f 
goal: Filter.comap (⇑e.symm) f = Filter.map (⇑e) f

full_name: Filter.map_swap_eq_comap_swap
code: theorem map_swap_eq_comap_swap {f : Filter (α × β)} : Prod.swap <$> f = comap Prod.swap f 
goal: Prod.swap <$> f = Filter.comap Prod.swap f

full_name: Filter.map_swap4_eq_comap
code: /-- A useful lemma when dealing with uniformities. -/
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 
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

full_name: Filter.le_map
code: theorem le_map {f : Filter α} {m : α → β} {g : Filter β} (h : ∀ s ∈ f, m '' s ∈ g) : g ≤ f.map m 
goal: g ≤ Filter.map m f

full_name: Filter.le_map_iff
code: theorem le_map_iff {f : Filter α} {m : α → β} {g : Filter β} : g ≤ f.map m ↔ ∀ s ∈ f, m '' s ∈ g 
goal: g ≤ Filter.map m f ↔ ∀ s ∈ f, m '' s ∈ g

full_name: Filter.push_pull
code: protected theorem push_pull (f : α → β) (F : Filter α) (G : Filter β) :
    map f (F ⊓ comap f G) = map f F ⊓ G 
goal: Filter.map f (F ⊓ Filter.comap f G) = Filter.map f F ⊓ G

full_name: Filter.push_pull'
code: protected theorem push_pull' (f : α → β) (F : Filter α) (G : Filter β) :
    map f (comap f G ⊓ F) = G ⊓ map f F 
goal: Filter.map f (Filter.comap f G ⊓ F) = G ⊓ Filter.map f F

full_name: Filter.principal_eq_map_coe_top
code: theorem principal_eq_map_coe_top (s : Set α) : 𝓟 s = map ((↑) : s → α) ⊤ 
goal: 𝓟 s = Filter.map Subtype.val ⊤

full_name: Filter.inf_principal_eq_bot_iff_comap
code: theorem inf_principal_eq_bot_iff_comap {F : Filter α} {s : Set α} :
    F ⊓ 𝓟 s = ⊥ ↔ comap ((↑) : s → α) F = ⊥ 
goal: F ⊓ 𝓟 s = ⊥ ↔ Filter.comap Subtype.val F = ⊥

full_name: Filter.singleton_mem_pure
code: theorem singleton_mem_pure {a : α} : {a} ∈ (pure a : Filter α) 
goal: {a} ∈ pure a

full_name: Filter.pure_injective
code: theorem pure_injective : Injective (pure : α → Filter α) 
goal: Function.Injective pure

full_name: Filter.pure_neBot
code: instance pure_neBot {α : Type u} {a : α} : NeBot (pure a) 
goal: (pure a).NeBot

full_name: Filter.le_pure_iff
code: @[simp]
theorem le_pure_iff {f : Filter α} {a : α} : f ≤ pure a ↔ {a} ∈ f 
goal: f ≤ pure a ↔ {a} ∈ f

full_name: Filter.mem_seq_def
code: 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 
goal: s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, ∀ x ∈ u, ∀ y ∈ t, x y ∈ s

full_name: Filter.mem_seq_iff
code: theorem mem_seq_iff {f : Filter (α → β)} {g : Filter α} {s : Set β} :
    s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, Set.seq u t ⊆ s 
goal: s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, u.seq t ⊆ s

full_name: Filter.mem_map_seq_iff
code: 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 
goal: s ∈ (Filter.map m f).seq g ↔ ∃ t u, t ∈ g ∧ u ∈ f ∧ ∀ x ∈ u, ∀ y ∈ t, m x y ∈ s

full_name: Filter.seq_mem_seq
code: theorem seq_mem_seq {f : Filter (α → β)} {g : Filter α} {s : Set (α → β)} {t : Set α} (hs : s ∈ f)
    (ht : t ∈ g) : s.seq t ∈ f.seq g 
goal: s.seq t ∈ f.seq g

full_name: Filter.le_seq
code: theorem le_seq {f : Filter (α → β)} {g : Filter α} {h : Filter β}
    (hh : ∀ t ∈ f, ∀ u ∈ g, Set.seq t u ∈ h) : h ≤ seq f g 
goal: h ≤ f.seq g

full_name: Filter.seq_mono
code: @[mono]
theorem seq_mono {f₁ f₂ : Filter (α → β)} {g₁ g₂ : Filter α} (hf : f₁ ≤ f₂) (hg : g₁ ≤ g₂) :
    f₁.seq g₁ ≤ f₂.seq g₂ 
goal: f₁.seq g₁ ≤ f₂.seq g₂

full_name: Filter.pure_seq_eq_map
code: @[simp]
theorem pure_seq_eq_map (g : α → β) (f : Filter α) : seq (pure g) f = f.map g 
goal: (pure g).seq f = Filter.map g f

full_name: Filter.seq_pure
code: @[simp]
theorem seq_pure (f : Filter (α → β)) (a : α) : seq f (pure a) = map (fun g : α → β => g a) f 
goal: f.seq (pure a) = Filter.map (fun g => g a) f

full_name: Filter.seq_assoc
code: @[simp]
theorem seq_assoc (x : Filter α) (g : Filter (α → β)) (h : Filter (β → γ)) :
    seq h (seq g x) = seq (seq (map (· ∘ ·) h) g) x 
goal: h.seq (g.seq x) = ((Filter.map (fun x x_1 => x ∘ x_1) h).seq g).seq x

full_name: Filter.prod_map_seq_comm
code: theorem prod_map_seq_comm (f : Filter α) (g : Filter β) :
    (map Prod.mk f).seq g = seq (map (fun b a => (a, b)) g) f 
goal: (Filter.map Prod.mk f).seq g = (Filter.map (fun b a => (a, b)) g).seq f

full_name: Filter.seq_eq_filter_seq
code: theorem seq_eq_filter_seq {α β : Type u} (f : Filter (α → β)) (g : Filter α) :
    f <*> g = seq f g 
goal: (Seq.seq f fun x => g) = f.seq g

full_name: Filter.instLawfulApplicative
code: instance : LawfulApplicative (Filter : Type u → Type u) 
goal: LawfulApplicative Filter

full_name: Filter.instCommApplicative
code: instance : CommApplicative (Filter : Type u → Type u) 
goal: CommApplicative Filter

full_name: Filter.eventually_bind
code: @[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 
goal: (∀ᶠ (y : β) in f.bind m, p y) ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in m x, p y

full_name: Filter.eventuallyEq_bind
code: @[simp]
theorem eventuallyEq_bind {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ} :
    g₁ =ᶠ[bind f m] g₂ ↔ ∀ᶠ x in f, g₁ =ᶠ[m x] g₂ 
goal: g₁ =ᶠ[f.bind m] g₂ ↔ ∀ᶠ (x : α) in f, g₁ =ᶠ[m x] g₂

full_name: Filter.eventuallyLE_bind
code: @[simp]
theorem eventuallyLE_bind [LE γ] {f : Filter α} {m : α → Filter β} {g₁ g₂ : β → γ} :
    g₁ ≤ᶠ[bind f m] g₂ ↔ ∀ᶠ x in f, g₁ ≤ᶠ[m x] g₂ 
goal: g₁ ≤ᶠ[f.bind m] g₂ ↔ ∀ᶠ (x : α) in f, g₁ ≤ᶠ[m x] g₂

full_name: Filter.mem_bind'
code: theorem mem_bind' {s : Set β} {f : Filter α} {m : α → Filter β} :
    s ∈ bind f m ↔ { a | s ∈ m a } ∈ f 
goal: s ∈ f.bind m ↔ {a | s ∈ m a} ∈ f

full_name: Filter.mem_bind
code: @[simp]
theorem mem_bind {s : Set β} {f : Filter α} {m : α → Filter β} :
    s ∈ bind f m ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x 
goal: s ∈ f.bind m ↔ ∃ t ∈ f, ∀ x ∈ t, s ∈ m x

full_name: Filter.bind_le
code: theorem bind_le {f : Filter α} {g : α → Filter β} {l : Filter β} (h : ∀ᶠ x in f, g x ≤ l) :
    f.bind g ≤ l 
goal: f.bind g ≤ l

full_name: Filter.bind_mono
code: @[mono]
theorem bind_mono {f₁ f₂ : Filter α} {g₁ g₂ : α → Filter β} (hf : f₁ ≤ f₂) (hg : g₁ ≤ᶠ[f₁] g₂) :
    bind f₁ g₁ ≤ bind f₂ g₂ 
goal: f₁.bind g₁ ≤ f₂.bind g₂

full_name: Filter.bind_inf_principal
code: theorem bind_inf_principal {f : Filter α} {g : α → Filter β} {s : Set β} :
    (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s 
goal: (f.bind fun x => g x ⊓ 𝓟 s) = f.bind g ⊓ 𝓟 s

full_name: Filter.sup_bind
code: theorem sup_bind {f g : Filter α} {h : α → Filter β} : bind (f ⊔ g) h = bind f h ⊔ bind g h 
goal: (f ⊔ g).bind h = f.bind h ⊔ g.bind h

full_name: Filter.principal_bind
code: theorem principal_bind {s : Set α} {f : α → Filter β} : bind (𝓟 s) f = ⨆ x ∈ s, f x 
goal: (𝓟 s).bind f = ⨆ x ∈ s, f x

full_name: Filter.Tendsto
code: /-- `Filter.Tendsto` is the generic "limit of a function" predicate.
  `Tendsto f l₁ l₂` asserts that for every `l₂` neighborhood `a`,
  the `f`-preimage of `a` is an `l₁` neighborhood. -/
def Tendsto (f : α → β) (l₁ : Filter α) (l₂ : Filter β) 
goal: Prop

full_name: Filter.tendsto_def
code: theorem tendsto_def {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ 
goal: Filter.Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁

full_name: Filter.tendsto_iff_eventually
code: 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) 
goal: Filter.Tendsto f l₁ l₂ ↔ ∀ ⦃p : β → Prop⦄, (∀ᶠ (y : β) in l₂, p y) → ∀ᶠ (x : α) in l₁, p (f x)

full_name: Filter.tendsto_iff_forall_eventually_mem
code: theorem tendsto_iff_forall_eventually_mem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, ∀ᶠ x in l₁, f x ∈ s 
goal: Filter.Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, ∀ᶠ (x : α) in l₁, f x ∈ s

full_name: Filter.Tendsto.eventually_mem
code: 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 
goal: ∀ᶠ (x : α) in l₁, f x ∈ s

full_name: Filter.Tendsto.eventually
code: 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) 
goal: ∀ᶠ (x : α) in l₁, p (f x)

full_name: Filter.not_tendsto_iff_exists_frequently_nmem
code: theorem not_tendsto_iff_exists_frequently_nmem {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    ¬Tendsto f l₁ l₂ ↔ ∃ s ∈ l₂, ∃ᶠ x in l₁, f x ∉ s 
goal: ¬Filter.Tendsto f l₁ l₂ ↔ ∃ s ∈ l₂, ∃ᶠ (x : α) in l₁, f x ∉ s

full_name: Filter.Tendsto.frequently
code: 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 
goal: ∃ᶠ (y : β) in l₂, p y

full_name: Filter.Tendsto.frequently_map
code: 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 
goal: ∃ᶠ (y : β) in l₂, q y

full_name: Filter.tendsto_bot
code: @[simp]
theorem tendsto_bot {f : α → β} {l : Filter β} : Tendsto f ⊥ l 
goal: Filter.Tendsto f ⊥ l

full_name: Filter.tendsto_top
code: @[simp] theorem tendsto_top {f : α → β} {l : Filter α} : Tendsto f l ⊤ 
goal: Filter.Tendsto f l ⊤

full_name: Filter.le_map_of_right_inverse
code: theorem le_map_of_right_inverse {mab : α → β} {mba : β → α} {f : Filter α} {g : Filter β}
    (h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : Tendsto mba g f) : g ≤ map mab f 
goal: g ≤ Filter.map mab f

full_name: Filter.tendsto_of_isEmpty
code: theorem tendsto_of_isEmpty [IsEmpty α] {f : α → β} {la : Filter α} {lb : Filter β} :
    Tendsto f la lb 
goal: Filter.Tendsto f la lb

full_name: Filter.eventuallyEq_of_left_inv_of_right_inv
code: theorem eventuallyEq_of_left_inv_of_right_inv {f : α → β} {g₁ g₂ : β → α} {fa : Filter α}
    {fb : Filter β} (hleft : ∀ᶠ x in fa, g₁ (f x) = x) (hright : ∀ᶠ y in fb, f (g₂ y) = y)
    (htendsto : Tendsto g₂ fb fa) : g₁ =ᶠ[fb] g₂ 
goal: g₁ =ᶠ[fb] g₂

full_name: Filter.tendsto_iff_comap
code: theorem tendsto_iff_comap {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    Tendsto f l₁ l₂ ↔ l₁ ≤ l₂.comap f 
goal: Filter.Tendsto f l₁ l₂ ↔ l₁ ≤ Filter.comap f l₂

full_name: Filter.Tendsto.disjoint
code: protected theorem Tendsto.disjoint {f : α → β} {la₁ la₂ : Filter α} {lb₁ lb₂ : Filter β}
    (h₁ : Tendsto f la₁ lb₁) (hd : Disjoint lb₁ lb₂) (h₂ : Tendsto f la₂ lb₂) : Disjoint la₁ la₂ 
goal: Disjoint la₁ la₂

full_name: Filter.tendsto_congr'
code: theorem tendsto_congr' {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β} (hl : f₁ =ᶠ[l₁] f₂) :
    Tendsto f₁ l₁ l₂ ↔ Tendsto f₂ l₁ l₂ 
goal: Filter.Tendsto f₁ l₁ l₂ ↔ Filter.Tendsto f₂ l₁ l₂

full_name: Filter.Tendsto.congr'
code: theorem Tendsto.congr' {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β} (hl : f₁ =ᶠ[l₁] f₂)
    (h : Tendsto f₁ l₁ l₂) : Tendsto f₂ l₁ l₂ 
goal: Filter.Tendsto f₂ l₁ l₂

full_name: Filter.tendsto_congr
code: theorem tendsto_congr {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β} (h : ∀ x, f₁ x = f₂ x) :
    Tendsto f₁ l₁ l₂ ↔ Tendsto f₂ l₁ l₂ 
goal: Filter.Tendsto f₁ l₁ l₂ ↔ Filter.Tendsto f₂ l₁ l₂

full_name: Filter.Tendsto.congr
code: theorem Tendsto.congr {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β} (h : ∀ x, f₁ x = f₂ x) :
    Tendsto f₁ l₁ l₂ → Tendsto f₂ l₁ l₂ 
goal: Filter.Tendsto f₁ l₁ l₂ → Filter.Tendsto f₂ l₁ l₂

full_name: Filter.tendsto_id'
code: theorem tendsto_id' {x y : Filter α} : Tendsto id x y ↔ x ≤ y 
goal: Filter.Tendsto id x y ↔ x ≤ y

full_name: Filter.tendsto_id
code: theorem tendsto_id {x : Filter α} : Tendsto id x x 
goal: Filter.Tendsto id x x

full_name: Filter.Tendsto.comp
code: theorem Tendsto.comp {f : α → β} {g : β → γ} {x : Filter α} {y : Filter β} {z : Filter γ}
    (hg : Tendsto g y z) (hf : Tendsto f x y) : Tendsto (g ∘ f) x z 
goal: Filter.Tendsto (g ∘ f) x z

full_name: Filter.Tendsto.iterate
code: protected theorem Tendsto.iterate {f : α → α} {l : Filter α} (h : Tendsto f l l) :
    ∀ n, Tendsto (f^[n]) l l
  
goal: Filter.Tendsto f^[n] l l

full_name: Filter.Tendsto.mono_left
code: theorem Tendsto.mono_left {f : α → β} {x y : Filter α} {z : Filter β} (hx : Tendsto f x z)
    (h : y ≤ x) : Tendsto f y z 
goal: Filter.Tendsto f y z

full_name: Filter.Tendsto.mono_right
code: theorem Tendsto.mono_right {f : α → β} {x : Filter α} {y z : Filter β} (hy : Tendsto f x y)
    (hz : y ≤ z) : Tendsto f x z 
goal: Filter.Tendsto f x z

full_name: Filter.Tendsto.neBot
code: theorem Tendsto.neBot {f : α → β} {x : Filter α} {y : Filter β} (h : Tendsto f x y) [hx : NeBot x] :
    NeBot y 
goal: y.NeBot

full_name: Filter.tendsto_map
code: theorem tendsto_map {f : α → β} {x : Filter α} : Tendsto f x (map f x) 
goal: Filter.Tendsto f x (Filter.map f x)

full_name: Filter.tendsto_map'_iff
code: @[simp]
theorem tendsto_map'_iff {f : β → γ} {g : α → β} {x : Filter α} {y : Filter γ} :
    Tendsto f (map g x) y ↔ Tendsto (f ∘ g) x y 
goal: Filter.Tendsto f (Filter.map g x) y ↔ Filter.Tendsto (f ∘ g) x y

full_name: Filter.tendsto_comap
code: theorem tendsto_comap {f : α → β} {x : Filter β} : Tendsto f (comap f x) x 
goal: Filter.Tendsto f (Filter.comap f x) x

full_name: Filter.tendsto_comap_iff
code: @[simp]
theorem tendsto_comap_iff {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ} :
    Tendsto f a (c.comap g) ↔ Tendsto (g ∘ f) a c 
goal: Filter.Tendsto f a (Filter.comap g c) ↔ Filter.Tendsto (g ∘ f) a c

full_name: Filter.tendsto_comap'_iff
code: theorem tendsto_comap'_iff {m : α → β} {f : Filter α} {g : Filter β} {i : γ → α} (h : range i ∈ f) :
    Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g 
goal: Filter.Tendsto (m ∘ i) (Filter.comap i f) g ↔ Filter.Tendsto m f g

full_name: Filter.Tendsto.of_tendsto_comp
code: theorem Tendsto.of_tendsto_comp {f : α → β} {g : β → γ} {a : Filter α} {b : Filter β} {c : Filter γ}
    (hfg : Tendsto (g ∘ f) a c) (hg : comap g c ≤ b) : Tendsto f a b 
goal: Filter.Tendsto f a b

full_name: Filter.comap_eq_of_inverse
code: theorem comap_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : ψ ∘ φ = id)
    (hφ : Tendsto φ f g) (hψ : Tendsto ψ g f) : comap φ g = f 
goal: Filter.comap φ g = f

full_name: Filter.map_eq_of_inverse
code: theorem map_eq_of_inverse {f : Filter α} {g : Filter β} {φ : α → β} (ψ : β → α) (eq : φ ∘ ψ = id)
    (hφ : Tendsto φ f g) (hψ : Tendsto ψ g f) : map φ f = g 
goal: Filter.map φ f = g

full_name: Filter.tendsto_inf
code: theorem tendsto_inf {f : α → β} {x : Filter α} {y₁ y₂ : Filter β} :
    Tendsto f x (y₁ ⊓ y₂) ↔ Tendsto f x y₁ ∧ Tendsto f x y₂ 
goal: Filter.Tendsto f x (y₁ ⊓ y₂) ↔ Filter.Tendsto f x y₁ ∧ Filter.Tendsto f x y₂

full_name: Filter.tendsto_inf_left
code: theorem tendsto_inf_left {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₁ y) :
    Tendsto f (x₁ ⊓ x₂) y 
goal: Filter.Tendsto f (x₁ ⊓ x₂) y

full_name: Filter.tendsto_inf_right
code: theorem tendsto_inf_right {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} (h : Tendsto f x₂ y) :
    Tendsto f (x₁ ⊓ x₂) y 
goal: Filter.Tendsto f (x₁ ⊓ x₂) y

full_name: Filter.Tendsto.inf
code: theorem Tendsto.inf {f : α → β} {x₁ x₂ : Filter α} {y₁ y₂ : Filter β} (h₁ : Tendsto f x₁ y₁)
    (h₂ : Tendsto f x₂ y₂) : Tendsto f (x₁ ⊓ x₂) (y₁ ⊓ y₂) 
goal: Filter.Tendsto f (x₁ ⊓ x₂) (y₁ ⊓ y₂)

full_name: Filter.tendsto_iInf
code: @[simp]
theorem tendsto_iInf {f : α → β} {x : Filter α} {y : ι → Filter β} :
    Tendsto f x (⨅ i, y i) ↔ ∀ i, Tendsto f x (y i) 
goal: Filter.Tendsto f x (⨅ i, y i) ↔ ∀ (i : ι), Filter.Tendsto f x (y i)

full_name: Filter.tendsto_iInf'
code: theorem tendsto_iInf' {f : α → β} {x : ι → Filter α} {y : Filter β} (i : ι)
    (hi : Tendsto f (x i) y) : Tendsto f (⨅ i, x i) y 
goal: Filter.Tendsto f (⨅ i, x i) y

full_name: Filter.tendsto_iInf_iInf
code: theorem tendsto_iInf_iInf {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
    (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (iInf x) (iInf y) 
goal: Filter.Tendsto f (iInf x) (iInf y)

full_name: Filter.tendsto_sup
code: @[simp]
theorem tendsto_sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
    Tendsto f (x₁ ⊔ x₂) y ↔ Tendsto f x₁ y ∧ Tendsto f x₂ y 
goal: Filter.Tendsto f (x₁ ⊔ x₂) y ↔ Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y

full_name: Filter.Tendsto.sup
code: theorem Tendsto.sup {f : α → β} {x₁ x₂ : Filter α} {y : Filter β} :
    Tendsto f x₁ y → Tendsto f x₂ y → Tendsto f (x₁ ⊔ x₂) y 
goal: Filter.Tendsto f x₁ y → Filter.Tendsto f x₂ y → Filter.Tendsto f (x₁ ⊔ x₂) y

full_name: Filter.Tendsto.sup_sup
code: theorem Tendsto.sup_sup {f : α → β} {x₁ x₂ : Filter α} {y₁ y₂ : Filter β}
    (h₁ : Tendsto f x₁ y₁) (h₂ : Tendsto f x₂ y₂) : Tendsto f (x₁ ⊔ x₂) (y₁ ⊔ y₂) 
goal: Filter.Tendsto f (x₁ ⊔ x₂) (y₁ ⊔ y₂)

full_name: Filter.tendsto_iSup
code: @[simp]
theorem tendsto_iSup {f : α → β} {x : ι → Filter α} {y : Filter β} :
    Tendsto f (⨆ i, x i) y ↔ ∀ i, Tendsto f (x i) y 
goal: Filter.Tendsto f (⨆ i, x i) y ↔ ∀ (i : ι), Filter.Tendsto f (x i) y

full_name: Filter.tendsto_iSup_iSup
code: theorem tendsto_iSup_iSup {f : α → β} {x : ι → Filter α} {y : ι → Filter β}
    (h : ∀ i, Tendsto f (x i) (y i)) : Tendsto f (iSup x) (iSup y) 
goal: Filter.Tendsto f (iSup x) (iSup y)

full_name: Filter.tendsto_principal
code: @[simp] theorem tendsto_principal {f : α → β} {l : Filter α} {s : Set β} :
    Tendsto f l (𝓟 s) ↔ ∀ᶠ a in l, f a ∈ s 
goal: Filter.Tendsto f l (𝓟 s) ↔ ∀ᶠ (a : α) in l, f a ∈ s

full_name: Filter.tendsto_principal_principal
code: theorem tendsto_principal_principal {f : α → β} {s : Set α} {t : Set β} :
    Tendsto f (𝓟 s) (𝓟 t) ↔ ∀ a ∈ s, f a ∈ t 
goal: Filter.Tendsto f (𝓟 s) (𝓟 t) ↔ ∀ a ∈ s, f a ∈ t

full_name: Filter.tendsto_pure
code: @[simp] theorem tendsto_pure {f : α → β} {a : Filter α} {b : β} :
    Tendsto f a (pure b) ↔ ∀ᶠ x in a, f x = b 
goal: Filter.Tendsto f a (pure b) ↔ ∀ᶠ (x : α) in a, f x = b

full_name: Filter.tendsto_pure_pure
code: theorem tendsto_pure_pure (f : α → β) (a : α) : Tendsto f (pure a) (pure (f a)) 
goal: Filter.Tendsto f (pure a) (pure (f a))

full_name: Filter.tendsto_const_pure
code: theorem tendsto_const_pure {a : Filter α} {b : β} : Tendsto (fun _ => b) a (pure b) 
goal: Filter.Tendsto (fun x => b) a (pure b)

full_name: Filter.pure_le_iff
code: theorem pure_le_iff {a : α} {l : Filter α} : pure a ≤ l ↔ ∀ s ∈ l, a ∈ s 
goal: pure a ≤ l ↔ ∀ s ∈ l, a ∈ s

full_name: Filter.tendsto_pure_left
code: theorem tendsto_pure_left {f : α → β} {a : α} {l : Filter β} :
    Tendsto f (pure a) l ↔ ∀ s ∈ l, f a ∈ s 
goal: Filter.Tendsto f (pure a) l ↔ ∀ s ∈ l, f a ∈ s

full_name: Filter.map_inf_principal_preimage
code: @[simp]
theorem map_inf_principal_preimage {f : α → β} {s : Set β} {l : Filter α} :
    map f (l ⊓ 𝓟 (f ⁻¹' s)) = map f l ⊓ 𝓟 s 
goal: Filter.map f (l ⊓ 𝓟 (f ⁻¹' s)) = Filter.map f l ⊓ 𝓟 s

full_name: Filter.Tendsto.not_tendsto
code: /-- If two filters are disjoint, then a function cannot tend to both of them along a non-trivial
filter. -/
theorem Tendsto.not_tendsto {f : α → β} {a : Filter α} {b₁ b₂ : Filter β} (hf : Tendsto f a b₁)
    [NeBot a] (hb : Disjoint b₁ b₂) : ¬Tendsto f a b₂ 
goal: ¬Filter.Tendsto f a b₂

full_name: Filter.Tendsto.if
code: protected theorem Tendsto.if {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {p : α → Prop}
    [∀ x, Decidable (p x)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 { x | p x }) l₂)
    (h₁ : Tendsto g (l₁ ⊓ 𝓟 { x | ¬p x }) l₂) :
    Tendsto (fun x => if p x then f x else g x) l₁ l₂ 
goal: Filter.Tendsto (fun x => if p x then f x else g x) l₁ l₂

full_name: Filter.Tendsto.if'
code: protected theorem Tendsto.if' {α β : Type*} {l₁ : Filter α} {l₂ : Filter β} {f g : α → β}
    {p : α → Prop} [DecidablePred p] (hf : Tendsto f l₁ l₂) (hg : Tendsto g l₁ l₂) :
    Tendsto (fun a => if p a then f a else g a) l₁ l₂ 
goal: Filter.Tendsto (fun a => if p a then f a else g a) l₁ l₂

full_name: Filter.Tendsto.piecewise
code: protected theorem Tendsto.piecewise {l₁ : Filter α} {l₂ : Filter β} {f g : α → β} {s : Set α}
    [∀ x, Decidable (x ∈ s)] (h₀ : Tendsto f (l₁ ⊓ 𝓟 s) l₂) (h₁ : Tendsto g (l₁ ⊓ 𝓟 sᶜ) l₂) :
    Tendsto (piecewise s f g) l₁ l₂ 
goal: Filter.Tendsto (s.piecewise f g) l₁ l₂

full_name: Set.EqOn.eventuallyEq
code: theorem Set.EqOn.eventuallyEq {α β} {s : Set α} {f g : α → β} (h : EqOn f g s) : f =ᶠ[𝓟 s] g 
goal: f =ᶠ[𝓟 s] g

full_name: Set.EqOn.eventuallyEq_of_mem
code: theorem Set.EqOn.eventuallyEq_of_mem {α β} {s : Set α} {l : Filter α} {f g : α → β} (h : EqOn f g s)
    (hl : s ∈ l) : f =ᶠ[l] g 
goal: f =ᶠ[l] g

full_name: HasSubset.Subset.eventuallyLE
code: theorem HasSubset.Subset.eventuallyLE {α} {l : Filter α} {s t : Set α} (h : s ⊆ t) : s ≤ᶠ[l] t 
goal: s ≤ᶠ[l] t

full_name: Set.MapsTo.tendsto
code: theorem Set.MapsTo.tendsto {α β} {s : Set α} {t : Set β} {f : α → β} (h : MapsTo f s t) :
    Filter.Tendsto f (𝓟 s) (𝓟 t) 
goal: Filter.Tendsto f (𝓟 s) (𝓟 t)

full_name: Filter.EventuallyEq.comp_tendsto
code: theorem Filter.EventuallyEq.comp_tendsto {α β γ : Type*} {l : Filter α} {f : α → β} {f' : α → β}
    (H : f =ᶠ[l] f') {g : γ → α} {lc : Filter γ} (hg : Tendsto g lc l) :
    f ∘ g =ᶠ[lc] f' ∘ g 
goal: f ∘ g =ᶠ[lc] f' ∘ g

full_name: Filter.map_mapsTo_Iic_iff_tendsto
code: theorem Filter.map_mapsTo_Iic_iff_tendsto {m : α → β} :
    MapsTo (map m) (Iic F) (Iic G) ↔ Tendsto m F G 
goal: Set.MapsTo (Filter.map m) (Set.Iic F) (Set.Iic G) ↔ Filter.Tendsto m F G

full_name: Filter.map_mapsTo_Iic_iff_mapsTo
code: theorem Filter.map_mapsTo_Iic_iff_mapsTo {s : Set α} {t : Set β} {m : α → β} :
    MapsTo (map m) (Iic <| 𝓟 s) (Iic <| 𝓟 t) ↔ MapsTo m s t 
goal: Set.MapsTo (Filter.map m) (Set.Iic (𝓟 s)) (Set.Iic (𝓟 t)) ↔ Set.MapsTo m s t

full_name: Filter.map_surjOn_Iic_iff_le_map
code: theorem Filter.map_surjOn_Iic_iff_le_map {m : α → β} :
    SurjOn (map m) (Iic F) (Iic G) ↔ G ≤ map m F 
goal: Set.SurjOn (Filter.map m) (Set.Iic F) (Set.Iic G) ↔ G ≤ Filter.map m F

full_name: Filter.map_surjOn_Iic_iff_surjOn
code: theorem Filter.map_surjOn_Iic_iff_surjOn {s : Set α} {t : Set β} {m : α → β} :
    SurjOn (map m) (Iic <| 𝓟 s) (Iic <| 𝓟 t) ↔ SurjOn m s t 
goal: Set.SurjOn (Filter.map m) (Set.Iic (𝓟 s)) (Set.Iic (𝓟 t)) ↔ Set.SurjOn m s t

full_name: Filter.filter_injOn_Iic_iff_injOn
code: theorem Filter.filter_injOn_Iic_iff_injOn {s : Set α} {m : α → β} :
    InjOn (map m) (Iic <| 𝓟 s) ↔ InjOn m s 
goal: Set.InjOn (Filter.map m) (Set.Iic (𝓟 s)) ↔ Set.InjOn m s

full_name: Filter.comk
code: /-- Construct a filter from a property that is stable under finite unions.
A set `s` belongs to `Filter.comk p _ _ _` iff its complement satisfies the predicate `p`.
This constructor is useful to define filters like `Filter.cofinite`. -/
def comk (p : Set α → Prop) (he : p ∅) (hmono : ∀ t, p t → ∀ s ⊆ t, p s)
    (hunion : ∀ s, p s → ∀ t, p t → p (s ∪ t)) : Filter α 
goal: Filter α

full_name: Filter.mem_comk
code: @[simp]
lemma mem_comk {p : Set α → Prop} {he hmono hunion s} :
    s ∈ comk p he hmono hunion ↔ p sᶜ 
goal: s ∈ Filter.comk p he hmono hunion ↔ p sᶜ

full_name: Filter.compl_mem_comk
code: lemma compl_mem_comk {p : Set α → Prop} {he hmono hunion s} :
    sᶜ ∈ comk p he hmono hunion ↔ p s 
goal: sᶜ ∈ Filter.comk p he hmono hunion ↔ p s