File: Mathlib/Order/LiminfLimsup.lean

full_name: Filter.IsBounded
code: /-- `f.IsBounded (≺)`: the filter `f` is eventually bounded w.r.t. the relation `≺`, i.e.
eventually, it is bounded by some uniform bound.
`r` will be usually instantiated with `≤` or `≥`. -/
def IsBounded (r : α → α → Prop) (f : Filter α) 
goal: Prop

full_name: Filter.IsBoundedUnder
code: /-- `f.IsBoundedUnder (≺) u`: the image of the filter `f` under `u` is eventually bounded w.r.t.
the relation `≺`, i.e. eventually, it is bounded by some uniform bound. -/
def IsBoundedUnder (r : α → α → Prop) (f : Filter β) (u : β → α) 
goal: Prop

full_name: Filter.isBounded_iff
code: /-- `f` is eventually bounded if and only if, there exists an admissible set on which it is
bounded. -/
theorem isBounded_iff : f.IsBounded r ↔ ∃ s ∈ f.sets, ∃ b, s ⊆ { x | r x b } 
goal: Filter.IsBounded r f ↔ ∃ s ∈ f.sets, ∃ b, s ⊆ {x | r x b}

full_name: Filter.isBoundedUnder_of
code: /-- A bounded function `u` is in particular eventually bounded. -/
theorem isBoundedUnder_of {f : Filter β} {u : β → α} : (∃ b, ∀ x, r (u x) b) → f.IsBoundedUnder r u
  
goal: (∃ b, ∀ (x : β), r (u x) b) → Filter.IsBoundedUnder r f u

full_name: Filter.isBounded_bot
code: theorem isBounded_bot : IsBounded r ⊥ ↔ Nonempty α 
goal: Filter.IsBounded r ⊥ ↔ Nonempty α

full_name: Filter.isBounded_top
code: theorem isBounded_top : IsBounded r ⊤ ↔ ∃ t, ∀ x, r x t 
goal: Filter.IsBounded r ⊤ ↔ ∃ t, ∀ (x : α), r x t

full_name: Filter.isBounded_principal
code: theorem isBounded_principal (s : Set α) : IsBounded r (𝓟 s) ↔ ∃ t, ∀ x ∈ s, r x t 
goal: Filter.IsBounded r (𝓟 s) ↔ ∃ t, ∀ x ∈ s, r x t

full_name: Filter.isBounded_sup
code: theorem isBounded_sup [IsTrans α r] [IsDirected α r] :
    IsBounded r f → IsBounded r g → IsBounded r (f ⊔ g)
  
goal: Filter.IsBounded r f → Filter.IsBounded r g → Filter.IsBounded r (f ⊔ g)

full_name: Filter.IsBounded.mono
code: theorem IsBounded.mono (h : f ≤ g) : IsBounded r g → IsBounded r f
  
goal: Filter.IsBounded r g → Filter.IsBounded r f

full_name: Filter.IsBoundedUnder.mono
code: theorem IsBoundedUnder.mono {f g : Filter β} {u : β → α} (h : f ≤ g) :
    g.IsBoundedUnder r u → f.IsBoundedUnder r u 
goal: Filter.IsBoundedUnder r g u → Filter.IsBoundedUnder r f u

full_name: Filter.IsBoundedUnder.mono_le
code: theorem IsBoundedUnder.mono_le [Preorder β] {l : Filter α} {u v : α → β}
    (hu : IsBoundedUnder (· ≤ ·) l u) (hv : v ≤ᶠ[l] u) : IsBoundedUnder (· ≤ ·) l v 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l v

full_name: Filter.IsBoundedUnder.mono_ge
code: theorem IsBoundedUnder.mono_ge [Preorder β] {l : Filter α} {u v : α → β}
    (hu : IsBoundedUnder (· ≥ ·) l u) (hv : u ≤ᶠ[l] v) : IsBoundedUnder (· ≥ ·) l v 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l v

full_name: Filter.isBoundedUnder_const
code: theorem isBoundedUnder_const [IsRefl α r] {l : Filter β} {a : α} : IsBoundedUnder r l fun _ => a 
goal: Filter.IsBoundedUnder r l fun x => a

full_name: Filter.IsBounded.isBoundedUnder
code: theorem IsBounded.isBoundedUnder {q : β → β → Prop} {u : α → β}
    (hu : ∀ a₀ a₁, r a₀ a₁ → q (u a₀) (u a₁)) : f.IsBounded r → f.IsBoundedUnder q u
  
goal: Filter.IsBounded r f → Filter.IsBoundedUnder q f u

full_name: Filter.IsBoundedUnder.comp
code: theorem IsBoundedUnder.comp {l : Filter γ} {q : β → β → Prop} {u : γ → α} {v : α → β}
    (hv : ∀ a₀ a₁, r a₀ a₁ → q (v a₀) (v a₁)) : l.IsBoundedUnder r u → l.IsBoundedUnder q (v ∘ u)
  
goal: Filter.IsBoundedUnder r l u → Filter.IsBoundedUnder q l (v ∘ u)

full_name: BddAbove.isBoundedUnder
code: /-- A bounded above function `u` is in particular eventually bounded above. -/
lemma _root_.BddAbove.isBoundedUnder [Preorder α] {f : Filter β} {u : β → α} :
    BddAbove (Set.range u) → f.IsBoundedUnder (· ≤ ·) u
  
goal: BddAbove (Set.range u) → Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u

full_name: BddBelow.isBoundedUnder
code: /-- A bounded below function `u` is in particular eventually bounded below. -/
lemma _root_.BddBelow.isBoundedUnder [Preorder α] {f : Filter β} {u : β → α} :
    BddBelow (Set.range u) → f.IsBoundedUnder (· ≥ ·) u
  
goal: BddBelow (Set.range u) → Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u

full_name: Monotone.isBoundedUnder_le_comp
code: theorem _root_.Monotone.isBoundedUnder_le_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Monotone v) (hl : l.IsBoundedUnder (· ≤ ·) u) :
    l.IsBoundedUnder (· ≤ ·) (v ∘ u) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (v ∘ u)

full_name: Monotone.isBoundedUnder_ge_comp
code: theorem _root_.Monotone.isBoundedUnder_ge_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Monotone v) (hl : l.IsBoundedUnder (· ≥ ·) u) :
    l.IsBoundedUnder (· ≥ ·) (v ∘ u) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l (v ∘ u)

full_name: Antitone.isBoundedUnder_le_comp
code: theorem _root_.Antitone.isBoundedUnder_le_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Antitone v) (hl : l.IsBoundedUnder (· ≥ ·) u) :
    l.IsBoundedUnder (· ≤ ·) (v ∘ u) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (v ∘ u)

full_name: Antitone.isBoundedUnder_ge_comp
code: theorem _root_.Antitone.isBoundedUnder_ge_comp [Preorder α] [Preorder β] {l : Filter γ} {u : γ → α}
    {v : α → β} (hv : Antitone v) (hl : l.IsBoundedUnder (· ≤ ·) u) :
    l.IsBoundedUnder (· ≥ ·) (v ∘ u) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l (v ∘ u)

full_name: Filter.not_isBoundedUnder_of_tendsto_atTop
code: theorem not_isBoundedUnder_of_tendsto_atTop [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α}
    [l.NeBot] (hf : Tendsto f l atTop) : ¬IsBoundedUnder (· ≤ ·) l f 
goal: ¬Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

full_name: Filter.not_isBoundedUnder_of_tendsto_atBot
code: theorem not_isBoundedUnder_of_tendsto_atBot [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α}
    [l.NeBot] (hf : Tendsto f l atBot) : ¬IsBoundedUnder (· ≥ ·) l f 
goal: ¬Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l f

full_name: Filter.IsBoundedUnder.bddAbove_range_of_cofinite
code: theorem IsBoundedUnder.bddAbove_range_of_cofinite [Preorder β] [IsDirected β (· ≤ ·)] {f : α → β}
    (hf : IsBoundedUnder (· ≤ ·) cofinite f) : BddAbove (range f) 
goal: BddAbove (Set.range f)

full_name: Filter.IsBoundedUnder.bddBelow_range_of_cofinite
code: theorem IsBoundedUnder.bddBelow_range_of_cofinite [Preorder β] [IsDirected β (· ≥ ·)] {f : α → β}
    (hf : IsBoundedUnder (· ≥ ·) cofinite f) : BddBelow (range f) 
goal: BddBelow (Set.range f)

full_name: Filter.IsBoundedUnder.bddAbove_range
code: theorem IsBoundedUnder.bddAbove_range [Preorder β] [IsDirected β (· ≤ ·)] {f : ℕ → β}
    (hf : IsBoundedUnder (· ≤ ·) atTop f) : BddAbove (range f) 
goal: BddAbove (Set.range f)

full_name: Filter.IsBoundedUnder.bddBelow_range
code: theorem IsBoundedUnder.bddBelow_range [Preorder β] [IsDirected β (· ≥ ·)] {f : ℕ → β}
    (hf : IsBoundedUnder (· ≥ ·) atTop f) : BddBelow (range f) 
goal: BddBelow (Set.range f)

full_name: Filter.IsCobounded
code: /-- `IsCobounded (≺) f` states that the filter `f` does not tend to infinity w.r.t. `≺`. This is
also called frequently bounded. Will be usually instantiated with `≤` or `≥`.

There is a subtlety in this definition: we want `f.IsCobounded` to hold for any `f` in the case of
complete lattices. This will be relevant to deduce theorems on complete lattices from their
versions on conditionally complete lattices with additional assumptions. We have to be careful in
the edge case of the trivial filter containing the empty set: the other natural definition
  `¬ ∀ a, ∀ᶠ n in f, a ≤ n`
would not work as well in this case.
-/
def IsCobounded (r : α → α → Prop) (f : Filter α) 
goal: Prop

full_name: Filter.IsCoboundedUnder
code: /-- `IsCoboundedUnder (≺) f u` states that the image of the filter `f` under the map `u` does not
tend to infinity w.r.t. `≺`. This is also called frequently bounded. Will be usually instantiated
with `≤` or `≥`. -/
def IsCoboundedUnder (r : α → α → Prop) (f : Filter β) (u : β → α) 
goal: Prop

full_name: Filter.IsCobounded.mk
code: /-- To check that a filter is frequently bounded, it suffices to have a witness
which bounds `f` at some point for every admissible set.

This is only an implication, as the other direction is wrong for the trivial filter. -/
theorem IsCobounded.mk [IsTrans α r] (a : α) (h : ∀ s ∈ f, ∃ x ∈ s, r a x) : f.IsCobounded r 
goal: Filter.IsCobounded r f

full_name: Filter.IsBounded.isCobounded_flip
code: /-- A filter which is eventually bounded is in particular frequently bounded (in the opposite
direction). At least if the filter is not trivial. -/
theorem IsBounded.isCobounded_flip [IsTrans α r] [NeBot f] : f.IsBounded r → f.IsCobounded (flip r)
  
goal: Filter.IsBounded r f → Filter.IsCobounded (flip r) f

full_name: Filter.IsBounded.isCobounded_ge
code: theorem IsBounded.isCobounded_ge [Preorder α] [NeBot f] (h : f.IsBounded (· ≤ ·)) :
    f.IsCobounded (· ≥ ·) 
goal: Filter.IsCobounded (fun x x_1 => x ≥ x_1) f

full_name: Filter.IsBounded.isCobounded_le
code: theorem IsBounded.isCobounded_le [Preorder α] [NeBot f] (h : f.IsBounded (· ≥ ·)) :
    f.IsCobounded (· ≤ ·) 
goal: Filter.IsCobounded (fun x x_1 => x ≤ x_1) f

full_name: Filter.IsBoundedUnder.isCoboundedUnder_flip
code: theorem IsBoundedUnder.isCoboundedUnder_flip {u : γ → α} {l : Filter γ} [IsTrans α r] [NeBot l]
    (h : l.IsBoundedUnder r u) : l.IsCoboundedUnder (flip r) u 
goal: Filter.IsCoboundedUnder (flip r) l u

full_name: Filter.IsBoundedUnder.isCoboundedUnder_le
code: theorem IsBoundedUnder.isCoboundedUnder_le {u : γ → α} {l : Filter γ} [Preorder α] [NeBot l]
    (h : l.IsBoundedUnder (· ≥ ·) u) : l.IsCoboundedUnder (· ≤ ·) u 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) l u

full_name: Filter.IsBoundedUnder.isCoboundedUnder_ge
code: theorem IsBoundedUnder.isCoboundedUnder_ge {u : γ → α} {l : Filter γ} [Preorder α] [NeBot l]
    (h : l.IsBoundedUnder (· ≤ ·) u) : l.IsCoboundedUnder (· ≥ ·) u 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) l u

full_name: Filter.isCoboundedUnder_le_of_eventually_le
code: lemma isCoboundedUnder_le_of_eventually_le [Preorder α] (l : Filter ι) [NeBot l] {f : ι → α} {x : α}
    (hf : ∀ᶠ i in l, x ≤ f i) :
    IsCoboundedUnder (· ≤ ·) l f 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) l f

full_name: Filter.isCoboundedUnder_ge_of_eventually_le
code: lemma isCoboundedUnder_ge_of_eventually_le [Preorder α] (l : Filter ι) [NeBot l] {f : ι → α} {x : α}
    (hf : ∀ᶠ i in l, f i ≤ x) :
    IsCoboundedUnder (· ≥ ·) l f 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) l f

full_name: Filter.isCoboundedUnder_le_of_le
code: lemma isCoboundedUnder_le_of_le [Preorder α] (l : Filter ι) [NeBot l] {f : ι → α} {x : α}
    (hf : ∀ i, x ≤ f i) :
    IsCoboundedUnder (· ≤ ·) l f 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) l f

full_name: Filter.isCoboundedUnder_ge_of_le
code: lemma isCoboundedUnder_ge_of_le [Preorder α] (l : Filter ι) [NeBot l] {f : ι → α} {x : α}
    (hf : ∀ i, f i ≤ x) :
    IsCoboundedUnder (· ≥ ·) l f 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) l f

full_name: Filter.isCobounded_bot
code: theorem isCobounded_bot : IsCobounded r ⊥ ↔ ∃ b, ∀ x, r b x 
goal: Filter.IsCobounded r ⊥ ↔ ∃ b, ∀ (x : α), r b x

full_name: Filter.isCobounded_top
code: theorem isCobounded_top : IsCobounded r ⊤ ↔ Nonempty α 
goal: Filter.IsCobounded r ⊤ ↔ Nonempty α

full_name: Filter.isCobounded_principal
code: theorem isCobounded_principal (s : Set α) :
    (𝓟 s).IsCobounded r ↔ ∃ b, ∀ a, (∀ x ∈ s, r x a) → r b a 
goal: Filter.IsCobounded r (𝓟 s) ↔ ∃ b, ∀ (a : α), (∀ x ∈ s, r x a) → r b a

full_name: Filter.IsCobounded.mono
code: theorem IsCobounded.mono (h : f ≤ g) : f.IsCobounded r → g.IsCobounded r
  
goal: Filter.IsCobounded r f → Filter.IsCobounded r g

full_name: Filter.isBoundedUnder_ge_add
code: lemma isBoundedUnder_ge_add [Add R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u v : α → R} (u_bdd_ge : f.IsBoundedUnder (· ≥ ·) u) (v_bdd_ge : f.IsBoundedUnder (· ≥ ·) v) :
    f.IsBoundedUnder (· ≥ ·) (u + v) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f (u + v)

full_name: Filter.isBoundedUnder_le_add
code: lemma isBoundedUnder_le_add [Add R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u v : α → R} (u_bdd_le : f.IsBoundedUnder (· ≤ ·) u) (v_bdd_le : f.IsBoundedUnder (· ≤ ·) v) :
    f.IsBoundedUnder (· ≤ ·) (u + v) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f (u + v)

full_name: Filter.isBoundedUnder_sum
code: lemma isBoundedUnder_sum {κ : Type*} [AddCommMonoid R] {r : R → R → Prop}
    (hr : ∀ (v₁ v₂ : α → R), f.IsBoundedUnder r v₁ → f.IsBoundedUnder r v₂
      → f.IsBoundedUnder r (v₁ + v₂)) (hr₀ : r 0 0)
    {u : κ → α → R} (s : Finset κ) (h : ∀ k ∈ s, f.IsBoundedUnder r (u k)) :
    f.IsBoundedUnder r (∑ k ∈ s, u k) 
goal: Filter.IsBoundedUnder r f (∑ k ∈ s, u k)

full_name: Filter.isBoundedUnder_le_sum
code: lemma isBoundedUnder_le_sum {κ : Type*} [AddCommMonoid R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u : κ → α → R} (s : Finset κ) :
    (∀ k ∈ s, f.IsBoundedUnder (· ≤ ·) (u k)) → f.IsBoundedUnder (· ≤ ·) (∑ k ∈ s, u k) 
goal: (∀ k ∈ s, Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f (u k)) →
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f (∑ k ∈ s, u k)

full_name: Filter.isBoundedUnder_ge_sum
code: lemma isBoundedUnder_ge_sum {κ : Type*} [AddCommMonoid R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u : κ → α → R} (s : Finset κ) :
    (∀ k ∈ s, f.IsBoundedUnder (· ≥ ·) (u k)) →
      f.IsBoundedUnder (· ≥ ·) (∑ k ∈ s, u k) 
goal: (∀ k ∈ s, Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f (u k)) →
  Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f (∑ k ∈ s, u k)

full_name: Filter.isBounded_le_atBot
code: theorem isBounded_le_atBot : (atBot : Filter α).IsBounded (· ≤ ·) 
goal: Filter.IsBounded (fun x x_1 => x ≤ x_1) Filter.atBot

full_name: Filter.isBounded_ge_atTop
code: theorem isBounded_ge_atTop : (atTop : Filter α).IsBounded (· ≥ ·) 
goal: Filter.IsBounded (fun x x_1 => x ≥ x_1) Filter.atTop

full_name: Filter.Tendsto.isBoundedUnder_le_atBot
code: theorem Tendsto.isBoundedUnder_le_atBot (h : Tendsto u f atBot) : f.IsBoundedUnder (· ≤ ·) u 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u

full_name: Filter.Tendsto.isBoundedUnder_ge_atTop
code: theorem Tendsto.isBoundedUnder_ge_atTop (h : Tendsto u f atTop) : f.IsBoundedUnder (· ≥ ·) u 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u

full_name: Filter.bddAbove_range_of_tendsto_atTop_atBot
code: theorem bddAbove_range_of_tendsto_atTop_atBot [IsDirected α (· ≤ ·)] {u : ℕ → α}
    (hx : Tendsto u atTop atBot) : BddAbove (Set.range u) 
goal: BddAbove (Set.range u)

full_name: Filter.bddBelow_range_of_tendsto_atTop_atTop
code: theorem bddBelow_range_of_tendsto_atTop_atTop [IsDirected α (· ≥ ·)] {u : ℕ → α}
    (hx : Tendsto u atTop atTop) : BddBelow (Set.range u) 
goal: BddBelow (Set.range u)

full_name: Filter.isCobounded_le_of_bot
code: theorem isCobounded_le_of_bot [Preorder α] [OrderBot α] {f : Filter α} : f.IsCobounded (· ≤ ·) 
goal: Filter.IsCobounded (fun x x_1 => x ≤ x_1) f

full_name: Filter.isCobounded_ge_of_top
code: theorem isCobounded_ge_of_top [Preorder α] [OrderTop α] {f : Filter α} : f.IsCobounded (· ≥ ·) 
goal: Filter.IsCobounded (fun x x_1 => x ≥ x_1) f

full_name: Filter.isBounded_le_of_top
code: theorem isBounded_le_of_top [Preorder α] [OrderTop α] {f : Filter α} : f.IsBounded (· ≤ ·) 
goal: Filter.IsBounded (fun x x_1 => x ≤ x_1) f

full_name: Filter.isBounded_ge_of_bot
code: theorem isBounded_ge_of_bot [Preorder α] [OrderBot α] {f : Filter α} : f.IsBounded (· ≥ ·) 
goal: Filter.IsBounded (fun x x_1 => x ≥ x_1) f

full_name: OrderIso.isBoundedUnder_le_comp
code: @[simp]
theorem _root_.OrderIso.isBoundedUnder_le_comp [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ}
    {u : γ → α} : (IsBoundedUnder (· ≤ ·) l fun x => e (u x)) ↔ IsBoundedUnder (· ≤ ·) l u 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => e (u x)) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u

full_name: OrderIso.isBoundedUnder_ge_comp
code: @[simp]
theorem _root_.OrderIso.isBoundedUnder_ge_comp [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ}
    {u : γ → α} : (IsBoundedUnder (· ≥ ·) l fun x => e (u x)) ↔ IsBoundedUnder (· ≥ ·) l u 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l fun x => e (u x)) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u

full_name: Filter.isBoundedUnder_le_inv
code: @[to_additive (attr := simp)]
theorem isBoundedUnder_le_inv [OrderedCommGroup α] {l : Filter β} {u : β → α} :
    (IsBoundedUnder (· ≤ ·) l fun x => (u x)⁻¹) ↔ IsBoundedUnder (· ≥ ·) l u 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => (u x)⁻¹) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u

full_name: Filter.isBoundedUnder_le_neg
code: @[to_additive (attr := simp)]
theorem isBoundedUnder_le_inv [OrderedCommGroup α] {l : Filter β} {u : β → α} :
    (IsBoundedUnder (· ≤ ·) l fun x => (u x)⁻¹) ↔ IsBoundedUnder (· ≥ ·) l u 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => -u x) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l u

full_name: Filter.isBoundedUnder_ge_neg
code: @[to_additive (attr := simp)]
theorem isBoundedUnder_ge_inv [OrderedCommGroup α] {l : Filter β} {u : β → α} :
    (IsBoundedUnder (· ≥ ·) l fun x => (u x)⁻¹) ↔ IsBoundedUnder (· ≤ ·) l u 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l fun x => -u x) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u

full_name: Filter.isBoundedUnder_ge_inv
code: @[to_additive (attr := simp)]
theorem isBoundedUnder_ge_inv [OrderedCommGroup α] {l : Filter β} {u : β → α} :
    (IsBoundedUnder (· ≥ ·) l fun x => (u x)⁻¹) ↔ IsBoundedUnder (· ≤ ·) l u 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l fun x => (u x)⁻¹) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l u

full_name: Filter.IsBoundedUnder.sup
code: theorem IsBoundedUnder.sup [SemilatticeSup α] {f : Filter β} {u v : β → α} :
    f.IsBoundedUnder (· ≤ ·) u →
      f.IsBoundedUnder (· ≤ ·) v → f.IsBoundedUnder (· ≤ ·) fun a => u a ⊔ v a
  
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u →
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f v → Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => u a ⊔ v a

full_name: Filter.isBoundedUnder_le_sup
code: @[simp]
theorem isBoundedUnder_le_sup [SemilatticeSup α] {f : Filter β} {u v : β → α} :
    (f.IsBoundedUnder (· ≤ ·) fun a => u a ⊔ v a) ↔
      f.IsBoundedUnder (· ≤ ·) u ∧ f.IsBoundedUnder (· ≤ ·) v 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => u a ⊔ v a) ↔
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u ∧ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f v

full_name: Filter.IsBoundedUnder.inf
code: theorem IsBoundedUnder.inf [SemilatticeInf α] {f : Filter β} {u v : β → α} :
    f.IsBoundedUnder (· ≥ ·) u →
      f.IsBoundedUnder (· ≥ ·) v → f.IsBoundedUnder (· ≥ ·) fun a => u a ⊓ v a 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u →
  Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f v → Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f fun a => u a ⊓ v a

full_name: Filter.isBoundedUnder_ge_inf
code: @[simp]
theorem isBoundedUnder_ge_inf [SemilatticeInf α] {f : Filter β} {u v : β → α} :
    (f.IsBoundedUnder (· ≥ ·) fun a => u a ⊓ v a) ↔
      f.IsBoundedUnder (· ≥ ·) u ∧ f.IsBoundedUnder (· ≥ ·) v 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f fun a => u a ⊓ v a) ↔
  Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u ∧ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f v

full_name: Filter.isBoundedUnder_le_abs
code: theorem isBoundedUnder_le_abs [LinearOrderedAddCommGroup α] {f : Filter β} {u : β → α} :
    (f.IsBoundedUnder (· ≤ ·) fun a => |u a|) ↔
      f.IsBoundedUnder (· ≤ ·) u ∧ f.IsBoundedUnder (· ≥ ·) u 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => |u a|) ↔
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f u ∧ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f u

full_name: Filter._aux_Mathlib_Order_LiminfLimsup___macroRules_Filter_tacticIsBoundedDefault_1
code: macro "isBoundedDefault" : tactic =>
  `(tactic| first
    | apply isCobounded_le_of_bot
    | apply isCobounded_ge_of_top
    | apply isBounded_le_of_top
    | apply isBounded_ge_of_bot
    | assumption)
goal: Lean.Macro

full_name: Filter.tacticIsBoundedDefault
code: macro "isBoundedDefault" : tactic =>
  `(tactic| first
    | apply isCobounded_le_of_bot
    | apply isCobounded_ge_of_top
    | apply isBounded_le_of_top
    | apply isBounded_ge_of_bot
    | assumption)
goal: Lean.ParserDescr

full_name: Filter.limsSup
code: /-- The `limsSup` of a filter `f` is the infimum of the `a` such that, eventually for `f`,
holds `x ≤ a`. -/
def limsSup (f : Filter α) : α 
goal: α

full_name: Filter.limsInf
code: /-- The `limsInf` of a filter `f` is the supremum of the `a` such that, eventually for `f`,
holds `x ≥ a`. -/
def limsInf (f : Filter α) : α 
goal: α

full_name: Filter.limsup
code: /-- The `limsup` of a function `u` along a filter `f` is the infimum of the `a` such that,
eventually for `f`, holds `u x ≤ a`. -/
def limsup (u : β → α) (f : Filter β) : α 
goal: α

full_name: Filter.liminf
code: /-- The `liminf` of a function `u` along a filter `f` is the supremum of the `a` such that,
eventually for `f`, holds `u x ≥ a`. -/
def liminf (u : β → α) (f : Filter β) : α 
goal: α

full_name: Filter.blimsup
code: /-- The `blimsup` of a function `u` along a filter `f`, bounded by a predicate `p`, is the infimum
of the `a` such that, eventually for `f`, `u x ≤ a` whenever `p x` holds. -/
def blimsup (u : β → α) (f : Filter β) (p : β → Prop) 
goal: α

full_name: Filter.bliminf
code: /-- The `bliminf` of a function `u` along a filter `f`, bounded by a predicate `p`, is the supremum
of the `a` such that, eventually for `f`, `a ≤ u x` whenever `p x` holds. -/
def bliminf (u : β → α) (f : Filter β) (p : β → Prop) 
goal: α

full_name: Filter.limsup_eq
code: theorem limsup_eq : limsup u f = sInf { a | ∀ᶠ n in f, u n ≤ a } 
goal: Filter.limsup u f = sInf {a | ∀ᶠ (n : β) in f, u n ≤ a}

full_name: Filter.liminf_eq
code: theorem liminf_eq : liminf u f = sSup { a | ∀ᶠ n in f, a ≤ u n } 
goal: Filter.liminf u f = sSup {a | ∀ᶠ (n : β) in f, a ≤ u n}

full_name: Filter.blimsup_eq
code: theorem blimsup_eq : blimsup u f p = sInf { a | ∀ᶠ x in f, p x → u x ≤ a } 
goal: Filter.blimsup u f p = sInf {a | ∀ᶠ (x : β) in f, p x → u x ≤ a}

full_name: Filter.bliminf_eq
code: theorem bliminf_eq : bliminf u f p = sSup { a | ∀ᶠ x in f, p x → a ≤ u x } 
goal: Filter.bliminf u f p = sSup {a | ∀ᶠ (x : β) in f, p x → a ≤ u x}

full_name: Filter.liminf_comp
code: lemma liminf_comp (u : β → α) (v : γ → β) (f : Filter γ) :
    liminf (u ∘ v) f = liminf u (map v f) 
goal: Filter.liminf (u ∘ v) f = Filter.liminf u (Filter.map v f)

full_name: Filter.limsup_comp
code: lemma limsup_comp (u : β → α) (v : γ → β) (f : Filter γ) :
    limsup (u ∘ v) f = limsup u (map v f) 
goal: Filter.limsup (u ∘ v) f = Filter.limsup u (Filter.map v f)

full_name: Filter.blimsup_true
code: @[simp]
theorem blimsup_true (f : Filter β) (u : β → α) : (blimsup u f fun _ => True) = limsup u f 
goal: (Filter.blimsup u f fun x => True) = Filter.limsup u f

full_name: Filter.bliminf_true
code: @[simp]
theorem bliminf_true (f : Filter β) (u : β → α) : (bliminf u f fun _ => True) = liminf u f 
goal: (Filter.bliminf u f fun x => True) = Filter.liminf u f

full_name: Filter.blimsup_eq_limsup
code: lemma blimsup_eq_limsup {f : Filter β} {u : β → α} {p : β → Prop} :
    blimsup u f p = limsup u (f ⊓ 𝓟 {x | p x}) 
goal: Filter.blimsup u f p = Filter.limsup u (f ⊓ 𝓟 {x | p x})

full_name: Filter.bliminf_eq_liminf
code: lemma bliminf_eq_liminf {f : Filter β} {u : β → α} {p : β → Prop} :
    bliminf u f p = liminf u (f ⊓ 𝓟 {x | p x}) 
goal: Filter.bliminf u f p = Filter.liminf u (f ⊓ 𝓟 {x | p x})

full_name: Filter.blimsup_eq_limsup_subtype
code: theorem blimsup_eq_limsup_subtype {f : Filter β} {u : β → α} {p : β → Prop} :
    blimsup u f p = limsup (u ∘ ((↑) : { x | p x } → β)) (comap (↑) f) 
goal: Filter.blimsup u f p = Filter.limsup (u ∘ Subtype.val) (Filter.comap Subtype.val f)

full_name: Filter.bliminf_eq_liminf_subtype
code: theorem bliminf_eq_liminf_subtype {f : Filter β} {u : β → α} {p : β → Prop} :
    bliminf u f p = liminf (u ∘ ((↑) : { x | p x } → β)) (comap (↑) f) 
goal: Filter.bliminf u f p = Filter.liminf (u ∘ Subtype.val) (Filter.comap Subtype.val f)

full_name: Filter.limsSup_le_of_le
code: theorem limsSup_le_of_le {f : Filter α} {a}
    (hf : f.IsCobounded (· ≤ ·) := by isBoundedDefault)
    (h : ∀ᶠ n in f, n ≤ a) : limsSup f ≤ a 
goal: f.limsSup ≤ a

full_name: Filter.le_limsInf_of_le
code: theorem le_limsInf_of_le {f : Filter α} {a}
    (hf : f.IsCobounded (· ≥ ·) := by isBoundedDefault)
    (h : ∀ᶠ n in f, a ≤ n) : a ≤ limsInf f 
goal: a ≤ f.limsInf

full_name: Filter.limsup_le_of_le
code: theorem limsup_le_of_le {f : Filter β} {u : β → α} {a}
    (hf : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h : ∀ᶠ n in f, u n ≤ a) : limsup u f ≤ a 
goal: Filter.limsup u f ≤ a

full_name: Filter.le_liminf_of_le
code: theorem le_liminf_of_le {f : Filter β} {u : β → α} {a}
    (hf : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h : ∀ᶠ n in f, a ≤ u n) : a ≤ liminf u f 
goal: a ≤ Filter.liminf u f

full_name: Filter.le_limsSup_of_le
code: theorem le_limsSup_of_le {f : Filter α} {a}
    (hf : f.IsBounded (· ≤ ·) := by isBoundedDefault)
    (h : ∀ b, (∀ᶠ n in f, n ≤ b) → a ≤ b) : a ≤ limsSup f 
goal: a ≤ f.limsSup

full_name: Filter.limsInf_le_of_le
code: theorem limsInf_le_of_le {f : Filter α} {a}
    (hf : f.IsBounded (· ≥ ·) := by isBoundedDefault)
    (h : ∀ b, (∀ᶠ n in f, b ≤ n) → b ≤ a) : limsInf f ≤ a 
goal: f.limsInf ≤ a

full_name: Filter.le_limsup_of_le
code: theorem le_limsup_of_le {f : Filter β} {u : β → α} {a}
    (hf : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h : ∀ b, (∀ᶠ n in f, u n ≤ b) → a ≤ b) : a ≤ limsup u f 
goal: a ≤ Filter.limsup u f

full_name: Filter.liminf_le_of_le
code: theorem liminf_le_of_le {f : Filter β} {u : β → α} {a}
    (hf : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h : ∀ b, (∀ᶠ n in f, b ≤ u n) → b ≤ a) : liminf u f ≤ a 
goal: Filter.liminf u f ≤ a

full_name: Filter.limsInf_le_limsSup
code: theorem limsInf_le_limsSup {f : Filter α} [NeBot f]
    (h₁ : f.IsBounded (· ≤ ·) := by isBoundedDefault)
    (h₂ : f.IsBounded (· ≥ ·) := by isBoundedDefault) :
    limsInf f ≤ limsSup f 
goal: f.limsInf ≤ f.limsSup

full_name: Filter.liminf_le_limsup
code: theorem liminf_le_limsup {f : Filter β} [NeBot f] {u : β → α}
    (h : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h' : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
    liminf u f ≤ limsup u f 
goal: Filter.liminf u f ≤ Filter.limsup u f

full_name: Filter.limsSup_le_limsSup
code: theorem limsSup_le_limsSup {f g : Filter α}
    (hf : f.IsCobounded (· ≤ ·) := by isBoundedDefault)
    (hg : g.IsBounded (· ≤ ·) := by isBoundedDefault)
    (h : ∀ a, (∀ᶠ n in g, n ≤ a) → ∀ᶠ n in f, n ≤ a) : limsSup f ≤ limsSup g 
goal: f.limsSup ≤ g.limsSup

full_name: Filter.limsInf_le_limsInf
code: theorem limsInf_le_limsInf {f g : Filter α}
    (hf : f.IsBounded (· ≥ ·) := by isBoundedDefault)
    (hg : g.IsCobounded (· ≥ ·) := by isBoundedDefault)
    (h : ∀ a, (∀ᶠ n in f, a ≤ n) → ∀ᶠ n in g, a ≤ n) : limsInf f ≤ limsInf g 
goal: f.limsInf ≤ g.limsInf

full_name: Filter.limsup_le_limsup
code: theorem limsup_le_limsup {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β}
    (h : u ≤ᶠ[f] v)
    (hu : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (hv : f.IsBoundedUnder (· ≤ ·) v := by isBoundedDefault) :
    limsup u f ≤ limsup v f 
goal: Filter.limsup u f ≤ Filter.limsup v f

full_name: Filter.liminf_le_liminf
code: theorem liminf_le_liminf {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β}
    (h : ∀ᶠ a in f, u a ≤ v a)
    (hu : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
    (hv : f.IsCoboundedUnder (· ≥ ·) v := by isBoundedDefault) :
    liminf u f ≤ liminf v f 
goal: Filter.liminf u f ≤ Filter.liminf v f

full_name: Filter.limsSup_le_limsSup_of_le
code: theorem limsSup_le_limsSup_of_le {f g : Filter α} (h : f ≤ g)
    (hf : f.IsCobounded (· ≤ ·) := by isBoundedDefault)
    (hg : g.IsBounded (· ≤ ·) := by isBoundedDefault) :
    limsSup f ≤ limsSup g 
goal: f.limsSup ≤ g.limsSup

full_name: Filter.limsInf_le_limsInf_of_le
code: theorem limsInf_le_limsInf_of_le {f g : Filter α} (h : g ≤ f)
    (hf : f.IsBounded (· ≥ ·) := by isBoundedDefault)
    (hg : g.IsCobounded (· ≥ ·) := by isBoundedDefault) :
    limsInf f ≤ limsInf g 
goal: f.limsInf ≤ g.limsInf

full_name: Filter.limsup_le_limsup_of_le
code: theorem limsup_le_limsup_of_le {α β} [ConditionallyCompleteLattice β] {f g : Filter α} (h : f ≤ g)
    {u : α → β}
    (hf : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (hg : g.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
    limsup u f ≤ limsup u g 
goal: Filter.limsup u f ≤ Filter.limsup u g

full_name: Filter.liminf_le_liminf_of_le
code: theorem liminf_le_liminf_of_le {α β} [ConditionallyCompleteLattice β] {f g : Filter α} (h : g ≤ f)
    {u : α → β}
    (hf : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
    (hg : g.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault) :
    liminf u f ≤ liminf u g 
goal: Filter.liminf u f ≤ Filter.liminf u g

full_name: Filter.limsSup_principal
code: theorem limsSup_principal {s : Set α} (h : BddAbove s) (hs : s.Nonempty) :
    limsSup (𝓟 s) = sSup s 
goal: (𝓟 s).limsSup = sSup s

full_name: Filter.limsInf_principal
code: theorem limsInf_principal {s : Set α} (h : BddBelow s) (hs : s.Nonempty) : limsInf (𝓟 s) = sInf s 
goal: (𝓟 s).limsInf = sInf s

full_name: Filter.limsup_congr
code: theorem limsup_congr {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β}
    (h : ∀ᶠ a in f, u a = v a) : limsup u f = limsup v f 
goal: Filter.limsup u f = Filter.limsup v f

full_name: Filter.blimsup_congr
code: theorem blimsup_congr {f : Filter β} {u v : β → α} {p : β → Prop} (h : ∀ᶠ a in f, p a → u a = v a) :
    blimsup u f p = blimsup v f p 
goal: Filter.blimsup u f p = Filter.blimsup v f p

full_name: Filter.bliminf_congr
code: theorem bliminf_congr {f : Filter β} {u v : β → α} {p : β → Prop} (h : ∀ᶠ a in f, p a → u a = v a) :
    bliminf u f p = bliminf v f p 
goal: Filter.bliminf u f p = Filter.bliminf v f p

full_name: Filter.liminf_congr
code: theorem liminf_congr {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β}
    (h : ∀ᶠ a in f, u a = v a) : liminf u f = liminf v f 
goal: Filter.liminf u f = Filter.liminf v f

full_name: Filter.limsup_const
code: @[simp]
theorem limsup_const {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} [NeBot f]
    (b : β) : limsup (fun _ => b) f = b 
goal: Filter.limsup (fun x => b) f = b

full_name: Filter.liminf_const
code: @[simp]
theorem liminf_const {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} [NeBot f]
    (b : β) : liminf (fun _ => b) f = b 
goal: Filter.liminf (fun x => b) f = b

full_name: Filter.HasBasis.liminf_eq_sSup_iUnion_iInter
code: theorem HasBasis.liminf_eq_sSup_iUnion_iInter {ι ι' : Type*} {f : ι → α} {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasBasis p s) :
    liminf f v = sSup (⋃ (j : Subtype p), ⋂ (i : s j), Iic (f i)) 
goal: Filter.liminf f v = sSup (⋃ j, ⋂ i, Set.Iic (f ↑i))

full_name: Filter.HasBasis.liminf_eq_sSup_univ_of_empty
code: theorem HasBasis.liminf_eq_sSup_univ_of_empty {f : ι → α} {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasBasis p s) (i : ι') (hi : p i) (h'i : s i = ∅) :
    liminf f v = sSup univ 
goal: Filter.liminf f v = sSup Set.univ

full_name: Filter.HasBasis.limsup_eq_sInf_iUnion_iInter
code: theorem HasBasis.limsup_eq_sInf_iUnion_iInter {ι ι' : Type*} {f : ι → α} {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasBasis p s) :
    limsup f v = sInf (⋃ (j : Subtype p), ⋂ (i : s j), Ici (f i)) 
goal: Filter.limsup f v = sInf (⋃ j, ⋂ i, Set.Ici (f ↑i))

full_name: Filter.HasBasis.limsup_eq_sInf_univ_of_empty
code: theorem HasBasis.limsup_eq_sInf_univ_of_empty {f : ι → α} {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasBasis p s) (i : ι') (hi : p i) (h'i : s i = ∅) :
    limsup f v = sInf univ 
goal: Filter.limsup f v = sInf Set.univ

full_name: Filter.liminf_nat_add
code: @[simp, nolint simpNF]
theorem liminf_nat_add (f : ℕ → α) (k : ℕ) :
    liminf (fun i => f (i + k)) atTop = liminf f atTop 
goal: Filter.liminf (fun i => f (i + k)) Filter.atTop = Filter.liminf f Filter.atTop

full_name: Filter.limsup_nat_add
code: @[simp, nolint simpNF]
theorem limsup_nat_add (f : ℕ → α) (k : ℕ) : limsup (fun i => f (i + k)) atTop = limsup f atTop 
goal: Filter.limsup (fun i => f (i + k)) Filter.atTop = Filter.limsup f Filter.atTop

full_name: Filter.limsSup_bot
code: @[simp]
theorem limsSup_bot : limsSup (⊥ : Filter α) = ⊥ 
goal: ⊥.limsSup = ⊥

full_name: Filter.limsup_bot
code: @[simp] theorem limsup_bot (f : β → α) : limsup f ⊥ = ⊥ 
goal: Filter.limsup f ⊥ = ⊥

full_name: Filter.limsInf_bot
code: @[simp]
theorem limsInf_bot : limsInf (⊥ : Filter α) = ⊤ 
goal: ⊥.limsInf = ⊤

full_name: Filter.liminf_bot
code: @[simp] theorem liminf_bot (f : β → α) : liminf f ⊥ = ⊤ 
goal: Filter.liminf f ⊥ = ⊤

full_name: Filter.limsSup_top
code: @[simp]
theorem limsSup_top : limsSup (⊤ : Filter α) = ⊤ 
goal: ⊤.limsSup = ⊤

full_name: Filter.limsInf_top
code: @[simp]
theorem limsInf_top : limsInf (⊤ : Filter α) = ⊥ 
goal: ⊤.limsInf = ⊥

full_name: Filter.blimsup_false
code: @[simp]
theorem blimsup_false {f : Filter β} {u : β → α} : (blimsup u f fun _ => False) = ⊥ 
goal: (Filter.blimsup u f fun x => False) = ⊥

full_name: Filter.bliminf_false
code: @[simp]
theorem bliminf_false {f : Filter β} {u : β → α} : (bliminf u f fun _ => False) = ⊤ 
goal: (Filter.bliminf u f fun x => False) = ⊤

full_name: Filter.limsup_const_bot
code: /-- Same as limsup_const applied to `⊥` but without the `NeBot f` assumption -/
@[simp]
theorem limsup_const_bot {f : Filter β} : limsup (fun _ : β => (⊥ : α)) f = (⊥ : α) 
goal: Filter.limsup (fun x => ⊥) f = ⊥

full_name: Filter.liminf_const_top
code: /-- Same as limsup_const applied to `⊤` but without the `NeBot f` assumption -/
@[simp]
theorem liminf_const_top {f : Filter β} : liminf (fun _ : β => (⊤ : α)) f = (⊤ : α) 
goal: Filter.liminf (fun x => ⊤) f = ⊤

full_name: Filter.HasBasis.limsSup_eq_iInf_sSup
code: theorem HasBasis.limsSup_eq_iInf_sSup {ι} {p : ι → Prop} {s} {f : Filter α} (h : f.HasBasis p s) :
    limsSup f = ⨅ (i) (_ : p i), sSup (s i) 
goal: f.limsSup = ⨅ i, ⨅ (_ : p i), sSup (s i)

full_name: Filter.HasBasis.limsInf_eq_iSup_sInf
code: theorem HasBasis.limsInf_eq_iSup_sInf {p : ι → Prop} {s : ι → Set α} {f : Filter α}
    (h : f.HasBasis p s) : limsInf f = ⨆ (i) (_ : p i), sInf (s i) 
goal: f.limsInf = ⨆ i, ⨆ (_ : p i), sInf (s i)

full_name: Filter.limsSup_eq_iInf_sSup
code: theorem limsSup_eq_iInf_sSup {f : Filter α} : limsSup f = ⨅ s ∈ f, sSup s 
goal: f.limsSup = ⨅ s ∈ f, sSup s

full_name: Filter.limsInf_eq_iSup_sInf
code: theorem limsInf_eq_iSup_sInf {f : Filter α} : limsInf f = ⨆ s ∈ f, sInf s 
goal: f.limsInf = ⨆ s ∈ f, sInf s

full_name: Filter.limsup_le_iSup
code: theorem limsup_le_iSup {f : Filter β} {u : β → α} : limsup u f ≤ ⨆ n, u n 
goal: Filter.limsup u f ≤ ⨆ n, u n

full_name: Filter.iInf_le_liminf
code: theorem iInf_le_liminf {f : Filter β} {u : β → α} : ⨅ n, u n ≤ liminf u f 
goal: ⨅ n, u n ≤ Filter.liminf u f

full_name: Filter.limsup_eq_iInf_iSup
code: /-- In a complete lattice, the limsup of a function is the infimum over sets `s` in the filter
of the supremum of the function over `s` -/
theorem limsup_eq_iInf_iSup {f : Filter β} {u : β → α} : limsup u f = ⨅ s ∈ f, ⨆ a ∈ s, u a 
goal: Filter.limsup u f = ⨅ s ∈ f, ⨆ a ∈ s, u a

full_name: Filter.limsup_eq_iInf_iSup_of_nat
code: theorem limsup_eq_iInf_iSup_of_nat {u : ℕ → α} : limsup u atTop = ⨅ n : ℕ, ⨆ i ≥ n, u i 
goal: Filter.limsup u Filter.atTop = ⨅ n, ⨆ i, ⨆ (_ : i ≥ n), u i

full_name: Filter.limsup_eq_iInf_iSup_of_nat'
code: theorem limsup_eq_iInf_iSup_of_nat' {u : ℕ → α} : limsup u atTop = ⨅ n : ℕ, ⨆ i : ℕ, u (i + n) 
goal: Filter.limsup u Filter.atTop = ⨅ n, ⨆ i, u (i + n)

full_name: Filter.HasBasis.limsup_eq_iInf_iSup
code: theorem HasBasis.limsup_eq_iInf_iSup {p : ι → Prop} {s : ι → Set β} {f : Filter β} {u : β → α}
    (h : f.HasBasis p s) : limsup u f = ⨅ (i) (_ : p i), ⨆ a ∈ s i, u a 
goal: Filter.limsup u f = ⨅ i, ⨅ (_ : p i), ⨆ a ∈ s i, u a

full_name: Filter.blimsup_congr'
code: theorem blimsup_congr' {f : Filter β} {p q : β → Prop} {u : β → α}
    (h : ∀ᶠ x in f, u x ≠ ⊥ → (p x ↔ q x)) : blimsup u f p = blimsup u f q 
goal: Filter.blimsup u f p = Filter.blimsup u f q

full_name: Filter.bliminf_congr'
code: theorem bliminf_congr' {f : Filter β} {p q : β → Prop} {u : β → α}
    (h : ∀ᶠ x in f, u x ≠ ⊤ → (p x ↔ q x)) : bliminf u f p = bliminf u f q 
goal: Filter.bliminf u f p = Filter.bliminf u f q

full_name: Filter.HasBasis.blimsup_eq_iInf_iSup
code: lemma HasBasis.blimsup_eq_iInf_iSup {p : ι → Prop} {s : ι → Set β} {f : Filter β} {u : β → α}
    (hf : f.HasBasis p s) {q : β → Prop} :
    blimsup u f q = ⨅ (i) (_ : p i), ⨆ a ∈ s i, ⨆ (_ : q a), u a 
goal: Filter.blimsup u f q = ⨅ i, ⨅ (_ : p i), ⨆ a ∈ s i, ⨆ (_ : q a), u a

full_name: Filter.blimsup_eq_iInf_biSup
code: theorem blimsup_eq_iInf_biSup {f : Filter β} {p : β → Prop} {u : β → α} :
    blimsup u f p = ⨅ s ∈ f, ⨆ (b) (_ : p b ∧ b ∈ s), u b 
goal: Filter.blimsup u f p = ⨅ s ∈ f, ⨆ b, ⨆ (_ : p b ∧ b ∈ s), u b

full_name: Filter.blimsup_eq_iInf_biSup_of_nat
code: theorem blimsup_eq_iInf_biSup_of_nat {p : ℕ → Prop} {u : ℕ → α} :
    blimsup u atTop p = ⨅ i, ⨆ (j) (_ : p j ∧ i ≤ j), u j 
goal: Filter.blimsup u Filter.atTop p = ⨅ i, ⨆ j, ⨆ (_ : p j ∧ i ≤ j), u j

full_name: Filter.liminf_eq_iSup_iInf
code: /-- In a complete lattice, the liminf of a function is the infimum over sets `s` in the filter
of the supremum of the function over `s` -/
theorem liminf_eq_iSup_iInf {f : Filter β} {u : β → α} : liminf u f = ⨆ s ∈ f, ⨅ a ∈ s, u a 
goal: Filter.liminf u f = ⨆ s ∈ f, ⨅ a ∈ s, u a

full_name: Filter.liminf_eq_iSup_iInf_of_nat
code: theorem liminf_eq_iSup_iInf_of_nat {u : ℕ → α} : liminf u atTop = ⨆ n : ℕ, ⨅ i ≥ n, u i 
goal: Filter.liminf u Filter.atTop = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), u i

full_name: Filter.liminf_eq_iSup_iInf_of_nat'
code: theorem liminf_eq_iSup_iInf_of_nat' {u : ℕ → α} : liminf u atTop = ⨆ n : ℕ, ⨅ i : ℕ, u (i + n) 
goal: Filter.liminf u Filter.atTop = ⨆ n, ⨅ i, u (i + n)

full_name: Filter.HasBasis.liminf_eq_iSup_iInf
code: theorem HasBasis.liminf_eq_iSup_iInf {p : ι → Prop} {s : ι → Set β} {f : Filter β} {u : β → α}
    (h : f.HasBasis p s) : liminf u f = ⨆ (i) (_ : p i), ⨅ a ∈ s i, u a 
goal: Filter.liminf u f = ⨆ i, ⨆ (_ : p i), ⨅ a ∈ s i, u a

full_name: Filter.bliminf_eq_iSup_biInf
code: theorem bliminf_eq_iSup_biInf {f : Filter β} {p : β → Prop} {u : β → α} :
    bliminf u f p = ⨆ s ∈ f, ⨅ (b) (_ : p b ∧ b ∈ s), u b 
goal: Filter.bliminf u f p = ⨆ s ∈ f, ⨅ b, ⨅ (_ : p b ∧ b ∈ s), u b

full_name: Filter.bliminf_eq_iSup_biInf_of_nat
code: theorem bliminf_eq_iSup_biInf_of_nat {p : ℕ → Prop} {u : ℕ → α} :
    bliminf u atTop p = ⨆ i, ⨅ (j) (_ : p j ∧ i ≤ j), u j 
goal: Filter.bliminf u Filter.atTop p = ⨆ i, ⨅ j, ⨅ (_ : p j ∧ i ≤ j), u j

full_name: Filter.limsup_eq_sInf_sSup
code: theorem limsup_eq_sInf_sSup {ι R : Type*} (F : Filter ι) [CompleteLattice R] (a : ι → R) :
    limsup a F = sInf ((fun I => sSup (a '' I)) '' F.sets) 
goal: Filter.limsup a F = sInf ((fun I => sSup (a '' I)) '' F.sets)

full_name: Filter.liminf_eq_sSup_sInf
code: theorem liminf_eq_sSup_sInf {ι R : Type*} (F : Filter ι) [CompleteLattice R] (a : ι → R) :
    liminf a F = sSup ((fun I => sInf (a '' I)) '' F.sets) 
goal: Filter.liminf a F = sSup ((fun I => sInf (a '' I)) '' F.sets)

full_name: Filter.liminf_le_of_frequently_le'
code: theorem liminf_le_of_frequently_le' {α β} [CompleteLattice β] {f : Filter α} {u : α → β} {x : β}
    (h : ∃ᶠ a in f, u a ≤ x) : liminf u f ≤ x 
goal: Filter.liminf u f ≤ x

full_name: Filter.le_limsup_of_frequently_le'
code: theorem le_limsup_of_frequently_le' {α β} [CompleteLattice β] {f : Filter α} {u : α → β} {x : β}
    (h : ∃ᶠ a in f, x ≤ u a) : x ≤ limsup u f 
goal: x ≤ Filter.limsup u f

full_name: CompleteLatticeHom.apply_limsup_iterate
code: /-- If `f : α → α` is a morphism of complete lattices, then the limsup of its iterates of any
`a : α` is a fixed point. -/
@[simp]
theorem _root_.CompleteLatticeHom.apply_limsup_iterate (f : CompleteLatticeHom α α) (a : α) :
    f (limsup (fun n => f^[n] a) atTop) = limsup (fun n => f^[n] a) atTop 
goal: f (Filter.limsup (fun n => (⇑f)^[n] a) Filter.atTop) = Filter.limsup (fun n => (⇑f)^[n] a) Filter.atTop

full_name: CompleteLatticeHom.apply_liminf_iterate
code: /-- If `f : α → α` is a morphism of complete lattices, then the liminf of its iterates of any
`a : α` is a fixed point. -/
theorem _root_.CompleteLatticeHom.apply_liminf_iterate (f : CompleteLatticeHom α α) (a : α) :
    f (liminf (fun n => f^[n] a) atTop) = liminf (fun n => f^[n] a) atTop 
goal: f (Filter.liminf (fun n => (⇑f)^[n] a) Filter.atTop) = Filter.liminf (fun n => (⇑f)^[n] a) Filter.atTop

full_name: Filter.blimsup_mono
code: theorem blimsup_mono (h : ∀ x, p x → q x) : blimsup u f p ≤ blimsup u f q 
goal: Filter.blimsup u f p ≤ Filter.blimsup u f q

full_name: Filter.bliminf_antitone
code: theorem bliminf_antitone (h : ∀ x, p x → q x) : bliminf u f q ≤ bliminf u f p 
goal: Filter.bliminf u f q ≤ Filter.bliminf u f p

full_name: Filter.mono_blimsup'
code: theorem mono_blimsup' (h : ∀ᶠ x in f, p x → u x ≤ v x) : blimsup u f p ≤ blimsup v f p 
goal: Filter.blimsup u f p ≤ Filter.blimsup v f p

full_name: Filter.mono_blimsup
code: theorem mono_blimsup (h : ∀ x, p x → u x ≤ v x) : blimsup u f p ≤ blimsup v f p 
goal: Filter.blimsup u f p ≤ Filter.blimsup v f p

full_name: Filter.mono_bliminf'
code: theorem mono_bliminf' (h : ∀ᶠ x in f, p x → u x ≤ v x) : bliminf u f p ≤ bliminf v f p 
goal: Filter.bliminf u f p ≤ Filter.bliminf v f p

full_name: Filter.mono_bliminf
code: theorem mono_bliminf (h : ∀ x, p x → u x ≤ v x) : bliminf u f p ≤ bliminf v f p 
goal: Filter.bliminf u f p ≤ Filter.bliminf v f p

full_name: Filter.bliminf_antitone_filter
code: theorem bliminf_antitone_filter (h : f ≤ g) : bliminf u g p ≤ bliminf u f p 
goal: Filter.bliminf u g p ≤ Filter.bliminf u f p

full_name: Filter.blimsup_monotone_filter
code: theorem blimsup_monotone_filter (h : f ≤ g) : blimsup u f p ≤ blimsup u g p 
goal: Filter.blimsup u f p ≤ Filter.blimsup u g p

full_name: Filter.blimsup_and_le_inf
code: theorem blimsup_and_le_inf : (blimsup u f fun x => p x ∧ q x) ≤ blimsup u f p ⊓ blimsup u f q 
goal: (Filter.blimsup u f fun x => p x ∧ q x) ≤ Filter.blimsup u f p ⊓ Filter.blimsup u f q

full_name: Filter.bliminf_sup_le_inf_aux_left
code: @[simp]
theorem bliminf_sup_le_inf_aux_left :
    (blimsup u f fun x => p x ∧ q x) ≤ blimsup u f p 
goal: (Filter.blimsup u f fun x => p x ∧ q x) ≤ Filter.blimsup u f p

full_name: Filter.bliminf_sup_le_inf_aux_right
code: @[simp]
theorem bliminf_sup_le_inf_aux_right :
    (blimsup u f fun x => p x ∧ q x) ≤ blimsup u f q 
goal: (Filter.blimsup u f fun x => p x ∧ q x) ≤ Filter.blimsup u f q

full_name: Filter.bliminf_sup_le_and
code: theorem bliminf_sup_le_and : bliminf u f p ⊔ bliminf u f q ≤ bliminf u f fun x => p x ∧ q x 
goal: Filter.bliminf u f p ⊔ Filter.bliminf u f q ≤ Filter.bliminf u f fun x => p x ∧ q x

full_name: Filter.bliminf_sup_le_and_aux_left
code: @[simp]
theorem bliminf_sup_le_and_aux_left : bliminf u f p ≤ bliminf u f fun x => p x ∧ q x 
goal: Filter.bliminf u f p ≤ Filter.bliminf u f fun x => p x ∧ q x

full_name: Filter.bliminf_sup_le_and_aux_right
code: @[simp]
theorem bliminf_sup_le_and_aux_right : bliminf u f q ≤ bliminf u f fun x => p x ∧ q x 
goal: Filter.bliminf u f q ≤ Filter.bliminf u f fun x => p x ∧ q x

full_name: Filter.blimsup_sup_le_or
code: /-- See also `Filter.blimsup_or_eq_sup`. -/
-- @[simp] -- Porting note: simp_nf linter, lhs simplifies, added _aux simp versions below
theorem blimsup_sup_le_or : blimsup u f p ⊔ blimsup u f q ≤ blimsup u f fun x => p x ∨ q x 
goal: Filter.blimsup u f p ⊔ Filter.blimsup u f q ≤ Filter.blimsup u f fun x => p x ∨ q x

full_name: Filter.bliminf_sup_le_or_aux_left
code: @[simp]
theorem bliminf_sup_le_or_aux_left : blimsup u f p ≤ blimsup u f fun x => p x ∨ q x 
goal: Filter.blimsup u f p ≤ Filter.blimsup u f fun x => p x ∨ q x

full_name: Filter.bliminf_sup_le_or_aux_right
code: @[simp]
theorem bliminf_sup_le_or_aux_right : blimsup u f q ≤ blimsup u f fun x => p x ∨ q x 
goal: Filter.blimsup u f q ≤ Filter.blimsup u f fun x => p x ∨ q x

full_name: Filter.bliminf_or_le_inf
code: /-- See also `Filter.bliminf_or_eq_inf`. -/
--@[simp] -- Porting note: simp_nf linter, lhs simplifies, added _aux simp versions below
theorem bliminf_or_le_inf : (bliminf u f fun x => p x ∨ q x) ≤ bliminf u f p ⊓ bliminf u f q 
goal: (Filter.bliminf u f fun x => p x ∨ q x) ≤ Filter.bliminf u f p ⊓ Filter.bliminf u f q

full_name: Filter.bliminf_or_le_inf_aux_left
code: @[simp]
theorem bliminf_or_le_inf_aux_left : (bliminf u f fun x => p x ∨ q x) ≤ bliminf u f p 
goal: (Filter.bliminf u f fun x => p x ∨ q x) ≤ Filter.bliminf u f p

full_name: Filter.bliminf_or_le_inf_aux_right
code: @[simp]
theorem bliminf_or_le_inf_aux_right : (bliminf u f fun x => p x ∨ q x) ≤ bliminf u f q 
goal: (Filter.bliminf u f fun x => p x ∨ q x) ≤ Filter.bliminf u f q

full_name: OrderIso.apply_blimsup
code: theorem _root_.OrderIso.apply_blimsup [CompleteLattice γ] (e : α ≃o γ) :
    e (blimsup u f p) = blimsup (e ∘ u) f p 
goal: e (Filter.blimsup u f p) = Filter.blimsup (⇑e ∘ u) f p

full_name: OrderIso.apply_bliminf
code: theorem _root_.OrderIso.apply_bliminf [CompleteLattice γ] (e : α ≃o γ) :
    e (bliminf u f p) = bliminf (e ∘ u) f p 
goal: e (Filter.bliminf u f p) = Filter.bliminf (⇑e ∘ u) f p

full_name: sSupHom.apply_blimsup_le
code: theorem _root_.sSupHom.apply_blimsup_le [CompleteLattice γ] (g : sSupHom α γ) :
    g (blimsup u f p) ≤ blimsup (g ∘ u) f p 
goal: g (Filter.blimsup u f p) ≤ Filter.blimsup (⇑g ∘ u) f p

full_name: sInfHom.le_apply_bliminf
code: theorem _root_.sInfHom.le_apply_bliminf [CompleteLattice γ] (g : sInfHom α γ) :
    bliminf (g ∘ u) f p ≤ g (bliminf u f p) 
goal: Filter.bliminf (⇑g ∘ u) f p ≤ g (Filter.bliminf u f p)

full_name: Filter.limsup_sup_filter
code: lemma limsup_sup_filter {g} : limsup u (f ⊔ g) = limsup u f ⊔ limsup u g 
goal: Filter.limsup u (f ⊔ g) = Filter.limsup u f ⊔ Filter.limsup u g

full_name: Filter.liminf_sup_filter
code: lemma liminf_sup_filter {g} : liminf u (f ⊔ g) = liminf u f ⊓ liminf u g 
goal: Filter.liminf u (f ⊔ g) = Filter.liminf u f ⊓ Filter.liminf u g

full_name: Filter.blimsup_or_eq_sup
code: @[simp]
theorem blimsup_or_eq_sup : (blimsup u f fun x => p x ∨ q x) = blimsup u f p ⊔ blimsup u f q 
goal: (Filter.blimsup u f fun x => p x ∨ q x) = Filter.blimsup u f p ⊔ Filter.blimsup u f q

full_name: Filter.bliminf_or_eq_inf
code: @[simp]
theorem bliminf_or_eq_inf : (bliminf u f fun x => p x ∨ q x) = bliminf u f p ⊓ bliminf u f q 
goal: (Filter.bliminf u f fun x => p x ∨ q x) = Filter.bliminf u f p ⊓ Filter.bliminf u f q

full_name: Filter.blimsup_sup_not
code: @[simp]
lemma blimsup_sup_not : blimsup u f p ⊔ blimsup u f (¬p ·) = limsup u f 
goal: (Filter.blimsup u f p ⊔ Filter.blimsup u f fun x => ¬p x) = Filter.limsup u f

full_name: Filter.bliminf_inf_not
code: @[simp]
lemma bliminf_inf_not : bliminf u f p ⊓ bliminf u f (¬p ·) = liminf u f 
goal: (Filter.bliminf u f p ⊓ Filter.bliminf u f fun x => ¬p x) = Filter.liminf u f

full_name: Filter.blimsup_not_sup
code: @[simp]
lemma blimsup_not_sup : blimsup u f (¬p ·) ⊔ blimsup u f p = limsup u f 
goal: (Filter.blimsup u f fun x => ¬p x) ⊔ Filter.blimsup u f p = Filter.limsup u f

full_name: Filter.bliminf_not_inf
code: @[simp]
lemma bliminf_not_inf : bliminf u f (¬p ·) ⊓ bliminf u f p = liminf u f 
goal: (Filter.bliminf u f fun x => ¬p x) ⊓ Filter.bliminf u f p = Filter.liminf u f

full_name: Filter.limsup_piecewise
code: lemma limsup_piecewise {s : Set β} [DecidablePred (· ∈ s)] {v} :
    limsup (s.piecewise u v) f = blimsup u f (· ∈ s) ⊔ blimsup v f (· ∉ s) 
goal: Filter.limsup (s.piecewise u v) f = (Filter.blimsup u f fun x => x ∈ s) ⊔ Filter.blimsup v f fun x => x ∉ s

full_name: Filter.liminf_piecewise
code: lemma liminf_piecewise {s : Set β} [DecidablePred (· ∈ s)] {v} :
    liminf (s.piecewise u v) f = bliminf u f (· ∈ s) ⊓ bliminf v f (· ∉ s) 
goal: Filter.liminf (s.piecewise u v) f = (Filter.bliminf u f fun x => x ∈ s) ⊓ Filter.bliminf v f fun x => x ∉ s

full_name: Filter.sup_limsup
code: theorem sup_limsup [NeBot f] (a : α) : a ⊔ limsup u f = limsup (fun x => a ⊔ u x) f 
goal: a ⊔ Filter.limsup u f = Filter.limsup (fun x => a ⊔ u x) f

full_name: Filter.inf_liminf
code: theorem inf_liminf [NeBot f] (a : α) : a ⊓ liminf u f = liminf (fun x => a ⊓ u x) f 
goal: a ⊓ Filter.liminf u f = Filter.liminf (fun x => a ⊓ u x) f

full_name: Filter.sup_liminf
code: theorem sup_liminf (a : α) : a ⊔ liminf u f = liminf (fun x => a ⊔ u x) f 
goal: a ⊔ Filter.liminf u f = Filter.liminf (fun x => a ⊔ u x) f

full_name: Filter.inf_limsup
code: theorem inf_limsup (a : α) : a ⊓ limsup u f = limsup (fun x => a ⊓ u x) f 
goal: a ⊓ Filter.limsup u f = Filter.limsup (fun x => a ⊓ u x) f

full_name: Filter.limsup_compl
code: theorem limsup_compl : (limsup u f)ᶜ = liminf (compl ∘ u) f 
goal: (Filter.limsup u f)ᶜ = Filter.liminf (compl ∘ u) f

full_name: Filter.liminf_compl
code: theorem liminf_compl : (liminf u f)ᶜ = limsup (compl ∘ u) f 
goal: (Filter.liminf u f)ᶜ = Filter.limsup (compl ∘ u) f

full_name: Filter.limsup_sdiff
code: theorem limsup_sdiff (a : α) : limsup u f \ a = limsup (fun b => u b \ a) f 
goal: Filter.limsup u f \ a = Filter.limsup (fun b => u b \ a) f

full_name: Filter.liminf_sdiff
code: theorem liminf_sdiff [NeBot f] (a : α) : liminf u f \ a = liminf (fun b => u b \ a) f 
goal: Filter.liminf u f \ a = Filter.liminf (fun b => u b \ a) f

full_name: Filter.sdiff_limsup
code: theorem sdiff_limsup [NeBot f] (a : α) : a \ limsup u f = liminf (fun b => a \ u b) f 
goal: a \ Filter.limsup u f = Filter.liminf (fun b => a \ u b) f

full_name: Filter.sdiff_liminf
code: theorem sdiff_liminf (a : α) : a \ liminf u f = limsup (fun b => a \ u b) f 
goal: a \ Filter.liminf u f = Filter.limsup (fun b => a \ u b) f

full_name: Filter.mem_liminf_iff_eventually_mem
code: lemma mem_liminf_iff_eventually_mem : (a ∈ liminf s 𝓕) ↔ (∀ᶠ i in 𝓕, a ∈ s i) 
goal: a ∈ Filter.liminf s 𝓕 ↔ ∀ᶠ (i : ι) in 𝓕, a ∈ s i

full_name: Filter.mem_limsup_iff_frequently_mem
code: lemma mem_limsup_iff_frequently_mem : (a ∈ limsup s 𝓕) ↔ (∃ᶠ i in 𝓕, a ∈ s i) 
goal: a ∈ Filter.limsup s 𝓕 ↔ ∃ᶠ (i : ι) in 𝓕, a ∈ s i

full_name: Filter.cofinite.blimsup_set_eq
code: theorem cofinite.blimsup_set_eq :
    blimsup s cofinite p = { x | { n | p n ∧ x ∈ s n }.Infinite } 
goal: Filter.blimsup s Filter.cofinite p = {x | {n | p n ∧ x ∈ s n}.Infinite}

full_name: Filter.cofinite.bliminf_set_eq
code: theorem cofinite.bliminf_set_eq : bliminf s cofinite p = { x | { n | p n ∧ x ∉ s n }.Finite } 
goal: Filter.bliminf s Filter.cofinite p = {x | {n | p n ∧ x ∉ s n}.Finite}

full_name: Filter.cofinite.limsup_set_eq
code: /-- In other words, `limsup cofinite s` is the set of elements lying inside the family `s`
infinitely often. -/
theorem cofinite.limsup_set_eq : limsup s cofinite = { x | { n | x ∈ s n }.Infinite } 
goal: Filter.limsup s Filter.cofinite = {x | {n | x ∈ s n}.Infinite}

full_name: Filter.cofinite.liminf_set_eq
code: /-- In other words, `liminf cofinite s` is the set of elements lying outside the family `s`
finitely often. -/
theorem cofinite.liminf_set_eq : liminf s cofinite = { x | { n | x ∉ s n }.Finite } 
goal: Filter.liminf s Filter.cofinite = {x | {n | x ∉ s n}.Finite}

full_name: Filter.exists_forall_mem_of_hasBasis_mem_blimsup
code: theorem exists_forall_mem_of_hasBasis_mem_blimsup {l : Filter β} {b : ι → Set β} {q : ι → Prop}
    (hl : l.HasBasis q b) {u : β → Set α} {p : β → Prop} {x : α} (hx : x ∈ blimsup u l p) :
    ∃ f : { i | q i } → β, ∀ i, x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i 
goal: ∃ f, ∀ (i : ↑{i | q i}), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b ↑i

full_name: Filter.exists_forall_mem_of_hasBasis_mem_blimsup'
code: theorem exists_forall_mem_of_hasBasis_mem_blimsup' {l : Filter β} {b : ι → Set β}
    (hl : l.HasBasis (fun _ => True) b) {u : β → Set α} {p : β → Prop} {x : α}
    (hx : x ∈ blimsup u l p) : ∃ f : ι → β, ∀ i, x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i 
goal: ∃ f, ∀ (i : ι), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i

full_name: Filter.frequently_lt_of_lt_limsSup
code: theorem frequently_lt_of_lt_limsSup {f : Filter α} [ConditionallyCompleteLinearOrder α] {a : α}
    (hf : f.IsCobounded (· ≤ ·) := by isBoundedDefault)
    (h : a < limsSup f) : ∃ᶠ n in f, a < n 
goal: ∃ᶠ (n : α) in f, a < n

full_name: Filter.frequently_lt_of_limsInf_lt
code: theorem frequently_lt_of_limsInf_lt {f : Filter α} [ConditionallyCompleteLinearOrder α] {a : α}
    (hf : f.IsCobounded (· ≥ ·) := by isBoundedDefault)
    (h : limsInf f < a) : ∃ᶠ n in f, n < a 
goal: ∃ᶠ (n : α) in f, n < a

full_name: Filter.eventually_lt_of_lt_liminf
code: theorem eventually_lt_of_lt_liminf {f : Filter α} [ConditionallyCompleteLinearOrder β] {u : α → β}
    {b : β} (h : b < liminf u f)
    (hu : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
    ∀ᶠ a in f, b < u a 
goal: ∀ᶠ (a : α) in f, b < u a

full_name: Filter.eventually_lt_of_limsup_lt
code: theorem eventually_lt_of_limsup_lt {f : Filter α} [ConditionallyCompleteLinearOrder β] {u : α → β}
    {b : β} (h : limsup u f < b)
    (hu : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
    ∀ᶠ a in f, u a < b 
goal: ∀ᶠ (a : α) in f, u a < b

full_name: Filter.le_limsup_of_frequently_le
code: theorem le_limsup_of_frequently_le {α β} [ConditionallyCompleteLinearOrder β] {f : Filter α}
    {u : α → β} {b : β} (hu_le : ∃ᶠ x in f, b ≤ u x)
    (hu : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
    b ≤ limsup u f 
goal: b ≤ Filter.limsup u f

full_name: Filter.liminf_le_of_frequently_le
code: theorem liminf_le_of_frequently_le {α β} [ConditionallyCompleteLinearOrder β] {f : Filter α}
    {u : α → β} {b : β} (hu_le : ∃ᶠ x in f, u x ≤ b)
    (hu : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
    liminf u f ≤ b 
goal: Filter.liminf u f ≤ b

full_name: Filter.frequently_lt_of_lt_limsup
code: theorem frequently_lt_of_lt_limsup {α β} [ConditionallyCompleteLinearOrder β] {f : Filter α}
    {u : α → β} {b : β}
    (hu : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h : b < limsup u f) : ∃ᶠ x in f, b < u x 
goal: ∃ᶠ (x : α) in f, b < u x

full_name: Filter.frequently_lt_of_liminf_lt
code: theorem frequently_lt_of_liminf_lt {α β} [ConditionallyCompleteLinearOrder β] {f : Filter α}
    {u : α → β} {b : β}
    (hu : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h : liminf u f < b) : ∃ᶠ x in f, u x < b 
goal: ∃ᶠ (x : α) in f, u x < b

full_name: Filter.limsup_le_iff
code: theorem limsup_le_iff {α β} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β} {x : β}
    (h₁ : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h₂ : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
    limsup u f ≤ x ↔ ∀ y > x, ∀ᶠ a in f, u a < y 
goal: Filter.limsup u f ≤ x ↔ ∀ y > x, ∀ᶠ (a : α) in f, u a < y

full_name: Filter.le_limsup_iff
code: theorem le_limsup_iff {α β} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β} {x : β}
    (h₁ : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h₂ : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault) :
    x ≤ limsup u f ↔ ∀ y < x, ∃ᶠ a in f, y < u a 
goal: x ≤ Filter.limsup u f ↔ ∀ y < x, ∃ᶠ (a : α) in f, y < u a

full_name: Filter.le_liminf_iff
code: theorem le_liminf_iff {α β} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β} {x : β}
    (h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h₂ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
    x ≤ liminf u f ↔ ∀ y < x, ∀ᶠ a in f, y < u a 
goal: x ≤ Filter.liminf u f ↔ ∀ y < x, ∀ᶠ (a : α) in f, y < u a

full_name: Filter.liminf_le_iff
code: theorem liminf_le_iff {α β} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β} {x : β}
    (h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h₂ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
    liminf u f ≤ x ↔ ∀ y > x, ∃ᶠ a in f, u a < y 
goal: Filter.liminf u f ≤ x ↔ ∀ y > x, ∃ᶠ (a : α) in f, u a < y

full_name: Filter.lt_mem_sets_of_limsSup_lt
code: theorem lt_mem_sets_of_limsSup_lt (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
    ∀ᶠ a in f, a < b 
goal: ∀ᶠ (a : α) in f, a < b

full_name: Filter.gt_mem_sets_of_limsInf_gt
code: theorem gt_mem_sets_of_limsInf_gt : f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a 
goal: Filter.IsBounded (fun x x_1 => x ≥ x_1) f → b < f.limsInf → ∀ᶠ (a : α) in f, b < a

full_name: Filter.liminf_reparam
code: /-- Given an indexed family of sets `s j` over `j : Subtype p` and a function `f`, then
`liminf_reparam j` is equal to `j` if `f` is bounded below on `s j`, and otherwise to some
index `k` such that `f` is bounded below on `s k` (if there exists one).
To ensure good measurability behavior, this index `k` is chosen as the minimal suitable index.
This function is used to write down a liminf in a measurable way,
in `Filter.HasBasis.liminf_eq_ciSup_ciInf` and `Filter.HasBasis.liminf_eq_ite`. -/
noncomputable def liminf_reparam
    (f : ι → α) (s : ι' → Set ι) (p : ι' → Prop) [Countable (Subtype p)] [Nonempty (Subtype p)]
    (j : Subtype p) : Subtype p 
goal: Subtype p

full_name: Filter.HasBasis.liminf_eq_ciSup_ciInf
code: /-- Writing a liminf as a supremum of infimum, in a (possibly non-complete) conditionally complete
linear order. A reparametrization trick is needed to avoid taking the infimum of sets which are
not bounded below. -/
theorem HasBasis.liminf_eq_ciSup_ciInf {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} [Countable (Subtype p)] [Nonempty (Subtype p)]
    (hv : v.HasBasis p s) {f : ι → α} (hs : ∀ (j : Subtype p), (s j).Nonempty)
    (H : ∃ (j : Subtype p), BddBelow (range (fun (i : s j) ↦ f i))) :
    liminf f v = ⨆ (j : Subtype p), ⨅ (i : s (liminf_reparam f s p j)), f i 
goal: Filter.liminf f v = ⨆ j, ⨅ i, f ↑i

full_name: Filter.HasBasis.liminf_eq_ite
code: /-- Writing a liminf as a supremum of infimum, in a (possibly non-complete) conditionally complete
linear order. A reparametrization trick is needed to avoid taking the infimum of sets which are
not bounded below. -/
theorem HasBasis.liminf_eq_ite {v : Filter ι} {p : ι' → Prop} {s : ι' → Set ι}
    [Countable (Subtype p)] [Nonempty (Subtype p)] (hv : v.HasBasis p s) (f : ι → α) :
    liminf f v = if ∃ (j : Subtype p), s j = ∅ then sSup univ else
      if ∀ (j : Subtype p), ¬BddBelow (range (fun (i : s j) ↦ f i)) then sSup ∅
      else ⨆ (j : Subtype p), ⨅ (i : s (liminf_reparam f s p j)), f i 
goal: Filter.liminf f v =
  if ∃ j, s ↑j = ∅ then sSup Set.univ
  else if ∀ (j : Subtype p), ¬BddBelow (Set.range fun i => f ↑i) then sSup ∅ else ⨆ j, ⨅ i, f ↑i

full_name: Filter.limsup_reparam
code: /-- Given an indexed family of sets `s j` and a function `f`, then `limsup_reparam j` is equal
to `j` if `f` is bounded above on `s j`, and otherwise to some index `k` such that `f` is bounded
above on `s k` (if there exists one). To ensure good measurability behavior, this index `k` is
chosen as the minimal suitable index. This function is used to write down a limsup in a measurable
way, in `Filter.HasBasis.limsup_eq_ciInf_ciSup` and `Filter.HasBasis.limsup_eq_ite`. -/
noncomputable def limsup_reparam
    (f : ι → α) (s : ι' → Set ι) (p : ι' → Prop) [Countable (Subtype p)] [Nonempty (Subtype p)]
    (j : Subtype p) : Subtype p 
goal: Subtype p

full_name: Filter.HasBasis.limsup_eq_ciInf_ciSup
code: /-- Writing a limsup as an infimum of supremum, in a (possibly non-complete) conditionally complete
linear order. A reparametrization trick is needed to avoid taking the supremum of sets which are
not bounded above. -/
theorem HasBasis.limsup_eq_ciInf_ciSup {v : Filter ι}
    {p : ι' → Prop} {s : ι' → Set ι} [Countable (Subtype p)] [Nonempty (Subtype p)]
    (hv : v.HasBasis p s) {f : ι → α} (hs : ∀ (j : Subtype p), (s j).Nonempty)
    (H : ∃ (j : Subtype p), BddAbove (range (fun (i : s j) ↦ f i))) :
    limsup f v = ⨅ (j : Subtype p), ⨆ (i : s (limsup_reparam f s p j)), f i 
goal: Filter.limsup f v = ⨅ j, ⨆ i, f ↑i

full_name: Filter.HasBasis.limsup_eq_ite
code: /-- Writing a limsup as an infimum of supremum, in a (possibly non-complete) conditionally complete
linear order. A reparametrization trick is needed to avoid taking the supremum of sets which are
not bounded below. -/
theorem HasBasis.limsup_eq_ite {v : Filter ι} {p : ι' → Prop} {s : ι' → Set ι}
    [Countable (Subtype p)] [Nonempty (Subtype p)] (hv : v.HasBasis p s) (f : ι → α) :
    limsup f v = if ∃ (j : Subtype p), s j = ∅ then sInf univ else
      if ∀ (j : Subtype p), ¬BddAbove (range (fun (i : s j) ↦ f i)) then sInf ∅
      else ⨅ (j : Subtype p), ⨆ (i : s (limsup_reparam f s p j)), f i 
goal: Filter.limsup f v =
  if ∃ j, s ↑j = ∅ then sInf Set.univ
  else if ∀ (j : Subtype p), ¬BddAbove (Set.range fun i => f ↑i) then sInf ∅ else ⨅ j, ⨆ i, f ↑i

full_name: Monotone.isBoundedUnder_le_comp_iff
code: theorem Monotone.isBoundedUnder_le_comp_iff [Nonempty β] [LinearOrder β] [Preorder γ] [NoMaxOrder γ]
    {g : β → γ} {f : α → β} {l : Filter α} (hg : Monotone g) (hg' : Tendsto g atTop atTop) :
    IsBoundedUnder (· ≤ ·) l (g ∘ f) ↔ IsBoundedUnder (· ≤ ·) l f 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (g ∘ f) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

full_name: Monotone.isBoundedUnder_ge_comp_iff
code: theorem Monotone.isBoundedUnder_ge_comp_iff [Nonempty β] [LinearOrder β] [Preorder γ] [NoMinOrder γ]
    {g : β → γ} {f : α → β} {l : Filter α} (hg : Monotone g) (hg' : Tendsto g atBot atBot) :
    IsBoundedUnder (· ≥ ·) l (g ∘ f) ↔ IsBoundedUnder (· ≥ ·) l f 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l (g ∘ f) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l f

full_name: Antitone.isBoundedUnder_le_comp_iff
code: theorem Antitone.isBoundedUnder_le_comp_iff [Nonempty β] [LinearOrder β] [Preorder γ] [NoMaxOrder γ]
    {g : β → γ} {f : α → β} {l : Filter α} (hg : Antitone g) (hg' : Tendsto g atBot atTop) :
    IsBoundedUnder (· ≤ ·) l (g ∘ f) ↔ IsBoundedUnder (· ≥ ·) l f 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (g ∘ f) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l f

full_name: Antitone.isBoundedUnder_ge_comp_iff
code: theorem Antitone.isBoundedUnder_ge_comp_iff [Nonempty β] [LinearOrder β] [Preorder γ] [NoMinOrder γ]
    {g : β → γ} {f : α → β} {l : Filter α} (hg : Antitone g) (hg' : Tendsto g atTop atBot) :
    IsBoundedUnder (· ≥ ·) l (g ∘ f) ↔ IsBoundedUnder (· ≤ ·) l f 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l (g ∘ f) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

full_name: GaloisConnection.l_limsup_le
code: theorem GaloisConnection.l_limsup_le [ConditionallyCompleteLattice β]
    [ConditionallyCompleteLattice γ] {f : Filter α} {v : α → β} {l : β → γ} {u : γ → β}
    (gc : GaloisConnection l u)
    (hlv : f.IsBoundedUnder (· ≤ ·) fun x => l (v x) := by isBoundedDefault)
    (hv_co : f.IsCoboundedUnder (· ≤ ·) v := by isBoundedDefault) :
    l (limsup v f) ≤ limsup (fun x => l (v x)) f 
goal: l (Filter.limsup v f) ≤ Filter.limsup (fun x => l (v x)) f

full_name: OrderIso.limsup_apply
code: theorem OrderIso.limsup_apply {γ} [ConditionallyCompleteLattice β] [ConditionallyCompleteLattice γ]
    {f : Filter α} {u : α → β} (g : β ≃o γ)
    (hu : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (hu_co : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (hgu : f.IsBoundedUnder (· ≤ ·) fun x => g (u x) := by isBoundedDefault)
    (hgu_co : f.IsCoboundedUnder (· ≤ ·) fun x => g (u x) := by isBoundedDefault) :
    g (limsup u f) = limsup (fun x => g (u x)) f 
goal: g (Filter.limsup u f) = Filter.limsup (fun x => g (u x)) f

full_name: OrderIso.liminf_apply
code: theorem OrderIso.liminf_apply {γ} [ConditionallyCompleteLattice β] [ConditionallyCompleteLattice γ]
    {f : Filter α} {u : α → β} (g : β ≃o γ)
    (hu : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
    (hu_co : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
    (hgu : f.IsBoundedUnder (· ≥ ·) fun x => g (u x) := by isBoundedDefault)
    (hgu_co : f.IsCoboundedUnder (· ≥ ·) fun x => g (u x) := by isBoundedDefault) :
    g (liminf u f) = liminf (fun x => g (u x)) f 
goal: g (Filter.liminf u f) = Filter.liminf (fun x => g (u x)) f

full_name: isCoboundedUnder_le_max
code: theorem isCoboundedUnder_le_max [LinearOrder β] {f : Filter α} {u v : α → β}
    (h : f.IsCoboundedUnder (· ≤ ·) u ∨ f.IsCoboundedUnder (· ≤ ·) v) :
    f.IsCoboundedUnder (· ≤ ·) (fun a ↦ max (u a) (v a)) 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) f fun a => max (u a) (v a)

full_name: limsup_max
code: theorem limsup_max [ConditionallyCompleteLinearOrder β] {f : Filter α} {u v : α → β}
    (h₁ : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h₂ : f.IsCoboundedUnder (· ≤ ·) v := by isBoundedDefault)
    (h₃ : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h₄ : f.IsBoundedUnder (· ≤ ·) v := by isBoundedDefault) :
    limsup (fun a ↦ max (u a) (v a)) f = max (limsup u f) (limsup v f) 
goal: Filter.limsup (fun a => max (u a) (v a)) f = max (Filter.limsup u f) (Filter.limsup v f)

full_name: liminf_min
code: theorem liminf_min [ConditionallyCompleteLinearOrder β] {f : Filter α} {u v : α → β}
    (h₁ : f.IsCoboundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h₂ : f.IsCoboundedUnder (· ≥ ·) v := by isBoundedDefault)
    (h₃ : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault)
    (h₄ : f.IsBoundedUnder (· ≥ ·) v := by isBoundedDefault) :
    liminf (fun a ↦ min (u a) (v a)) f = min (liminf u f) (liminf v f) 
goal: Filter.liminf (fun a => min (u a) (v a)) f = min (Filter.liminf u f) (Filter.liminf v f)

full_name: isBoundedUnder_le_finset_sup'
code: theorem isBoundedUnder_le_finset_sup' [LinearOrder β] [Nonempty β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (hs : s.Nonempty) (h : ∀ i ∈ s, f.IsBoundedUnder (· ≤ ·) (F i)) :
    f.IsBoundedUnder (· ≤ ·) (fun a ↦ sup' s hs (fun i ↦ F i a)) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup' hs fun i => F i a

full_name: isCoboundedUnder_le_finset_sup'
code: theorem isCoboundedUnder_le_finset_sup' [LinearOrder β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (hs : s.Nonempty) (h : ∃ i ∈ s, f.IsCoboundedUnder (· ≤ ·) (F i)) :
    f.IsCoboundedUnder (· ≤ ·) (fun a ↦ sup' s hs (fun i ↦ F i a)) 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup' hs fun i => F i a

full_name: isBoundedUnder_le_finset_sup
code: theorem isBoundedUnder_le_finset_sup [LinearOrder β] [OrderBot β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (h : ∀ i ∈ s, f.IsBoundedUnder (· ≤ ·) (F i)) :
    f.IsBoundedUnder (· ≤ ·) (fun a ↦ sup s (fun i ↦ F i a)) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) f fun a => s.sup fun i => F i a

full_name: isBoundedUnder_ge_finset_inf'
code: theorem isBoundedUnder_ge_finset_inf' [LinearOrder β] [Nonempty β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (hs : s.Nonempty) (h : ∀ i ∈ s, f.IsBoundedUnder (· ≥ ·) (F i)) :
    f.IsBoundedUnder (· ≥ ·) (fun a ↦ inf' s hs (fun i ↦ F i a)) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f fun a => s.inf' hs fun i => F i a

full_name: isCoboundedUnder_ge_finset_inf'
code: theorem isCoboundedUnder_ge_finset_inf' [LinearOrder β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (hs : s.Nonempty) (h : ∃ i ∈ s, f.IsCoboundedUnder (· ≥ ·) (F i)) :
    f.IsCoboundedUnder (· ≥ ·) (fun a ↦ inf' s hs (fun i ↦ F i a)) 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) f fun a => s.inf' hs fun i => F i a

full_name: isBoundedUnder_ge_finset_inf
code: theorem isBoundedUnder_ge_finset_inf [LinearOrder β] [OrderTop β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (h : ∀ i ∈ s, f.IsBoundedUnder (· ≥ ·) (F i)) :
    f.IsBoundedUnder (· ≥ ·) (fun a ↦ inf s (fun i ↦ F i a)) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) f fun a => s.inf fun i => F i a

full_name: limsup_finset_sup'
code: theorem limsup_finset_sup' [ConditionallyCompleteLinearOrder β] {f : Filter α}
    {F : ι → α → β} {s : Finset ι} (hs : s.Nonempty)
    (h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
    (h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
    limsup (fun a ↦ sup' s hs (fun i ↦ F i a)) f = sup' s hs (fun i ↦ limsup (F i) f) 
goal: Filter.limsup (fun a => s.sup' hs fun i => F i a) f = s.sup' hs fun i => Filter.limsup (F i) f

full_name: limsup_finset_sup
code: theorem limsup_finset_sup [ConditionallyCompleteLinearOrder β] [OrderBot β] {f : Filter α}
    {F : ι → α → β} {s : Finset ι}
    (h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
    (h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≤ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
    limsup (fun a ↦ sup s (fun i ↦ F i a)) f = sup s (fun i ↦ limsup (F i) f) 
goal: Filter.limsup (fun a => s.sup fun i => F i a) f = s.sup fun i => Filter.limsup (F i) f

full_name: liminf_finset_inf'
code: theorem liminf_finset_inf' [ConditionallyCompleteLinearOrder β] {f : Filter α}
    {F : ι → α → β} {s : Finset ι} (hs : s.Nonempty)
    (h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≥ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
    (h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≥ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
    liminf (fun a ↦ inf' s hs (fun i ↦ F i a)) f = inf' s hs (fun i ↦ liminf (F i) f) 
goal: Filter.liminf (fun a => s.inf' hs fun i => F i a) f = s.inf' hs fun i => Filter.liminf (F i) f

full_name: liminf_finset_inf
code: theorem liminf_finset_inf [ConditionallyCompleteLinearOrder β] [OrderTop β] {f : Filter α}
    {F : ι → α → β} {s : Finset ι}
    (h₁ : ∀ i ∈ s, f.IsCoboundedUnder (· ≥ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault)
    (h₂ : ∀ i ∈ s, f.IsBoundedUnder (· ≥ ·) (F i) := by exact fun _ _ ↦ by isBoundedDefault) :
    liminf (fun a ↦ inf s (fun i ↦ F i a)) f = inf s (fun i ↦ liminf (F i) f) 
goal: Filter.liminf (fun a => s.inf fun i => F i a) f = s.inf fun i => Filter.liminf (F i) f

full_name: Filter.IsCobounded.frequently_ge
code: /-- For nontrivial filters in linear orders, coboundedness for `≤` implies frequent boundedness
from below. -/
lemma IsCobounded.frequently_ge [NeBot F] (cobdd : IsCobounded (· ≤ ·) F) :
    ∃ l, ∃ᶠ x in F, l ≤ x 
goal: ∃ l, ∃ᶠ (x : R) in F, l ≤ x

full_name: Filter.IsCobounded.frequently_le
code: /-- For nontrivial filters in linear orders, coboundedness for `≥` implies frequent boundedness
from above. -/
lemma IsCobounded.frequently_le [NeBot F] (cobdd : IsCobounded (· ≥ ·) F) :
    ∃ u, ∃ᶠ x in F, x ≤ u 
goal: ∃ u, ∃ᶠ (x : R) in F, x ≤ u

full_name: Filter.IsCobounded.of_frequently_ge
code: /-- In linear orders, frequent boundedness from below implies coboundedness for `≤`. -/
lemma IsCobounded.of_frequently_ge {l : R} (freq_ge : ∃ᶠ x in F, l ≤ x) :
    IsCobounded (· ≤ ·) F 
goal: Filter.IsCobounded (fun x x_1 => x ≤ x_1) F

full_name: Filter.IsCobounded.of_frequently_le
code: /-- In linear orders, frequent boundedness from above implies coboundedness for `≥`. -/
lemma IsCobounded.of_frequently_le {u : R} (freq_le : ∃ᶠ r in F, r ≤ u) :
    IsCobounded (· ≥ ·) F 
goal: Filter.IsCobounded (fun x x_1 => x ≥ x_1) F

full_name: Monotone.frequently_ge_map_of_frequently_ge
code: lemma Monotone.frequently_ge_map_of_frequently_ge {f : R → S} (f_incr : Monotone f)
    {l : R} (freq_ge : ∃ᶠ x in F, l ≤ x) :
    ∃ᶠ x' in F.map f, f l ≤ x' 
goal: ∃ᶠ (x' : S) in Filter.map f F, f l ≤ x'

full_name: Monotone.frequently_le_map_of_frequently_le
code: lemma Monotone.frequently_le_map_of_frequently_le {f : R → S} (f_incr : Monotone f)
    {u : R} (freq_le : ∃ᶠ x in F, x ≤ u) :
    ∃ᶠ y in F.map f, y ≤ f u 
goal: ∃ᶠ (y : S) in Filter.map f F, y ≤ f u

full_name: Antitone.frequently_le_map_of_frequently_ge
code: lemma Antitone.frequently_le_map_of_frequently_ge {f : R → S} (f_decr : Antitone f)
    {l : R} (frbdd : ∃ᶠ x in F, l ≤ x) :
    ∃ᶠ y in F.map f, y ≤ f l 
goal: ∃ᶠ (y : S) in Filter.map f F, y ≤ f l

full_name: Antitone.frequently_ge_map_of_frequently_le
code: lemma Antitone.frequently_ge_map_of_frequently_le {f : R → S} (f_decr : Antitone f)
    {u : R} (frbdd : ∃ᶠ x in F, x ≤ u) :
    ∃ᶠ y in F.map f, f u ≤ y 
goal: ∃ᶠ (y : S) in Filter.map f F, f u ≤ y

full_name: Monotone.isCoboundedUnder_le_of_isCobounded
code: lemma Monotone.isCoboundedUnder_le_of_isCobounded {f : R → S} (f_incr : Monotone f)
    [NeBot F] (cobdd : IsCobounded (· ≤ ·) F) :
    F.IsCoboundedUnder (· ≤ ·) f 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) F f

full_name: Monotone.isCoboundedUnder_ge_of_isCobounded
code: lemma Monotone.isCoboundedUnder_ge_of_isCobounded {f : R → S} (f_incr : Monotone f)
    [NeBot F] (cobdd : IsCobounded (· ≥ ·) F) :
    F.IsCoboundedUnder (· ≥ ·) f 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) F f

full_name: Antitone.isCoboundedUnder_le_of_isCobounded
code: lemma Antitone.isCoboundedUnder_le_of_isCobounded {f : R → S} (f_decr : Antitone f)
    [NeBot F] (cobdd : IsCobounded (· ≥ ·) F) :
    F.IsCoboundedUnder (· ≤ ·) f 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) F f

full_name: Antitone.isCoboundedUnder_ge_of_isCobounded
code: lemma Antitone.isCoboundedUnder_ge_of_isCobounded {f : R → S} (f_decr : Antitone f)
    [NeBot F] (cobdd : IsCobounded (· ≤ ·) F) :
    F.IsCoboundedUnder (· ≥ ·) f 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) F f