Documentation

Mathlib.Order.LiminfLimsup

liminfs and limsups of functions and filters #

Defines the liminf/limsup of a function taking values in a conditionally complete lattice, with respect to an arbitrary filter.

We define limsSup f (limsInf f) where f is a filter taking values in a conditionally complete lattice. limsSup f is the smallest element a such that, eventually, u ≤ a (and vice versa for limsInf f). To work with the Limsup along a function u use limsSup (map u f).

Usually, one defines the Limsup as inf (sup s) where the Inf is taken over all sets in the filter. For instance, in ℕ along a function u, this is inf_n (sup_{k ≥ n} u k) (and the latter quantity decreases with n, so this is in fact a limit.). There is however a difficulty: it is well possible that u is not bounded on the whole space, only eventually (think of limsup (fun x ↦ 1/x) on ℝ. Then there is no guarantee that the quantity above really decreases (the value of the sup beforehand is not really well defined, as one can not use ∞), so that the Inf could be anything. So one can not use this inf sup ... definition in conditionally complete lattices, and one has to use a less tractable definition.

In conditionally complete lattices, the definition is only useful for filters which are eventually bounded above (otherwise, the Limsup would morally be +∞, which does not belong to the space) and which are frequently bounded below (otherwise, the Limsup would morally be -∞, which is not in the space either). We start with definitions of these concepts for arbitrary filters, before turning to the definitions of Limsup and Liminf.

In complete lattices, however, it coincides with the Inf Sup definition.

def Filter.IsBounded {α : Type u_1} (r : ααProp) (f : Filter α) :

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 .

Equations
Instances For
    def Filter.IsBoundedUnder {α : Type u_1} {β : Type u_2} (r : ααProp) (f : Filter β) (u : βα) :

    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.

    Equations
    Instances For
      theorem Filter.isBounded_iff {α : Type u_1} {r : ααProp} {f : Filter α} :
      Filter.IsBounded r f sf.sets, ∃ (b : α), s {x : α | r x b}

      f is eventually bounded if and only if, there exists an admissible set on which it is bounded.

      theorem Filter.isBoundedUnder_of {α : Type u_1} {β : Type u_2} {r : ααProp} {f : Filter β} {u : βα} :
      (∃ (b : α), ∀ (x : β), r (u x) b)Filter.IsBoundedUnder r f u

      A bounded function u is in particular eventually bounded.

      theorem Filter.isBounded_bot {α : Type u_1} {r : ααProp} :
      theorem Filter.isBounded_top {α : Type u_1} {r : ααProp} :
      Filter.IsBounded r ∃ (t : α), ∀ (x : α), r x t
      theorem Filter.isBounded_principal {α : Type u_1} {r : ααProp} (s : Set α) :
      Filter.IsBounded r (Filter.principal s) ∃ (t : α), xs, r x t
      theorem Filter.isBounded_sup {α : Type u_1} {r : ααProp} {f : Filter α} {g : Filter α} [IsTrans α r] [IsDirected α r] :
      theorem Filter.IsBounded.mono {α : Type u_1} {r : ααProp} {f : Filter α} {g : Filter α} (h : f g) :
      theorem Filter.IsBoundedUnder.mono {α : Type u_1} {β : Type u_2} {r : ααProp} {f : Filter β} {g : Filter β} {u : βα} (h : f g) :
      theorem Filter.IsBoundedUnder.mono_le {α : Type u_1} {β : Type u_2} [Preorder β] {l : Filter α} {u : αβ} {v : αβ} (hu : Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l u) (hv : v ≤ᶠ[l] u) :
      Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l v
      theorem Filter.IsBoundedUnder.mono_ge {α : Type u_1} {β : Type u_2} [Preorder β] {l : Filter α} {u : αβ} {v : αβ} (hu : Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l u) (hv : u ≤ᶠ[l] v) :
      Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l v
      theorem Filter.isBoundedUnder_const {α : Type u_1} {β : Type u_2} {r : ααProp} [IsRefl α r] {l : Filter β} {a : α} :
      Filter.IsBoundedUnder r l fun (x : β) => a
      theorem Filter.IsBounded.isBoundedUnder {α : Type u_1} {β : Type u_2} {r : ααProp} {f : Filter α} {q : ββProp} {u : αβ} (hu : ∀ (a₀ a₁ : α), r a₀ a₁q (u a₀) (u a₁)) :
      theorem Filter.IsBoundedUnder.comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : ααProp} {l : Filter γ} {q : ββProp} {u : γα} {v : αβ} (hv : ∀ (a₀ a₁ : α), r a₀ a₁q (v a₀) (v a₁)) :
      theorem BddAbove.isBoundedUnder {α : Type u_1} {β : Type u_2} [Preorder α] {f : Filter β} {u : βα} :
      BddAbove (Set.range u)Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f u

      A bounded above function u is in particular eventually bounded above.

      theorem BddBelow.isBoundedUnder {α : Type u_1} {β : Type u_2} [Preorder α] {f : Filter β} {u : βα} :
      BddBelow (Set.range u)Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f u

      A bounded below function u is in particular eventually bounded below.

      theorem Monotone.isBoundedUnder_le_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] {l : Filter γ} {u : γα} {v : αβ} (hv : Monotone v) (hl : Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) l u) :
      Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l (v u)
      theorem Monotone.isBoundedUnder_ge_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] {l : Filter γ} {u : γα} {v : αβ} (hv : Monotone v) (hl : Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) l u) :
      Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l (v u)
      theorem Antitone.isBoundedUnder_le_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] {l : Filter γ} {u : γα} {v : αβ} (hv : Antitone v) (hl : Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) l u) :
      Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l (v u)
      theorem Antitone.isBoundedUnder_ge_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] {l : Filter γ} {u : γα} {v : αβ} (hv : Antitone v) (hl : Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) l u) :
      Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l (v u)
      theorem Filter.not_isBoundedUnder_of_tendsto_atTop {α : Type u_1} {β : Type u_2} [Preorder β] [NoMaxOrder β] {f : αβ} {l : Filter α} [l.NeBot] (hf : Filter.Tendsto f l Filter.atTop) :
      ¬Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l f
      theorem Filter.not_isBoundedUnder_of_tendsto_atBot {α : Type u_1} {β : Type u_2} [Preorder β] [NoMinOrder β] {f : αβ} {l : Filter α} [l.NeBot] (hf : Filter.Tendsto f l Filter.atBot) :
      ¬Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l f
      theorem Filter.IsBoundedUnder.bddAbove_range_of_cofinite {α : Type u_1} {β : Type u_2} [Preorder β] [IsDirected β fun (x x_1 : β) => x x_1] {f : αβ} (hf : Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) Filter.cofinite f) :
      theorem Filter.IsBoundedUnder.bddBelow_range_of_cofinite {α : Type u_1} {β : Type u_2} [Preorder β] [IsDirected β fun (x x_1 : β) => x x_1] {f : αβ} (hf : Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) Filter.cofinite f) :
      theorem Filter.IsBoundedUnder.bddAbove_range {β : Type u_2} [Preorder β] [IsDirected β fun (x x_1 : β) => x x_1] {f : β} (hf : Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) Filter.atTop f) :
      theorem Filter.IsBoundedUnder.bddBelow_range {β : Type u_2} [Preorder β] [IsDirected β fun (x x_1 : β) => x x_1] {f : β} (hf : Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) Filter.atTop f) :
      def Filter.IsCobounded {α : Type u_1} (r : ααProp) (f : Filter α) :

      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.

      Equations
      Instances For
        def Filter.IsCoboundedUnder {α : Type u_1} {β : Type u_2} (r : ααProp) (f : Filter β) (u : βα) :

        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 .

        Equations
        Instances For
          theorem Filter.IsCobounded.mk {α : Type u_1} {r : ααProp} {f : Filter α} [IsTrans α r] (a : α) (h : sf, xs, r a x) :

          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 Filter.IsBounded.isCobounded_flip {α : Type u_1} {r : ααProp} {f : Filter α} [IsTrans α r] [f.NeBot] :

          A filter which is eventually bounded is in particular frequently bounded (in the opposite direction). At least if the filter is not trivial.

          theorem Filter.IsBounded.isCobounded_ge {α : Type u_1} {f : Filter α} [Preorder α] [f.NeBot] (h : Filter.IsBounded (fun (x x_1 : α) => x x_1) f) :
          Filter.IsCobounded (fun (x x_1 : α) => x x_1) f
          theorem Filter.IsBounded.isCobounded_le {α : Type u_1} {f : Filter α} [Preorder α] [f.NeBot] (h : Filter.IsBounded (fun (x x_1 : α) => x x_1) f) :
          Filter.IsCobounded (fun (x x_1 : α) => x x_1) f
          theorem Filter.IsBoundedUnder.isCoboundedUnder_flip {α : Type u_1} {γ : Type u_3} {r : ααProp} {u : γα} {l : Filter γ} [IsTrans α r] [l.NeBot] (h : Filter.IsBoundedUnder r l u) :
          theorem Filter.IsBoundedUnder.isCoboundedUnder_le {α : Type u_1} {γ : Type u_3} {u : γα} {l : Filter γ} [Preorder α] [l.NeBot] (h : Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) l u) :
          Filter.IsCoboundedUnder (fun (x x_1 : α) => x x_1) l u
          theorem Filter.IsBoundedUnder.isCoboundedUnder_ge {α : Type u_1} {γ : Type u_3} {u : γα} {l : Filter γ} [Preorder α] [l.NeBot] (h : Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) l u) :
          Filter.IsCoboundedUnder (fun (x x_1 : α) => x x_1) l u
          theorem Filter.isCoboundedUnder_le_of_eventually_le {α : Type u_1} {ι : Type u_4} [Preorder α] (l : Filter ι) [l.NeBot] {f : ια} {x : α} (hf : ∀ᶠ (i : ι) in l, x f i) :
          Filter.IsCoboundedUnder (fun (x x_1 : α) => x x_1) l f
          theorem Filter.isCoboundedUnder_ge_of_eventually_le {α : Type u_1} {ι : Type u_4} [Preorder α] (l : Filter ι) [l.NeBot] {f : ια} {x : α} (hf : ∀ᶠ (i : ι) in l, f i x) :
          Filter.IsCoboundedUnder (fun (x x_1 : α) => x x_1) l f
          theorem Filter.isCoboundedUnder_le_of_le {α : Type u_1} {ι : Type u_4} [Preorder α] (l : Filter ι) [l.NeBot] {f : ια} {x : α} (hf : ∀ (i : ι), x f i) :
          Filter.IsCoboundedUnder (fun (x x_1 : α) => x x_1) l f
          theorem Filter.isCoboundedUnder_ge_of_le {α : Type u_1} {ι : Type u_4} [Preorder α] (l : Filter ι) [l.NeBot] {f : ια} {x : α} (hf : ∀ (i : ι), f i x) :
          Filter.IsCoboundedUnder (fun (x x_1 : α) => x x_1) l f
          theorem Filter.isCobounded_bot {α : Type u_1} {r : ααProp} :
          Filter.IsCobounded r ∃ (b : α), ∀ (x : α), r b x
          theorem Filter.isCobounded_top {α : Type u_1} {r : ααProp} :
          theorem Filter.isCobounded_principal {α : Type u_1} {r : ααProp} (s : Set α) :
          Filter.IsCobounded r (Filter.principal s) ∃ (b : α), ∀ (a : α), (xs, r x a)r b a
          theorem Filter.IsCobounded.mono {α : Type u_1} {r : ααProp} {f : Filter α} {g : Filter α} (h : f g) :
          theorem Filter.isBounded_le_atBot {α : Type u_1} [Preorder α] [Nonempty α] :
          Filter.IsBounded (fun (x x_1 : α) => x x_1) Filter.atBot
          theorem Filter.isBounded_ge_atTop {α : Type u_1} [Preorder α] [Nonempty α] :
          Filter.IsBounded (fun (x x_1 : α) => x x_1) Filter.atTop
          theorem Filter.Tendsto.isBoundedUnder_le_atBot {α : Type u_1} {β : Type u_2} [Preorder α] [Nonempty α] {f : Filter β} {u : βα} (h : Filter.Tendsto u f Filter.atBot) :
          Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f u
          theorem Filter.Tendsto.isBoundedUnder_ge_atTop {α : Type u_1} {β : Type u_2} [Preorder α] [Nonempty α] {f : Filter β} {u : βα} (h : Filter.Tendsto u f Filter.atTop) :
          Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f u
          theorem Filter.bddAbove_range_of_tendsto_atTop_atBot {α : Type u_1} [Preorder α] [Nonempty α] [IsDirected α fun (x x_1 : α) => x x_1] {u : α} (hx : Filter.Tendsto u Filter.atTop Filter.atBot) :
          theorem Filter.bddBelow_range_of_tendsto_atTop_atTop {α : Type u_1} [Preorder α] [Nonempty α] [IsDirected α fun (x x_1 : α) => x x_1] {u : α} (hx : Filter.Tendsto u Filter.atTop Filter.atTop) :
          theorem Filter.isCobounded_le_of_bot {α : Type u_1} [Preorder α] [OrderBot α] {f : Filter α} :
          Filter.IsCobounded (fun (x x_1 : α) => x x_1) f
          theorem Filter.isCobounded_ge_of_top {α : Type u_1} [Preorder α] [OrderTop α] {f : Filter α} :
          Filter.IsCobounded (fun (x x_1 : α) => x x_1) f
          theorem Filter.isBounded_le_of_top {α : Type u_1} [Preorder α] [OrderTop α] {f : Filter α} :
          Filter.IsBounded (fun (x x_1 : α) => x x_1) f
          theorem Filter.isBounded_ge_of_bot {α : Type u_1} [Preorder α] [OrderBot α] {f : Filter α} :
          Filter.IsBounded (fun (x x_1 : α) => x x_1) f
          @[simp]
          theorem OrderIso.isBoundedUnder_le_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ} {u : γα} :
          (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
          @[simp]
          theorem OrderIso.isBoundedUnder_ge_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] (e : α ≃o β) {l : Filter γ} {u : γα} :
          (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
          @[simp]
          theorem Filter.isBoundedUnder_le_neg {α : Type u_1} {β : Type u_2} [OrderedAddCommGroup α] {l : Filter β} {u : βα} :
          (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
          @[simp]
          theorem Filter.isBoundedUnder_le_inv {α : Type u_1} {β : Type u_2} [OrderedCommGroup α] {l : Filter β} {u : βα} :
          (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
          @[simp]
          theorem Filter.isBoundedUnder_ge_neg {α : Type u_1} {β : Type u_2} [OrderedAddCommGroup α] {l : Filter β} {u : βα} :
          (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
          @[simp]
          theorem Filter.isBoundedUnder_ge_inv {α : Type u_1} {β : Type u_2} [OrderedCommGroup α] {l : Filter β} {u : βα} :
          (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
          theorem Filter.IsBoundedUnder.sup {α : Type u_1} {β : Type u_2} [SemilatticeSup α] {f : Filter β} {u : βα} {v : βα} :
          Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f uFilter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f vFilter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f fun (a : β) => u a v a
          @[simp]
          theorem Filter.isBoundedUnder_le_sup {α : Type u_1} {β : Type u_2} [SemilatticeSup α] {f : Filter β} {u : βα} {v : βα} :
          (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
          theorem Filter.IsBoundedUnder.inf {α : Type u_1} {β : Type u_2} [SemilatticeInf α] {f : Filter β} {u : βα} {v : βα} :
          Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f uFilter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f vFilter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f fun (a : β) => u a v a
          @[simp]
          theorem Filter.isBoundedUnder_ge_inf {α : Type u_1} {β : Type u_2} [SemilatticeInf α] {f : Filter β} {u : βα} {v : βα} :
          (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
          theorem Filter.isBoundedUnder_le_abs {α : Type u_1} {β : Type u_2} [LinearOrderedAddCommGroup α] {f : Filter β} {u : βα} :
          (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

          Filters are automatically bounded or cobounded in complete lattices. To use the same statements in complete and conditionally complete lattices but let automation fill automatically the boundedness proofs in complete lattices, we use the tactic isBoundedDefault in the statements, in the form (hf : f.IsBounded (≥) := by isBoundedDefault).

          Equations
          Instances For
            def Filter.limsSup {α : Type u_1} [ConditionallyCompleteLattice α] (f : Filter α) :
            α

            The limsSup of a filter f is the infimum of the a such that, eventually for f, holds x ≤ a.

            Equations
            • f.limsSup = sInf {a : α | ∀ᶠ (n : α) in f, n a}
            Instances For
              def Filter.limsInf {α : Type u_1} [ConditionallyCompleteLattice α] (f : Filter α) :
              α

              The limsInf of a filter f is the supremum of the a such that, eventually for f, holds x ≥ a.

              Equations
              • f.limsInf = sSup {a : α | ∀ᶠ (n : α) in f, a n}
              Instances For
                def Filter.limsup {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] (u : βα) (f : Filter β) :
                α

                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.

                Equations
                Instances For
                  def Filter.liminf {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] (u : βα) (f : Filter β) :
                  α

                  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.

                  Equations
                  Instances For
                    def Filter.blimsup {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] (u : βα) (f : Filter β) (p : βProp) :
                    α

                    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.

                    Equations
                    Instances For
                      def Filter.bliminf {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] (u : βα) (f : Filter β) (p : βProp) :
                      α

                      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.

                      Equations
                      Instances For
                        theorem Filter.limsup_eq {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} :
                        Filter.limsup u f = sInf {a : α | ∀ᶠ (n : β) in f, u n a}
                        theorem Filter.liminf_eq {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} :
                        Filter.liminf u f = sSup {a : α | ∀ᶠ (n : β) in f, a u n}
                        theorem Filter.blimsup_eq {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {p : βProp} :
                        Filter.blimsup u f p = sInf {a : α | ∀ᶠ (x : β) in f, p xu x a}
                        theorem Filter.bliminf_eq {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {p : βProp} :
                        Filter.bliminf u f p = sSup {a : α | ∀ᶠ (x : β) in f, p xa u x}
                        theorem Filter.liminf_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [ConditionallyCompleteLattice α] (u : βα) (v : γβ) (f : Filter γ) :
                        theorem Filter.limsup_comp {α : Type u_1} {β : Type u_2} {γ : Type u_3} [ConditionallyCompleteLattice α] (u : βα) (v : γβ) (f : Filter γ) :
                        @[simp]
                        theorem Filter.blimsup_true {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] (f : Filter β) (u : βα) :
                        (Filter.blimsup u f fun (x : β) => True) = Filter.limsup u f
                        @[simp]
                        theorem Filter.bliminf_true {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] (f : Filter β) (u : βα) :
                        (Filter.bliminf u f fun (x : β) => True) = Filter.liminf u f
                        theorem Filter.blimsup_eq_limsup {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {p : βProp} :
                        theorem Filter.bliminf_eq_liminf {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {p : βProp} :
                        theorem Filter.blimsup_eq_limsup_subtype {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {p : βProp} :
                        Filter.blimsup u f p = Filter.limsup (u Subtype.val) (Filter.comap Subtype.val f)
                        theorem Filter.bliminf_eq_liminf_subtype {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {p : βProp} :
                        Filter.bliminf u f p = Filter.liminf (u Subtype.val) (Filter.comap Subtype.val f)
                        theorem Filter.limsSup_le_of_le {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} {a : α} (hf : autoParam (Filter.IsCobounded (fun (x x_1 : α) => x x_1) f) _auto✝) (h : ∀ᶠ (n : α) in f, n a) :
                        f.limsSup a
                        theorem Filter.le_limsInf_of_le {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} {a : α} (hf : autoParam (Filter.IsCobounded (fun (x x_1 : α) => x x_1) f) _auto✝) (h : ∀ᶠ (n : α) in f, a n) :
                        a f.limsInf
                        theorem Filter.limsup_le_of_le {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {a : α} (hf : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : α) => x x_1) f u) _auto✝) (h : ∀ᶠ (n : β) in f, u n a) :
                        theorem Filter.le_liminf_of_le {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {a : α} (hf : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : α) => x x_1) f u) _auto✝) (h : ∀ᶠ (n : β) in f, a u n) :
                        theorem Filter.le_limsSup_of_le {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} {a : α} (hf : autoParam (Filter.IsBounded (fun (x x_1 : α) => x x_1) f) _auto✝) (h : ∀ (b : α), (∀ᶠ (n : α) in f, n b)a b) :
                        a f.limsSup
                        theorem Filter.limsInf_le_of_le {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} {a : α} (hf : autoParam (Filter.IsBounded (fun (x x_1 : α) => x x_1) f) _auto✝) (h : ∀ (b : α), (∀ᶠ (n : α) in f, b n)b a) :
                        f.limsInf a
                        theorem Filter.le_limsup_of_le {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {a : α} (hf : autoParam (Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f u) _auto✝) (h : ∀ (b : α), (∀ᶠ (n : β) in f, u n b)a b) :
                        theorem Filter.liminf_le_of_le {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {a : α} (hf : autoParam (Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f u) _auto✝) (h : ∀ (b : α), (∀ᶠ (n : β) in f, b u n)b a) :
                        theorem Filter.limsInf_le_limsSup {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} [f.NeBot] (h₁ : autoParam (Filter.IsBounded (fun (x x_1 : α) => x x_1) f) _auto✝) (h₂ : autoParam (Filter.IsBounded (fun (x x_1 : α) => x x_1) f) _auto✝) :
                        f.limsInf f.limsSup
                        theorem Filter.liminf_le_limsup {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} [f.NeBot] {u : βα} (h : autoParam (Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f u) _auto✝) (h' : autoParam (Filter.IsBoundedUnder (fun (x x_1 : α) => x x_1) f u) _auto✝) :
                        theorem Filter.limsSup_le_limsSup {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} {g : Filter α} (hf : autoParam (Filter.IsCobounded (fun (x x_1 : α) => x x_1) f) _auto✝) (hg : autoParam (Filter.IsBounded (fun (x x_1 : α) => x x_1) g) _auto✝) (h : ∀ (a : α), (∀ᶠ (n : α) in g, n a)∀ᶠ (n : α) in f, n a) :
                        f.limsSup g.limsSup
                        theorem Filter.limsInf_le_limsInf {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} {g : Filter α} (hf : autoParam (Filter.IsBounded (fun (x x_1 : α) => x x_1) f) _auto✝) (hg : autoParam (Filter.IsCobounded (fun (x x_1 : α) => x x_1) g) _auto✝) (h : ∀ (a : α), (∀ᶠ (n : α) in f, a n)∀ᶠ (n : α) in g, a n) :
                        f.limsInf g.limsInf
                        theorem Filter.limsup_le_limsup {β : Type u_2} {α : Type u_6} [ConditionallyCompleteLattice β] {f : Filter α} {u : αβ} {v : αβ} (h : u ≤ᶠ[f] v) (hu : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (hv : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f v) _auto✝) :
                        theorem Filter.liminf_le_liminf {β : Type u_2} {α : Type u_6} [ConditionallyCompleteLattice β] {f : Filter α} {u : αβ} {v : αβ} (h : ∀ᶠ (a : α) in f, u a v a) (hu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (hv : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f v) _auto✝) :
                        theorem Filter.limsSup_le_limsSup_of_le {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} {g : Filter α} (h : f g) (hf : autoParam (Filter.IsCobounded (fun (x x_1 : α) => x x_1) f) _auto✝) (hg : autoParam (Filter.IsBounded (fun (x x_1 : α) => x x_1) g) _auto✝) :
                        f.limsSup g.limsSup
                        theorem Filter.limsInf_le_limsInf_of_le {α : Type u_1} [ConditionallyCompleteLattice α] {f : Filter α} {g : Filter α} (h : g f) (hf : autoParam (Filter.IsBounded (fun (x x_1 : α) => x x_1) f) _auto✝) (hg : autoParam (Filter.IsCobounded (fun (x x_1 : α) => x x_1) g) _auto✝) :
                        f.limsInf g.limsInf
                        theorem Filter.limsup_le_limsup_of_le {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLattice β] {f : Filter α} {g : Filter α} (h : f g) {u : αβ} (hf : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (hg : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) g u) _auto✝) :
                        theorem Filter.liminf_le_liminf_of_le {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLattice β] {f : Filter α} {g : Filter α} (h : g f) {u : αβ} (hf : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (hg : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) g u) _auto✝) :
                        theorem Filter.limsSup_principal {α : Type u_1} [ConditionallyCompleteLattice α] {s : Set α} (h : BddAbove s) (hs : s.Nonempty) :
                        (Filter.principal s).limsSup = sSup s
                        theorem Filter.limsInf_principal {α : Type u_1} [ConditionallyCompleteLattice α] {s : Set α} (h : BddBelow s) (hs : s.Nonempty) :
                        (Filter.principal s).limsInf = sInf s
                        theorem Filter.limsup_congr {β : Type u_2} {α : Type u_6} [ConditionallyCompleteLattice β] {f : Filter α} {u : αβ} {v : αβ} (h : ∀ᶠ (a : α) in f, u a = v a) :
                        theorem Filter.blimsup_congr {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {v : βα} {p : βProp} (h : ∀ᶠ (a : β) in f, p au a = v a) :
                        theorem Filter.bliminf_congr {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLattice α] {f : Filter β} {u : βα} {v : βα} {p : βProp} (h : ∀ᶠ (a : β) in f, p au a = v a) :
                        theorem Filter.liminf_congr {β : Type u_2} {α : Type u_6} [ConditionallyCompleteLattice β] {f : Filter α} {u : αβ} {v : αβ} (h : ∀ᶠ (a : α) in f, u a = v a) :
                        @[simp]
                        theorem Filter.limsup_const {β : Type u_2} {α : Type u_6} [ConditionallyCompleteLattice β] {f : Filter α} [f.NeBot] (b : β) :
                        Filter.limsup (fun (x : α) => b) f = b
                        @[simp]
                        theorem Filter.liminf_const {β : Type u_2} {α : Type u_6} [ConditionallyCompleteLattice β] {f : Filter α} [f.NeBot] (b : β) :
                        Filter.liminf (fun (x : α) => b) f = b
                        theorem Filter.HasBasis.liminf_eq_sSup_iUnion_iInter {α : Type u_1} [ConditionallyCompleteLattice α] {ι : Type u_6} {ι' : Type u_7} {f : ια} {v : Filter ι} {p : ι'Prop} {s : ι'Set ι} (hv : v.HasBasis p s) :
                        Filter.liminf f v = sSup (⋃ (j : Subtype p), ⋂ (i : (s j)), Set.Iic (f i))
                        theorem Filter.HasBasis.liminf_eq_sSup_univ_of_empty {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [ConditionallyCompleteLattice α] {f : ια} {v : Filter ι} {p : ι'Prop} {s : ι'Set ι} (hv : v.HasBasis p s) (i : ι') (hi : p i) (h'i : s i = ) :
                        Filter.liminf f v = sSup Set.univ
                        theorem Filter.HasBasis.limsup_eq_sInf_iUnion_iInter {α : Type u_1} [ConditionallyCompleteLattice α] {ι : Type u_6} {ι' : Type u_7} {f : ια} {v : Filter ι} {p : ι'Prop} {s : ι'Set ι} (hv : v.HasBasis p s) :
                        Filter.limsup f v = sInf (⋃ (j : Subtype p), ⋂ (i : (s j)), Set.Ici (f i))
                        theorem Filter.HasBasis.limsup_eq_sInf_univ_of_empty {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [ConditionallyCompleteLattice α] {f : ια} {v : Filter ι} {p : ι'Prop} {s : ι'Set ι} (hv : v.HasBasis p s) (i : ι') (hi : p i) (h'i : s i = ) :
                        Filter.limsup f v = sInf Set.univ
                        @[simp]
                        theorem Filter.liminf_nat_add {α : Type u_1} [ConditionallyCompleteLattice α] (f : α) (k : ) :
                        Filter.liminf (fun (i : ) => f (i + k)) Filter.atTop = Filter.liminf f Filter.atTop
                        @[simp]
                        theorem Filter.limsup_nat_add {α : Type u_1} [ConditionallyCompleteLattice α] (f : α) (k : ) :
                        Filter.limsup (fun (i : ) => f (i + k)) Filter.atTop = Filter.limsup f Filter.atTop
                        @[simp]
                        theorem Filter.limsSup_bot {α : Type u_1} [CompleteLattice α] :
                        .limsSup =
                        @[simp]
                        theorem Filter.limsup_bot {α : Type u_1} {β : Type u_2} [CompleteLattice α] (f : βα) :
                        @[simp]
                        theorem Filter.limsInf_bot {α : Type u_1} [CompleteLattice α] :
                        .limsInf =
                        @[simp]
                        theorem Filter.liminf_bot {α : Type u_1} {β : Type u_2} [CompleteLattice α] (f : βα) :
                        @[simp]
                        theorem Filter.limsSup_top {α : Type u_1} [CompleteLattice α] :
                        .limsSup =
                        @[simp]
                        theorem Filter.limsInf_top {α : Type u_1} [CompleteLattice α] :
                        .limsInf =
                        @[simp]
                        theorem Filter.blimsup_false {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {u : βα} :
                        (Filter.blimsup u f fun (x : β) => False) =
                        @[simp]
                        theorem Filter.bliminf_false {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {u : βα} :
                        (Filter.bliminf u f fun (x : β) => False) =
                        @[simp]
                        theorem Filter.limsup_const_bot {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} :
                        Filter.limsup (fun (x : β) => ) f =

                        Same as limsup_const applied to but without the NeBot f assumption

                        @[simp]
                        theorem Filter.liminf_const_top {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} :
                        Filter.liminf (fun (x : β) => ) f =

                        Same as limsup_const applied to but without the NeBot f assumption

                        theorem Filter.HasBasis.limsSup_eq_iInf_sSup {α : Type u_1} [CompleteLattice α] {ι : Sort u_6} {p : ιProp} {s : ιSet α} {f : Filter α} (h : f.HasBasis p s) :
                        f.limsSup = ⨅ (i : ι), ⨅ (_ : p i), sSup (s i)
                        theorem Filter.HasBasis.limsInf_eq_iSup_sInf {α : Type u_1} {ι : Type u_4} [CompleteLattice α] {p : ιProp} {s : ιSet α} {f : Filter α} (h : f.HasBasis p s) :
                        f.limsInf = ⨆ (i : ι), ⨆ (_ : p i), sInf (s i)
                        theorem Filter.limsSup_eq_iInf_sSup {α : Type u_1} [CompleteLattice α] {f : Filter α} :
                        f.limsSup = sf, sSup s
                        theorem Filter.limsInf_eq_iSup_sInf {α : Type u_1} [CompleteLattice α] {f : Filter α} :
                        f.limsInf = sf, sInf s
                        theorem Filter.limsup_le_iSup {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {u : βα} :
                        Filter.limsup u f ⨆ (n : β), u n
                        theorem Filter.iInf_le_liminf {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {u : βα} :
                        ⨅ (n : β), u n Filter.liminf u f
                        theorem Filter.limsup_eq_iInf_iSup {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {u : βα} :
                        Filter.limsup u f = sf, as, u a

                        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 Filter.limsup_eq_iInf_iSup_of_nat {α : Type u_1} [CompleteLattice α] {u : α} :
                        Filter.limsup u Filter.atTop = ⨅ (n : ), ⨆ (i : ), ⨆ (_ : i n), u i
                        theorem Filter.limsup_eq_iInf_iSup_of_nat' {α : Type u_1} [CompleteLattice α] {u : α} :
                        Filter.limsup u Filter.atTop = ⨅ (n : ), ⨆ (i : ), u (i + n)
                        theorem Filter.HasBasis.limsup_eq_iInf_iSup {α : Type u_1} {β : Type u_2} {ι : Type u_4} [CompleteLattice α] {p : ιProp} {s : ιSet β} {f : Filter β} {u : βα} (h : f.HasBasis p s) :
                        Filter.limsup u f = ⨅ (i : ι), ⨅ (_ : p i), as i, u a
                        theorem Filter.blimsup_congr' {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} (h : ∀ᶠ (x : β) in f, u x (p x q x)) :
                        theorem Filter.bliminf_congr' {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} (h : ∀ᶠ (x : β) in f, u x (p x q x)) :
                        theorem Filter.HasBasis.blimsup_eq_iInf_iSup {α : Type u_1} {β : Type u_2} {ι : Type u_4} [CompleteLattice α] {p : ιProp} {s : ιSet β} {f : Filter β} {u : βα} (hf : f.HasBasis p s) {q : βProp} :
                        Filter.blimsup u f q = ⨅ (i : ι), ⨅ (_ : p i), as i, ⨆ (_ : q a), u a
                        theorem Filter.blimsup_eq_iInf_biSup {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} :
                        Filter.blimsup u f p = sf, ⨆ (b : β), ⨆ (_ : p b b s), u b
                        theorem Filter.blimsup_eq_iInf_biSup_of_nat {α : Type u_1} [CompleteLattice α] {p : Prop} {u : α} :
                        Filter.blimsup u Filter.atTop p = ⨅ (i : ), ⨆ (j : ), ⨆ (_ : p j i j), u j
                        theorem Filter.liminf_eq_iSup_iInf {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {u : βα} :
                        Filter.liminf u f = sf, as, u a

                        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 Filter.liminf_eq_iSup_iInf_of_nat {α : Type u_1} [CompleteLattice α] {u : α} :
                        Filter.liminf u Filter.atTop = ⨆ (n : ), ⨅ (i : ), ⨅ (_ : i n), u i
                        theorem Filter.liminf_eq_iSup_iInf_of_nat' {α : Type u_1} [CompleteLattice α] {u : α} :
                        Filter.liminf u Filter.atTop = ⨆ (n : ), ⨅ (i : ), u (i + n)
                        theorem Filter.HasBasis.liminf_eq_iSup_iInf {α : Type u_1} {β : Type u_2} {ι : Type u_4} [CompleteLattice α] {p : ιProp} {s : ιSet β} {f : Filter β} {u : βα} (h : f.HasBasis p s) :
                        Filter.liminf u f = ⨆ (i : ι), ⨆ (_ : p i), as i, u a
                        theorem Filter.bliminf_eq_iSup_biInf {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} :
                        Filter.bliminf u f p = sf, ⨅ (b : β), ⨅ (_ : p b b s), u b
                        theorem Filter.bliminf_eq_iSup_biInf_of_nat {α : Type u_1} [CompleteLattice α] {p : Prop} {u : α} :
                        Filter.bliminf u Filter.atTop p = ⨆ (i : ), ⨅ (j : ), ⨅ (_ : p j i j), u j
                        theorem Filter.limsup_eq_sInf_sSup {ι : Type u_6} {R : Type u_7} (F : Filter ι) [CompleteLattice R] (a : ιR) :
                        Filter.limsup a F = sInf ((fun (I : Set ι) => sSup (a '' I)) '' F.sets)
                        theorem Filter.liminf_eq_sSup_sInf {ι : Type u_6} {R : Type u_7} (F : Filter ι) [CompleteLattice R] (a : ιR) :
                        Filter.liminf a F = sSup ((fun (I : Set ι) => sInf (a '' I)) '' F.sets)
                        theorem Filter.liminf_le_of_frequently_le' {α : Type u_6} {β : Type u_7} [CompleteLattice β] {f : Filter α} {u : αβ} {x : β} (h : ∃ᶠ (a : α) in f, u a x) :
                        theorem Filter.le_limsup_of_frequently_le' {α : Type u_6} {β : Type u_7} [CompleteLattice β] {f : Filter α} {u : αβ} {x : β} (h : ∃ᶠ (a : α) in f, x u a) :
                        @[simp]
                        theorem Filter.CompleteLatticeHom.apply_limsup_iterate {α : Type u_1} [CompleteLattice α] (f : CompleteLatticeHom α α) (a : α) :
                        f (Filter.limsup (fun (n : ) => (f)^[n] a) Filter.atTop) = Filter.limsup (fun (n : ) => (f)^[n] a) Filter.atTop

                        If f : α → α is a morphism of complete lattices, then the limsup of its iterates of any a : α is a fixed point.

                        theorem Filter.CompleteLatticeHom.apply_liminf_iterate {α : Type u_1} [CompleteLattice α] (f : CompleteLatticeHom α α) (a : α) :
                        f (Filter.liminf (fun (n : ) => (f)^[n] a) Filter.atTop) = Filter.liminf (fun (n : ) => (f)^[n] a) Filter.atTop

                        If f : α → α is a morphism of complete lattices, then the liminf of its iterates of any a : α is a fixed point.

                        theorem Filter.blimsup_mono {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} (h : ∀ (x : β), p xq x) :
                        theorem Filter.bliminf_antitone {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} (h : ∀ (x : β), p xq x) :
                        theorem Filter.mono_blimsup' {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} {v : βα} (h : ∀ᶠ (x : β) in f, p xu x v x) :
                        theorem Filter.mono_blimsup {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} {v : βα} (h : ∀ (x : β), p xu x v x) :
                        theorem Filter.mono_bliminf' {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} {v : βα} (h : ∀ᶠ (x : β) in f, p xu x v x) :
                        theorem Filter.mono_bliminf {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} {v : βα} (h : ∀ (x : β), p xu x v x) :
                        theorem Filter.bliminf_antitone_filter {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {g : Filter β} {p : βProp} {u : βα} (h : f g) :
                        theorem Filter.blimsup_monotone_filter {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {g : Filter β} {p : βProp} {u : βα} (h : f g) :
                        theorem Filter.blimsup_and_le_inf {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        (Filter.blimsup u f fun (x : β) => p x q x) Filter.blimsup u f p Filter.blimsup u f q
                        @[simp]
                        theorem Filter.bliminf_sup_le_inf_aux_left {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        (Filter.blimsup u f fun (x : β) => p x q x) Filter.blimsup u f p
                        @[simp]
                        theorem Filter.bliminf_sup_le_inf_aux_right {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        (Filter.blimsup u f fun (x : β) => p x q x) Filter.blimsup u f q
                        theorem Filter.bliminf_sup_le_and {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        Filter.bliminf u f p Filter.bliminf u f q Filter.bliminf u f fun (x : β) => p x q x
                        @[simp]
                        theorem Filter.bliminf_sup_le_and_aux_left {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        Filter.bliminf u f p Filter.bliminf u f fun (x : β) => p x q x
                        @[simp]
                        theorem Filter.bliminf_sup_le_and_aux_right {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        Filter.bliminf u f q Filter.bliminf u f fun (x : β) => p x q x
                        theorem Filter.blimsup_sup_le_or {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        Filter.blimsup u f p Filter.blimsup u f q Filter.blimsup u f fun (x : β) => p x q x

                        See also Filter.blimsup_or_eq_sup.

                        @[simp]
                        theorem Filter.bliminf_sup_le_or_aux_left {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        Filter.blimsup u f p Filter.blimsup u f fun (x : β) => p x q x
                        @[simp]
                        theorem Filter.bliminf_sup_le_or_aux_right {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        Filter.blimsup u f q Filter.blimsup u f fun (x : β) => p x q x
                        theorem Filter.bliminf_or_le_inf {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        (Filter.bliminf u f fun (x : β) => p x q x) Filter.bliminf u f p Filter.bliminf u f q

                        See also Filter.bliminf_or_eq_inf.

                        @[simp]
                        theorem Filter.bliminf_or_le_inf_aux_left {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        (Filter.bliminf u f fun (x : β) => p x q x) Filter.bliminf u f p
                        @[simp]
                        theorem Filter.bliminf_or_le_inf_aux_right {α : Type u_1} {β : Type u_2} [CompleteLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        (Filter.bliminf u f fun (x : β) => p x q x) Filter.bliminf u f q
                        theorem Filter.OrderIso.apply_blimsup {α : Type u_1} {β : Type u_2} {γ : Type u_3} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} [CompleteLattice γ] (e : α ≃o γ) :
                        e (Filter.blimsup u f p) = Filter.blimsup (e u) f p
                        theorem Filter.OrderIso.apply_bliminf {α : Type u_1} {β : Type u_2} {γ : Type u_3} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} [CompleteLattice γ] (e : α ≃o γ) :
                        e (Filter.bliminf u f p) = Filter.bliminf (e u) f p
                        theorem Filter.SupHom.apply_blimsup_le {α : Type u_1} {β : Type u_2} {γ : Type u_3} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} [CompleteLattice γ] (g : sSupHom α γ) :
                        g (Filter.blimsup u f p) Filter.blimsup (g u) f p
                        theorem Filter.InfHom.le_apply_bliminf {α : Type u_1} {β : Type u_2} {γ : Type u_3} [CompleteLattice α] {f : Filter β} {p : βProp} {u : βα} [CompleteLattice γ] (g : sInfHom α γ) :
                        Filter.bliminf (g u) f p g (Filter.bliminf u f p)
                        theorem Filter.limsup_sup_filter {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {u : βα} {g : Filter β} :
                        theorem Filter.liminf_sup_filter {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {u : βα} {g : Filter β} :
                        @[simp]
                        theorem Filter.blimsup_or_eq_sup {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        (Filter.blimsup u f fun (x : β) => p x q x) = Filter.blimsup u f p Filter.blimsup u f q
                        @[simp]
                        theorem Filter.bliminf_or_eq_inf {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {p : βProp} {q : βProp} {u : βα} :
                        (Filter.bliminf u f fun (x : β) => p x q x) = Filter.bliminf u f p Filter.bliminf u f q
                        @[simp]
                        theorem Filter.blimsup_sup_not {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {p : βProp} {u : βα} :
                        (Filter.blimsup u f p Filter.blimsup u f fun (x : β) => ¬p x) = Filter.limsup u f
                        @[simp]
                        theorem Filter.bliminf_inf_not {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {p : βProp} {u : βα} :
                        (Filter.bliminf u f p Filter.bliminf u f fun (x : β) => ¬p x) = Filter.liminf u f
                        @[simp]
                        theorem Filter.blimsup_not_sup {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {p : βProp} {u : βα} :
                        (Filter.blimsup u f fun (x : β) => ¬p x) Filter.blimsup u f p = Filter.limsup u f
                        @[simp]
                        theorem Filter.bliminf_not_inf {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {p : βProp} {u : βα} :
                        (Filter.bliminf u f fun (x : β) => ¬p x) Filter.bliminf u f p = Filter.liminf u f
                        theorem Filter.limsup_piecewise {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {u : βα} {s : Set β} [DecidablePred fun (x : β) => x s] {v : βα} :
                        Filter.limsup (s.piecewise u v) f = (Filter.blimsup u f fun (x : β) => x s) Filter.blimsup v f fun (x : β) => xs
                        theorem Filter.liminf_piecewise {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {u : βα} {s : Set β} [DecidablePred fun (x : β) => x s] {v : βα} :
                        Filter.liminf (s.piecewise u v) f = (Filter.bliminf u f fun (x : β) => x s) Filter.bliminf v f fun (x : β) => xs
                        theorem Filter.sup_limsup {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {u : βα} [f.NeBot] (a : α) :
                        a Filter.limsup u f = Filter.limsup (fun (x : β) => a u x) f
                        theorem Filter.inf_liminf {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {u : βα} [f.NeBot] (a : α) :
                        a Filter.liminf u f = Filter.liminf (fun (x : β) => a u x) f
                        theorem Filter.sup_liminf {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {u : βα} (a : α) :
                        a Filter.liminf u f = Filter.liminf (fun (x : β) => a u x) f
                        theorem Filter.inf_limsup {α : Type u_1} {β : Type u_2} [CompleteDistribLattice α] {f : Filter β} {u : βα} (a : α) :
                        a Filter.limsup u f = Filter.limsup (fun (x : β) => a u x) f
                        theorem Filter.limsup_compl {α : Type u_1} {β : Type u_2} [CompleteBooleanAlgebra α] (f : Filter β) (u : βα) :
                        theorem Filter.liminf_compl {α : Type u_1} {β : Type u_2} [CompleteBooleanAlgebra α] (f : Filter β) (u : βα) :
                        theorem Filter.limsup_sdiff {α : Type u_1} {β : Type u_2} [CompleteBooleanAlgebra α] (f : Filter β) (u : βα) (a : α) :
                        Filter.limsup u f \ a = Filter.limsup (fun (b : β) => u b \ a) f
                        theorem Filter.liminf_sdiff {α : Type u_1} {β : Type u_2} [CompleteBooleanAlgebra α] (f : Filter β) (u : βα) [f.NeBot] (a : α) :
                        Filter.liminf u f \ a = Filter.liminf (fun (b : β) => u b \ a) f
                        theorem Filter.sdiff_limsup {α : Type u_1} {β : Type u_2} [CompleteBooleanAlgebra α] (f : Filter β) (u : βα) [f.NeBot] (a : α) :
                        a \ Filter.limsup u f = Filter.liminf (fun (b : β) => a \ u b) f
                        theorem Filter.sdiff_liminf {α : Type u_1} {β : Type u_2} [CompleteBooleanAlgebra α] (f : Filter β) (u : βα) (a : α) :
                        a \ Filter.liminf u f = Filter.limsup (fun (b : β) => a \ u b) f
                        theorem Filter.mem_liminf_iff_eventually_mem {α : Type u_1} {ι : Type u_4} {s : ιSet α} {𝓕 : Filter ι} {a : α} :
                        a Filter.liminf s 𝓕 ∀ᶠ (i : ι) in 𝓕, a s i
                        theorem Filter.mem_limsup_iff_frequently_mem {α : Type u_1} {ι : Type u_4} {s : ιSet α} {𝓕 : Filter ι} {a : α} :
                        a Filter.limsup s 𝓕 ∃ᶠ (i : ι) in 𝓕, a s i
                        theorem Filter.cofinite.blimsup_set_eq {α : Type u_1} {ι : Type u_4} {p : ιProp} {s : ιSet α} :
                        Filter.blimsup s Filter.cofinite p = {x : α | {n : ι | p n x s n}.Infinite}
                        theorem Filter.cofinite.bliminf_set_eq {α : Type u_1} {ι : Type u_4} {p : ιProp} {s : ιSet α} :
                        Filter.bliminf s Filter.cofinite p = {x : α | {n : ι | p n xs n}.Finite}
                        theorem Filter.cofinite.limsup_set_eq {α : Type u_1} {ι : Type u_4} {s : ιSet α} :
                        Filter.limsup s Filter.cofinite = {x : α | {n : ι | x s n}.Infinite}

                        In other words, limsup cofinite s is the set of elements lying inside the family s infinitely often.

                        theorem Filter.cofinite.liminf_set_eq {α : Type u_1} {ι : Type u_4} {s : ιSet α} :
                        Filter.liminf s Filter.cofinite = {x : α | {n : ι | xs n}.Finite}

                        In other words, liminf cofinite s is the set of elements lying outside the family s finitely often.

                        theorem Filter.exists_forall_mem_of_hasBasis_mem_blimsup {α : Type u_1} {β : Type u_2} {ι : Type u_4} {l : Filter β} {b : ιSet β} {q : ιProp} (hl : l.HasBasis q b) {u : βSet α} {p : βProp} {x : α} (hx : x Filter.blimsup u l p) :
                        ∃ (f : {i : ι | q i}β), ∀ (i : {i : ι | q i}), x u (f i) p (f i) f i b i
                        theorem Filter.exists_forall_mem_of_hasBasis_mem_blimsup' {α : Type u_1} {β : Type u_2} {ι : Type u_4} {l : Filter β} {b : ιSet β} (hl : l.HasBasis (fun (x : ι) => True) b) {u : βSet α} {p : βProp} {x : α} (hx : x Filter.blimsup u l p) :
                        ∃ (f : ιβ), ∀ (i : ι), x u (f i) p (f i) f i b i
                        theorem Filter.frequently_lt_of_lt_limsSup {α : Type u_1} {f : Filter α} [ConditionallyCompleteLinearOrder α] {a : α} (hf : autoParam (Filter.IsCobounded (fun (x x_1 : α) => x x_1) f) _auto✝) (h : a < f.limsSup) :
                        ∃ᶠ (n : α) in f, a < n
                        theorem Filter.frequently_lt_of_limsInf_lt {α : Type u_1} {f : Filter α} [ConditionallyCompleteLinearOrder α] {a : α} (hf : autoParam (Filter.IsCobounded (fun (x x_1 : α) => x x_1) f) _auto✝) (h : f.limsInf < a) :
                        ∃ᶠ (n : α) in f, n < a
                        theorem Filter.eventually_lt_of_lt_liminf {α : Type u_1} {β : Type u_2} {f : Filter α} [ConditionallyCompleteLinearOrder β] {u : αβ} {b : β} (h : b < Filter.liminf u f) (hu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) :
                        ∀ᶠ (a : α) in f, b < u a
                        theorem Filter.eventually_lt_of_limsup_lt {α : Type u_1} {β : Type u_2} {f : Filter α} [ConditionallyCompleteLinearOrder β] {u : αβ} {b : β} (h : Filter.limsup u f < b) (hu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) :
                        ∀ᶠ (a : α) in f, u a < b
                        theorem Filter.le_limsup_of_frequently_le {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {b : β} (hu_le : ∃ᶠ (x : α) in f, b u x) (hu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) :
                        theorem Filter.liminf_le_of_frequently_le {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {b : β} (hu_le : ∃ᶠ (x : α) in f, u x b) (hu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) :
                        theorem Filter.frequently_lt_of_lt_limsup {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {b : β} (hu : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h : b < Filter.limsup u f) :
                        ∃ᶠ (x : α) in f, b < u x
                        theorem Filter.frequently_lt_of_liminf_lt {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {b : β} (hu : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h : Filter.liminf u f < b) :
                        ∃ᶠ (x : α) in f, u x < b
                        theorem Filter.limsup_le_iff {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {x : β} (h₁ : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h₂ : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) :
                        Filter.limsup u f x y > x, ∀ᶠ (a : α) in f, u a < y
                        theorem Filter.le_limsup_iff {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {x : β} (h₁ : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h₂ : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) :
                        x Filter.limsup u f y < x, ∃ᶠ (a : α) in f, y < u a
                        theorem Filter.le_liminf_iff {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {x : β} (h₁ : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h₂ : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) :
                        x Filter.liminf u f y < x, ∀ᶠ (a : α) in f, y < u a
                        theorem Filter.liminf_le_iff {α : Type u_6} {β : Type u_7} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {x : β} (h₁ : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h₂ : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) :
                        Filter.liminf u f x y > x, ∃ᶠ (a : α) in f, u a < y
                        theorem Filter.lt_mem_sets_of_limsSup_lt {α : Type u_1} [ConditionallyCompleteLinearOrder α] {f : Filter α} {b : α} (h : Filter.IsBounded (fun (x x_1 : α) => x x_1) f) (l : f.limsSup < b) :
                        ∀ᶠ (a : α) in f, a < b
                        theorem Filter.gt_mem_sets_of_limsInf_gt {α : Type u_1} [ConditionallyCompleteLinearOrder α] {f : Filter α} {b : α} :
                        Filter.IsBounded (fun (x x_1 : α) => x x_1) fb < f.limsInf∀ᶠ (a : α) in f, b < a
                        noncomputable def Filter.liminf_reparam {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [ConditionallyCompleteLinearOrder α] (f : ια) (s : ι'Set ι) (p : ι'Prop) [Countable (Subtype p)] [Nonempty (Subtype p)] (j : Subtype p) :

                        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.

                        Equations
                        Instances For
                          theorem Filter.HasBasis.liminf_eq_ciSup_ciInf {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [ConditionallyCompleteLinearOrder α] {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 (Set.range fun (i : (s j)) => f i)) :
                          Filter.liminf f v = ⨆ (j : Subtype p), ⨅ (i : (s (Filter.liminf_reparam f s p j))), f i

                          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 Filter.HasBasis.liminf_eq_ite {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [ConditionallyCompleteLinearOrder α] {v : Filter ι} {p : ι'Prop} {s : ι'Set ι} [Countable (Subtype p)] [Nonempty (Subtype p)] (hv : v.HasBasis p s) (f : ια) :
                          Filter.liminf f v = if ∃ (j : Subtype p), s j = then sSup Set.univ else if ∀ (j : Subtype p), ¬BddBelow (Set.range fun (i : (s j)) => f i) then sSup else ⨆ (j : Subtype p), ⨅ (i : (s (Filter.liminf_reparam f s p j))), f i

                          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.

                          noncomputable def Filter.limsup_reparam {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [ConditionallyCompleteLinearOrder α] (f : ια) (s : ι'Set ι) (p : ι'Prop) [Countable (Subtype p)] [Nonempty (Subtype p)] (j : Subtype p) :

                          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.

                          Equations
                          Instances For
                            theorem Filter.HasBasis.limsup_eq_ciInf_ciSup {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [ConditionallyCompleteLinearOrder α] {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 (Set.range fun (i : (s j)) => f i)) :
                            Filter.limsup f v = ⨅ (j : Subtype p), ⨆ (i : (s (Filter.limsup_reparam f s p j))), f i

                            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 Filter.HasBasis.limsup_eq_ite {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [ConditionallyCompleteLinearOrder α] {v : Filter ι} {p : ι'Prop} {s : ι'Set ι} [Countable (Subtype p)] [Nonempty (Subtype p)] (hv : v.HasBasis p s) (f : ια) :
                            Filter.limsup f v = if ∃ (j : Subtype p), s j = then sInf Set.univ else if ∀ (j : Subtype p), ¬BddAbove (Set.range fun (i : (s j)) => f i) then sInf else ⨅ (j : Subtype p), ⨆ (i : (s (Filter.limsup_reparam f s p j))), f i

                            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 Monotone.isBoundedUnder_le_comp_iff {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Nonempty β] [LinearOrder β] [Preorder γ] [NoMaxOrder γ] {g : βγ} {f : αβ} {l : Filter α} (hg : Monotone g) (hg' : Filter.Tendsto g Filter.atTop Filter.atTop) :
                            Filter.IsBoundedUnder (fun (x x_1 : γ) => x x_1) l (g f) Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l f
                            theorem Monotone.isBoundedUnder_ge_comp_iff {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Nonempty β] [LinearOrder β] [Preorder γ] [NoMinOrder γ] {g : βγ} {f : αβ} {l : Filter α} (hg : Monotone g) (hg' : Filter.Tendsto g Filter.atBot Filter.atBot) :
                            Filter.IsBoundedUnder (fun (x x_1 : γ) => x x_1) l (g f) Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l f
                            theorem Antitone.isBoundedUnder_le_comp_iff {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Nonempty β] [LinearOrder β] [Preorder γ] [NoMaxOrder γ] {g : βγ} {f : αβ} {l : Filter α} (hg : Antitone g) (hg' : Filter.Tendsto g Filter.atBot Filter.atTop) :
                            Filter.IsBoundedUnder (fun (x x_1 : γ) => x x_1) l (g f) Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l f
                            theorem Antitone.isBoundedUnder_ge_comp_iff {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Nonempty β] [LinearOrder β] [Preorder γ] [NoMinOrder γ] {g : βγ} {f : αβ} {l : Filter α} (hg : Antitone g) (hg' : Filter.Tendsto g Filter.atTop Filter.atBot) :
                            Filter.IsBoundedUnder (fun (x x_1 : γ) => x x_1) l (g f) Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) l f
                            theorem GaloisConnection.l_limsup_le {α : Type u_1} {β : Type u_2} {γ : Type u_3} [ConditionallyCompleteLattice β] [ConditionallyCompleteLattice γ] {f : Filter α} {v : αβ} {l : βγ} {u : γβ} (gc : GaloisConnection l u) (hlv : autoParam (Filter.IsBoundedUnder (fun (x x_1 : γ) => x x_1) f fun (x : α) => l (v x)) _auto✝) (hv_co : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f v) _auto✝) :
                            l (Filter.limsup v f) Filter.limsup (fun (x : α) => l (v x)) f
                            theorem OrderIso.limsup_apply {α : Type u_1} {β : Type u_2} {γ : Type u_6} [ConditionallyCompleteLattice β] [ConditionallyCompleteLattice γ] {f : Filter α} {u : αβ} (g : β ≃o γ) (hu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (hu_co : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (hgu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : γ) => x x_1) f fun (x : α) => g (u x)) _auto✝) (hgu_co : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : γ) => x x_1) f fun (x : α) => g (u x)) _auto✝) :
                            g (Filter.limsup u f) = Filter.limsup (fun (x : α) => g (u x)) f
                            theorem OrderIso.liminf_apply {α : Type u_1} {β : Type u_2} {γ : Type u_6} [ConditionallyCompleteLattice β] [ConditionallyCompleteLattice γ] {f : Filter α} {u : αβ} (g : β ≃o γ) (hu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (hu_co : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (hgu : autoParam (Filter.IsBoundedUnder (fun (x x_1 : γ) => x x_1) f fun (x : α) => g (u x)) _auto✝) (hgu_co : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : γ) => x x_1) f fun (x : α) => g (u x)) _auto✝) :
                            g (Filter.liminf u f) = Filter.liminf (fun (x : α) => g (u x)) f
                            theorem isCoboundedUnder_le_max {α : Type u_1} {β : Type u_2} [LinearOrder β] {f : Filter α} {u : αβ} {v : αβ} (h : Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f v) :
                            Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f fun (a : α) => max (u a) (v a)
                            theorem limsup_max {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {v : αβ} (h₁ : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h₂ : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f v) _auto✝) (h₃ : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h₄ : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f v) _auto✝) :
                            Filter.limsup (fun (a : α) => max (u a) (v a)) f = max (Filter.limsup u f) (Filter.limsup v f)
                            theorem liminf_min {α : Type u_1} {β : Type u_2} [ConditionallyCompleteLinearOrder β] {f : Filter α} {u : αβ} {v : αβ} (h₁ : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h₂ : autoParam (Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f v) _auto✝) (h₃ : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f u) _auto✝) (h₄ : autoParam (Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f v) _auto✝) :
                            Filter.liminf (fun (a : α) => min (u a) (v a)) f = min (Filter.liminf u f) (Filter.liminf v f)
                            theorem isBoundedUnder_le_finset_sup' {α : Type u_1} {β : Type u_2} {ι : Type u_4} [LinearOrder β] [Nonempty β] {f : Filter α} {F : ιαβ} {s : Finset ι} (hs : s.Nonempty) (h : is, Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f (F i)) :
                            Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f fun (a : α) => s.sup' hs fun (i : ι) => F i a
                            theorem isCoboundedUnder_le_finset_sup' {α : Type u_1} {β : Type u_2} {ι : Type u_4} [LinearOrder β] {f : Filter α} {F : ιαβ} {s : Finset ι} (hs : s.Nonempty) (h : is, Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f (F i)) :
                            Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f fun (a : α) => s.sup' hs fun (i : ι) => F i a
                            theorem isBoundedUnder_le_finset_sup {α : Type u_1} {β : Type u_2} {ι : Type u_4} [LinearOrder β] [OrderBot β] {f : Filter α} {F : ιαβ} {s : Finset ι} (h : is, Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f (F i)) :
                            Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f fun (a : α) => s.sup fun (i : ι) => F i a
                            theorem isBoundedUnder_ge_finset_inf' {α : Type u_1} {β : Type u_2} {ι : Type u_4} [LinearOrder β] [Nonempty β] {f : Filter α} {F : ιαβ} {s : Finset ι} (hs : s.Nonempty) (h : is, Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f (F i)) :
                            Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f fun (a : α) => s.inf' hs fun (i : ι) => F i a
                            theorem isCoboundedUnder_ge_finset_inf' {α : Type u_1} {β : Type u_2} {ι : Type u_4} [LinearOrder β] {f : Filter α} {F : ιαβ} {s : Finset ι} (hs : s.Nonempty) (h : is, Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f (F i)) :
                            Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f fun (a : α) => s.inf' hs fun (i : ι) => F i a
                            theorem isBoundedUnder_ge_finset_inf {α : Type u_1} {β : Type u_2} {ι : Type u_4} [LinearOrder β] [OrderTop β] {f : Filter α} {F : ιαβ} {s : Finset ι} (h : is, Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f (F i)) :
                            Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f fun (a : α) => s.inf fun (i : ι) => F i a
                            theorem limsup_finset_sup' {α : Type u_1} {β : Type u_2} {ι : Type u_4} [ConditionallyCompleteLinearOrder β] {f : Filter α} {F : ιαβ} {s : Finset ι} (hs : s.Nonempty) (h₁ : autoParam (is, Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f (F i)) _auto✝) (h₂ : autoParam (is, Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f (F i)) _auto✝) :
                            Filter.limsup (fun (a : α) => s.sup' hs fun (i : ι) => F i a) f = s.sup' hs fun (i : ι) => Filter.limsup (F i) f
                            theorem limsup_finset_sup {α : Type u_1} {β : Type u_2} {ι : Type u_4} [ConditionallyCompleteLinearOrder β] [OrderBot β] {f : Filter α} {F : ιαβ} {s : Finset ι} (h₁ : autoParam (is, Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f (F i)) _auto✝) (h₂ : autoParam (is, Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f (F i)) _auto✝) :
                            Filter.limsup (fun (a : α) => s.sup fun (i : ι) => F i a) f = s.sup fun (i : ι) => Filter.limsup (F i) f
                            theorem liminf_finset_inf' {α : Type u_1} {β : Type u_2} {ι : Type u_4} [ConditionallyCompleteLinearOrder β] {f : Filter α} {F : ιαβ} {s : Finset ι} (hs : s.Nonempty) (h₁ : autoParam (is, Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f (F i)) _auto✝) (h₂ : autoParam (is, Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f (F i)) _auto✝) :
                            Filter.liminf (fun (a : α) => s.inf' hs fun (i : ι) => F i a) f = s.inf' hs fun (i : ι) => Filter.liminf (F i) f
                            theorem liminf_finset_inf {α : Type u_1} {β : Type u_2} {ι : Type u_4} [ConditionallyCompleteLinearOrder β] [OrderTop β] {f : Filter α} {F : ιαβ} {s : Finset ι} (h₁ : autoParam (is, Filter.IsCoboundedUnder (fun (x x_1 : β) => x x_1) f (F i)) _auto✝) (h₂ : autoParam (is, Filter.IsBoundedUnder (fun (x x_1 : β) => x x_1) f (F i)) _auto✝) :
                            Filter.liminf (fun (a : α) => s.inf fun (i : ι) => F i a) f = s.inf fun (i : ι) => Filter.liminf (F i) f