File: Mathlib/Topology/Algebra/Order/LiminfLimsup.lean

full_name: BoundedLENhdsClass.isBounded_le_nhds
code: /-- Ad hoc typeclass stating that neighborhoods are eventually bounded above. -/
class BoundedLENhdsClass (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where
  isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·)
goal: Filter.IsBounded (fun x x_1 => x ≤ x_1) (𝓝 a)

full_name: BoundedLENhdsClass
code: /-- Ad hoc typeclass stating that neighborhoods are eventually bounded above. -/
class BoundedLENhdsClass (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where
  isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·)
goal: Prop

full_name: BoundedGENhdsClass
code: /-- Ad hoc typeclass stating that neighborhoods are eventually bounded below. -/
class BoundedGENhdsClass (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where
  isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·)
goal: Prop

full_name: BoundedGENhdsClass.isBounded_ge_nhds
code: /-- Ad hoc typeclass stating that neighborhoods are eventually bounded below. -/
class BoundedGENhdsClass (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where
  isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·)
goal: Filter.IsBounded (fun x x_1 => x ≥ x_1) (𝓝 a)

full_name: isBounded_le_nhds
code: theorem isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·) 
goal: Filter.IsBounded (fun x x_1 => x ≤ x_1) (𝓝 a)

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

full_name: Filter.Tendsto.bddAbove_range_of_cofinite
code: theorem Filter.Tendsto.bddAbove_range_of_cofinite [IsDirected α (· ≤ ·)]
    (h : Tendsto u cofinite (𝓝 a)) : BddAbove (Set.range u) 
goal: BddAbove (Set.range u)

full_name: Filter.Tendsto.bddAbove_range
code: theorem Filter.Tendsto.bddAbove_range [IsDirected α (· ≤ ·)] {u : ℕ → α}
    (h : Tendsto u atTop (𝓝 a)) : BddAbove (Set.range u) 
goal: BddAbove (Set.range u)

full_name: isCobounded_ge_nhds
code: theorem isCobounded_ge_nhds (a : α) : (𝓝 a).IsCobounded (· ≥ ·) 
goal: Filter.IsCobounded (fun x x_1 => x ≥ x_1) (𝓝 a)

full_name: Filter.Tendsto.isCoboundedUnder_ge
code: theorem Filter.Tendsto.isCoboundedUnder_ge [NeBot f] (h : Tendsto u f (𝓝 a)) :
    f.IsCoboundedUnder (· ≥ ·) u 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≥ x_1) f u

full_name: instBoundedGENhdsClassOrderDual
code: instance : BoundedGENhdsClass αᵒᵈ 
goal: BoundedGENhdsClass αᵒᵈ

full_name: Prod.instBoundedLENhdsClass
code: instance Prod.instBoundedLENhdsClass : BoundedLENhdsClass (α × β) 
goal: BoundedLENhdsClass (α × β)

full_name: Pi.instBoundedLENhdsClass
code: instance Pi.instBoundedLENhdsClass [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
    [∀ i, BoundedLENhdsClass (π i)] : BoundedLENhdsClass (∀ i, π i) 
goal: BoundedLENhdsClass ((i : ι) → π i)

full_name: isBounded_ge_nhds
code: theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·) 
goal: Filter.IsBounded (fun x x_1 => x ≥ x_1) (𝓝 a)

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

full_name: Filter.Tendsto.bddBelow_range_of_cofinite
code: theorem Filter.Tendsto.bddBelow_range_of_cofinite [IsDirected α (· ≥ ·)]
    (h : Tendsto u cofinite (𝓝 a)) : BddBelow (Set.range u) 
goal: BddBelow (Set.range u)

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

full_name: isCobounded_le_nhds
code: theorem isCobounded_le_nhds (a : α) : (𝓝 a).IsCobounded (· ≤ ·) 
goal: Filter.IsCobounded (fun x x_1 => x ≤ x_1) (𝓝 a)

full_name: Filter.Tendsto.isCoboundedUnder_le
code: theorem Filter.Tendsto.isCoboundedUnder_le [NeBot f] (h : Tendsto u f (𝓝 a)) :
    f.IsCoboundedUnder (· ≤ ·) u 
goal: Filter.IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u

full_name: instBoundedLENhdsClassOrderDual
code: instance : BoundedLENhdsClass αᵒᵈ 
goal: BoundedLENhdsClass αᵒᵈ

full_name: Prod.instBoundedGENhdsClass
code: instance Prod.instBoundedGENhdsClass : BoundedGENhdsClass (α × β) 
goal: BoundedGENhdsClass (α × β)

full_name: Pi.instBoundedGENhdsClass
code: instance Pi.instBoundedGENhdsClass [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
    [∀ i, BoundedGENhdsClass (π i)] : BoundedGENhdsClass (∀ i, π i) 
goal: BoundedGENhdsClass ((i : ι) → π i)

full_name: OrderTop.to_BoundedLENhdsClass
code: instance (priority := 100) OrderTop.to_BoundedLENhdsClass [OrderTop α] : BoundedLENhdsClass α 
goal: BoundedLENhdsClass α

full_name: OrderBot.to_BoundedGENhdsClass
code: instance (priority := 100) OrderBot.to_BoundedGENhdsClass [OrderBot α] : BoundedGENhdsClass α 
goal: BoundedGENhdsClass α

full_name: OrderTopology.to_BoundedLENhdsClass
code: instance (priority := 100) OrderTopology.to_BoundedLENhdsClass [IsDirected α (· ≤ ·)]
    [OrderTopology α] : BoundedLENhdsClass α 
goal: BoundedLENhdsClass α

full_name: OrderTopology.to_BoundedGENhdsClass
code: instance (priority := 100) OrderTopology.to_BoundedGENhdsClass [IsDirected α (· ≥ ·)]
    [OrderTopology α] : BoundedGENhdsClass α 
goal: BoundedGENhdsClass α

full_name: le_nhds_of_limsSup_eq_limsInf
code: /-- If the liminf and the limsup of a filter coincide, then this filter converges to
their common value, at least if the filter is eventually bounded above and below. -/
theorem le_nhds_of_limsSup_eq_limsInf {f : Filter α} {a : α} (hl : f.IsBounded (· ≤ ·))
    (hg : f.IsBounded (· ≥ ·)) (hs : f.limsSup = a) (hi : f.limsInf = a) : f ≤ 𝓝 a 
goal: f ≤ 𝓝 a

full_name: limsSup_nhds
code: theorem limsSup_nhds (a : α) : limsSup (𝓝 a) = a 
goal: (𝓝 a).limsSup = a

full_name: limsInf_nhds
code: theorem limsInf_nhds : ∀ a : α, limsInf (𝓝 a) = a 
goal: (𝓝 a).limsInf = a

full_name: limsInf_eq_of_le_nhds
code: /-- If a filter is converging, its limsup coincides with its limit. -/
theorem limsInf_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝 a) : f.limsInf = a 
goal: f.limsInf = a

full_name: limsSup_eq_of_le_nhds
code: /-- If a filter is converging, its liminf coincides with its limit. -/
theorem limsSup_eq_of_le_nhds : ∀ {f : Filter α} {a : α} [NeBot f], f ≤ 𝓝 a → f.limsSup = a 
goal: f ≤ 𝓝 a → f.limsSup = a

full_name: Filter.Tendsto.limsup_eq
code: /-- If a function has a limit, then its limsup coincides with its limit. -/
theorem Filter.Tendsto.limsup_eq {f : Filter β} {u : β → α} {a : α} [NeBot f]
    (h : Tendsto u f (𝓝 a)) : limsup u f = a 
goal: Filter.limsup u f = a

full_name: Filter.Tendsto.liminf_eq
code: /-- If a function has a limit, then its liminf coincides with its limit. -/
theorem Filter.Tendsto.liminf_eq {f : Filter β} {u : β → α} {a : α} [NeBot f]
    (h : Tendsto u f (𝓝 a)) : liminf u f = a 
goal: Filter.liminf u f = a

full_name: tendsto_of_liminf_eq_limsup
code: /-- If the liminf and the limsup of a function coincide, then the limit of the function
exists and has the same value. -/
theorem tendsto_of_liminf_eq_limsup {f : Filter β} {u : β → α} {a : α} (hinf : liminf u f = a)
    (hsup : limsup u f = a) (h : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h' : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) : Tendsto u f (𝓝 a) 
goal: Filter.Tendsto u f (𝓝 a)

full_name: tendsto_of_le_liminf_of_limsup_le
code: /-- If a number `a` is less than or equal to the `liminf` of a function `f` at some filter
and is greater than or equal to the `limsup` of `f`, then `f` tends to `a` along this filter. -/
theorem tendsto_of_le_liminf_of_limsup_le {f : Filter β} {u : β → α} {a : α} (hinf : a ≤ liminf u f)
    (hsup : limsup u f ≤ a) (h : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h' : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) : Tendsto u f (𝓝 a) 
goal: Filter.Tendsto u f (𝓝 a)

full_name: tendsto_of_no_upcrossings
code: /-- Assume that, for any `a < b`, a sequence can not be infinitely many times below `a` and
above `b`. If it is also ultimately bounded above and below, then it has to converge. This even
works if `a` and `b` are restricted to a dense subset.
-/
theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β → α} {s : Set α}
    (hs : Dense s) (H : ∀ a ∈ s, ∀ b ∈ s, a < b → ¬((∃ᶠ n in f, u n < a) ∧ ∃ᶠ n in f, b < u n))
    (h : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h' : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
    ∃ c : α, Tendsto u f (𝓝 c) 
goal: ∃ c, Filter.Tendsto u f (𝓝 c)

full_name: eventually_le_limsup
code: theorem eventually_le_limsup (hf : IsBoundedUnder (· ≤ ·) f u := by isBoundedDefault) :
    ∀ᶠ b in f, u b ≤ f.limsup u 
goal: ∀ᶠ (b : β) in f, u b ≤ Filter.limsup u f

full_name: eventually_liminf_le
code: theorem eventually_liminf_le (hf : IsBoundedUnder (· ≥ ·) f u := by isBoundedDefault) :
    ∀ᶠ b in f, f.liminf u ≤ u b 
goal: ∀ᶠ (b : β) in f, Filter.liminf u f ≤ u b

full_name: limsup_eq_bot
code: @[simp]
theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ 
goal: Filter.limsup u f = ⊥ ↔ u =ᶠ[f] ⊥

full_name: liminf_eq_top
code: @[simp]
theorem liminf_eq_top : f.liminf u = ⊤ ↔ u =ᶠ[f] ⊤ 
goal: Filter.liminf u f = ⊤ ↔ u =ᶠ[f] ⊤

full_name: Antitone.map_limsSup_of_continuousAt
code: /-- An antitone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsSup` to the `Filter.liminf` of the image if the function is continuous at the `limsSup`
(and the filter is bounded from above and frequently bounded from below). -/
theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsSup)
    (bdd_above : F.IsBounded (· ≤ ·) := by isBoundedDefault)
    (cobdd : F.IsCobounded (· ≤ ·) := by isBoundedDefault) :
    f F.limsSup = F.liminf f 
goal: f F.limsSup = Filter.liminf f F

full_name: Antitone.map_limsup_of_continuousAt
code: /-- A continuous antitone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsup` to the `Filter.liminf` of the images (if the filter is bounded from above and
frequently bounded from below). -/
theorem Antitone.map_limsup_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
    (f_cont : ContinuousAt f (F.limsup a))
    (bdd_above : F.IsBoundedUnder (· ≤ ·) a := by isBoundedDefault)
    (cobdd : F.IsCoboundedUnder (· ≤ ·) a := by isBoundedDefault) :
    f (F.limsup a) = F.liminf (f ∘ a) 
goal: f (Filter.limsup a F) = Filter.liminf (f ∘ a) F

full_name: Antitone.map_limsInf_of_continuousAt
code: /-- An antitone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsInf` to the `Filter.limsup` of the image if the function is continuous at the `limsInf`
(and the filter is bounded from below and frequently bounded from above). -/
theorem Antitone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsInf)
    (cobdd : F.IsCobounded (· ≥ ·) := by isBoundedDefault)
    (bdd_below : F.IsBounded (· ≥ ·) := by isBoundedDefault) : f F.limsInf = F.limsup f 
goal: f F.limsInf = Filter.limsup f F

full_name: Antitone.map_liminf_of_continuousAt
code: /-- A continuous antitone function between (conditionally) complete linear ordered spaces sends a
`Filter.liminf` to the `Filter.limsup` of the images (if the filter is bounded from below and
frequently bounded from above). -/
theorem Antitone.map_liminf_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
    (f_cont : ContinuousAt f (F.liminf a))
    (cobdd : F.IsCoboundedUnder (· ≥ ·) a := by isBoundedDefault)
    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
    f (F.liminf a) = F.limsup (f ∘ a) 
goal: f (Filter.liminf a F) = Filter.limsup (f ∘ a) F

full_name: Monotone.map_limsSup_of_continuousAt
code: /-- A monotone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsSup` to the `Filter.limsup` of the image if the function is continuous at the `limsSup`
(and the filter is bounded from above and frequently bounded from below). -/
theorem Monotone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsSup)
    (bdd_above : F.IsBounded (· ≤ ·) := by isBoundedDefault)
    (cobdd : F.IsCobounded (· ≤ ·) := by isBoundedDefault) : f F.limsSup = F.limsup f 
goal: f F.limsSup = Filter.limsup f F

full_name: Monotone.map_limsup_of_continuousAt
code: /-- A continuous monotone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsup` to the `Filter.limsup` of the images (if the filter is bounded from above and
frequently bounded from below). -/
theorem Monotone.map_limsup_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
    (f_cont : ContinuousAt f (F.limsup a))
    (bdd_above : F.IsBoundedUnder (· ≤ ·) a := by isBoundedDefault)
    (cobdd : F.IsCoboundedUnder (· ≤ ·) a := by isBoundedDefault) :
    f (F.limsup a) = F.limsup (f ∘ a) 
goal: f (Filter.limsup a F) = Filter.limsup (f ∘ a) F

full_name: Monotone.map_limsInf_of_continuousAt
code: /-- A monotone function between (conditionally) complete linear ordered spaces sends a
`Filter.limsInf` to the `Filter.liminf` of the image if the function is continuous at the `limsInf`
(and the filter is bounded from below and frequently bounded from above). -/
theorem Monotone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsInf)
    (cobdd : F.IsCobounded (· ≥ ·) := by isBoundedDefault)
    (bdd_below : F.IsBounded (· ≥ ·) := by isBoundedDefault) : f F.limsInf = F.liminf f 
goal: f F.limsInf = Filter.liminf f F

full_name: Monotone.map_liminf_of_continuousAt
code: /-- A continuous monotone function between (conditionally) complete linear ordered spaces sends a
`Filter.liminf` to the `Filter.liminf` of the images (if the filter is bounded from below and
frequently bounded from above). -/
theorem Monotone.map_liminf_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
    (f_cont : ContinuousAt f (F.liminf a))
    (cobdd : F.IsCoboundedUnder (· ≥ ·) a := by isBoundedDefault)
    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
    f (F.liminf a) = F.liminf (f ∘ a) 
goal: f (Filter.liminf a F) = Filter.liminf (f ∘ a) F

full_name: iInf_eq_of_forall_le_of_tendsto
code: theorem iInf_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (x_le : ∀ i, x ≤ as i) {F : Filter ι}
    [Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) : ⨅ i, as i = x 
goal: ⨅ i, as i = x

full_name: iSup_eq_of_forall_le_of_tendsto
code: theorem iSup_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (le_x : ∀ i, as i ≤ x) {F : Filter ι}
    [Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) : ⨆ i, as i = x 
goal: ⨆ i, as i = x

full_name: iUnion_Ici_eq_Ioi_of_lt_of_tendsto
code: theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
    {F : Filter ι} [Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) :
    ⋃ i : ι, Ici (as i) = Ioi x 
goal: ⋃ i, Set.Ici (as i) = Set.Ioi x

full_name: iUnion_Iic_eq_Iio_of_lt_of_tendsto
code: theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
    {F : Filter ι} [Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) :
    ⋃ i : ι, Iic (as i) = Iio x 
goal: ⋃ i, Set.Iic (as i) = Set.Iio x

full_name: limsup_eq_tendsto_sum_indicator_nat_atTop
code: theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
    limsup s atTop = { ω | Tendsto
      (fun n ↦ ∑ k ∈ Finset.range n, (s (k + 1)).indicator (1 : α → ℕ) ω) atTop atTop } 
goal: Filter.limsup s Filter.atTop =
  {ω | Filter.Tendsto (fun n => ∑ k ∈ Finset.range n, (s (k + 1)).indicator 1 ω) Filter.atTop Filter.atTop}

full_name: limsup_eq_tendsto_sum_indicator_atTop
code: theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type*) [StrictOrderedSemiring R] [Archimedean R]
    (s : ℕ → Set α) : limsup s atTop = { ω | Tendsto
      (fun n ↦ ∑ k ∈ Finset.range n, (s (k + 1)).indicator (1 : α → R) ω) atTop atTop } 
goal: Filter.limsup s Filter.atTop =
  {ω | Filter.Tendsto (fun n => ∑ k ∈ Finset.range n, (s (k + 1)).indicator 1 ω) Filter.atTop Filter.atTop}

full_name: limsup_const_add
code: /-- `liminf (c + xᵢ) = c + liminf xᵢ`. -/
lemma limsup_const_add (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
    [CovariantClass R R (fun x y ↦ x + y) fun x y ↦ x ≤ y] (f : ι → R) (c : R)
    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
    Filter.limsup (fun i ↦ c + f i) F = c + Filter.limsup f F 
goal: Filter.limsup (fun i => c + f i) F = c + Filter.limsup f F

full_name: limsup_add_const
code: /-- `limsup (xᵢ + c) = (limsup xᵢ) + c`. -/
lemma limsup_add_const (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
    [CovariantClass R R (Function.swap fun x y ↦ x + y) fun x y ↦ x ≤ y] (f : ι → R) (c : R)
    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
    Filter.limsup (fun i ↦ f i + c) F = Filter.limsup f F + c 
goal: Filter.limsup (fun i => f i + c) F = Filter.limsup f F + c

full_name: liminf_const_add
code: /-- `liminf (c + xᵢ) = c + limsup xᵢ`. -/
lemma liminf_const_add (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
    [CovariantClass R R (fun x y ↦ x + y) fun x y ↦ x ≤ y]  (f : ι → R) (c : R)
    (cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
    Filter.liminf (fun i ↦ c + f i) F = c + Filter.liminf f F 
goal: Filter.liminf (fun i => c + f i) F = c + Filter.liminf f F

full_name: liminf_add_const
code: /-- `liminf (xᵢ + c) = (liminf xᵢ) + c`. -/
lemma liminf_add_const (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
    [CovariantClass R R (Function.swap fun x y ↦ x + y) fun x y ↦ x ≤ y] (f : ι → R) (c : R)
    (cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
    Filter.liminf (fun i ↦ f i + c) F = Filter.liminf f F + c 
goal: Filter.liminf (fun i => f i + c) F = Filter.liminf f F + c

full_name: limsup_const_sub
code: /-- `limsup (c - xᵢ) = c - liminf xᵢ`. -/
lemma limsup_const_sub (F : Filter ι) [NeBot F] [AddCommSemigroup R] [Sub R] [ContinuousSub R]
    [OrderedSub R] [CovariantClass R R (fun x y ↦ x + y) fun x y ↦ x ≤ y] (f : ι → R) (c : R)
    (cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
    Filter.limsup (fun i ↦ c - f i) F = c - Filter.liminf f F 
goal: Filter.limsup (fun i => c - f i) F = c - Filter.liminf f F

full_name: limsup_sub_const
code: /-- `limsup (xᵢ - c) = (limsup xᵢ) - c`. -/
lemma limsup_sub_const (F : Filter ι) [NeBot F] [AddCommSemigroup R] [Sub R] [ContinuousSub R]
    [OrderedSub R] (f : ι → R) (c : R)
    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
    Filter.limsup (fun i ↦ f i - c) F = Filter.limsup f F - c 
goal: Filter.limsup (fun i => f i - c) F = Filter.limsup f F - c

full_name: liminf_const_sub
code: /-- `liminf (c - xᵢ) = c - limsup xᵢ`. -/
lemma liminf_const_sub (F : Filter ι) [NeBot F] [AddCommSemigroup R] [Sub R] [ContinuousSub R]
    [OrderedSub R] [CovariantClass R R (fun x y ↦ x + y) fun x y ↦ x ≤ y] (f : ι → R) (c : R)
    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (cobdd : F.IsCoboundedUnder (· ≤ ·) f) :
    Filter.liminf (fun i ↦ c - f i) F = c - Filter.limsup f F 
goal: Filter.liminf (fun i => c - f i) F = c - Filter.limsup f F

full_name: liminf_sub_const
code: /-- `liminf (xᵢ - c) = (liminf xᵢ) - c`. -/
lemma liminf_sub_const (F : Filter ι) [NeBot F] [AddCommSemigroup R] [Sub R] [ContinuousSub R]
    [OrderedSub R] (f : ι → R) (c : R)
    (cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
    Filter.liminf (fun i ↦ f i - c) F = Filter.liminf f F - c 
goal: Filter.liminf (fun i => f i - c) F = Filter.liminf f F - c