topology.algebra.order.liminf_limsupMathlib.Topology.Algebra.Order.LiminfLimsup

This file has been ported!

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(last sync)

feat(topology/algebra/order/liminf_limsup): Eventual boundedness of neighborhoods (#18629)

Generalise bounded_le_nhds/bounded_ge_nhds using two ad hoc typeclasses. The goal here is to circumvent the fact that the product of order topologies is not an order topology, and apply those lemmas to ℝⁿ.

Diff
@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov
+Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov, Yaël Dillies
 -/
 import algebra.big_operators.intervals
 import algebra.big_operators.order
@@ -16,68 +16,152 @@ import topology.order.basic
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
 > Any changes to this file require a corresponding PR to mathlib4.
+
+## Main declarations
+
+* `bounded_le_nhds_class`: Typeclass stating that neighborhoods are eventually bounded above.
+* `bounded_ge_nhds_class`: Typeclass stating that neighborhoods are eventually bounded below.
+
+## Implementation notes
+
+The same lemmas are true in `ℝ`, `ℝ × ℝ`, `ι → ℝ`, `euclidean_space ι ℝ`. To avoid code
+duplication, we provide an ad hoc axiomatisation of the properties we need.
 -/
 
 open filter topological_space
 open_locale topology classical
 
 universes u v
-variables {α : Type u} {β : Type v}
+variables {ι α β R S : Type*} {π : ι → Type*}
 
-section liminf_limsup
+/-- Ad hoc typeclass stating that neighborhoods are eventually bounded above. -/
+class bounded_le_nhds_class (α : Type*) [preorder α] [topological_space α] : Prop :=
+(is_bounded_le_nhds (a : α) : (𝓝 a).is_bounded (≤))
+
+/-- Ad hoc typeclass stating that neighborhoods are eventually bounded below. -/
+class bounded_ge_nhds_class (α : Type*) [preorder α] [topological_space α] : Prop :=
+(is_bounded_ge_nhds (a : α) : (𝓝 a).is_bounded (≥))
+
+section preorder
+variables [preorder α] [preorder β] [topological_space α] [topological_space β]
 
-section order_closed_topology
-variables [semilattice_sup α] [topological_space α] [order_topology α]
+section bounded_le_nhds_class
+variables [bounded_le_nhds_class α] [bounded_le_nhds_class β] {f : filter ι} {u : ι → α} {a : α}
 
 lemma is_bounded_le_nhds (a : α) : (𝓝 a).is_bounded (≤) :=
-(is_top_or_exists_gt a).elim (λ h, ⟨a, eventually_of_forall h⟩) (λ ⟨b, hb⟩, ⟨b, ge_mem_nhds hb⟩)
+bounded_le_nhds_class.is_bounded_le_nhds _
 
-lemma filter.tendsto.is_bounded_under_le {f : filter β} {u : β → α} {a : α}
-  (h : tendsto u f (𝓝 a)) : f.is_bounded_under (≤) u :=
+lemma filter.tendsto.is_bounded_under_le (h : tendsto u f (𝓝 a)) :
+  f.is_bounded_under (≤) u :=
 (is_bounded_le_nhds a).mono h
 
-lemma filter.tendsto.bdd_above_range_of_cofinite {u : β → α} {a : α}
+lemma filter.tendsto.bdd_above_range_of_cofinite [is_directed α (≤)]
   (h : tendsto u cofinite (𝓝 a)) : bdd_above (set.range u) :=
 h.is_bounded_under_le.bdd_above_range_of_cofinite
 
-lemma filter.tendsto.bdd_above_range {u : ℕ → α} {a : α}
-  (h : tendsto u at_top (𝓝 a)) : bdd_above (set.range u) :=
+lemma filter.tendsto.bdd_above_range [is_directed α (≤)] {u : ℕ → α} (h : tendsto u at_top (𝓝 a)) :
+  bdd_above (set.range u) :=
 h.is_bounded_under_le.bdd_above_range
 
 lemma is_cobounded_ge_nhds (a : α) : (𝓝 a).is_cobounded (≥) :=
 (is_bounded_le_nhds a).is_cobounded_flip
 
-lemma filter.tendsto.is_cobounded_under_ge {f : filter β} {u : β → α} {a : α}
-  [ne_bot f] (h : tendsto u f (𝓝 a)) : f.is_cobounded_under (≥) u :=
+lemma filter.tendsto.is_cobounded_under_ge [ne_bot f] (h : tendsto u f (𝓝 a)) :
+  f.is_cobounded_under (≥) u :=
 h.is_bounded_under_le.is_cobounded_flip
 
-end order_closed_topology
+instance : bounded_ge_nhds_class αᵒᵈ := ⟨@is_bounded_le_nhds α _ _ _⟩
+
+instance : bounded_le_nhds_class (α × β) :=
+begin
+  refine ⟨λ x, _⟩,
+  obtain ⟨a, ha⟩ := is_bounded_le_nhds x.1,
+  obtain ⟨b, hb⟩ := is_bounded_le_nhds x.2,
+  rw [←@prod.mk.eta _ _ x, nhds_prod_eq],
+  exact ⟨(a, b), ha.prod_mk hb⟩,
+end
+
+instance [finite ι] [Π i, preorder (π i)] [Π i, topological_space (π i)]
+  [Π i, bounded_le_nhds_class (π i)] : bounded_le_nhds_class (Π i, π i) :=
+begin
+  refine ⟨λ x, _⟩,
+  rw nhds_pi,
+  choose f hf using λ i, is_bounded_le_nhds (x i),
+  exact ⟨f, eventually_pi hf⟩,
+end
+
+end bounded_le_nhds_class
 
-section order_closed_topology
-variables [semilattice_inf α] [topological_space α] [order_topology α]
+section bounded_ge_nhds_class
+variables [bounded_ge_nhds_class α] [bounded_ge_nhds_class β] {f : filter ι} {u : ι → α} {a : α}
 
-lemma is_bounded_ge_nhds (a : α) : (𝓝 a).is_bounded (≥) := @is_bounded_le_nhds αᵒᵈ _ _ _ a
+lemma is_bounded_ge_nhds (a : α) : (𝓝 a).is_bounded (≥) :=
+bounded_ge_nhds_class.is_bounded_ge_nhds _
 
-lemma filter.tendsto.is_bounded_under_ge {f : filter β} {u : β → α} {a : α}
-  (h : tendsto u f (𝓝 a)) : f.is_bounded_under (≥) u :=
+lemma filter.tendsto.is_bounded_under_ge (h : tendsto u f (𝓝 a)) :
+  f.is_bounded_under (≥) u :=
 (is_bounded_ge_nhds a).mono h
 
-lemma filter.tendsto.bdd_below_range_of_cofinite {u : β → α} {a : α}
+lemma filter.tendsto.bdd_below_range_of_cofinite [is_directed α (≥)]
   (h : tendsto u cofinite (𝓝 a)) : bdd_below (set.range u) :=
 h.is_bounded_under_ge.bdd_below_range_of_cofinite
 
-lemma filter.tendsto.bdd_below_range {u : ℕ → α} {a : α}
-  (h : tendsto u at_top (𝓝 a)) : bdd_below (set.range u) :=
+lemma filter.tendsto.bdd_below_range [is_directed α (≥)] {u : ℕ → α} (h : tendsto u at_top (𝓝 a)) :
+  bdd_below (set.range u) :=
 h.is_bounded_under_ge.bdd_below_range
 
 lemma is_cobounded_le_nhds (a : α) : (𝓝 a).is_cobounded (≤) :=
 (is_bounded_ge_nhds a).is_cobounded_flip
 
-lemma filter.tendsto.is_cobounded_under_le {f : filter β} {u : β → α} {a : α}
-  [ne_bot f] (h : tendsto u f (𝓝 a)) : f.is_cobounded_under (≤) u :=
+lemma filter.tendsto.is_cobounded_under_le [ne_bot f] (h : tendsto u f (𝓝 a)) :
+  f.is_cobounded_under (≤) u :=
 h.is_bounded_under_ge.is_cobounded_flip
 
-end order_closed_topology
+instance : bounded_le_nhds_class αᵒᵈ := ⟨@is_bounded_ge_nhds α _ _ _⟩
+
+instance : bounded_ge_nhds_class (α × β) :=
+begin
+  refine ⟨λ x, _⟩,
+  obtain ⟨a, ha⟩ := is_bounded_ge_nhds x.1,
+  obtain ⟨b, hb⟩ := is_bounded_ge_nhds x.2,
+  rw [←@prod.mk.eta _ _ x, nhds_prod_eq],
+  exact ⟨(a, b), ha.prod_mk hb⟩,
+end
+
+instance [finite ι] [Π i, preorder (π i)] [Π i, topological_space (π i)]
+  [Π i, bounded_ge_nhds_class (π i)] : bounded_ge_nhds_class (Π i, π i) :=
+begin
+  refine ⟨λ x, _⟩,
+  rw nhds_pi,
+  choose f hf using λ i, is_bounded_ge_nhds (x i),
+  exact ⟨f, eventually_pi hf⟩,
+end
+
+end bounded_ge_nhds_class
+
+@[priority 100] -- See note [lower instance priority]
+instance order_top.to_bounded_le_nhds_class [order_top α] : bounded_le_nhds_class α :=
+⟨λ a, is_bounded_le_of_top⟩
+
+@[priority 100] -- See note [lower instance priority]
+instance order_bot.to_bounded_ge_nhds_class [order_bot α] : bounded_ge_nhds_class α :=
+⟨λ a, is_bounded_ge_of_bot⟩
+
+@[priority 100] -- See note [lower instance priority]
+instance order_topology.to_bounded_le_nhds_class [is_directed α (≤)] [order_topology α] :
+  bounded_le_nhds_class α :=
+⟨λ a, (is_top_or_exists_gt a).elim (λ h, ⟨a, eventually_of_forall h⟩) $ Exists.imp $ λ b,
+  ge_mem_nhds⟩
+
+@[priority 100] -- See note [lower instance priority]
+instance order_topology.to_bounded_ge_nhds_class [is_directed α (≥)] [order_topology α] :
+  bounded_ge_nhds_class α :=
+⟨λ a, (is_bot_or_exists_lt a).elim (λ h, ⟨a, eventually_of_forall h⟩) $ Exists.imp $ λ b,
+  le_mem_nhds⟩
+
+end preorder
+
+section liminf_limsup
 
 section conditionally_complete_linear_order
 variables [conditionally_complete_linear_order α]
@@ -224,7 +308,7 @@ end liminf_limsup
 
 section monotone
 
-variables {ι R S : Type*} {F : filter ι} [ne_bot F]
+variables {F : filter ι} [ne_bot F]
   [complete_linear_order R] [topological_space R] [order_topology R]
   [complete_linear_order S] [topological_space S] [order_topology S]
 
@@ -334,7 +418,7 @@ open_locale topology
 
 open filter set
 
-variables {ι : Type*} {R : Type*} [complete_linear_order R] [topological_space R] [order_topology R]
+variables [complete_linear_order R] [topological_space R] [order_topology R]
 
 lemma infi_eq_of_forall_le_of_tendsto {x : R} {as : ι → R}
   (x_le : ∀ i, x ≤ as i) {F : filter ι} [filter.ne_bot F] (as_lim : filter.tendsto as F (𝓝 x)) :
@@ -349,7 +433,7 @@ lemma supr_eq_of_forall_le_of_tendsto {x : R} {as : ι → R}
   (⨆ i, as i) = x :=
 @infi_eq_of_forall_le_of_tendsto ι (order_dual R) _ _ _ x as le_x F _ as_lim
 
-lemma Union_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type*} (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
+lemma Union_Ici_eq_Ioi_of_lt_of_tendsto (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
   {F : filter ι} [filter.ne_bot F] (as_lim : filter.tendsto as F (𝓝 x)) :
   (⋃ (i : ι), Ici (as i)) = Ioi x :=
 begin
@@ -361,10 +445,10 @@ begin
   exact Union_Ici_eq_Ioi_infi obs,
 end
 
-lemma Union_Iic_eq_Iio_of_lt_of_tendsto {ι : Type*} (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
+lemma Union_Iic_eq_Iio_of_lt_of_tendsto (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
   {F : filter ι} [filter.ne_bot F] (as_lim : filter.tendsto as F (𝓝 x)) :
   (⋃ (i : ι), Iic (as i)) = Iio x :=
-@Union_Ici_eq_Ioi_of_lt_of_tendsto (order_dual R) _ _ _ ι x as lt_x F _ as_lim
+@Union_Ici_eq_Ioi_of_lt_of_tendsto ι Rᵒᵈ _ _ _ _ _ lt_x F _ as_lim
 
 end infi_and_supr
 

(no changes)

(no changes)

(no changes)

chore(order/liminf_limsup): Generalise and move lemmas (#18628)

Generalise lemmas from semilattices to codirected orders. Move topology-less lemmas from topology.algebra.order.liminf_limsup to order.liminf_limsup. Also turn arguments to bdd_above_insert and friends implicit.

Diff
@@ -51,19 +51,6 @@ lemma filter.tendsto.is_cobounded_under_ge {f : filter β} {u : β → α} {a :
   [ne_bot f] (h : tendsto u f (𝓝 a)) : f.is_cobounded_under (≥) u :=
 h.is_bounded_under_le.is_cobounded_flip
 
-lemma is_bounded_le_at_bot (α : Type*) [hα : nonempty α] [preorder α] :
-  (at_bot : filter α).is_bounded (≤) :=
-is_bounded_iff.2 ⟨set.Iic hα.some, mem_at_bot _, hα.some, λ x hx, hx⟩
-
-lemma filter.tendsto.is_bounded_under_le_at_bot {α : Type*} [nonempty α] [preorder α]
-  {f : filter β} {u : β → α} (h : tendsto u f at_bot) :
-  f.is_bounded_under (≤) u :=
-(is_bounded_le_at_bot α).mono h
-
-lemma bdd_above_range_of_tendsto_at_top_at_bot {α : Type*} [nonempty α] [semilattice_sup α]
-  {u : ℕ → α} (hx : tendsto u at_top at_bot) : bdd_above (set.range u) :=
-(filter.tendsto.is_bounded_under_le_at_bot hx).bdd_above_range
-
 end order_closed_topology
 
 section order_closed_topology
@@ -90,33 +77,11 @@ lemma filter.tendsto.is_cobounded_under_le {f : filter β} {u : β → α} {a :
   [ne_bot f] (h : tendsto u f (𝓝 a)) : f.is_cobounded_under (≤) u :=
 h.is_bounded_under_ge.is_cobounded_flip
 
-lemma is_bounded_ge_at_top (α : Type*) [hα : nonempty α] [preorder α] :
-  (at_top : filter α).is_bounded (≥) :=
-is_bounded_le_at_bot αᵒᵈ
-
-lemma filter.tendsto.is_bounded_under_ge_at_top {α : Type*} [nonempty α] [preorder α]
-  {f : filter β} {u : β → α} (h : tendsto u f at_top) :
-  f.is_bounded_under (≥) u :=
-(is_bounded_ge_at_top α).mono h
-
-lemma bdd_below_range_of_tendsto_at_top_at_top {α : Type*} [nonempty α] [semilattice_inf α]
-  {u : ℕ → α} (hx : tendsto u at_top at_top) : bdd_below (set.range u) :=
-(filter.tendsto.is_bounded_under_ge_at_top hx).bdd_below_range
-
 end order_closed_topology
 
 section conditionally_complete_linear_order
 variables [conditionally_complete_linear_order α]
 
-theorem lt_mem_sets_of_Limsup_lt {f : filter α} {b} (h : f.is_bounded (≤)) (l : f.Limsup < b) :
-  ∀ᶠ a in f, a < b :=
-let ⟨c, (h : ∀ᶠ a in f, a ≤ c), hcb⟩ := exists_lt_of_cInf_lt h l in
-mem_of_superset h $ assume a hac, lt_of_le_of_lt hac hcb
-
-theorem gt_mem_sets_of_Liminf_gt : ∀ {f : filter α} {b}, f.is_bounded (≥) → b < f.Liminf →
-  ∀ᶠ a in f, b < a :=
-@lt_mem_sets_of_Limsup_lt αᵒᵈ _
-
 variables [topological_space α] [order_topology α]
 
 /-- If the liminf and the limsup of a filter coincide, then this filter converges to

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

chore(measure_theory/function/ess_sup): Generalise (#18669)

A handful of lemmas hold for bounded filters in conditionally complete lattices, rather than just filter in complete lattices (which are automatically bounded).

Also prove that μ {y | x < f y} = 0 when x is greater than the essential supremum of f, and dually.

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr>

Diff
@@ -8,6 +8,7 @@ import algebra.big_operators.order
 import algebra.indicator_function
 import order.liminf_limsup
 import order.filter.archimedean
+import order.filter.countable_Inter
 import topology.order.basic
 
 /-!
@@ -17,7 +18,7 @@ import topology.order.basic
 > Any changes to this file require a corresponding PR to mathlib4.
 -/
 
-open filter
+open filter topological_space
 open_locale topology classical
 
 universes u v
@@ -215,8 +216,45 @@ begin
   exact H a as b bs ab ⟨A, B⟩,
 end
 
+variables [first_countable_topology α] {f : filter β} [countable_Inter_filter f] {u : β → α}
+
+lemma eventually_le_limsup (hf : is_bounded_under (≤) f u . is_bounded_default) :
+  ∀ᶠ b in f, u b ≤ f.limsup u :=
+begin
+  obtain ha | ha := is_top_or_exists_gt (f.limsup u),
+  { exact eventually_of_forall (λ _, ha _) },
+  by_cases H : is_glb (set.Ioi (f.limsup u)) (f.limsup u),
+  { obtain ⟨u, -, -, hua, hu⟩ := H.exists_seq_antitone_tendsto ha,
+    have := λ n, eventually_lt_of_limsup_lt (hu n) hf,
+    exact (eventually_countable_forall.2 this).mono
+      (λ b hb, ge_of_tendsto hua $ eventually_of_forall $ λ n, (hb _).le) },
+  { obtain ⟨x, hx, xa⟩ : ∃ x, (∀ ⦃b⦄, f.limsup u < b → x ≤ b) ∧ f.limsup u < x,
+    { simp only [is_glb, is_greatest, lower_bounds, upper_bounds, set.mem_Ioi, set.mem_set_of_eq,
+        not_and, not_forall, not_le, exists_prop] at H,
+      exact H (λ x hx, le_of_lt hx) },
+    filter_upwards [eventually_lt_of_limsup_lt xa hf] with y hy,
+    contrapose! hy,
+    exact hx hy }
+end
+
+lemma eventually_liminf_le (hf : is_bounded_under (≥) f u . is_bounded_default) :
+  ∀ᶠ b in f, f.liminf u ≤ u b :=
+@eventually_le_limsup αᵒᵈ _ _ _ _ _ _ _ _ hf
+
 end conditionally_complete_linear_order
 
+section complete_linear_order
+variables [complete_linear_order α] [topological_space α] [first_countable_topology α]
+  [order_topology α] {f : filter β} [countable_Inter_filter f] {u : β → α}
+
+@[simp] lemma limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
+⟨λ h, (eventually_le.trans eventually_le_limsup $ eventually_of_forall $ λ _, h.le).mono $ λ x hx,
+  le_antisymm hx bot_le, λ h, by { rw limsup_congr h, exact limsup_const_bot }⟩
+
+@[simp] lemma liminf_eq_top : f.liminf u = ⊤ ↔ u =ᶠ[f] ⊤ := @limsup_eq_bot αᵒᵈ _ _ _ _ _ _ _ _
+
+end complete_linear_order
+
 end liminf_limsup
 
 section monotone

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(no changes)

(first ported)

Changes in mathlib3port

mathlib3
mathlib3port
Diff
@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov, Yaël Dillies
 -/
 import Algebra.BigOperators.Intervals
-import Algebra.BigOperators.Order
+import Algebra.Order.BigOperators.Group.Finset
 import Algebra.Function.Indicator
 import Order.LiminfLimsup
 import Order.Filter.Archimedean
Diff
@@ -5,7 +5,7 @@ Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov, Yaël Dillies
 -/
 import Algebra.BigOperators.Intervals
 import Algebra.BigOperators.Order
-import Algebra.IndicatorFunction
+import Algebra.Function.Indicator
 import Order.LiminfLimsup
 import Order.Filter.Archimedean
 import Order.Filter.CountableInter
Diff
@@ -390,7 +390,7 @@ theorem eventually_le_limsup
   · obtain ⟨x, hx, xa⟩ : ∃ x, (∀ ⦃b⦄, f.limsup u < b → x ≤ b) ∧ f.limsup u < x :=
       by
       simp only [IsGLB, IsGreatest, lowerBounds, upperBounds, Set.mem_Ioi, Set.mem_setOf_eq,
-        not_and, Classical.not_forall, not_le, exists_prop] at H 
+        not_and, Classical.not_forall, not_le, exists_prop] at H
       exact H fun x hx => le_of_lt hx
     filter_upwards [eventually_lt_of_limsup_lt xa hf] with y hy
     contrapose! hy
@@ -488,7 +488,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
     obtain ⟨m, l_m, m_lt⟩ : (Set.Ioo l F.Limsup).Nonempty :=
       by
       contrapose! h'
-      refine' ⟨l, l_lt, by rwa [Set.not_nonempty_iff_eq_empty] at h' ⟩
+      refine' ⟨l, l_lt, by rwa [Set.not_nonempty_iff_eq_empty] at h'⟩
     have B : F.liminf f ≤ f m := by
       apply liminf_le_of_frequently_le
       apply
@@ -641,7 +641,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
             (Finset.range_mono hnm))
         _
     rintro ⟨i, h⟩
-    simp only [mem_upperBounds, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff] at h 
+    simp only [mem_upperBounds, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff] at h
     induction' i with k hk
     · obtain ⟨j, hj₁, hj₂⟩ := hω 1
       refine'
@@ -652,8 +652,8 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
           ⟨j - 1, Finset.mem_range.2 (lt_of_le_of_lt (Nat.sub_le _ _) j.lt_succ_self), _⟩
       rw [Nat.sub_add_cancel hj₁, Set.indicator_of_mem hj₂]
       exact zero_lt_one
-    · rw [imp_false] at hk 
-      push_neg at hk 
+    · rw [imp_false] at hk
+      push_neg at hk
       obtain ⟨i, hi⟩ := hk
       obtain ⟨j, hj₁, hj₂⟩ := hω (i + 1)
       replace hi : ∑ k in Finset.range i, (s (k + 1)).indicator 1 ω = k + 1 := le_antisymm (h i) hi
@@ -672,9 +672,9 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
         Set.indicator_of_mem hj₂]
       exact zero_lt_one
   · rintro hω i
-    rw [Set.mem_setOf_eq, tendsto_at_top_at_top] at hω 
+    rw [Set.mem_setOf_eq, tendsto_at_top_at_top] at hω
     by_contra hcon
-    push_neg at hcon 
+    push_neg at hcon
     obtain ⟨j, h⟩ := hω (i + 1)
     have : ∑ k in Finset.range j, (s (k + 1)).indicator 1 ω ≤ i :=
       by
Diff
@@ -357,7 +357,7 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
   haveI : ne_bot f := ⟨hbot⟩
   refine' ⟨limsup u f, _⟩
   apply tendsto_of_le_liminf_of_limsup_le _ le_rfl h h'
-  by_contra' hlt
+  by_contra! hlt
   obtain ⟨a, ⟨⟨la, au⟩, as⟩⟩ : ∃ a, (f.liminf u < a ∧ a < f.limsup u) ∧ a ∈ s :=
     dense_iff_inter_open.1 hs (Set.Ioo (f.liminf u) (f.limsup u)) isOpen_Ioo
       (Set.nonempty_Ioo.2 hlt)
@@ -477,12 +477,12 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
                   is_bounded_default)
               c_lt).mono
         intro x hx
-        by_contra'
+        by_contra!
         have : (Set.Ioo c F.Limsup).Nonempty := ⟨x, ⟨hx, this⟩⟩
         simpa [hc]
       apply liminf_le_of_frequently_le
       exact B.mono fun x hx => f_decr hx
-    by_contra' H
+    by_contra! H
     obtain ⟨l, l_lt, h'l⟩ : ∃ l < F.Limsup, Set.Ioc l F.Limsup ⊆ {x : R | f x < F.liminf f}
     exact exists_Ioc_subset_of_mem_nhds ((tendsto_order.1 f_cont.tendsto).2 _ H) ⟨⊥, Limsup_ne_bot⟩
     obtain ⟨m, l_m, m_lt⟩ : (Set.Ioo l F.Limsup).Nonempty :=
Diff
@@ -39,27 +39,31 @@ universe u v
 
 variable {ι α β R S : Type _} {π : ι → Type _}
 
+#print BoundedLENhdsClass /-
 /-- Ad hoc typeclass stating that neighborhoods are eventually bounded above. -/
-class BoundedLeNhdsClass (α : Type _) [Preorder α] [TopologicalSpace α] : Prop where
+class BoundedLENhdsClass (α : Type _) [Preorder α] [TopologicalSpace α] : Prop where
   isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·)
-#align bounded_le_nhds_class BoundedLeNhdsClass
+#align bounded_le_nhds_class BoundedLENhdsClass
+-/
 
+#print BoundedGENhdsClass /-
 /-- Ad hoc typeclass stating that neighborhoods are eventually bounded below. -/
-class BoundedGeNhdsClass (α : Type _) [Preorder α] [TopologicalSpace α] : Prop where
+class BoundedGENhdsClass (α : Type _) [Preorder α] [TopologicalSpace α] : Prop where
   isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·)
-#align bounded_ge_nhds_class BoundedGeNhdsClass
+#align bounded_ge_nhds_class BoundedGENhdsClass
+-/
 
 section Preorder
 
 variable [Preorder α] [Preorder β] [TopologicalSpace α] [TopologicalSpace β]
 
-section BoundedLeNhdsClass
+section BoundedLENhdsClass
 
-variable [BoundedLeNhdsClass α] [BoundedLeNhdsClass β] {f : Filter ι} {u : ι → α} {a : α}
+variable [BoundedLENhdsClass α] [BoundedLENhdsClass β] {f : Filter ι} {u : ι → α} {a : α}
 
 #print isBounded_le_nhds /-
 theorem isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·) :=
-  BoundedLeNhdsClass.isBounded_le_nhds _
+  BoundedLENhdsClass.isBounded_le_nhds _
 #align is_bounded_le_nhds isBounded_le_nhds
 -/
 
@@ -96,10 +100,10 @@ theorem Filter.Tendsto.isCoboundedUnder_ge [NeBot f] (h : Tendsto u f (𝓝 a))
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
 -/
 
-instance : BoundedGeNhdsClass αᵒᵈ :=
+instance : BoundedGENhdsClass αᵒᵈ :=
   ⟨@isBounded_le_nhds α _ _ _⟩
 
-instance : BoundedLeNhdsClass (α × β) :=
+instance : BoundedLENhdsClass (α × β) :=
   by
   refine' ⟨fun x => _⟩
   obtain ⟨a, ha⟩ := isBounded_le_nhds x.1
@@ -108,22 +112,22 @@ instance : BoundedLeNhdsClass (α × β) :=
   exact ⟨(a, b), ha.prod_mk hb⟩
 
 instance [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
-    [∀ i, BoundedLeNhdsClass (π i)] : BoundedLeNhdsClass (∀ i, π i) :=
+    [∀ i, BoundedLENhdsClass (π i)] : BoundedLENhdsClass (∀ i, π i) :=
   by
   refine' ⟨fun x => _⟩
   rw [nhds_pi]
   choose f hf using fun i => isBounded_le_nhds (x i)
   exact ⟨f, eventually_pi hf⟩
 
-end BoundedLeNhdsClass
+end BoundedLENhdsClass
 
-section BoundedGeNhdsClass
+section BoundedGENhdsClass
 
-variable [BoundedGeNhdsClass α] [BoundedGeNhdsClass β] {f : Filter ι} {u : ι → α} {a : α}
+variable [BoundedGENhdsClass α] [BoundedGENhdsClass β] {f : Filter ι} {u : ι → α} {a : α}
 
 #print isBounded_ge_nhds /-
 theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·) :=
-  BoundedGeNhdsClass.isBounded_ge_nhds _
+  BoundedGENhdsClass.isBounded_ge_nhds _
 #align is_bounded_ge_nhds isBounded_ge_nhds
 -/
 
@@ -160,10 +164,10 @@ theorem Filter.Tendsto.isCoboundedUnder_le [NeBot f] (h : Tendsto u f (𝓝 a))
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
 -/
 
-instance : BoundedLeNhdsClass αᵒᵈ :=
+instance : BoundedLENhdsClass αᵒᵈ :=
   ⟨@isBounded_ge_nhds α _ _ _⟩
 
-instance : BoundedGeNhdsClass (α × β) :=
+instance : BoundedGENhdsClass (α × β) :=
   by
   refine' ⟨fun x => _⟩
   obtain ⟨a, ha⟩ := isBounded_ge_nhds x.1
@@ -172,40 +176,48 @@ instance : BoundedGeNhdsClass (α × β) :=
   exact ⟨(a, b), ha.prod_mk hb⟩
 
 instance [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
-    [∀ i, BoundedGeNhdsClass (π i)] : BoundedGeNhdsClass (∀ i, π i) :=
+    [∀ i, BoundedGENhdsClass (π i)] : BoundedGENhdsClass (∀ i, π i) :=
   by
   refine' ⟨fun x => _⟩
   rw [nhds_pi]
   choose f hf using fun i => isBounded_ge_nhds (x i)
   exact ⟨f, eventually_pi hf⟩
 
-end BoundedGeNhdsClass
+end BoundedGENhdsClass
 
+#print OrderTop.to_BoundedLENhdsClass /-
 -- See note [lower instance priority]
-instance (priority := 100) OrderTop.to_boundedLeNhdsClass [OrderTop α] : BoundedLeNhdsClass α :=
+instance (priority := 100) OrderTop.to_BoundedLENhdsClass [OrderTop α] : BoundedLENhdsClass α :=
   ⟨fun a => isBounded_le_of_top⟩
-#align order_top.to_bounded_le_nhds_class OrderTop.to_boundedLeNhdsClass
+#align order_top.to_bounded_le_nhds_class OrderTop.to_BoundedLENhdsClass
+-/
 
+#print OrderBot.to_BoundedGENhdsClass /-
 -- See note [lower instance priority]
-instance (priority := 100) OrderBot.to_boundedGeNhdsClass [OrderBot α] : BoundedGeNhdsClass α :=
+instance (priority := 100) OrderBot.to_BoundedGENhdsClass [OrderBot α] : BoundedGENhdsClass α :=
   ⟨fun a => isBounded_ge_of_bot⟩
-#align order_bot.to_bounded_ge_nhds_class OrderBot.to_boundedGeNhdsClass
+#align order_bot.to_bounded_ge_nhds_class OrderBot.to_BoundedGENhdsClass
+-/
 
+#print OrderTopology.to_BoundedLENhdsClass /-
 -- See note [lower instance priority]
-instance (priority := 100) OrderTopology.to_boundedLeNhdsClass [IsDirected α (· ≤ ·)]
-    [OrderTopology α] : BoundedLeNhdsClass α :=
+instance (priority := 100) OrderTopology.to_BoundedLENhdsClass [IsDirected α (· ≤ ·)]
+    [OrderTopology α] : BoundedLENhdsClass α :=
   ⟨fun a =>
     ((isTop_or_exists_gt a).elim fun h => ⟨a, eventually_of_forall h⟩) <|
       Exists.imp fun b => ge_mem_nhds⟩
-#align order_topology.to_bounded_le_nhds_class OrderTopology.to_boundedLeNhdsClass
+#align order_topology.to_bounded_le_nhds_class OrderTopology.to_BoundedLENhdsClass
+-/
 
+#print OrderTopology.to_BoundedGENhdsClass /-
 -- See note [lower instance priority]
-instance (priority := 100) OrderTopology.to_boundedGeNhdsClass [IsDirected α (· ≥ ·)]
-    [OrderTopology α] : BoundedGeNhdsClass α :=
+instance (priority := 100) OrderTopology.to_BoundedGENhdsClass [IsDirected α (· ≥ ·)]
+    [OrderTopology α] : BoundedGENhdsClass α :=
   ⟨fun a =>
     ((isBot_or_exists_lt a).elim fun h => ⟨a, eventually_of_forall h⟩) <|
       Exists.imp fun b => le_mem_nhds⟩
-#align order_topology.to_bounded_ge_nhds_class OrderTopology.to_boundedGeNhdsClass
+#align order_topology.to_bounded_ge_nhds_class OrderTopology.to_BoundedGENhdsClass
+-/
 
 end Preorder
 
Diff
@@ -378,7 +378,7 @@ theorem eventually_le_limsup
   · obtain ⟨x, hx, xa⟩ : ∃ x, (∀ ⦃b⦄, f.limsup u < b → x ≤ b) ∧ f.limsup u < x :=
       by
       simp only [IsGLB, IsGreatest, lowerBounds, upperBounds, Set.mem_Ioi, Set.mem_setOf_eq,
-        not_and, not_forall, not_le, exists_prop] at H 
+        not_and, Classical.not_forall, not_le, exists_prop] at H 
       exact H fun x hx => le_of_lt hx
     filter_upwards [eventually_lt_of_limsup_lt xa hf] with y hy
     contrapose! hy
Diff
@@ -629,7 +629,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
             (Finset.range_mono hnm))
         _
     rintro ⟨i, h⟩
-    simp only [mem_upperBounds, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff'] at h 
+    simp only [mem_upperBounds, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff] at h 
     induction' i with k hk
     · obtain ⟨j, hj₁, hj₂⟩ := hω 1
       refine'
Diff
@@ -653,7 +653,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
         Finset.sum_lt_sum (fun m _ => Set.indicator_nonneg (fun _ _ => zero_le_one) _)
           ⟨j - 1,
             Finset.mem_Ico.2
-              ⟨(Nat.le_sub_iff_right (le_trans ((le_add_iff_nonneg_left _).2 zero_le') hj₁)).2 hj₁,
+              ⟨(Nat.le_sub_iff_add_le (le_trans ((le_add_iff_nonneg_left _).2 zero_le') hj₁)).2 hj₁,
                 lt_of_le_of_lt (Nat.sub_le _ _) j.lt_succ_self⟩,
             _⟩
       rw [Nat.sub_add_cancel (le_trans ((le_add_iff_nonneg_left _).2 zero_le') hj₁),
Diff
@@ -3,13 +3,13 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov, Yaël Dillies
 -/
-import Mathbin.Algebra.BigOperators.Intervals
-import Mathbin.Algebra.BigOperators.Order
-import Mathbin.Algebra.IndicatorFunction
-import Mathbin.Order.LiminfLimsup
-import Mathbin.Order.Filter.Archimedean
-import Mathbin.Order.Filter.CountableInter
-import Mathbin.Topology.Order.Basic
+import Algebra.BigOperators.Intervals
+import Algebra.BigOperators.Order
+import Algebra.IndicatorFunction
+import Order.LiminfLimsup
+import Order.Filter.Archimedean
+import Order.Filter.CountableInter
+import Topology.Order.Basic
 
 #align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
 
Diff
@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov
+Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov, Yaël Dillies
 -/
 import Mathbin.Algebra.BigOperators.Intervals
 import Mathbin.Algebra.BigOperators.Order
@@ -11,13 +11,23 @@ import Mathbin.Order.Filter.Archimedean
 import Mathbin.Order.Filter.CountableInter
 import Mathbin.Topology.Order.Basic
 
-#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ffde2d8a6e689149e44fd95fa862c23a57f8c780"
+#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
 
 /-!
 # Lemmas about liminf and limsup in an order topology.
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
 > Any changes to this file require a corresponding PR to mathlib4.
+
+## Main declarations
+
+* `bounded_le_nhds_class`: Typeclass stating that neighborhoods are eventually bounded above.
+* `bounded_ge_nhds_class`: Typeclass stating that neighborhoods are eventually bounded below.
+
+## Implementation notes
+
+The same lemmas are true in `ℝ`, `ℝ × ℝ`, `ι → ℝ`, `euclidean_space ι ℝ`. To avoid code
+duplication, we provide an ad hoc axiomatisation of the properties we need.
 -/
 
 
@@ -27,38 +37,48 @@ open scoped Topology Classical
 
 universe u v
 
-variable {α : Type u} {β : Type v}
+variable {ι α β R S : Type _} {π : ι → Type _}
 
-section LiminfLimsup
+/-- Ad hoc typeclass stating that neighborhoods are eventually bounded above. -/
+class BoundedLeNhdsClass (α : Type _) [Preorder α] [TopologicalSpace α] : Prop where
+  isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·)
+#align bounded_le_nhds_class BoundedLeNhdsClass
 
-section OrderClosedTopology
+/-- Ad hoc typeclass stating that neighborhoods are eventually bounded below. -/
+class BoundedGeNhdsClass (α : Type _) [Preorder α] [TopologicalSpace α] : Prop where
+  isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·)
+#align bounded_ge_nhds_class BoundedGeNhdsClass
 
-variable [SemilatticeSup α] [TopologicalSpace α] [OrderTopology α]
+section Preorder
+
+variable [Preorder α] [Preorder β] [TopologicalSpace α] [TopologicalSpace β]
+
+section BoundedLeNhdsClass
+
+variable [BoundedLeNhdsClass α] [BoundedLeNhdsClass β] {f : Filter ι} {u : ι → α} {a : α}
 
 #print isBounded_le_nhds /-
 theorem isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·) :=
-  (isTop_or_exists_gt a).elim (fun h => ⟨a, eventually_of_forall h⟩) fun ⟨b, hb⟩ =>
-    ⟨b, ge_mem_nhds hb⟩
+  BoundedLeNhdsClass.isBounded_le_nhds _
 #align is_bounded_le_nhds isBounded_le_nhds
 -/
 
 #print Filter.Tendsto.isBoundedUnder_le /-
-theorem Filter.Tendsto.isBoundedUnder_le {f : Filter β} {u : β → α} {a : α}
-    (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≤ ·) u :=
+theorem Filter.Tendsto.isBoundedUnder_le (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≤ ·) u :=
   (isBounded_le_nhds a).mono h
 #align filter.tendsto.is_bounded_under_le Filter.Tendsto.isBoundedUnder_le
 -/
 
 #print Filter.Tendsto.bddAbove_range_of_cofinite /-
-theorem Filter.Tendsto.bddAbove_range_of_cofinite {u : β → α} {a : α}
+theorem Filter.Tendsto.bddAbove_range_of_cofinite [IsDirected α (· ≤ ·)]
     (h : Tendsto u cofinite (𝓝 a)) : BddAbove (Set.range u) :=
   h.isBoundedUnder_le.bddAbove_range_of_cofinite
 #align filter.tendsto.bdd_above_range_of_cofinite Filter.Tendsto.bddAbove_range_of_cofinite
 -/
 
 #print Filter.Tendsto.bddAbove_range /-
-theorem Filter.Tendsto.bddAbove_range {u : ℕ → α} {a : α} (h : Tendsto u atTop (𝓝 a)) :
-    BddAbove (Set.range u) :=
+theorem Filter.Tendsto.bddAbove_range [IsDirected α (· ≤ ·)] {u : ℕ → α}
+    (h : Tendsto u atTop (𝓝 a)) : BddAbove (Set.range u) :=
   h.isBoundedUnder_le.bddAbove_range
 #align filter.tendsto.bdd_above_range Filter.Tendsto.bddAbove_range
 -/
@@ -70,41 +90,59 @@ theorem isCobounded_ge_nhds (a : α) : (𝓝 a).IsCobounded (· ≥ ·) :=
 -/
 
 #print Filter.Tendsto.isCoboundedUnder_ge /-
-theorem Filter.Tendsto.isCoboundedUnder_ge {f : Filter β} {u : β → α} {a : α} [NeBot f]
-    (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≥ ·) u :=
+theorem Filter.Tendsto.isCoboundedUnder_ge [NeBot f] (h : Tendsto u f (𝓝 a)) :
+    f.IsCoboundedUnder (· ≥ ·) u :=
   h.isBoundedUnder_le.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
 -/
 
-end OrderClosedTopology
+instance : BoundedGeNhdsClass αᵒᵈ :=
+  ⟨@isBounded_le_nhds α _ _ _⟩
 
-section OrderClosedTopology
+instance : BoundedLeNhdsClass (α × β) :=
+  by
+  refine' ⟨fun x => _⟩
+  obtain ⟨a, ha⟩ := isBounded_le_nhds x.1
+  obtain ⟨b, hb⟩ := isBounded_le_nhds x.2
+  rw [← @Prod.mk.eta _ _ x, nhds_prod_eq]
+  exact ⟨(a, b), ha.prod_mk hb⟩
+
+instance [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
+    [∀ i, BoundedLeNhdsClass (π i)] : BoundedLeNhdsClass (∀ i, π i) :=
+  by
+  refine' ⟨fun x => _⟩
+  rw [nhds_pi]
+  choose f hf using fun i => isBounded_le_nhds (x i)
+  exact ⟨f, eventually_pi hf⟩
+
+end BoundedLeNhdsClass
 
-variable [SemilatticeInf α] [TopologicalSpace α] [OrderTopology α]
+section BoundedGeNhdsClass
+
+variable [BoundedGeNhdsClass α] [BoundedGeNhdsClass β] {f : Filter ι} {u : ι → α} {a : α}
 
 #print isBounded_ge_nhds /-
 theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·) :=
-  @isBounded_le_nhds αᵒᵈ _ _ _ a
+  BoundedGeNhdsClass.isBounded_ge_nhds _
 #align is_bounded_ge_nhds isBounded_ge_nhds
 -/
 
 #print Filter.Tendsto.isBoundedUnder_ge /-
-theorem Filter.Tendsto.isBoundedUnder_ge {f : Filter β} {u : β → α} {a : α}
-    (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≥ ·) u :=
+theorem Filter.Tendsto.isBoundedUnder_ge (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≥ ·) u :=
   (isBounded_ge_nhds a).mono h
 #align filter.tendsto.is_bounded_under_ge Filter.Tendsto.isBoundedUnder_ge
 -/
 
 #print Filter.Tendsto.bddBelow_range_of_cofinite /-
-theorem Filter.Tendsto.bddBelow_range_of_cofinite {u : β → α} {a : α}
+theorem Filter.Tendsto.bddBelow_range_of_cofinite [IsDirected α (· ≥ ·)]
     (h : Tendsto u cofinite (𝓝 a)) : BddBelow (Set.range u) :=
   h.isBoundedUnder_ge.bddBelow_range_of_cofinite
 #align filter.tendsto.bdd_below_range_of_cofinite Filter.Tendsto.bddBelow_range_of_cofinite
 -/
 
 #print Filter.Tendsto.bddBelow_range /-
-theorem Filter.Tendsto.bddBelow_range {u : ℕ → α} {a : α} (h : Tendsto u atTop (𝓝 a)) :
-    BddBelow (Set.range u) :=
+theorem Filter.Tendsto.bddBelow_range [IsDirected α (· ≥ ·)] {u : ℕ → α}
+    (h : Tendsto u atTop (𝓝 a)) : BddBelow (Set.range u) :=
   h.isBoundedUnder_ge.bddBelow_range
 #align filter.tendsto.bdd_below_range Filter.Tendsto.bddBelow_range
 -/
@@ -116,13 +154,62 @@ theorem isCobounded_le_nhds (a : α) : (𝓝 a).IsCobounded (· ≤ ·) :=
 -/
 
 #print Filter.Tendsto.isCoboundedUnder_le /-
-theorem Filter.Tendsto.isCoboundedUnder_le {f : Filter β} {u : β → α} {a : α} [NeBot f]
-    (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≤ ·) u :=
+theorem Filter.Tendsto.isCoboundedUnder_le [NeBot f] (h : Tendsto u f (𝓝 a)) :
+    f.IsCoboundedUnder (· ≤ ·) u :=
   h.isBoundedUnder_ge.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
 -/
 
-end OrderClosedTopology
+instance : BoundedLeNhdsClass αᵒᵈ :=
+  ⟨@isBounded_ge_nhds α _ _ _⟩
+
+instance : BoundedGeNhdsClass (α × β) :=
+  by
+  refine' ⟨fun x => _⟩
+  obtain ⟨a, ha⟩ := isBounded_ge_nhds x.1
+  obtain ⟨b, hb⟩ := isBounded_ge_nhds x.2
+  rw [← @Prod.mk.eta _ _ x, nhds_prod_eq]
+  exact ⟨(a, b), ha.prod_mk hb⟩
+
+instance [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
+    [∀ i, BoundedGeNhdsClass (π i)] : BoundedGeNhdsClass (∀ i, π i) :=
+  by
+  refine' ⟨fun x => _⟩
+  rw [nhds_pi]
+  choose f hf using fun i => isBounded_ge_nhds (x i)
+  exact ⟨f, eventually_pi hf⟩
+
+end BoundedGeNhdsClass
+
+-- See note [lower instance priority]
+instance (priority := 100) OrderTop.to_boundedLeNhdsClass [OrderTop α] : BoundedLeNhdsClass α :=
+  ⟨fun a => isBounded_le_of_top⟩
+#align order_top.to_bounded_le_nhds_class OrderTop.to_boundedLeNhdsClass
+
+-- See note [lower instance priority]
+instance (priority := 100) OrderBot.to_boundedGeNhdsClass [OrderBot α] : BoundedGeNhdsClass α :=
+  ⟨fun a => isBounded_ge_of_bot⟩
+#align order_bot.to_bounded_ge_nhds_class OrderBot.to_boundedGeNhdsClass
+
+-- See note [lower instance priority]
+instance (priority := 100) OrderTopology.to_boundedLeNhdsClass [IsDirected α (· ≤ ·)]
+    [OrderTopology α] : BoundedLeNhdsClass α :=
+  ⟨fun a =>
+    ((isTop_or_exists_gt a).elim fun h => ⟨a, eventually_of_forall h⟩) <|
+      Exists.imp fun b => ge_mem_nhds⟩
+#align order_topology.to_bounded_le_nhds_class OrderTopology.to_boundedLeNhdsClass
+
+-- See note [lower instance priority]
+instance (priority := 100) OrderTopology.to_boundedGeNhdsClass [IsDirected α (· ≥ ·)]
+    [OrderTopology α] : BoundedGeNhdsClass α :=
+  ⟨fun a =>
+    ((isBot_or_exists_lt a).elim fun h => ⟨a, eventually_of_forall h⟩) <|
+      Exists.imp fun b => le_mem_nhds⟩
+#align order_topology.to_bounded_ge_nhds_class OrderTopology.to_boundedGeNhdsClass
+
+end Preorder
+
+section LiminfLimsup
 
 section ConditionallyCompleteLinearOrder
 
@@ -340,8 +427,8 @@ end LiminfLimsup
 
 section Monotone
 
-variable {ι R S : Type _} {F : Filter ι} [NeBot F] [CompleteLinearOrder R] [TopologicalSpace R]
-  [OrderTopology R] [CompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
+variable {F : Filter ι} [NeBot F] [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
+  [CompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
@@ -477,7 +564,7 @@ open scoped Topology
 
 open Filter Set
 
-variable {ι : Type _} {R : Type _} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
+variable [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
 #print iInf_eq_of_forall_le_of_tendsto /-
 theorem iInf_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (x_le : ∀ i, x ≤ as i) {F : Filter ι}
@@ -496,7 +583,7 @@ theorem iSup_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (le_x : ∀ i, a
 -/
 
 #print iUnion_Ici_eq_Ioi_of_lt_of_tendsto /-
-theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
+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 :=
   by
@@ -510,10 +597,10 @@ theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R}
 -/
 
 #print iUnion_Iic_eq_Iio_of_lt_of_tendsto /-
-theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
+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 :=
-  @iUnion_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
+  @iUnion_Ici_eq_Ioi_of_lt_of_tendsto ι Rᵒᵈ _ _ _ _ _ lt_x F _ as_lim
 #align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendsto
 -/
 
Diff
@@ -11,7 +11,7 @@ import Mathbin.Order.Filter.Archimedean
 import Mathbin.Order.Filter.CountableInter
 import Mathbin.Topology.Order.Basic
 
-#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"52932b3a083d4142e78a15dc928084a22fea9ba0"
+#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ffde2d8a6e689149e44fd95fa862c23a57f8c780"
 
 /-!
 # Lemmas about liminf and limsup in an order topology.
@@ -76,27 +76,6 @@ theorem Filter.Tendsto.isCoboundedUnder_ge {f : Filter β} {u : β → α} {a :
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
 -/
 
-#print isBounded_le_atBot /-
-theorem isBounded_le_atBot (α : Type _) [hα : Nonempty α] [Preorder α] :
-    (atBot : Filter α).IsBounded (· ≤ ·) :=
-  isBounded_iff.2 ⟨Set.Iic hα.some, mem_atBot _, hα.some, fun x hx => hx⟩
-#align is_bounded_le_at_bot isBounded_le_atBot
--/
-
-#print Filter.Tendsto.isBoundedUnder_le_atBot /-
-theorem Filter.Tendsto.isBoundedUnder_le_atBot {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
-    {u : β → α} (h : Tendsto u f atBot) : f.IsBoundedUnder (· ≤ ·) u :=
-  (isBounded_le_atBot α).mono h
-#align filter.tendsto.is_bounded_under_le_at_bot Filter.Tendsto.isBoundedUnder_le_atBot
--/
-
-#print bddAbove_range_of_tendsto_atTop_atBot /-
-theorem bddAbove_range_of_tendsto_atTop_atBot {α : Type _} [Nonempty α] [SemilatticeSup α]
-    {u : ℕ → α} (hx : Tendsto u atTop atBot) : BddAbove (Set.range u) :=
-  (Filter.Tendsto.isBoundedUnder_le_atBot hx).bddAbove_range
-#align bdd_above_range_of_tendsto_at_top_at_bot bddAbove_range_of_tendsto_atTop_atBot
--/
-
 end OrderClosedTopology
 
 section OrderClosedTopology
@@ -143,48 +122,12 @@ theorem Filter.Tendsto.isCoboundedUnder_le {f : Filter β} {u : β → α} {a :
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
 -/
 
-#print isBounded_ge_atTop /-
-theorem isBounded_ge_atTop (α : Type _) [hα : Nonempty α] [Preorder α] :
-    (atTop : Filter α).IsBounded (· ≥ ·) :=
-  isBounded_le_atBot αᵒᵈ
-#align is_bounded_ge_at_top isBounded_ge_atTop
--/
-
-#print Filter.Tendsto.isBoundedUnder_ge_atTop /-
-theorem Filter.Tendsto.isBoundedUnder_ge_atTop {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
-    {u : β → α} (h : Tendsto u f atTop) : f.IsBoundedUnder (· ≥ ·) u :=
-  (isBounded_ge_atTop α).mono h
-#align filter.tendsto.is_bounded_under_ge_at_top Filter.Tendsto.isBoundedUnder_ge_atTop
--/
-
-#print bddBelow_range_of_tendsto_atTop_atTop /-
-theorem bddBelow_range_of_tendsto_atTop_atTop {α : Type _} [Nonempty α] [SemilatticeInf α]
-    {u : ℕ → α} (hx : Tendsto u atTop atTop) : BddBelow (Set.range u) :=
-  (Filter.Tendsto.isBoundedUnder_ge_atTop hx).bddBelow_range
-#align bdd_below_range_of_tendsto_at_top_at_top bddBelow_range_of_tendsto_atTop_atTop
--/
-
 end OrderClosedTopology
 
 section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α]
 
-#print lt_mem_sets_of_limsSup_lt /-
-theorem lt_mem_sets_of_limsSup_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
-    ∀ᶠ a in f, a < b :=
-  let ⟨c, (h : ∀ᶠ a in f, a ≤ c), hcb⟩ := exists_lt_of_csInf_lt h l
-  mem_of_superset h fun a hac => lt_of_le_of_lt hac hcb
-#align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_lt
--/
-
-#print gt_mem_sets_of_limsInf_gt /-
-theorem gt_mem_sets_of_limsInf_gt :
-    ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a :=
-  @lt_mem_sets_of_limsSup_lt αᵒᵈ _
-#align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_limsInf_gt
--/
-
 variable [TopologicalSpace α] [OrderTopology α]
 
 #print le_nhds_of_limsSup_eq_limsInf /-
Diff
@@ -2,11 +2,6 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov
-
-! This file was ported from Lean 3 source module topology.algebra.order.liminf_limsup
-! leanprover-community/mathlib commit 52932b3a083d4142e78a15dc928084a22fea9ba0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.BigOperators.Intervals
 import Mathbin.Algebra.BigOperators.Order
@@ -16,6 +11,8 @@ import Mathbin.Order.Filter.Archimedean
 import Mathbin.Order.Filter.CountableInter
 import Mathbin.Topology.Order.Basic
 
+#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"52932b3a083d4142e78a15dc928084a22fea9ba0"
+
 /-!
 # Lemmas about liminf and limsup in an order topology.
 
Diff
@@ -86,10 +86,12 @@ theorem isBounded_le_atBot (α : Type _) [hα : Nonempty α] [Preorder α] :
 #align is_bounded_le_at_bot isBounded_le_atBot
 -/
 
+#print Filter.Tendsto.isBoundedUnder_le_atBot /-
 theorem Filter.Tendsto.isBoundedUnder_le_atBot {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
     {u : β → α} (h : Tendsto u f atBot) : f.IsBoundedUnder (· ≤ ·) u :=
   (isBounded_le_atBot α).mono h
 #align filter.tendsto.is_bounded_under_le_at_bot Filter.Tendsto.isBoundedUnder_le_atBot
+-/
 
 #print bddAbove_range_of_tendsto_atTop_atBot /-
 theorem bddAbove_range_of_tendsto_atTop_atBot {α : Type _} [Nonempty α] [SemilatticeSup α]
@@ -151,10 +153,12 @@ theorem isBounded_ge_atTop (α : Type _) [hα : Nonempty α] [Preorder α] :
 #align is_bounded_ge_at_top isBounded_ge_atTop
 -/
 
+#print Filter.Tendsto.isBoundedUnder_ge_atTop /-
 theorem Filter.Tendsto.isBoundedUnder_ge_atTop {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
     {u : β → α} (h : Tendsto u f atTop) : f.IsBoundedUnder (· ≥ ·) u :=
   (isBounded_ge_atTop α).mono h
 #align filter.tendsto.is_bounded_under_ge_at_top Filter.Tendsto.isBoundedUnder_ge_atTop
+-/
 
 #print bddBelow_range_of_tendsto_atTop_atTop /-
 theorem bddBelow_range_of_tendsto_atTop_atTop {α : Type _} [Nonempty α] [SemilatticeInf α]
@@ -186,6 +190,7 @@ theorem gt_mem_sets_of_limsInf_gt :
 
 variable [TopologicalSpace α] [OrderTopology α]
 
+#print le_nhds_of_limsSup_eq_limsInf /-
 /-- 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 (· ≤ ·))
@@ -194,6 +199,7 @@ theorem le_nhds_of_limsSup_eq_limsInf {f : Filter α} {a : α} (hl : f.IsBounded
     And.intro (fun b hb => gt_mem_sets_of_limsInf_gt hg <| hi.symm ▸ hb) fun b hb =>
       lt_mem_sets_of_limsSup_lt hl <| hs.symm ▸ hb
 #align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsSup_eq_limsInf
+-/
 
 #print limsSup_nhds /-
 theorem limsSup_nhds (a : α) : limsSup (𝓝 a) = a :=
@@ -213,6 +219,7 @@ theorem limsInf_nhds : ∀ a : α, limsInf (𝓝 a) = a :=
 #align Liminf_nhds limsInf_nhds
 -/
 
+#print limsInf_eq_of_le_nhds /-
 /-- 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 :=
   have hb_ge : IsBounded (· ≥ ·) f := (isBounded_ge_nhds a).mono h
@@ -226,11 +233,14 @@ theorem limsInf_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝
       a = (𝓝 a).limsInf := (limsInf_nhds a).symm
       _ ≤ f.limsInf := limsInf_le_limsInf_of_le h (isBounded_ge_nhds a) hb_le.isCobounded_flip)
 #align Liminf_eq_of_le_nhds limsInf_eq_of_le_nhds
+-/
 
+#print limsSup_eq_of_le_nhds /-
 /-- 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 :=
   @limsInf_eq_of_le_nhds αᵒᵈ _ _ _
 #align Limsup_eq_of_le_nhds limsSup_eq_of_le_nhds
+-/
 
 #print Filter.Tendsto.limsup_eq /-
 /-- If a function has a limit, then its limsup coincides with its limit. -/
@@ -367,6 +377,7 @@ section CompleteLinearOrder
 variable [CompleteLinearOrder α] [TopologicalSpace α] [FirstCountableTopology α] [OrderTopology α]
   {f : Filter β} [CountableInterFilter f] {u : β → α}
 
+#print limsup_eq_bot /-
 @[simp]
 theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
   ⟨fun h =>
@@ -374,11 +385,14 @@ theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
       le_antisymm hx bot_le,
     fun h => by rw [limsup_congr h]; exact limsup_const_bot⟩
 #align limsup_eq_bot limsup_eq_bot
+-/
 
+#print liminf_eq_top /-
 @[simp]
 theorem liminf_eq_top : f.liminf u = ⊤ ↔ u =ᶠ[f] ⊤ :=
   @limsup_eq_bot αᵒᵈ _ _ _ _ _ _ _ _
 #align liminf_eq_top liminf_eq_top
+-/
 
 end CompleteLinearOrder
 
@@ -391,6 +405,7 @@ variable {ι R S : Type _} {F : Filter ι} [NeBot F] [CompleteLinearOrder R] [To
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
+#print Antitone.map_limsSup_of_continuousAt /-
 /-- An antitone function between complete linear ordered spaces sends a `filter.Limsup`
 to the `filter.liminf` of the image if it is continuous at the `Limsup`. -/
 theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
@@ -448,14 +463,18 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
     have I : f m < F.liminf f := h'l ⟨l_m, m_lt.le⟩
     exact lt_irrefl _ (B.trans_lt I)
 #align antitone.map_Limsup_of_continuous_at Antitone.map_limsSup_of_continuousAt
+-/
 
+#print Antitone.map_limsup_of_continuousAt /-
 /-- A continuous antitone function between complete linear ordered spaces sends a `filter.limsup`
 to the `filter.liminf` of the images. -/
 theorem Antitone.map_limsup_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.limsup a)) : f (F.limsup a) = F.liminf (f ∘ a) :=
   f_decr.map_limsSup_of_continuousAt f_cont
 #align antitone.map_limsup_of_continuous_at Antitone.map_limsup_of_continuousAt
+-/
 
+#print Antitone.map_limsInf_of_continuousAt /-
 /-- An antitone function between complete linear ordered spaces sends a `filter.Liminf`
 to the `filter.limsup` of the image if it is continuous at the `Liminf`. -/
 theorem Antitone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
@@ -463,41 +482,52 @@ theorem Antitone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R →
   @Antitone.map_limsSup_of_continuousAt (OrderDual R) (OrderDual S) _ _ _ _ _ _ _ _ f f_decr.dual
     f_cont
 #align antitone.map_Liminf_of_continuous_at Antitone.map_limsInf_of_continuousAt
+-/
 
+#print Antitone.map_liminf_of_continuousAt /-
 /-- A continuous antitone function between complete linear ordered spaces sends a `filter.liminf`
 to the `filter.limsup` of the images. -/
 theorem Antitone.map_liminf_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.liminf a)) : f (F.liminf a) = F.limsup (f ∘ a) :=
   f_decr.map_limsInf_of_continuousAt f_cont
 #align antitone.map_liminf_of_continuous_at Antitone.map_liminf_of_continuousAt
+-/
 
+#print Monotone.map_limsSup_of_continuousAt /-
 /-- A monotone function between complete linear ordered spaces sends a `filter.Limsup`
 to the `filter.limsup` of the image if it is continuous at the `Limsup`. -/
 theorem Monotone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
     (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsSup) : f F.limsSup = F.limsup f :=
   @Antitone.map_limsSup_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
 #align monotone.map_Limsup_of_continuous_at Monotone.map_limsSup_of_continuousAt
+-/
 
+#print Monotone.map_limsup_of_continuousAt /-
 /-- A continuous monotone function between complete linear ordered spaces sends a `filter.limsup`
 to the `filter.limsup` of the images. -/
 theorem Monotone.map_limsup_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.limsup a)) : f (F.limsup a) = F.limsup (f ∘ a) :=
   f_incr.map_limsSup_of_continuousAt f_cont
 #align monotone.map_limsup_of_continuous_at Monotone.map_limsup_of_continuousAt
+-/
 
+#print Monotone.map_limsInf_of_continuousAt /-
 /-- A monotone function between complete linear ordered spaces sends a `filter.Liminf`
 to the `filter.liminf` of the image if it is continuous at the `Liminf`. -/
 theorem Monotone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
     (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsInf) : f F.limsInf = F.liminf f :=
   @Antitone.map_limsInf_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
 #align monotone.map_Liminf_of_continuous_at Monotone.map_limsInf_of_continuousAt
+-/
 
+#print Monotone.map_liminf_of_continuousAt /-
 /-- A continuous monotone function between complete linear ordered spaces sends a `filter.liminf`
 to the `filter.liminf` of the images. -/
 theorem Monotone.map_liminf_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.liminf a)) : f (F.liminf a) = F.liminf (f ∘ a) :=
   f_incr.map_limsInf_of_continuousAt f_cont
 #align monotone.map_liminf_of_continuous_at Monotone.map_liminf_of_continuousAt
+-/
 
 end Monotone
 
@@ -509,17 +539,21 @@ open Filter Set
 
 variable {ι : Type _} {R : Type _} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
+#print iInf_eq_of_forall_le_of_tendsto /-
 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 :=
   by
   refine' iInf_eq_of_forall_ge_of_forall_gt_exists_lt (fun i => x_le i) _
   apply fun w x_lt_w => ‹Filter.NeBot F›.nonempty_of_mem (eventually_lt_of_tendsto_lt x_lt_w as_lim)
 #align infi_eq_of_forall_le_of_tendsto iInf_eq_of_forall_le_of_tendsto
+-/
 
+#print iSup_eq_of_forall_le_of_tendsto /-
 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 :=
   @iInf_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
 #align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
+-/
 
 #print iUnion_Ici_eq_Ioi_of_lt_of_tendsto /-
 theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
@@ -549,6 +583,7 @@ section Indicator
 
 open scoped BigOperators
 
+#print limsup_eq_tendsto_sum_indicator_nat_atTop /-
 theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     limsup s atTop =
       {ω |
@@ -621,7 +656,9 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
         exact Set.indicator_of_not_mem (hcon _ <| (Finset.mem_Ico.1 hm).1.trans m.le_succ) _
     exact not_le.2 (lt_of_lt_of_le i.lt_succ_self <| h _ le_rfl) this
 #align limsup_eq_tendsto_sum_indicator_nat_at_top limsup_eq_tendsto_sum_indicator_nat_atTop
+-/
 
+#print limsup_eq_tendsto_sum_indicator_atTop /-
 theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type _) [StrictOrderedSemiring R] [Archimedean R]
     (s : ℕ → Set α) :
     limsup s atTop =
@@ -639,6 +676,7 @@ theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type _) [StrictOrderedSemirin
   · ext n
     simp only [Set.indicator, Pi.one_apply, Finset.sum_boole, Nat.cast_id]
 #align limsup_eq_tendsto_sum_indicator_at_top limsup_eq_tendsto_sum_indicator_atTop
+-/
 
 end Indicator
 
Diff
@@ -582,8 +582,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
       push_neg at hk 
       obtain ⟨i, hi⟩ := hk
       obtain ⟨j, hj₁, hj₂⟩ := hω (i + 1)
-      replace hi : (∑ k in Finset.range i, (s (k + 1)).indicator 1 ω) = k + 1 :=
-        le_antisymm (h i) hi
+      replace hi : ∑ k in Finset.range i, (s (k + 1)).indicator 1 ω = k + 1 := le_antisymm (h i) hi
       refine' not_lt.2 (h <| j + 1) _
       rw [← Finset.sum_range_add_sum_Ico _ (i.le_succ.trans (hj₁.trans j.le_succ)), hi]
       refine' lt_add_of_pos_right _ _
@@ -603,9 +602,9 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     by_contra hcon
     push_neg at hcon 
     obtain ⟨j, h⟩ := hω (i + 1)
-    have : (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i :=
+    have : ∑ k in Finset.range j, (s (k + 1)).indicator 1 ω ≤ i :=
       by
-      have hle : ∀ j ≤ i, (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i :=
+      have hle : ∀ j ≤ i, ∑ k in Finset.range j, (s (k + 1)).indicator 1 ω ≤ i :=
         by
         refine' fun j hij =>
           (Finset.sum_le_card_nsmul _ _ _ _ : _ ≤ (Finset.range j).card • 1).trans _
@@ -614,7 +613,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
       by_cases hij : j < i
       · exact hle _ hij.le
       · rw [← Finset.sum_range_add_sum_Ico _ (not_lt.1 hij)]
-        suffices (∑ k in Finset.Ico i j, (s (k + 1)).indicator 1 ω) = 0
+        suffices ∑ k in Finset.Ico i j, (s (k + 1)).indicator 1 ω = 0
           by
           rw [this, add_zero]
           exact hle _ le_rfl
Diff
@@ -221,12 +221,10 @@ theorem limsInf_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝
     (calc
       f.limsInf ≤ f.limsSup := limsInf_le_limsSup hb_le hb_ge
       _ ≤ (𝓝 a).limsSup := (limsSup_le_limsSup_of_le h hb_ge.isCobounded_flip (isBounded_le_nhds a))
-      _ = a := limsSup_nhds a
-      )
+      _ = a := limsSup_nhds a)
     (calc
       a = (𝓝 a).limsInf := (limsInf_nhds a).symm
-      _ ≤ f.limsInf := limsInf_le_limsInf_of_le h (isBounded_ge_nhds a) hb_le.isCobounded_flip
-      )
+      _ ≤ f.limsInf := limsInf_le_limsInf_of_le h (isBounded_ge_nhds a) hb_le.isCobounded_flip)
 #align Liminf_eq_of_le_nhds limsInf_eq_of_le_nhds
 
 /-- If a filter is converging, its liminf coincides with its limit. -/
Diff
@@ -198,9 +198,9 @@ theorem le_nhds_of_limsSup_eq_limsInf {f : Filter α} {a : α} (hl : f.IsBounded
 #print limsSup_nhds /-
 theorem limsSup_nhds (a : α) : limsSup (𝓝 a) = a :=
   csInf_eq_of_forall_ge_of_forall_gt_exists_lt (isBounded_le_nhds a)
-    (fun a' (h : { n : α | n ≤ a' } ∈ 𝓝 a) => show a ≤ a' from @mem_of_mem_nhds α _ a _ h)
+    (fun a' (h : {n : α | n ≤ a'} ∈ 𝓝 a) => show a ≤ a' from @mem_of_mem_nhds α _ a _ h)
     fun b (hba : a < b) =>
-    show ∃ (c : _) (h : { n : α | n ≤ c } ∈ 𝓝 a), c < b from
+    show ∃ (c : _) (h : {n : α | n ≤ c} ∈ 𝓝 a), c < b from
       match dense_or_discrete a b with
       | Or.inl ⟨c, hac, hcb⟩ => ⟨c, ge_mem_nhds hac, hcb⟩
       | Or.inr ⟨_, h⟩ => ⟨a, (𝓝 a).sets_of_superset (gt_mem_nhds hba) h, hba⟩
@@ -345,7 +345,7 @@ theorem eventually_le_limsup
       simp only [IsGLB, IsGreatest, lowerBounds, upperBounds, Set.mem_Ioi, Set.mem_setOf_eq,
         not_and, not_forall, not_le, exists_prop] at H 
       exact H fun x hx => le_of_lt hx
-    filter_upwards [eventually_lt_of_limsup_lt xa hf]with y hy
+    filter_upwards [eventually_lt_of_limsup_lt xa hf] with y hy
     contrapose! hy
     exact hx hy
 #align eventually_le_limsup eventually_le_limsup
@@ -399,7 +399,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
     (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsSup) : f F.limsSup = F.liminf f :=
   by
   apply le_antisymm
-  · have A : { a : R | ∀ᶠ n : R in F, n ≤ a }.Nonempty := ⟨⊤, by simp⟩
+  · have A : {a : R | ∀ᶠ n : R in F, n ≤ a}.Nonempty := ⟨⊤, by simp⟩
     rw [Limsup, f_decr.map_Inf_of_continuous_at' f_cont A]
     apply le_of_forall_lt
     intro c hc
@@ -407,7 +407,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
       Set.mem_image, exists_exists_and_eq_and] at hc ⊢
     rcases hc with ⟨d, hd, h'd⟩
     refine' ⟨f d, _, h'd⟩
-    filter_upwards [hd]with x hx using f_decr hx
+    filter_upwards [hd] with x hx using f_decr hx
   · rcases eq_or_lt_of_le (bot_le : ⊥ ≤ F.Limsup) with (h | Limsup_ne_bot)
     · rw [← h]
       apply liminf_le_of_frequently_le
@@ -431,7 +431,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
       apply liminf_le_of_frequently_le
       exact B.mono fun x hx => f_decr hx
     by_contra' H
-    obtain ⟨l, l_lt, h'l⟩ : ∃ l < F.Limsup, Set.Ioc l F.Limsup ⊆ { x : R | f x < F.liminf f }
+    obtain ⟨l, l_lt, h'l⟩ : ∃ l < F.Limsup, Set.Ioc l F.Limsup ⊆ {x : R | f x < F.liminf f}
     exact exists_Ioc_subset_of_mem_nhds ((tendsto_order.1 f_cont.tendsto).2 _ H) ⟨⊥, Limsup_ne_bot⟩
     obtain ⟨m, l_m, m_lt⟩ : (Set.Ioo l F.Limsup).Nonempty :=
       by
@@ -553,9 +553,9 @@ open scoped BigOperators
 
 theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     limsup s atTop =
-      { ω |
+      {ω |
         Tendsto (fun n => ∑ k in Finset.range n, (s (k + 1)).indicator (1 : α → ℕ) ω) atTop
-          atTop } :=
+          atTop} :=
   by
   ext ω
   simp only [limsup_eq_infi_supr_of_nat, ge_iff_le, Set.iSup_eq_iUnion, Set.iInf_eq_iInter,
@@ -581,7 +581,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
       rw [Nat.sub_add_cancel hj₁, Set.indicator_of_mem hj₂]
       exact zero_lt_one
     · rw [imp_false] at hk 
-      push_neg  at hk 
+      push_neg at hk 
       obtain ⟨i, hi⟩ := hk
       obtain ⟨j, hj₁, hj₂⟩ := hω (i + 1)
       replace hi : (∑ k in Finset.range i, (s (k + 1)).indicator 1 ω) = k + 1 :=
@@ -603,7 +603,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
   · rintro hω i
     rw [Set.mem_setOf_eq, tendsto_at_top_at_top] at hω 
     by_contra hcon
-    push_neg  at hcon 
+    push_neg at hcon 
     obtain ⟨j, h⟩ := hω (i + 1)
     have : (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i :=
       by
@@ -628,9 +628,9 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
 theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type _) [StrictOrderedSemiring R] [Archimedean R]
     (s : ℕ → Set α) :
     limsup s atTop =
-      { ω |
+      {ω |
         Tendsto (fun n => ∑ k in Finset.range n, (s (k + 1)).indicator (1 : α → R) ω) atTop
-          atTop } :=
+          atTop} :=
   by
   rw [limsup_eq_tendsto_sum_indicator_nat_atTop s]
   ext ω
Diff
@@ -200,7 +200,7 @@ theorem limsSup_nhds (a : α) : limsSup (𝓝 a) = a :=
   csInf_eq_of_forall_ge_of_forall_gt_exists_lt (isBounded_le_nhds a)
     (fun a' (h : { n : α | n ≤ a' } ∈ 𝓝 a) => show a ≤ a' from @mem_of_mem_nhds α _ a _ h)
     fun b (hba : a < b) =>
-    show ∃ (c : _)(h : { n : α | n ≤ c } ∈ 𝓝 a), c < b from
+    show ∃ (c : _) (h : { n : α | n ≤ c } ∈ 𝓝 a), c < b from
       match dense_or_discrete a b with
       | Or.inl ⟨c, hac, hcb⟩ => ⟨c, ge_mem_nhds hac, hcb⟩
       | Or.inr ⟨_, h⟩ => ⟨a, (𝓝 a).sets_of_superset (gt_mem_nhds hba) h, hba⟩
@@ -343,7 +343,7 @@ theorem eventually_le_limsup
   · obtain ⟨x, hx, xa⟩ : ∃ x, (∀ ⦃b⦄, f.limsup u < b → x ≤ b) ∧ f.limsup u < x :=
       by
       simp only [IsGLB, IsGreatest, lowerBounds, upperBounds, Set.mem_Ioi, Set.mem_setOf_eq,
-        not_and, not_forall, not_le, exists_prop] at H
+        not_and, not_forall, not_le, exists_prop] at H 
       exact H fun x hx => le_of_lt hx
     filter_upwards [eventually_lt_of_limsup_lt xa hf]with y hy
     contrapose! hy
@@ -404,7 +404,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
     apply le_of_forall_lt
     intro c hc
     simp only [liminf, Liminf, lt_sSup_iff, eventually_map, Set.mem_setOf_eq, exists_prop,
-      Set.mem_image, exists_exists_and_eq_and] at hc⊢
+      Set.mem_image, exists_exists_and_eq_and] at hc ⊢
     rcases hc with ⟨d, hd, h'd⟩
     refine' ⟨f d, _, h'd⟩
     filter_upwards [hd]with x hx using f_decr hx
@@ -436,7 +436,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
     obtain ⟨m, l_m, m_lt⟩ : (Set.Ioo l F.Limsup).Nonempty :=
       by
       contrapose! h'
-      refine' ⟨l, l_lt, by rwa [Set.not_nonempty_iff_eq_empty] at h'⟩
+      refine' ⟨l, l_lt, by rwa [Set.not_nonempty_iff_eq_empty] at h' ⟩
     have B : F.liminf f ≤ f m := by
       apply liminf_le_of_frequently_le
       apply
@@ -569,7 +569,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
             (Finset.range_mono hnm))
         _
     rintro ⟨i, h⟩
-    simp only [mem_upperBounds, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff'] at h
+    simp only [mem_upperBounds, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff'] at h 
     induction' i with k hk
     · obtain ⟨j, hj₁, hj₂⟩ := hω 1
       refine'
@@ -580,8 +580,8 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
           ⟨j - 1, Finset.mem_range.2 (lt_of_le_of_lt (Nat.sub_le _ _) j.lt_succ_self), _⟩
       rw [Nat.sub_add_cancel hj₁, Set.indicator_of_mem hj₂]
       exact zero_lt_one
-    · rw [imp_false] at hk
-      push_neg  at hk
+    · rw [imp_false] at hk 
+      push_neg  at hk 
       obtain ⟨i, hi⟩ := hk
       obtain ⟨j, hj₁, hj₂⟩ := hω (i + 1)
       replace hi : (∑ k in Finset.range i, (s (k + 1)).indicator 1 ω) = k + 1 :=
@@ -601,9 +601,9 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
         Set.indicator_of_mem hj₂]
       exact zero_lt_one
   · rintro hω i
-    rw [Set.mem_setOf_eq, tendsto_at_top_at_top] at hω
+    rw [Set.mem_setOf_eq, tendsto_at_top_at_top] at hω 
     by_contra hcon
-    push_neg  at hcon
+    push_neg  at hcon 
     obtain ⟨j, h⟩ := hω (i + 1)
     have : (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i :=
       by
Diff
@@ -26,7 +26,7 @@ import Mathbin.Topology.Order.Basic
 
 open Filter TopologicalSpace
 
-open Topology Classical
+open scoped Topology Classical
 
 universe u v
 
@@ -38,15 +38,19 @@ section OrderClosedTopology
 
 variable [SemilatticeSup α] [TopologicalSpace α] [OrderTopology α]
 
+#print isBounded_le_nhds /-
 theorem isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·) :=
   (isTop_or_exists_gt a).elim (fun h => ⟨a, eventually_of_forall h⟩) fun ⟨b, hb⟩ =>
     ⟨b, ge_mem_nhds hb⟩
 #align is_bounded_le_nhds isBounded_le_nhds
+-/
 
+#print Filter.Tendsto.isBoundedUnder_le /-
 theorem Filter.Tendsto.isBoundedUnder_le {f : Filter β} {u : β → α} {a : α}
     (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≤ ·) u :=
   (isBounded_le_nhds a).mono h
 #align filter.tendsto.is_bounded_under_le Filter.Tendsto.isBoundedUnder_le
+-/
 
 #print Filter.Tendsto.bddAbove_range_of_cofinite /-
 theorem Filter.Tendsto.bddAbove_range_of_cofinite {u : β → α} {a : α}
@@ -62,19 +66,25 @@ theorem Filter.Tendsto.bddAbove_range {u : ℕ → α} {a : α} (h : Tendsto u a
 #align filter.tendsto.bdd_above_range Filter.Tendsto.bddAbove_range
 -/
 
+#print isCobounded_ge_nhds /-
 theorem isCobounded_ge_nhds (a : α) : (𝓝 a).IsCobounded (· ≥ ·) :=
   (isBounded_le_nhds a).isCobounded_flip
 #align is_cobounded_ge_nhds isCobounded_ge_nhds
+-/
 
+#print Filter.Tendsto.isCoboundedUnder_ge /-
 theorem Filter.Tendsto.isCoboundedUnder_ge {f : Filter β} {u : β → α} {a : α} [NeBot f]
     (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≥ ·) u :=
   h.isBoundedUnder_le.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
+-/
 
+#print isBounded_le_atBot /-
 theorem isBounded_le_atBot (α : Type _) [hα : Nonempty α] [Preorder α] :
     (atBot : Filter α).IsBounded (· ≤ ·) :=
   isBounded_iff.2 ⟨Set.Iic hα.some, mem_atBot _, hα.some, fun x hx => hx⟩
 #align is_bounded_le_at_bot isBounded_le_atBot
+-/
 
 theorem Filter.Tendsto.isBoundedUnder_le_atBot {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
     {u : β → α} (h : Tendsto u f atBot) : f.IsBoundedUnder (· ≤ ·) u :=
@@ -94,14 +104,18 @@ section OrderClosedTopology
 
 variable [SemilatticeInf α] [TopologicalSpace α] [OrderTopology α]
 
+#print isBounded_ge_nhds /-
 theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·) :=
   @isBounded_le_nhds αᵒᵈ _ _ _ a
 #align is_bounded_ge_nhds isBounded_ge_nhds
+-/
 
+#print Filter.Tendsto.isBoundedUnder_ge /-
 theorem Filter.Tendsto.isBoundedUnder_ge {f : Filter β} {u : β → α} {a : α}
     (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≥ ·) u :=
   (isBounded_ge_nhds a).mono h
 #align filter.tendsto.is_bounded_under_ge Filter.Tendsto.isBoundedUnder_ge
+-/
 
 #print Filter.Tendsto.bddBelow_range_of_cofinite /-
 theorem Filter.Tendsto.bddBelow_range_of_cofinite {u : β → α} {a : α}
@@ -117,19 +131,25 @@ theorem Filter.Tendsto.bddBelow_range {u : ℕ → α} {a : α} (h : Tendsto u a
 #align filter.tendsto.bdd_below_range Filter.Tendsto.bddBelow_range
 -/
 
+#print isCobounded_le_nhds /-
 theorem isCobounded_le_nhds (a : α) : (𝓝 a).IsCobounded (· ≤ ·) :=
   (isBounded_ge_nhds a).isCobounded_flip
 #align is_cobounded_le_nhds isCobounded_le_nhds
+-/
 
+#print Filter.Tendsto.isCoboundedUnder_le /-
 theorem Filter.Tendsto.isCoboundedUnder_le {f : Filter β} {u : β → α} {a : α} [NeBot f]
     (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≤ ·) u :=
   h.isBoundedUnder_ge.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
+-/
 
+#print isBounded_ge_atTop /-
 theorem isBounded_ge_atTop (α : Type _) [hα : Nonempty α] [Preorder α] :
     (atTop : Filter α).IsBounded (· ≥ ·) :=
   isBounded_le_atBot αᵒᵈ
 #align is_bounded_ge_at_top isBounded_ge_atTop
+-/
 
 theorem Filter.Tendsto.isBoundedUnder_ge_atTop {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
     {u : β → α} (h : Tendsto u f atTop) : f.IsBoundedUnder (· ≥ ·) u :=
@@ -149,16 +169,20 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α]
 
+#print lt_mem_sets_of_limsSup_lt /-
 theorem lt_mem_sets_of_limsSup_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
     ∀ᶠ a in f, a < b :=
   let ⟨c, (h : ∀ᶠ a in f, a ≤ c), hcb⟩ := exists_lt_of_csInf_lt h l
   mem_of_superset h fun a hac => lt_of_le_of_lt hac hcb
 #align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_lt
+-/
 
+#print gt_mem_sets_of_limsInf_gt /-
 theorem gt_mem_sets_of_limsInf_gt :
     ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a :=
   @lt_mem_sets_of_limsSup_lt αᵒᵈ _
 #align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_limsInf_gt
+-/
 
 variable [TopologicalSpace α] [OrderTopology α]
 
@@ -228,6 +252,7 @@ theorem Filter.Tendsto.liminf_eq {f : Filter β} {u : β → α} {a : α} [NeBot
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+#print tendsto_of_liminf_eq_limsup /-
 /-- 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)
@@ -241,9 +266,11 @@ theorem tendsto_of_liminf_eq_limsup {f : Filter β} {u : β → α} {a : α} (hi
     Tendsto u f (𝓝 a) :=
   le_nhds_of_limsSup_eq_limsInf h h' hsup hinf
 #align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsup
+-/
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+#print tendsto_of_le_liminf_of_limsup_le /-
 /-- 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)
@@ -261,9 +288,11 @@ theorem tendsto_of_le_liminf_of_limsup_le {f : Filter β} {u : β → α} {a : 
     tendsto_of_liminf_eq_limsup (le_antisymm (le_trans (liminf_le_limsup h h') hsup) hinf)
       (le_antisymm hsup (le_trans hinf (liminf_le_limsup h h'))) h h'
 #align tendsto_of_le_liminf_of_limsup_le tendsto_of_le_liminf_of_limsup_le
+-/
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+#print tendsto_of_no_upcrossings /-
 /-- 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.
@@ -291,10 +320,12 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
   have B : ∃ᶠ n in f, b < u n := frequently_lt_of_lt_limsup (is_bounded.is_cobounded_le h') bu
   exact H a as b bs ab ⟨A, B⟩
 #align tendsto_of_no_upcrossings tendsto_of_no_upcrossings
+-/
 
 variable [FirstCountableTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+#print eventually_le_limsup /-
 theorem eventually_le_limsup
     (hf : IsBoundedUnder (· ≤ ·) f u := by
       run_tac
@@ -318,8 +349,10 @@ theorem eventually_le_limsup
     contrapose! hy
     exact hx hy
 #align eventually_le_limsup eventually_le_limsup
+-/
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+#print eventually_liminf_le /-
 theorem eventually_liminf_le
     (hf : IsBoundedUnder (· ≥ ·) f u := by
       run_tac
@@ -327,6 +360,7 @@ theorem eventually_liminf_le
     ∀ᶠ b in f, f.liminf u ≤ u b :=
   @eventually_le_limsup αᵒᵈ _ _ _ _ _ _ _ _ hf
 #align eventually_liminf_le eventually_liminf_le
+-/
 
 end ConditionallyCompleteLinearOrder
 
@@ -471,7 +505,7 @@ end Monotone
 
 section InfiAndSupr
 
-open Topology
+open scoped Topology
 
 open Filter Set
 
@@ -489,6 +523,7 @@ theorem iSup_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (le_x : ∀ i, a
   @iInf_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
 #align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
+#print iUnion_Ici_eq_Ioi_of_lt_of_tendsto /-
 theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (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 :=
@@ -500,18 +535,21 @@ theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R}
   rw [← iInf_eq_of_forall_le_of_tendsto (fun i => (x_lt i).le) as_lim] at *
   exact iUnion_Ici_eq_Ioi_iInf obs
 #align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendsto
+-/
 
+#print iUnion_Iic_eq_Iio_of_lt_of_tendsto /-
 theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (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 :=
   @iUnion_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
 #align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendsto
+-/
 
 end InfiAndSupr
 
 section Indicator
 
-open BigOperators
+open scoped BigOperators
 
 theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     limsup s atTop =
Diff
@@ -38,23 +38,11 @@ section OrderClosedTopology
 
 variable [SemilatticeSup α] [TopologicalSpace α] [OrderTopology α]
 
-/- warning: is_bounded_le_nhds -> isBounded_le_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (nhds.{u1} α _inst_2 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.52 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.54 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.52 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.54) (nhds.{u1} α _inst_2 a)
-Case conversion may be inaccurate. Consider using '#align is_bounded_le_nhds isBounded_le_nhdsₓ'. -/
 theorem isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·) :=
   (isTop_or_exists_gt a).elim (fun h => ⟨a, eventually_of_forall h⟩) fun ⟨b, hb⟩ =>
     ⟨b, ge_mem_nhds hb⟩
 #align is_bounded_le_nhds isBounded_le_nhds
 
-/- warning: filter.tendsto.is_bounded_under_le -> Filter.Tendsto.isBoundedUnder_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) f u)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.140 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.142 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.140 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.142) f u)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_bounded_under_le Filter.Tendsto.isBoundedUnder_leₓ'. -/
 theorem Filter.Tendsto.isBoundedUnder_le {f : Filter β} {u : β → α} {a : α}
     (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≤ ·) u :=
   (isBounded_le_nhds a).mono h
@@ -74,44 +62,20 @@ theorem Filter.Tendsto.bddAbove_range {u : ℕ → α} {a : α} (h : Tendsto u a
 #align filter.tendsto.bdd_above_range Filter.Tendsto.bddAbove_range
 -/
 
-/- warning: is_cobounded_ge_nhds -> isCobounded_ge_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsCobounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (nhds.{u1} α _inst_2 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsCobounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.261 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.263 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.261 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.263) (nhds.{u1} α _inst_2 a)
-Case conversion may be inaccurate. Consider using '#align is_cobounded_ge_nhds isCobounded_ge_nhdsₓ'. -/
 theorem isCobounded_ge_nhds (a : α) : (𝓝 a).IsCobounded (· ≥ ·) :=
   (isBounded_le_nhds a).isCobounded_flip
 #align is_cobounded_ge_nhds isCobounded_ge_nhds
 
-/- warning: filter.tendsto.is_cobounded_under_ge -> Filter.Tendsto.isCoboundedUnder_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α} [_inst_4 : Filter.NeBot.{u2} β f], (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsCoboundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) f u)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α} [_inst_4 : Filter.NeBot.{u2} β f], (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsCoboundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.317 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.319 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.317 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.319) f u)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_geₓ'. -/
 theorem Filter.Tendsto.isCoboundedUnder_ge {f : Filter β} {u : β → α} {a : α} [NeBot f]
     (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≥ ·) u :=
   h.isBoundedUnder_le.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
 
-/- warning: is_bounded_le_at_bot -> isBounded_le_atBot is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [hα : Nonempty.{succ u1} α] [_inst_4 : Preorder.{u1} α], Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_4)) (Filter.atBot.{u1} α _inst_4)
-but is expected to have type
-  forall (α : Type.{u1}) [hα : Nonempty.{succ u1} α] [_inst_4 : Preorder.{u1} α], Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.360 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.362 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_4) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.360 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.362) (Filter.atBot.{u1} α _inst_4)
-Case conversion may be inaccurate. Consider using '#align is_bounded_le_at_bot isBounded_le_atBotₓ'. -/
 theorem isBounded_le_atBot (α : Type _) [hα : Nonempty α] [Preorder α] :
     (atBot : Filter α).IsBounded (· ≤ ·) :=
   isBounded_iff.2 ⟨Set.Iic hα.some, mem_atBot _, hα.some, fun x hx => hx⟩
 #align is_bounded_le_at_bot isBounded_le_atBot
 
-/- warning: filter.tendsto.is_bounded_under_le_at_bot -> Filter.Tendsto.isBoundedUnder_le_atBot is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} {α : Type.{u2}} [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : Preorder.{u2} α] {f : Filter.{u1} β} {u : β -> α}, (Filter.Tendsto.{u1, u2} β α u f (Filter.atBot.{u2} α _inst_5)) -> (Filter.IsBoundedUnder.{u2, u1} α β (LE.le.{u2} α (Preorder.toHasLe.{u2} α _inst_5)) f u)
-but is expected to have type
-  forall {β : Type.{u2}} {α : Type.{u1}} [_inst_4 : Nonempty.{succ u1} α] [_inst_5 : Preorder.{u1} α] {f : Filter.{u2} β} {u : β -> α}, (Filter.Tendsto.{u2, u1} β α u f (Filter.atBot.{u1} α _inst_5)) -> (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.426 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.428 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_5) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.426 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.428) f u)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_bounded_under_le_at_bot Filter.Tendsto.isBoundedUnder_le_atBotₓ'. -/
 theorem Filter.Tendsto.isBoundedUnder_le_atBot {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
     {u : β → α} (h : Tendsto u f atBot) : f.IsBoundedUnder (· ≤ ·) u :=
   (isBounded_le_atBot α).mono h
@@ -130,22 +94,10 @@ section OrderClosedTopology
 
 variable [SemilatticeInf α] [TopologicalSpace α] [OrderTopology α]
 
-/- warning: is_bounded_ge_nhds -> isBounded_ge_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (nhds.{u1} α _inst_2 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.527 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.529 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.527 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.529) (nhds.{u1} α _inst_2 a)
-Case conversion may be inaccurate. Consider using '#align is_bounded_ge_nhds isBounded_ge_nhdsₓ'. -/
 theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·) :=
   @isBounded_le_nhds αᵒᵈ _ _ _ a
 #align is_bounded_ge_nhds isBounded_ge_nhds
 
-/- warning: filter.tendsto.is_bounded_under_ge -> Filter.Tendsto.isBoundedUnder_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) f u)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.581 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.583 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.581 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.583) f u)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_bounded_under_ge Filter.Tendsto.isBoundedUnder_geₓ'. -/
 theorem Filter.Tendsto.isBoundedUnder_ge {f : Filter β} {u : β → α} {a : α}
     (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≥ ·) u :=
   (isBounded_ge_nhds a).mono h
@@ -165,44 +117,20 @@ theorem Filter.Tendsto.bddBelow_range {u : ℕ → α} {a : α} (h : Tendsto u a
 #align filter.tendsto.bdd_below_range Filter.Tendsto.bddBelow_range
 -/
 
-/- warning: is_cobounded_le_nhds -> isCobounded_le_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsCobounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (nhds.{u1} α _inst_2 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsCobounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.702 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.704 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.702 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.704) (nhds.{u1} α _inst_2 a)
-Case conversion may be inaccurate. Consider using '#align is_cobounded_le_nhds isCobounded_le_nhdsₓ'. -/
 theorem isCobounded_le_nhds (a : α) : (𝓝 a).IsCobounded (· ≤ ·) :=
   (isBounded_ge_nhds a).isCobounded_flip
 #align is_cobounded_le_nhds isCobounded_le_nhds
 
-/- warning: filter.tendsto.is_cobounded_under_le -> Filter.Tendsto.isCoboundedUnder_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α} [_inst_4 : Filter.NeBot.{u2} β f], (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsCoboundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) f u)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α} [_inst_4 : Filter.NeBot.{u2} β f], (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsCoboundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.758 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.760 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.758 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.760) f u)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_leₓ'. -/
 theorem Filter.Tendsto.isCoboundedUnder_le {f : Filter β} {u : β → α} {a : α} [NeBot f]
     (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≤ ·) u :=
   h.isBoundedUnder_ge.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
 
-/- warning: is_bounded_ge_at_top -> isBounded_ge_atTop is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [hα : Nonempty.{succ u1} α] [_inst_4 : Preorder.{u1} α], Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α _inst_4)) (Filter.atTop.{u1} α _inst_4)
-but is expected to have type
-  forall (α : Type.{u1}) [hα : Nonempty.{succ u1} α] [_inst_4 : Preorder.{u1} α], Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.802 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.804 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α _inst_4) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.802 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.804) (Filter.atTop.{u1} α _inst_4)
-Case conversion may be inaccurate. Consider using '#align is_bounded_ge_at_top isBounded_ge_atTopₓ'. -/
 theorem isBounded_ge_atTop (α : Type _) [hα : Nonempty α] [Preorder α] :
     (atTop : Filter α).IsBounded (· ≥ ·) :=
   isBounded_le_atBot αᵒᵈ
 #align is_bounded_ge_at_top isBounded_ge_atTop
 
-/- warning: filter.tendsto.is_bounded_under_ge_at_top -> Filter.Tendsto.isBoundedUnder_ge_atTop is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} {α : Type.{u2}} [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : Preorder.{u2} α] {f : Filter.{u1} β} {u : β -> α}, (Filter.Tendsto.{u1, u2} β α u f (Filter.atTop.{u2} α _inst_5)) -> (Filter.IsBoundedUnder.{u2, u1} α β (GE.ge.{u2} α (Preorder.toHasLe.{u2} α _inst_5)) f u)
-but is expected to have type
-  forall {β : Type.{u2}} {α : Type.{u1}} [_inst_4 : Nonempty.{succ u1} α] [_inst_5 : Preorder.{u1} α] {f : Filter.{u2} β} {u : β -> α}, (Filter.Tendsto.{u2, u1} β α u f (Filter.atTop.{u1} α _inst_5)) -> (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.855 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.857 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α _inst_5) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.855 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.857) f u)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_bounded_under_ge_at_top Filter.Tendsto.isBoundedUnder_ge_atTopₓ'. -/
 theorem Filter.Tendsto.isBoundedUnder_ge_atTop {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
     {u : β → α} (h : Tendsto u f atTop) : f.IsBoundedUnder (· ≥ ·) u :=
   (isBounded_ge_atTop α).mono h
@@ -221,24 +149,12 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α]
 
-/- warning: lt_mem_sets_of_Limsup_lt -> lt_mem_sets_of_limsSup_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : Filter.{u1} α} {b : α}, (Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) b) -> (Filter.Eventually.{u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a b) f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : Filter.{u1} α} {b : α}, (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.937 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.939 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.937 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.939) f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) b) -> (Filter.Eventually.{u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a b) f)
-Case conversion may be inaccurate. Consider using '#align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_ltₓ'. -/
 theorem lt_mem_sets_of_limsSup_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
     ∀ᶠ a in f, a < b :=
   let ⟨c, (h : ∀ᶠ a in f, a ≤ c), hcb⟩ := exists_lt_of_csInf_lt h l
   mem_of_superset h fun a hac => lt_of_le_of_lt hac hcb
 #align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_lt
 
-/- warning: gt_mem_sets_of_Liminf_gt -> gt_mem_sets_of_limsInf_gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : Filter.{u1} α} {b : α}, (Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f)) -> (Filter.Eventually.{u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b a) f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : Filter.{u1} α} {b : α}, (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1060 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1062 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1060 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1062) f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f)) -> (Filter.Eventually.{u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b a) f)
-Case conversion may be inaccurate. Consider using '#align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_limsInf_gtₓ'. -/
 theorem gt_mem_sets_of_limsInf_gt :
     ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a :=
   @lt_mem_sets_of_limsSup_lt αᵒᵈ _
@@ -246,12 +162,6 @@ theorem gt_mem_sets_of_limsInf_gt :
 
 variable [TopologicalSpace α] [OrderTopology α]
 
-/- warning: le_nhds_of_Limsup_eq_Liminf -> le_nhds_of_limsSup_eq_limsInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1145 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1147 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1145 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1147) f) -> (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1161 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1163 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1161 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1163) f) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a))
-Case conversion may be inaccurate. Consider using '#align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsSup_eq_limsInfₓ'. -/
 /-- 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 (· ≤ ·))
@@ -279,12 +189,6 @@ theorem limsInf_nhds : ∀ a : α, limsInf (𝓝 a) = a :=
 #align Liminf_nhds limsInf_nhds
 -/
 
-/- warning: Liminf_eq_of_le_nhds -> limsInf_eq_of_le_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
-Case conversion may be inaccurate. Consider using '#align Liminf_eq_of_le_nhds limsInf_eq_of_le_nhdsₓ'. -/
 /-- 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 :=
   have hb_ge : IsBounded (· ≥ ·) f := (isBounded_ge_nhds a).mono h
@@ -301,12 +205,6 @@ theorem limsInf_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝
       )
 #align Liminf_eq_of_le_nhds limsInf_eq_of_le_nhds
 
-/- warning: Limsup_eq_of_le_nhds -> limsSup_eq_of_le_nhds is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
-Case conversion may be inaccurate. Consider using '#align Limsup_eq_of_le_nhds limsSup_eq_of_le_nhdsₓ'. -/
 /-- 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 :=
   @limsInf_eq_of_le_nhds αᵒᵈ _ _ _
@@ -328,9 +226,6 @@ theorem Filter.Tendsto.liminf_eq {f : Filter β} {u : β → α} {a : α} [NeBot
 #align filter.tendsto.liminf_eq Filter.Tendsto.liminf_eq
 -/
 
-/- warning: tendsto_of_liminf_eq_limsup -> tendsto_of_liminf_eq_limsup is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsupₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /-- If the liminf and the limsup of a function coincide, then the limit of the function
@@ -347,9 +242,6 @@ theorem tendsto_of_liminf_eq_limsup {f : Filter β} {u : β → α} {a : α} (hi
   le_nhds_of_limsSup_eq_limsInf h h' hsup hinf
 #align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsup
 
-/- warning: tendsto_of_le_liminf_of_limsup_le -> tendsto_of_le_liminf_of_limsup_le is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align tendsto_of_le_liminf_of_limsup_le tendsto_of_le_liminf_of_limsup_leₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /-- If a number `a` is less than or equal to the `liminf` of a function `f` at some filter
@@ -370,9 +262,6 @@ theorem tendsto_of_le_liminf_of_limsup_le {f : Filter β} {u : β → α} {a : 
       (le_antisymm hsup (le_trans hinf (liminf_le_limsup h h'))) h h'
 #align tendsto_of_le_liminf_of_limsup_le tendsto_of_le_liminf_of_limsup_le
 
-/- warning: tendsto_of_no_upcrossings -> tendsto_of_no_upcrossings is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align tendsto_of_no_upcrossings tendsto_of_no_upcrossingsₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /-- Assume that, for any `a < b`, a sequence can not be infinitely many times below `a` and
@@ -405,9 +294,6 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
 
 variable [FirstCountableTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}
 
-/- warning: eventually_le_limsup -> eventually_le_limsup is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align eventually_le_limsup eventually_le_limsupₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 theorem eventually_le_limsup
     (hf : IsBoundedUnder (· ≤ ·) f u := by
@@ -433,9 +319,6 @@ theorem eventually_le_limsup
     exact hx hy
 #align eventually_le_limsup eventually_le_limsup
 
-/- warning: eventually_liminf_le -> eventually_liminf_le is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align eventually_liminf_le eventually_liminf_leₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 theorem eventually_liminf_le
     (hf : IsBoundedUnder (· ≥ ·) f u := by
@@ -452,12 +335,6 @@ section CompleteLinearOrder
 variable [CompleteLinearOrder α] [TopologicalSpace α] [FirstCountableTopology α] [OrderTopology α]
   {f : Filter β} [CountableInterFilter f] {u : β → α}
 
-/- warning: limsup_eq_bot -> limsup_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] [_inst_4 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1))))] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, Iff (Eq.{succ u1} α (Filter.limsup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)) u f) (Bot.bot.{u1} α (ConditionallyCompleteLinearOrderBot.toHasBot.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1)))) (Filter.EventuallyEq.{u2, u1} β α f u (Bot.bot.{max u2 u1} (β -> α) (Pi.hasBot.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => ConditionallyCompleteLinearOrderBot.toHasBot.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] [_inst_4 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1))))] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, Iff (Eq.{succ u1} α (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1))) u f) (Bot.bot.{u1} α (ConditionallyCompleteLinearOrderBot.toBot.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1)))) (Filter.EventuallyEq.{u2, u1} β α f u (Bot.bot.{max u1 u2} (β -> α) (Pi.instBotForAll.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => ConditionallyCompleteLinearOrderBot.toBot.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align limsup_eq_bot limsup_eq_botₓ'. -/
 @[simp]
 theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
   ⟨fun h =>
@@ -466,12 +343,6 @@ theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
     fun h => by rw [limsup_congr h]; exact limsup_const_bot⟩
 #align limsup_eq_bot limsup_eq_bot
 
-/- warning: liminf_eq_top -> liminf_eq_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] [_inst_4 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1))))] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, Iff (Eq.{succ u1} α (Filter.liminf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)) u f) (Top.top.{u1} α (CompleteLattice.toHasTop.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)))) (Filter.EventuallyEq.{u2, u1} β α f u (Top.top.{max u2 u1} (β -> α) (Pi.hasTop.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => CompleteLattice.toHasTop.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] [_inst_4 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1))))] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, Iff (Eq.{succ u1} α (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1))) u f) (Top.top.{u1} α (CompleteLattice.toTop.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)))) (Filter.EventuallyEq.{u2, u1} β α f u (Top.top.{max u1 u2} (β -> α) (Pi.instTopForAll.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => CompleteLattice.toTop.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align liminf_eq_top liminf_eq_topₓ'. -/
 @[simp]
 theorem liminf_eq_top : f.liminf u = ⊤ ↔ u =ᶠ[f] ⊤ :=
   @limsup_eq_bot αᵒᵈ _ _ _ _ _ _ _ _
@@ -486,12 +357,6 @@ section Monotone
 variable {ι R S : Type _} {F : Filter ι} [NeBot F] [CompleteLinearOrder R] [TopologicalSpace R]
   [OrderTopology R] [CompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
 
-/- warning: antitone.map_Limsup_of_continuous_at -> Antitone.map_limsSup_of_continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Antitone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsSup.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsSup.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.liminf.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
-but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Antitone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsSup.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsSup.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.liminf.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
-Case conversion may be inaccurate. Consider using '#align antitone.map_Limsup_of_continuous_at Antitone.map_limsSup_of_continuousAtₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
 /-- An antitone function between complete linear ordered spaces sends a `filter.Limsup`
@@ -552,12 +417,6 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
     exact lt_irrefl _ (B.trans_lt I)
 #align antitone.map_Limsup_of_continuous_at Antitone.map_limsSup_of_continuousAt
 
-/- warning: antitone.map_limsup_of_continuous_at -> Antitone.map_limsup_of_continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} {F : Filter.{u1} ι} [_inst_1 : Filter.NeBot.{u1} ι F] [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u3} S] [_inst_6 : TopologicalSpace.{u3} S] [_inst_7 : OrderTopology.{u3} S _inst_6 (PartialOrder.toPreorder.{u3} S (CompleteSemilatticeInf.toPartialOrder.{u3} S (CompleteLattice.toCompleteSemilatticeInf.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5))))] {f : R -> S}, (Antitone.{u2, u3} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u3} S (CompleteSemilatticeInf.toPartialOrder.{u3} S (CompleteLattice.toCompleteSemilatticeInf.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5)))) f) -> (forall (a : ι -> R), (ContinuousAt.{u2, u3} R S _inst_3 _inst_6 f (Filter.limsup.{u2, u1} R ι (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)) a F)) -> (Eq.{succ u3} S (f (Filter.limsup.{u2, u1} R ι (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)) a F)) (Filter.liminf.{u3, u1} S ι (CompleteLattice.toConditionallyCompleteLattice.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5)) (Function.comp.{succ u1, succ u2, succ u3} ι R S f a) F)))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u3}} {S : Type.{u2}} {F : Filter.{u1} ι} [_inst_1 : Filter.NeBot.{u1} ι F] [_inst_2 : CompleteLinearOrder.{u3} R] [_inst_3 : TopologicalSpace.{u3} R] [_inst_4 : OrderTopology.{u3} R _inst_3 (PartialOrder.toPreorder.{u3} R (CompleteSemilatticeInf.toPartialOrder.{u3} R (CompleteLattice.toCompleteSemilatticeInf.{u3} R (CompleteLinearOrder.toCompleteLattice.{u3} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {f : R -> S}, (Antitone.{u3, u2} R S (PartialOrder.toPreorder.{u3} R (CompleteSemilatticeInf.toPartialOrder.{u3} R (CompleteLattice.toCompleteSemilatticeInf.{u3} R (CompleteLinearOrder.toCompleteLattice.{u3} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (forall (a : ι -> R), (ContinuousAt.{u3, u2} R S _inst_3 _inst_6 f (Filter.limsup.{u3, u1} R ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u3} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u3} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u3} R _inst_2))) a F)) -> (Eq.{succ u2} S (f (Filter.limsup.{u3, u1} R ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u3} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u3} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u3} R _inst_2))) a F)) (Filter.liminf.{u2, u1} S ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} S _inst_5))) (Function.comp.{succ u1, succ u3, succ u2} ι R S f a) F)))
-Case conversion may be inaccurate. Consider using '#align antitone.map_limsup_of_continuous_at Antitone.map_limsup_of_continuousAtₓ'. -/
 /-- A continuous antitone function between complete linear ordered spaces sends a `filter.limsup`
 to the `filter.liminf` of the images. -/
 theorem Antitone.map_limsup_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
@@ -565,12 +424,6 @@ theorem Antitone.map_limsup_of_continuousAt {f : R → S} (f_decr : Antitone f)
   f_decr.map_limsSup_of_continuousAt f_cont
 #align antitone.map_limsup_of_continuous_at Antitone.map_limsup_of_continuousAt
 
-/- warning: antitone.map_Liminf_of_continuous_at -> Antitone.map_limsInf_of_continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Antitone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsInf.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsInf.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.limsup.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
-but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Antitone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsInf.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsInf.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.limsup.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
-Case conversion may be inaccurate. Consider using '#align antitone.map_Liminf_of_continuous_at Antitone.map_limsInf_of_continuousAtₓ'. -/
 /-- An antitone function between complete linear ordered spaces sends a `filter.Liminf`
 to the `filter.limsup` of the image if it is continuous at the `Liminf`. -/
 theorem Antitone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
@@ -579,12 +432,6 @@ theorem Antitone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R →
     f_cont
 #align antitone.map_Liminf_of_continuous_at Antitone.map_limsInf_of_continuousAt
 
-/- warning: antitone.map_liminf_of_continuous_at -> Antitone.map_liminf_of_continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} {F : Filter.{u1} ι} [_inst_1 : Filter.NeBot.{u1} ι F] [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u3} S] [_inst_6 : TopologicalSpace.{u3} S] [_inst_7 : OrderTopology.{u3} S _inst_6 (PartialOrder.toPreorder.{u3} S (CompleteSemilatticeInf.toPartialOrder.{u3} S (CompleteLattice.toCompleteSemilatticeInf.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5))))] {f : R -> S}, (Antitone.{u2, u3} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u3} S (CompleteSemilatticeInf.toPartialOrder.{u3} S (CompleteLattice.toCompleteSemilatticeInf.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5)))) f) -> (forall (a : ι -> R), (ContinuousAt.{u2, u3} R S _inst_3 _inst_6 f (Filter.liminf.{u2, u1} R ι (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)) a F)) -> (Eq.{succ u3} S (f (Filter.liminf.{u2, u1} R ι (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)) a F)) (Filter.limsup.{u3, u1} S ι (CompleteLattice.toConditionallyCompleteLattice.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5)) (Function.comp.{succ u1, succ u2, succ u3} ι R S f a) F)))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u3}} {S : Type.{u2}} {F : Filter.{u1} ι} [_inst_1 : Filter.NeBot.{u1} ι F] [_inst_2 : CompleteLinearOrder.{u3} R] [_inst_3 : TopologicalSpace.{u3} R] [_inst_4 : OrderTopology.{u3} R _inst_3 (PartialOrder.toPreorder.{u3} R (CompleteSemilatticeInf.toPartialOrder.{u3} R (CompleteLattice.toCompleteSemilatticeInf.{u3} R (CompleteLinearOrder.toCompleteLattice.{u3} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {f : R -> S}, (Antitone.{u3, u2} R S (PartialOrder.toPreorder.{u3} R (CompleteSemilatticeInf.toPartialOrder.{u3} R (CompleteLattice.toCompleteSemilatticeInf.{u3} R (CompleteLinearOrder.toCompleteLattice.{u3} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (forall (a : ι -> R), (ContinuousAt.{u3, u2} R S _inst_3 _inst_6 f (Filter.liminf.{u3, u1} R ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u3} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u3} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u3} R _inst_2))) a F)) -> (Eq.{succ u2} S (f (Filter.liminf.{u3, u1} R ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u3} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u3} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u3} R _inst_2))) a F)) (Filter.limsup.{u2, u1} S ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} S _inst_5))) (Function.comp.{succ u1, succ u3, succ u2} ι R S f a) F)))
-Case conversion may be inaccurate. Consider using '#align antitone.map_liminf_of_continuous_at Antitone.map_liminf_of_continuousAtₓ'. -/
 /-- A continuous antitone function between complete linear ordered spaces sends a `filter.liminf`
 to the `filter.limsup` of the images. -/
 theorem Antitone.map_liminf_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
@@ -592,12 +439,6 @@ theorem Antitone.map_liminf_of_continuousAt {f : R → S} (f_decr : Antitone f)
   f_decr.map_limsInf_of_continuousAt f_cont
 #align antitone.map_liminf_of_continuous_at Antitone.map_liminf_of_continuousAt
 
-/- warning: monotone.map_Limsup_of_continuous_at -> Monotone.map_limsSup_of_continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Monotone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsSup.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsSup.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.limsup.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
-but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Monotone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsSup.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsSup.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.limsup.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
-Case conversion may be inaccurate. Consider using '#align monotone.map_Limsup_of_continuous_at Monotone.map_limsSup_of_continuousAtₓ'. -/
 /-- A monotone function between complete linear ordered spaces sends a `filter.Limsup`
 to the `filter.limsup` of the image if it is continuous at the `Limsup`. -/
 theorem Monotone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
@@ -605,12 +446,6 @@ theorem Monotone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
   @Antitone.map_limsSup_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
 #align monotone.map_Limsup_of_continuous_at Monotone.map_limsSup_of_continuousAt
 
-/- warning: monotone.map_limsup_of_continuous_at -> Monotone.map_limsup_of_continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} {F : Filter.{u1} ι} [_inst_1 : Filter.NeBot.{u1} ι F] [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u3} S] [_inst_6 : TopologicalSpace.{u3} S] [_inst_7 : OrderTopology.{u3} S _inst_6 (PartialOrder.toPreorder.{u3} S (CompleteSemilatticeInf.toPartialOrder.{u3} S (CompleteLattice.toCompleteSemilatticeInf.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5))))] {f : R -> S}, (Monotone.{u2, u3} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u3} S (CompleteSemilatticeInf.toPartialOrder.{u3} S (CompleteLattice.toCompleteSemilatticeInf.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5)))) f) -> (forall (a : ι -> R), (ContinuousAt.{u2, u3} R S _inst_3 _inst_6 f (Filter.limsup.{u2, u1} R ι (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)) a F)) -> (Eq.{succ u3} S (f (Filter.limsup.{u2, u1} R ι (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)) a F)) (Filter.limsup.{u3, u1} S ι (CompleteLattice.toConditionallyCompleteLattice.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5)) (Function.comp.{succ u1, succ u2, succ u3} ι R S f a) F)))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u3}} {S : Type.{u2}} {F : Filter.{u1} ι} [_inst_1 : Filter.NeBot.{u1} ι F] [_inst_2 : CompleteLinearOrder.{u3} R] [_inst_3 : TopologicalSpace.{u3} R] [_inst_4 : OrderTopology.{u3} R _inst_3 (PartialOrder.toPreorder.{u3} R (CompleteSemilatticeInf.toPartialOrder.{u3} R (CompleteLattice.toCompleteSemilatticeInf.{u3} R (CompleteLinearOrder.toCompleteLattice.{u3} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {f : R -> S}, (Monotone.{u3, u2} R S (PartialOrder.toPreorder.{u3} R (CompleteSemilatticeInf.toPartialOrder.{u3} R (CompleteLattice.toCompleteSemilatticeInf.{u3} R (CompleteLinearOrder.toCompleteLattice.{u3} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (forall (a : ι -> R), (ContinuousAt.{u3, u2} R S _inst_3 _inst_6 f (Filter.limsup.{u3, u1} R ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u3} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u3} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u3} R _inst_2))) a F)) -> (Eq.{succ u2} S (f (Filter.limsup.{u3, u1} R ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u3} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u3} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u3} R _inst_2))) a F)) (Filter.limsup.{u2, u1} S ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} S _inst_5))) (Function.comp.{succ u1, succ u3, succ u2} ι R S f a) F)))
-Case conversion may be inaccurate. Consider using '#align monotone.map_limsup_of_continuous_at Monotone.map_limsup_of_continuousAtₓ'. -/
 /-- A continuous monotone function between complete linear ordered spaces sends a `filter.limsup`
 to the `filter.limsup` of the images. -/
 theorem Monotone.map_limsup_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
@@ -618,12 +453,6 @@ theorem Monotone.map_limsup_of_continuousAt {f : R → S} (f_incr : Monotone f)
   f_incr.map_limsSup_of_continuousAt f_cont
 #align monotone.map_limsup_of_continuous_at Monotone.map_limsup_of_continuousAt
 
-/- warning: monotone.map_Liminf_of_continuous_at -> Monotone.map_limsInf_of_continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Monotone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsInf.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsInf.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.liminf.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
-but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Monotone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsInf.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsInf.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.liminf.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
-Case conversion may be inaccurate. Consider using '#align monotone.map_Liminf_of_continuous_at Monotone.map_limsInf_of_continuousAtₓ'. -/
 /-- A monotone function between complete linear ordered spaces sends a `filter.Liminf`
 to the `filter.liminf` of the image if it is continuous at the `Liminf`. -/
 theorem Monotone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
@@ -631,12 +460,6 @@ theorem Monotone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R →
   @Antitone.map_limsInf_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
 #align monotone.map_Liminf_of_continuous_at Monotone.map_limsInf_of_continuousAt
 
-/- warning: monotone.map_liminf_of_continuous_at -> Monotone.map_liminf_of_continuousAt is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} {S : Type.{u3}} {F : Filter.{u1} ι} [_inst_1 : Filter.NeBot.{u1} ι F] [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u3} S] [_inst_6 : TopologicalSpace.{u3} S] [_inst_7 : OrderTopology.{u3} S _inst_6 (PartialOrder.toPreorder.{u3} S (CompleteSemilatticeInf.toPartialOrder.{u3} S (CompleteLattice.toCompleteSemilatticeInf.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5))))] {f : R -> S}, (Monotone.{u2, u3} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u3} S (CompleteSemilatticeInf.toPartialOrder.{u3} S (CompleteLattice.toCompleteSemilatticeInf.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5)))) f) -> (forall (a : ι -> R), (ContinuousAt.{u2, u3} R S _inst_3 _inst_6 f (Filter.liminf.{u2, u1} R ι (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)) a F)) -> (Eq.{succ u3} S (f (Filter.liminf.{u2, u1} R ι (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)) a F)) (Filter.liminf.{u3, u1} S ι (CompleteLattice.toConditionallyCompleteLattice.{u3} S (CompleteLinearOrder.toCompleteLattice.{u3} S _inst_5)) (Function.comp.{succ u1, succ u2, succ u3} ι R S f a) F)))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u3}} {S : Type.{u2}} {F : Filter.{u1} ι} [_inst_1 : Filter.NeBot.{u1} ι F] [_inst_2 : CompleteLinearOrder.{u3} R] [_inst_3 : TopologicalSpace.{u3} R] [_inst_4 : OrderTopology.{u3} R _inst_3 (PartialOrder.toPreorder.{u3} R (CompleteSemilatticeInf.toPartialOrder.{u3} R (CompleteLattice.toCompleteSemilatticeInf.{u3} R (CompleteLinearOrder.toCompleteLattice.{u3} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {f : R -> S}, (Monotone.{u3, u2} R S (PartialOrder.toPreorder.{u3} R (CompleteSemilatticeInf.toPartialOrder.{u3} R (CompleteLattice.toCompleteSemilatticeInf.{u3} R (CompleteLinearOrder.toCompleteLattice.{u3} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (forall (a : ι -> R), (ContinuousAt.{u3, u2} R S _inst_3 _inst_6 f (Filter.liminf.{u3, u1} R ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u3} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u3} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u3} R _inst_2))) a F)) -> (Eq.{succ u2} S (f (Filter.liminf.{u3, u1} R ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u3} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u3} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u3} R _inst_2))) a F)) (Filter.liminf.{u2, u1} S ι (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} S _inst_5))) (Function.comp.{succ u1, succ u3, succ u2} ι R S f a) F)))
-Case conversion may be inaccurate. Consider using '#align monotone.map_liminf_of_continuous_at Monotone.map_liminf_of_continuousAtₓ'. -/
 /-- A continuous monotone function between complete linear ordered spaces sends a `filter.liminf`
 to the `filter.liminf` of the images. -/
 theorem Monotone.map_liminf_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
@@ -654,12 +477,6 @@ open Filter Set
 
 variable {ι : Type _} {R : Type _} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
-/- warning: infi_eq_of_forall_le_of_tendsto -> iInf_eq_of_forall_le_of_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toHasLe.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iInf.{u2, succ u1} R (ConditionallyCompleteLattice.toHasInf.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iInf.{u2, succ u1} R (ConditionallyCompleteLattice.toInfSet.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_1)))) ι (fun (i : ι) => as i)) x))
-Case conversion may be inaccurate. Consider using '#align infi_eq_of_forall_le_of_tendsto iInf_eq_of_forall_le_of_tendstoₓ'. -/
 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 :=
   by
@@ -667,23 +484,11 @@ theorem iInf_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (x_le : ∀ i, x
   apply fun w x_lt_w => ‹Filter.NeBot F›.nonempty_of_mem (eventually_lt_of_tendsto_lt x_lt_w as_lim)
 #align infi_eq_of_forall_le_of_tendsto iInf_eq_of_forall_le_of_tendsto
 
-/- warning: supr_eq_of_forall_le_of_tendsto -> iSup_eq_of_forall_le_of_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toHasLe.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iSup.{u2, succ u1} R (ConditionallyCompleteLattice.toHasSup.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
-but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iSup.{u2, succ u1} R (ConditionallyCompleteLattice.toSupSet.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_1)))) ι (fun (i : ι) => as i)) x))
-Case conversion may be inaccurate. Consider using '#align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendstoₓ'. -/
 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 :=
   @iInf_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
 #align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
-/- warning: Union_Ici_eq_Ioi_of_lt_of_tendsto -> iUnion_Ici_eq_Ioi_of_lt_of_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : CompleteLinearOrder.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : OrderTopology.{u1} R _inst_2 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))] {ι : Type.{u2}} (x : R) {as : ι -> R}, (forall (i : ι), LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u2} ι} [_inst_4 : Filter.NeBot.{u2} ι F], (Filter.Tendsto.{u2, u1} ι R as F (nhds.{u1} R _inst_2 x)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, succ u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) (as i))) (Set.Ioi.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) x)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : CompleteLinearOrder.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : OrderTopology.{u1} R _inst_2 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))] {ι : Type.{u2}} (x : R) {as : ι -> R}, (forall (i : ι), LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u2} ι} [_inst_4 : Filter.NeBot.{u2} ι F], (Filter.Tendsto.{u2, u1} ι R as F (nhds.{u1} R _inst_2 x)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, succ u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) (as i))) (Set.Ioi.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) x)))
-Case conversion may be inaccurate. Consider using '#align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendstoₓ'. -/
 theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (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 :=
@@ -696,12 +501,6 @@ theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R}
   exact iUnion_Ici_eq_Ioi_iInf obs
 #align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendsto
 
-/- warning: Union_Iic_eq_Iio_of_lt_of_tendsto -> iUnion_Iic_eq_Iio_of_lt_of_tendsto is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : CompleteLinearOrder.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : OrderTopology.{u1} R _inst_2 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))] {ι : Type.{u2}} (x : R) {as : ι -> R}, (forall (i : ι), LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u2} ι} [_inst_4 : Filter.NeBot.{u2} ι F], (Filter.Tendsto.{u2, u1} ι R as F (nhds.{u1} R _inst_2 x)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, succ u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) (as i))) (Set.Iio.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) x)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : CompleteLinearOrder.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : OrderTopology.{u1} R _inst_2 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))] {ι : Type.{u2}} (x : R) {as : ι -> R}, (forall (i : ι), LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u2} ι} [_inst_4 : Filter.NeBot.{u2} ι F], (Filter.Tendsto.{u2, u1} ι R as F (nhds.{u1} R _inst_2 x)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, succ u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) (as i))) (Set.Iio.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) x)))
-Case conversion may be inaccurate. Consider using '#align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendstoₓ'. -/
 theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (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 :=
@@ -714,12 +513,6 @@ section Indicator
 
 open BigOperators
 
-/- warning: limsup_eq_tendsto_sum_indicator_nat_at_top -> limsup_eq_tendsto_sum_indicator_nat_atTop is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Nat -> (Set.{u1} α)), Eq.{succ u1} (Set.{u1} α) (Filter.limsup.{u1, 0} (Set.{u1} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) (setOf.{u1} α (fun (ω : α) => Filter.Tendsto.{0, 0} Nat Nat (fun (n : Nat) => Finset.sum.{0, 0} Nat Nat Nat.addCommMonoid (Finset.range n) (fun (k : Nat) => Set.indicator.{u1, 0} α Nat Nat.hasZero (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (OfNat.ofNat.{u1} (α -> Nat) 1 (OfNat.mk.{u1} (α -> Nat) 1 (One.one.{u1} (α -> Nat) (Pi.instOne.{u1, 0} α (fun (ᾰ : α) => Nat) (fun (i : α) => Nat.hasOne))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))))
-but is expected to have type
-  forall {α : Type.{u1}} (s : Nat -> (Set.{u1} α)), Eq.{succ u1} (Set.{u1} α) (Filter.limsup.{u1, 0} (Set.{u1} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) (setOf.{u1} α (fun (ω : α) => Filter.Tendsto.{0, 0} Nat Nat (fun (n : Nat) => Finset.sum.{0, 0} Nat Nat Nat.addCommMonoid (Finset.range n) (fun (k : Nat) => Set.indicator.{u1, 0} α Nat (LinearOrderedCommMonoidWithZero.toZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (OfNat.ofNat.{u1} (α -> Nat) 1 (One.toOfNat1.{u1} (α -> Nat) (Pi.instOne.{u1, 0} α (fun (a._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.5073 : α) => Nat) (fun (i : α) => CanonicallyOrderedCommSemiring.toOne.{0} Nat Nat.canonicallyOrderedCommSemiring)))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))))
-Case conversion may be inaccurate. Consider using '#align limsup_eq_tendsto_sum_indicator_nat_at_top limsup_eq_tendsto_sum_indicator_nat_atTopₓ'. -/
 theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     limsup s atTop =
       { ω |
@@ -794,12 +587,6 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     exact not_le.2 (lt_of_lt_of_le i.lt_succ_self <| h _ le_rfl) this
 #align limsup_eq_tendsto_sum_indicator_nat_at_top limsup_eq_tendsto_sum_indicator_nat_atTop
 
-/- warning: limsup_eq_tendsto_sum_indicator_at_top -> limsup_eq_tendsto_sum_indicator_atTop is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (R : Type.{u2}) [_inst_1 : StrictOrderedSemiring.{u2} R] [_inst_2 : Archimedean.{u2} R (OrderedSemiring.toOrderedAddCommMonoid.{u2} R (StrictOrderedSemiring.toOrderedSemiring.{u2} R _inst_1))] (s : Nat -> (Set.{u1} α)), Eq.{succ u1} (Set.{u1} α) (Filter.limsup.{u1, 0} (Set.{u1} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) (setOf.{u1} α (fun (ω : α) => Filter.Tendsto.{0, u2} Nat R (fun (n : Nat) => Finset.sum.{u2, 0} R Nat (OrderedCancelAddCommMonoid.toAddCommMonoid.{u2} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u2} R _inst_1)) (Finset.range n) (fun (k : Nat) => Set.indicator.{u1, u2} α R (MulZeroClass.toHasZero.{u2} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (StrictOrderedSemiring.toSemiring.{u2} R _inst_1))))) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (OfNat.ofNat.{max u1 u2} (α -> R) 1 (OfNat.mk.{max u1 u2} (α -> R) 1 (One.one.{max u1 u2} (α -> R) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => AddMonoidWithOne.toOne.{u2} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u2} R (NonAssocSemiring.toAddCommMonoidWithOne.{u2} R (Semiring.toNonAssocSemiring.{u2} R (StrictOrderedSemiring.toSemiring.{u2} R _inst_1))))))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (Filter.atTop.{u2} R (PartialOrder.toPreorder.{u2} R (OrderedCancelAddCommMonoid.toPartialOrder.{u2} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u2} R _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u2}} (R : Type.{u1}) [_inst_1 : StrictOrderedSemiring.{u1} R] [_inst_2 : Archimedean.{u1} R (OrderedSemiring.toOrderedAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedSemiring.{u1} R _inst_1))] (s : Nat -> (Set.{u2} α)), Eq.{succ u2} (Set.{u2} α) (Filter.limsup.{u2, 0} (Set.{u2} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) (setOf.{u2} α (fun (ω : α) => Filter.Tendsto.{0, u1} Nat R (fun (n : Nat) => Finset.sum.{u1, 0} R Nat (OrderedCancelAddCommMonoid.toAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)) (Finset.range n) (fun (k : Nat) => Set.indicator.{u2, u1} α R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (OfNat.ofNat.{max u2 u1} (α -> R) 1 (One.toOfNat1.{max u2 u1} (α -> R) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.6013 : α) => R) (fun (i : α) => Semiring.toOne.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (Filter.atTop.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align limsup_eq_tendsto_sum_indicator_at_top limsup_eq_tendsto_sum_indicator_atTopₓ'. -/
 theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type _) [StrictOrderedSemiring R] [Archimedean R]
     (s : ℕ → Set α) :
     limsup s atTop =
Diff
@@ -388,9 +388,7 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
       run_tac
         is_bounded_default) :
     ∃ c : α, Tendsto u f (𝓝 c) := by
-  by_cases hbot : f = ⊥;
-  · rw [hbot]
-    exact ⟨Inf ∅, tendsto_bot⟩
+  by_cases hbot : f = ⊥; · rw [hbot]; exact ⟨Inf ∅, tendsto_bot⟩
   haveI : ne_bot f := ⟨hbot⟩
   refine' ⟨limsup u f, _⟩
   apply tendsto_of_le_liminf_of_limsup_le _ le_rfl h h'
@@ -465,9 +463,7 @@ theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
   ⟨fun h =>
     (EventuallyLE.trans eventually_le_limsup <| eventually_of_forall fun _ => h.le).mono fun x hx =>
       le_antisymm hx bot_le,
-    fun h => by
-    rw [limsup_congr h]
-    exact limsup_const_bot⟩
+    fun h => by rw [limsup_congr h]; exact limsup_const_bot⟩
 #align limsup_eq_bot limsup_eq_bot
 
 /- warning: liminf_eq_top -> liminf_eq_top is a dubious translation:
Diff
@@ -329,10 +329,7 @@ theorem Filter.Tendsto.liminf_eq {f : Filter β} {u : β → α} {a : α} [NeBot
 -/
 
 /- warning: tendsto_of_liminf_eq_limsup -> tendsto_of_liminf_eq_limsup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Eq.{succ u1} α (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (Eq.{succ u1} α (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Eq.{succ u1} α (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (Eq.{succ u1} α (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1869 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1871 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1869 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1871) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1835) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1911 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1913 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1911 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1913) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1883) -> (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a))
+<too large>
 Case conversion may be inaccurate. Consider using '#align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsupₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
@@ -351,10 +348,7 @@ theorem tendsto_of_liminf_eq_limsup {f : Filter β} {u : β → α} {a : α} (hi
 #align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsup
 
 /- warning: tendsto_of_le_liminf_of_limsup_le -> tendsto_of_le_liminf_of_limsup_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2001 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2003 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2001 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2003) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1973) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2043 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2045 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2043 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2045) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2015) -> (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a))
+<too large>
 Case conversion may be inaccurate. Consider using '#align tendsto_of_le_liminf_of_limsup_le tendsto_of_le_liminf_of_limsup_leₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
@@ -377,10 +371,7 @@ theorem tendsto_of_le_liminf_of_limsup_le {f : Filter β} {u : β → α} {a : 
 #align tendsto_of_le_liminf_of_limsup_le tendsto_of_le_liminf_of_limsup_le
 
 /- warning: tendsto_of_no_upcrossings -> tendsto_of_no_upcrossings is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : DenselyOrdered.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))] {f : Filter.{u2} β} {u : β -> α} {s : Set.{u1} α}, (Dense.{u1} α _inst_2 s) -> (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a b) -> (Not (And (Filter.Frequently.{u2} β (fun (n : β) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (u n) a) f) (Filter.Frequently.{u2} β (fun (n : β) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b (u n)) f))))) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Exists.{succ u1} α (fun (c : α) => Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 c)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : DenselyOrdered.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))] {f : Filter.{u2} β} {u : β -> α} {s : Set.{u1} α}, (Dense.{u1} α _inst_2 s) -> (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a b) -> (Not (And (Filter.Frequently.{u2} β (fun (n : β) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (u n) a) f) (Filter.Frequently.{u2} β (fun (n : β) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b (u n)) f))))) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2273 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2275 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2273 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2275) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2245) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2315 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2317 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2315 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2317) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2287) -> (Exists.{succ u1} α (fun (c : α) => Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 c)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align tendsto_of_no_upcrossings tendsto_of_no_upcrossingsₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
@@ -417,10 +408,7 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
 variable [FirstCountableTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}
 
 /- warning: eventually_le_limsup -> eventually_le_limsup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Eventually.{u2} β (fun (b : β) => LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (u b) (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f)) f)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2758 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2760 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2758 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2760) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2730) -> (Filter.Eventually.{u2} β (fun (b : β) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (u b) (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f)) f)
+<too large>
 Case conversion may be inaccurate. Consider using '#align eventually_le_limsup eventually_le_limsupₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 theorem eventually_le_limsup
@@ -448,10 +436,7 @@ theorem eventually_le_limsup
 #align eventually_le_limsup eventually_le_limsup
 
 /- warning: eventually_liminf_le -> eventually_liminf_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Eventually.{u2} β (fun (b : β) => LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) (u b)) f)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3050 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3052 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3050 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3052) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3022) -> (Filter.Eventually.{u2} β (fun (b : β) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) (u b)) f)
+<too large>
 Case conversion may be inaccurate. Consider using '#align eventually_liminf_le eventually_liminf_leₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 theorem eventually_liminf_le
Diff
@@ -38,19 +38,27 @@ section OrderClosedTopology
 
 variable [SemilatticeSup α] [TopologicalSpace α] [OrderTopology α]
 
-#print isBounded_le_nhds /-
+/- warning: is_bounded_le_nhds -> isBounded_le_nhds is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (nhds.{u1} α _inst_2 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.52 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.54 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.52 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.54) (nhds.{u1} α _inst_2 a)
+Case conversion may be inaccurate. Consider using '#align is_bounded_le_nhds isBounded_le_nhdsₓ'. -/
 theorem isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·) :=
   (isTop_or_exists_gt a).elim (fun h => ⟨a, eventually_of_forall h⟩) fun ⟨b, hb⟩ =>
     ⟨b, ge_mem_nhds hb⟩
 #align is_bounded_le_nhds isBounded_le_nhds
--/
 
-#print Filter.Tendsto.isBoundedUnder_le /-
+/- warning: filter.tendsto.is_bounded_under_le -> Filter.Tendsto.isBoundedUnder_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) f u)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.140 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.142 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.140 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.142) f u)
+Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_bounded_under_le Filter.Tendsto.isBoundedUnder_leₓ'. -/
 theorem Filter.Tendsto.isBoundedUnder_le {f : Filter β} {u : β → α} {a : α}
     (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≤ ·) u :=
   (isBounded_le_nhds a).mono h
 #align filter.tendsto.is_bounded_under_le Filter.Tendsto.isBoundedUnder_le
--/
 
 #print Filter.Tendsto.bddAbove_range_of_cofinite /-
 theorem Filter.Tendsto.bddAbove_range_of_cofinite {u : β → α} {a : α}
@@ -66,29 +74,41 @@ theorem Filter.Tendsto.bddAbove_range {u : ℕ → α} {a : α} (h : Tendsto u a
 #align filter.tendsto.bdd_above_range Filter.Tendsto.bddAbove_range
 -/
 
-#print isCobounded_ge_nhds /-
+/- warning: is_cobounded_ge_nhds -> isCobounded_ge_nhds is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsCobounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) (nhds.{u1} α _inst_2 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsCobounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.261 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.263 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.261 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.263) (nhds.{u1} α _inst_2 a)
+Case conversion may be inaccurate. Consider using '#align is_cobounded_ge_nhds isCobounded_ge_nhdsₓ'. -/
 theorem isCobounded_ge_nhds (a : α) : (𝓝 a).IsCobounded (· ≥ ·) :=
   (isBounded_le_nhds a).isCobounded_flip
 #align is_cobounded_ge_nhds isCobounded_ge_nhds
--/
 
-#print Filter.Tendsto.isCoboundedUnder_ge /-
+/- warning: filter.tendsto.is_cobounded_under_ge -> Filter.Tendsto.isCoboundedUnder_ge is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α} [_inst_4 : Filter.NeBot.{u2} β f], (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsCoboundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)))) f u)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α} [_inst_4 : Filter.NeBot.{u2} β f], (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsCoboundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.317 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.319 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.317 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.319) f u)
+Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_geₓ'. -/
 theorem Filter.Tendsto.isCoboundedUnder_ge {f : Filter β} {u : β → α} {a : α} [NeBot f]
     (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≥ ·) u :=
   h.isBoundedUnder_le.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
--/
 
-#print isBounded_le_atBot /-
+/- warning: is_bounded_le_at_bot -> isBounded_le_atBot is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [hα : Nonempty.{succ u1} α] [_inst_4 : Preorder.{u1} α], Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_4)) (Filter.atBot.{u1} α _inst_4)
+but is expected to have type
+  forall (α : Type.{u1}) [hα : Nonempty.{succ u1} α] [_inst_4 : Preorder.{u1} α], Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.360 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.362 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_4) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.360 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.362) (Filter.atBot.{u1} α _inst_4)
+Case conversion may be inaccurate. Consider using '#align is_bounded_le_at_bot isBounded_le_atBotₓ'. -/
 theorem isBounded_le_atBot (α : Type _) [hα : Nonempty α] [Preorder α] :
     (atBot : Filter α).IsBounded (· ≤ ·) :=
   isBounded_iff.2 ⟨Set.Iic hα.some, mem_atBot _, hα.some, fun x hx => hx⟩
 #align is_bounded_le_at_bot isBounded_le_atBot
--/
 
 /- warning: filter.tendsto.is_bounded_under_le_at_bot -> Filter.Tendsto.isBoundedUnder_le_atBot is a dubious translation:
 lean 3 declaration is
-  forall {β : Type.{u1}} {α : Type.{u2}} [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : Preorder.{u2} α] {f : Filter.{u1} β} {u : β -> α}, (Filter.Tendsto.{u1, u2} β α u f (Filter.atBot.{u2} α _inst_5)) -> (Filter.IsBoundedUnder.{u2, u1} α β (LE.le.{u2} α (Preorder.toLE.{u2} α _inst_5)) f u)
+  forall {β : Type.{u1}} {α : Type.{u2}} [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : Preorder.{u2} α] {f : Filter.{u1} β} {u : β -> α}, (Filter.Tendsto.{u1, u2} β α u f (Filter.atBot.{u2} α _inst_5)) -> (Filter.IsBoundedUnder.{u2, u1} α β (LE.le.{u2} α (Preorder.toHasLe.{u2} α _inst_5)) f u)
 but is expected to have type
   forall {β : Type.{u2}} {α : Type.{u1}} [_inst_4 : Nonempty.{succ u1} α] [_inst_5 : Preorder.{u1} α] {f : Filter.{u2} β} {u : β -> α}, (Filter.Tendsto.{u2, u1} β α u f (Filter.atBot.{u1} α _inst_5)) -> (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.426 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.428 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_5) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.426 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.428) f u)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_bounded_under_le_at_bot Filter.Tendsto.isBoundedUnder_le_atBotₓ'. -/
@@ -110,18 +130,26 @@ section OrderClosedTopology
 
 variable [SemilatticeInf α] [TopologicalSpace α] [OrderTopology α]
 
-#print isBounded_ge_nhds /-
+/- warning: is_bounded_ge_nhds -> isBounded_ge_nhds is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (nhds.{u1} α _inst_2 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.527 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.529 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.527 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.529) (nhds.{u1} α _inst_2 a)
+Case conversion may be inaccurate. Consider using '#align is_bounded_ge_nhds isBounded_ge_nhdsₓ'. -/
 theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·) :=
   @isBounded_le_nhds αᵒᵈ _ _ _ a
 #align is_bounded_ge_nhds isBounded_ge_nhds
--/
 
-#print Filter.Tendsto.isBoundedUnder_ge /-
+/- warning: filter.tendsto.is_bounded_under_ge -> Filter.Tendsto.isBoundedUnder_ge is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) f u)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.581 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.583 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.581 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.583) f u)
+Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_bounded_under_ge Filter.Tendsto.isBoundedUnder_geₓ'. -/
 theorem Filter.Tendsto.isBoundedUnder_ge {f : Filter β} {u : β → α} {a : α}
     (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≥ ·) u :=
   (isBounded_ge_nhds a).mono h
 #align filter.tendsto.is_bounded_under_ge Filter.Tendsto.isBoundedUnder_ge
--/
 
 #print Filter.Tendsto.bddBelow_range_of_cofinite /-
 theorem Filter.Tendsto.bddBelow_range_of_cofinite {u : β → α} {a : α}
@@ -137,29 +165,41 @@ theorem Filter.Tendsto.bddBelow_range {u : ℕ → α} {a : α} (h : Tendsto u a
 #align filter.tendsto.bdd_below_range Filter.Tendsto.bddBelow_range
 -/
 
-#print isCobounded_le_nhds /-
+/- warning: is_cobounded_le_nhds -> isCobounded_le_nhds is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsCobounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) (nhds.{u1} α _inst_2 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] (a : α), Filter.IsCobounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.702 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.704 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.702 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.704) (nhds.{u1} α _inst_2 a)
+Case conversion may be inaccurate. Consider using '#align is_cobounded_le_nhds isCobounded_le_nhdsₓ'. -/
 theorem isCobounded_le_nhds (a : α) : (𝓝 a).IsCobounded (· ≤ ·) :=
   (isBounded_ge_nhds a).isCobounded_flip
 #align is_cobounded_le_nhds isCobounded_le_nhds
--/
 
-#print Filter.Tendsto.isCoboundedUnder_le /-
+/- warning: filter.tendsto.is_cobounded_under_le -> Filter.Tendsto.isCoboundedUnder_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α} [_inst_4 : Filter.NeBot.{u2} β f], (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsCoboundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))) f u)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))] {f : Filter.{u2} β} {u : β -> α} {a : α} [_inst_4 : Filter.NeBot.{u2} β f], (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a)) -> (Filter.IsCoboundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.758 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.760 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.758 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.760) f u)
+Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_leₓ'. -/
 theorem Filter.Tendsto.isCoboundedUnder_le {f : Filter β} {u : β → α} {a : α} [NeBot f]
     (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≤ ·) u :=
   h.isBoundedUnder_ge.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
--/
 
-#print isBounded_ge_atTop /-
+/- warning: is_bounded_ge_at_top -> isBounded_ge_atTop is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [hα : Nonempty.{succ u1} α] [_inst_4 : Preorder.{u1} α], Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α _inst_4)) (Filter.atTop.{u1} α _inst_4)
+but is expected to have type
+  forall (α : Type.{u1}) [hα : Nonempty.{succ u1} α] [_inst_4 : Preorder.{u1} α], Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.802 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.804 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α _inst_4) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.802 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.804) (Filter.atTop.{u1} α _inst_4)
+Case conversion may be inaccurate. Consider using '#align is_bounded_ge_at_top isBounded_ge_atTopₓ'. -/
 theorem isBounded_ge_atTop (α : Type _) [hα : Nonempty α] [Preorder α] :
     (atTop : Filter α).IsBounded (· ≥ ·) :=
   isBounded_le_atBot αᵒᵈ
 #align is_bounded_ge_at_top isBounded_ge_atTop
--/
 
 /- warning: filter.tendsto.is_bounded_under_ge_at_top -> Filter.Tendsto.isBoundedUnder_ge_atTop is a dubious translation:
 lean 3 declaration is
-  forall {β : Type.{u1}} {α : Type.{u2}} [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : Preorder.{u2} α] {f : Filter.{u1} β} {u : β -> α}, (Filter.Tendsto.{u1, u2} β α u f (Filter.atTop.{u2} α _inst_5)) -> (Filter.IsBoundedUnder.{u2, u1} α β (GE.ge.{u2} α (Preorder.toLE.{u2} α _inst_5)) f u)
+  forall {β : Type.{u1}} {α : Type.{u2}} [_inst_4 : Nonempty.{succ u2} α] [_inst_5 : Preorder.{u2} α] {f : Filter.{u1} β} {u : β -> α}, (Filter.Tendsto.{u1, u2} β α u f (Filter.atTop.{u2} α _inst_5)) -> (Filter.IsBoundedUnder.{u2, u1} α β (GE.ge.{u2} α (Preorder.toHasLe.{u2} α _inst_5)) f u)
 but is expected to have type
   forall {β : Type.{u2}} {α : Type.{u1}} [_inst_4 : Nonempty.{succ u1} α] [_inst_5 : Preorder.{u1} α] {f : Filter.{u2} β} {u : β -> α}, (Filter.Tendsto.{u2, u1} β α u f (Filter.atTop.{u1} α _inst_5)) -> (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.855 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.857 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α _inst_5) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.855 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.857) f u)
 Case conversion may be inaccurate. Consider using '#align filter.tendsto.is_bounded_under_ge_at_top Filter.Tendsto.isBoundedUnder_ge_atTopₓ'. -/
@@ -181,26 +221,34 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α]
 
-#print lt_mem_sets_of_limsSup_lt /-
+/- warning: lt_mem_sets_of_Limsup_lt -> lt_mem_sets_of_limsSup_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : Filter.{u1} α} {b : α}, (Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) b) -> (Filter.Eventually.{u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a b) f)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : Filter.{u1} α} {b : α}, (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.937 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.939 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.937 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.939) f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) b) -> (Filter.Eventually.{u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a b) f)
+Case conversion may be inaccurate. Consider using '#align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_ltₓ'. -/
 theorem lt_mem_sets_of_limsSup_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
     ∀ᶠ a in f, a < b :=
   let ⟨c, (h : ∀ᶠ a in f, a ≤ c), hcb⟩ := exists_lt_of_csInf_lt h l
   mem_of_superset h fun a hac => lt_of_le_of_lt hac hcb
 #align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_lt
--/
 
-#print gt_mem_sets_of_limsInf_gt /-
+/- warning: gt_mem_sets_of_Liminf_gt -> gt_mem_sets_of_limsInf_gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : Filter.{u1} α} {b : α}, (Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f)) -> (Filter.Eventually.{u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b a) f)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : Filter.{u1} α} {b : α}, (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1060 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1062 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1060 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1062) f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f)) -> (Filter.Eventually.{u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b a) f)
+Case conversion may be inaccurate. Consider using '#align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_limsInf_gtₓ'. -/
 theorem gt_mem_sets_of_limsInf_gt :
     ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a :=
   @lt_mem_sets_of_limsSup_lt αᵒᵈ _
 #align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_limsInf_gt
--/
 
 variable [TopologicalSpace α] [OrderTopology α]
 
 /- warning: le_nhds_of_Limsup_eq_Liminf -> le_nhds_of_limsSup_eq_limsInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1145 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1147 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1145 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1147) f) -> (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1161 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1163 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1161 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1163) f) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a))
 Case conversion may be inaccurate. Consider using '#align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsSup_eq_limsInfₓ'. -/
@@ -233,7 +281,7 @@ theorem limsInf_nhds : ∀ a : α, limsInf (𝓝 a) = a :=
 
 /- warning: Liminf_eq_of_le_nhds -> limsInf_eq_of_le_nhds is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
 Case conversion may be inaccurate. Consider using '#align Liminf_eq_of_le_nhds limsInf_eq_of_le_nhdsₓ'. -/
@@ -255,7 +303,7 @@ theorem limsInf_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝
 
 /- warning: Limsup_eq_of_le_nhds -> limsSup_eq_of_le_nhds is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
 Case conversion may be inaccurate. Consider using '#align Limsup_eq_of_le_nhds limsSup_eq_of_le_nhdsₓ'. -/
@@ -280,9 +328,14 @@ theorem Filter.Tendsto.liminf_eq {f : Filter β} {u : β → α} {a : α} [NeBot
 #align filter.tendsto.liminf_eq Filter.Tendsto.liminf_eq
 -/
 
+/- warning: tendsto_of_liminf_eq_limsup -> tendsto_of_liminf_eq_limsup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Eq.{succ u1} α (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (Eq.{succ u1} α (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (Eq.{succ u1} α (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (Eq.{succ u1} α (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1869 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1871 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1869 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1871) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1835) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1911 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1913 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1911 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1913) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1883) -> (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a))
+Case conversion may be inaccurate. Consider using '#align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsupₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
-#print tendsto_of_liminf_eq_limsup /-
 /-- 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)
@@ -296,11 +349,15 @@ theorem tendsto_of_liminf_eq_limsup {f : Filter β} {u : β → α} {a : α} (hi
     Tendsto u f (𝓝 a) :=
   le_nhds_of_limsSup_eq_limsInf h h' hsup hinf
 #align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsup
--/
 
+/- warning: tendsto_of_le_liminf_of_limsup_le -> tendsto_of_le_liminf_of_limsup_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u2} β} {u : β -> α} {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) a) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2001 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2003 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2001 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2003) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1973) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2043 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2045 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2043 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2045) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2015) -> (Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 a))
+Case conversion may be inaccurate. Consider using '#align tendsto_of_le_liminf_of_limsup_le tendsto_of_le_liminf_of_limsup_leₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
-#print tendsto_of_le_liminf_of_limsup_le /-
 /-- 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)
@@ -318,11 +375,15 @@ theorem tendsto_of_le_liminf_of_limsup_le {f : Filter β} {u : β → α} {a : 
     tendsto_of_liminf_eq_limsup (le_antisymm (le_trans (liminf_le_limsup h h') hsup) hinf)
       (le_antisymm hsup (le_trans hinf (liminf_le_limsup h h'))) h h'
 #align tendsto_of_le_liminf_of_limsup_le tendsto_of_le_liminf_of_limsup_le
--/
 
+/- warning: tendsto_of_no_upcrossings -> tendsto_of_no_upcrossings is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : DenselyOrdered.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))] {f : Filter.{u2} β} {u : β -> α} {s : Set.{u1} α}, (Dense.{u1} α _inst_2 s) -> (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a b) -> (Not (And (Filter.Frequently.{u2} β (fun (n : β) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (u n) a) f) (Filter.Frequently.{u2} β (fun (n : β) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b (u n)) f))))) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Exists.{succ u1} α (fun (c : α) => Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 c)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : DenselyOrdered.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))] {f : Filter.{u2} β} {u : β -> α} {s : Set.{u1} α}, (Dense.{u1} α _inst_2 s) -> (forall (a : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) a b) -> (Not (And (Filter.Frequently.{u2} β (fun (n : β) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (u n) a) f) (Filter.Frequently.{u2} β (fun (n : β) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) b (u n)) f))))) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2273 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2275 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2273 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2275) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2245) -> (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2315 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2317 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2315 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2317) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2287) -> (Exists.{succ u1} α (fun (c : α) => Filter.Tendsto.{u2, u1} β α u f (nhds.{u1} α _inst_2 c)))
+Case conversion may be inaccurate. Consider using '#align tendsto_of_no_upcrossings tendsto_of_no_upcrossingsₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
-#print tendsto_of_no_upcrossings /-
 /-- 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.
@@ -352,12 +413,16 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
   have B : ∃ᶠ n in f, b < u n := frequently_lt_of_lt_limsup (is_bounded.is_cobounded_le h') bu
   exact H a as b bs ab ⟨A, B⟩
 #align tendsto_of_no_upcrossings tendsto_of_no_upcrossings
--/
 
 variable [FirstCountableTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}
 
+/- warning: eventually_le_limsup -> eventually_le_limsup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Eventually.{u2} β (fun (b : β) => LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (u b) (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f)) f)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2758 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2760 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2758 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2760) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.2730) -> (Filter.Eventually.{u2} β (fun (b : β) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (u b) (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f)) f)
+Case conversion may be inaccurate. Consider using '#align eventually_le_limsup eventually_le_limsupₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
-#print eventually_le_limsup /-
 theorem eventually_le_limsup
     (hf : IsBoundedUnder (· ≤ ·) f u := by
       run_tac
@@ -381,10 +446,14 @@ theorem eventually_le_limsup
     contrapose! hy
     exact hx hy
 #align eventually_le_limsup eventually_le_limsup
--/
 
+/- warning: eventually_liminf_le -> eventually_liminf_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, (autoParamₓ.{0} (Filter.IsBoundedUnder.{u1, u2} α β (GE.ge.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f u) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 110 (OfNat.mk.{0} Nat 110 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 95 (OfNat.mk.{0} Nat 95 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 100 (OfNat.mk.{0} Nat 100 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 97 (OfNat.mk.{0} Nat 97 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 102 (OfNat.mk.{0} Nat 102 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 116 (OfNat.mk.{0} Nat 116 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 101 (OfNat.mk.{0} Nat 101 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 114 (OfNat.mk.{0} Nat 114 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous))) -> (Filter.Eventually.{u2} β (fun (b : β) => LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) (u b)) f)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] [_inst_4 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, (autoParam.{0} (Filter.IsBoundedUnder.{u1, u2} α β (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3050 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3052 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3050 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3052) f u) _auto._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.3022) -> (Filter.Eventually.{u2} β (fun (b : β) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) u f) (u b)) f)
+Case conversion may be inaccurate. Consider using '#align eventually_liminf_le eventually_liminf_leₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
-#print eventually_liminf_le /-
 theorem eventually_liminf_le
     (hf : IsBoundedUnder (· ≥ ·) f u := by
       run_tac
@@ -392,7 +461,6 @@ theorem eventually_liminf_le
     ∀ᶠ b in f, f.liminf u ≤ u b :=
   @eventually_le_limsup αᵒᵈ _ _ _ _ _ _ _ _ hf
 #align eventually_liminf_le eventually_liminf_le
--/
 
 end ConditionallyCompleteLinearOrder
 
@@ -607,7 +675,7 @@ variable {ι : Type _} {R : Type _} [CompleteLinearOrder R] [TopologicalSpace R]
 
 /- warning: infi_eq_of_forall_le_of_tendsto -> iInf_eq_of_forall_le_of_tendsto is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iInf.{u2, succ u1} R (ConditionallyCompleteLattice.toHasInf.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
+  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toHasLe.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iInf.{u2, succ u1} R (ConditionallyCompleteLattice.toHasInf.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
 but is expected to have type
   forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iInf.{u2, succ u1} R (ConditionallyCompleteLattice.toInfSet.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_1)))) ι (fun (i : ι) => as i)) x))
 Case conversion may be inaccurate. Consider using '#align infi_eq_of_forall_le_of_tendsto iInf_eq_of_forall_le_of_tendstoₓ'. -/
@@ -620,7 +688,7 @@ theorem iInf_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (x_le : ∀ i, x
 
 /- warning: supr_eq_of_forall_le_of_tendsto -> iSup_eq_of_forall_le_of_tendsto is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iSup.{u2, succ u1} R (ConditionallyCompleteLattice.toHasSup.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
+  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toHasLe.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iSup.{u2, succ u1} R (ConditionallyCompleteLattice.toHasSup.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
 but is expected to have type
   forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iSup.{u2, succ u1} R (ConditionallyCompleteLattice.toSupSet.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_1)))) ι (fun (i : ι) => as i)) x))
 Case conversion may be inaccurate. Consider using '#align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendstoₓ'. -/
@@ -629,7 +697,12 @@ theorem iSup_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (le_x : ∀ i, a
   @iInf_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
 #align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
-#print iUnion_Ici_eq_Ioi_of_lt_of_tendsto /-
+/- warning: Union_Ici_eq_Ioi_of_lt_of_tendsto -> iUnion_Ici_eq_Ioi_of_lt_of_tendsto is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_1 : CompleteLinearOrder.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : OrderTopology.{u1} R _inst_2 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))] {ι : Type.{u2}} (x : R) {as : ι -> R}, (forall (i : ι), LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u2} ι} [_inst_4 : Filter.NeBot.{u2} ι F], (Filter.Tendsto.{u2, u1} ι R as F (nhds.{u1} R _inst_2 x)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, succ u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) (as i))) (Set.Ioi.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) x)))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_1 : CompleteLinearOrder.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : OrderTopology.{u1} R _inst_2 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))] {ι : Type.{u2}} (x : R) {as : ι -> R}, (forall (i : ι), LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u2} ι} [_inst_4 : Filter.NeBot.{u2} ι F], (Filter.Tendsto.{u2, u1} ι R as F (nhds.{u1} R _inst_2 x)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, succ u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) (as i))) (Set.Ioi.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) x)))
+Case conversion may be inaccurate. Consider using '#align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendstoₓ'. -/
 theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (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 :=
@@ -641,15 +714,18 @@ theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R}
   rw [← iInf_eq_of_forall_le_of_tendsto (fun i => (x_lt i).le) as_lim] at *
   exact iUnion_Ici_eq_Ioi_iInf obs
 #align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendsto
--/
 
-#print iUnion_Iic_eq_Iio_of_lt_of_tendsto /-
+/- warning: Union_Iic_eq_Iio_of_lt_of_tendsto -> iUnion_Iic_eq_Iio_of_lt_of_tendsto is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_1 : CompleteLinearOrder.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : OrderTopology.{u1} R _inst_2 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))] {ι : Type.{u2}} (x : R) {as : ι -> R}, (forall (i : ι), LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u2} ι} [_inst_4 : Filter.NeBot.{u2} ι F], (Filter.Tendsto.{u2, u1} ι R as F (nhds.{u1} R _inst_2 x)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, succ u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) (as i))) (Set.Iio.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) x)))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_1 : CompleteLinearOrder.{u1} R] [_inst_2 : TopologicalSpace.{u1} R] [_inst_3 : OrderTopology.{u1} R _inst_2 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))] {ι : Type.{u2}} (x : R) {as : ι -> R}, (forall (i : ι), LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u2} ι} [_inst_4 : Filter.NeBot.{u2} ι F], (Filter.Tendsto.{u2, u1} ι R as F (nhds.{u1} R _inst_2 x)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, succ u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) (as i))) (Set.Iio.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_1)))) x)))
+Case conversion may be inaccurate. Consider using '#align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendstoₓ'. -/
 theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (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 :=
   @iUnion_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
 #align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendsto
--/
 
 end InfiAndSupr
 
Diff
@@ -181,94 +181,94 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α]
 
-#print lt_mem_sets_of_limsupₛ_lt /-
-theorem lt_mem_sets_of_limsupₛ_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsupₛ < b) :
+#print lt_mem_sets_of_limsSup_lt /-
+theorem lt_mem_sets_of_limsSup_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
     ∀ᶠ a in f, a < b :=
-  let ⟨c, (h : ∀ᶠ a in f, a ≤ c), hcb⟩ := exists_lt_of_cinfₛ_lt h l
+  let ⟨c, (h : ∀ᶠ a in f, a ≤ c), hcb⟩ := exists_lt_of_csInf_lt h l
   mem_of_superset h fun a hac => lt_of_le_of_lt hac hcb
-#align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsupₛ_lt
+#align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_lt
 -/
 
-#print gt_mem_sets_of_liminfₛ_gt /-
-theorem gt_mem_sets_of_liminfₛ_gt :
-    ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.liminfₛ → ∀ᶠ a in f, b < a :=
-  @lt_mem_sets_of_limsupₛ_lt αᵒᵈ _
-#align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_liminfₛ_gt
+#print gt_mem_sets_of_limsInf_gt /-
+theorem gt_mem_sets_of_limsInf_gt :
+    ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a :=
+  @lt_mem_sets_of_limsSup_lt αᵒᵈ _
+#align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_limsInf_gt
 -/
 
 variable [TopologicalSpace α] [OrderTopology α]
 
-/- warning: le_nhds_of_Limsup_eq_Liminf -> le_nhds_of_limsupₛ_eq_liminfₛ is a dubious translation:
+/- warning: le_nhds_of_Limsup_eq_Liminf -> le_nhds_of_limsSup_eq_limsInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Eq.{succ u1} α (Filter.limsupₛ.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.liminfₛ.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a))
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Filter.IsBounded.{u1} α (GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))))) f) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1145 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1147 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1145 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1147) f) -> (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1161 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1163 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1161 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1163) f) -> (Eq.{succ u1} α (Filter.limsupₛ.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.liminfₛ.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a))
-Case conversion may be inaccurate. Consider using '#align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsupₛ_eq_liminfₛₓ'. -/
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α}, (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1145 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1147 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1145 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1147) f) -> (Filter.IsBounded.{u1} α (fun (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1161 : α) (x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1163 : α) => GE.ge.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))) x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1161 x._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.1163) f) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a))
+Case conversion may be inaccurate. Consider using '#align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsSup_eq_limsInfₓ'. -/
 /-- 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_limsupₛ_eq_liminfₛ {f : Filter α} {a : α} (hl : f.IsBounded (· ≤ ·))
-    (hg : f.IsBounded (· ≥ ·)) (hs : f.limsupₛ = a) (hi : f.liminfₛ = a) : f ≤ 𝓝 a :=
+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 :=
   tendsto_order.2 <|
-    And.intro (fun b hb => gt_mem_sets_of_liminfₛ_gt hg <| hi.symm ▸ hb) fun b hb =>
-      lt_mem_sets_of_limsupₛ_lt hl <| hs.symm ▸ hb
-#align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsupₛ_eq_liminfₛ
+    And.intro (fun b hb => gt_mem_sets_of_limsInf_gt hg <| hi.symm ▸ hb) fun b hb =>
+      lt_mem_sets_of_limsSup_lt hl <| hs.symm ▸ hb
+#align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsSup_eq_limsInf
 
-#print limsupₛ_nhds /-
-theorem limsupₛ_nhds (a : α) : limsupₛ (𝓝 a) = a :=
-  cinfₛ_eq_of_forall_ge_of_forall_gt_exists_lt (isBounded_le_nhds a)
+#print limsSup_nhds /-
+theorem limsSup_nhds (a : α) : limsSup (𝓝 a) = a :=
+  csInf_eq_of_forall_ge_of_forall_gt_exists_lt (isBounded_le_nhds a)
     (fun a' (h : { n : α | n ≤ a' } ∈ 𝓝 a) => show a ≤ a' from @mem_of_mem_nhds α _ a _ h)
     fun b (hba : a < b) =>
     show ∃ (c : _)(h : { n : α | n ≤ c } ∈ 𝓝 a), c < b from
       match dense_or_discrete a b with
       | Or.inl ⟨c, hac, hcb⟩ => ⟨c, ge_mem_nhds hac, hcb⟩
       | Or.inr ⟨_, h⟩ => ⟨a, (𝓝 a).sets_of_superset (gt_mem_nhds hba) h, hba⟩
-#align Limsup_nhds limsupₛ_nhds
+#align Limsup_nhds limsSup_nhds
 -/
 
-#print liminfₛ_nhds /-
-theorem liminfₛ_nhds : ∀ a : α, liminfₛ (𝓝 a) = a :=
-  @limsupₛ_nhds αᵒᵈ _ _ _
-#align Liminf_nhds liminfₛ_nhds
+#print limsInf_nhds /-
+theorem limsInf_nhds : ∀ a : α, limsInf (𝓝 a) = a :=
+  @limsSup_nhds αᵒᵈ _ _ _
+#align Liminf_nhds limsInf_nhds
 -/
 
-/- warning: Liminf_eq_of_le_nhds -> liminfₛ_eq_of_le_nhds is a dubious translation:
+/- warning: Liminf_eq_of_le_nhds -> limsInf_eq_of_le_nhds is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.liminfₛ.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.liminfₛ.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
-Case conversion may be inaccurate. Consider using '#align Liminf_eq_of_le_nhds liminfₛ_eq_of_le_nhdsₓ'. -/
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
+Case conversion may be inaccurate. Consider using '#align Liminf_eq_of_le_nhds limsInf_eq_of_le_nhdsₓ'. -/
 /-- If a filter is converging, its limsup coincides with its limit. -/
-theorem liminfₛ_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝 a) : f.liminfₛ = a :=
+theorem limsInf_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝 a) : f.limsInf = a :=
   have hb_ge : IsBounded (· ≥ ·) f := (isBounded_ge_nhds a).mono h
   have hb_le : IsBounded (· ≤ ·) f := (isBounded_le_nhds a).mono h
   le_antisymm
     (calc
-      f.liminfₛ ≤ f.limsupₛ := liminfₛ_le_limsupₛ hb_le hb_ge
-      _ ≤ (𝓝 a).limsupₛ := (limsupₛ_le_limsupₛ_of_le h hb_ge.isCobounded_flip (isBounded_le_nhds a))
-      _ = a := limsupₛ_nhds a
+      f.limsInf ≤ f.limsSup := limsInf_le_limsSup hb_le hb_ge
+      _ ≤ (𝓝 a).limsSup := (limsSup_le_limsSup_of_le h hb_ge.isCobounded_flip (isBounded_le_nhds a))
+      _ = a := limsSup_nhds a
       )
     (calc
-      a = (𝓝 a).liminfₛ := (liminfₛ_nhds a).symm
-      _ ≤ f.liminfₛ := liminfₛ_le_liminfₛ_of_le h (isBounded_ge_nhds a) hb_le.isCobounded_flip
+      a = (𝓝 a).limsInf := (limsInf_nhds a).symm
+      _ ≤ f.limsInf := limsInf_le_limsInf_of_le h (isBounded_ge_nhds a) hb_le.isCobounded_flip
       )
-#align Liminf_eq_of_le_nhds liminfₛ_eq_of_le_nhds
+#align Liminf_eq_of_le_nhds limsInf_eq_of_le_nhds
 
-/- warning: Limsup_eq_of_le_nhds -> limsupₛ_eq_of_le_nhds is a dubious translation:
+/- warning: Limsup_eq_of_le_nhds -> limsSup_eq_of_le_nhds is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsupₛ.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsupₛ.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
-Case conversion may be inaccurate. Consider using '#align Limsup_eq_of_le_nhds limsupₛ_eq_of_le_nhdsₓ'. -/
+  forall {α : Type.{u1}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)))))] {f : Filter.{u1} α} {a : α} [_inst_4 : Filter.NeBot.{u1} α f], (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) f (nhds.{u1} α _inst_2 a)) -> (Eq.{succ u1} α (Filter.limsSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1) f) a)
+Case conversion may be inaccurate. Consider using '#align Limsup_eq_of_le_nhds limsSup_eq_of_le_nhdsₓ'. -/
 /-- If a filter is converging, its liminf coincides with its limit. -/
-theorem limsupₛ_eq_of_le_nhds : ∀ {f : Filter α} {a : α} [NeBot f], f ≤ 𝓝 a → f.limsupₛ = a :=
-  @liminfₛ_eq_of_le_nhds αᵒᵈ _ _ _
-#align Limsup_eq_of_le_nhds limsupₛ_eq_of_le_nhds
+theorem limsSup_eq_of_le_nhds : ∀ {f : Filter α} {a : α} [NeBot f], f ≤ 𝓝 a → f.limsSup = a :=
+  @limsInf_eq_of_le_nhds αᵒᵈ _ _ _
+#align Limsup_eq_of_le_nhds limsSup_eq_of_le_nhds
 
 #print Filter.Tendsto.limsup_eq /-
 /-- 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 :=
-  limsupₛ_eq_of_le_nhds h
+  limsSup_eq_of_le_nhds h
 #align filter.tendsto.limsup_eq Filter.Tendsto.limsup_eq
 -/
 
@@ -276,7 +276,7 @@ theorem Filter.Tendsto.limsup_eq {f : Filter β} {u : β → α} {a : α} [NeBot
 /-- 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 :=
-  liminfₛ_eq_of_le_nhds h
+  limsInf_eq_of_le_nhds h
 #align filter.tendsto.liminf_eq Filter.Tendsto.liminf_eq
 -/
 
@@ -294,7 +294,7 @@ theorem tendsto_of_liminf_eq_limsup {f : Filter β} {u : β → α} {a : α} (hi
       run_tac
         is_bounded_default) :
     Tendsto u f (𝓝 a) :=
-  le_nhds_of_limsupₛ_eq_liminfₛ h h' hsup hinf
+  le_nhds_of_limsSup_eq_limsInf h h' hsup hinf
 #align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsup
 -/
 
@@ -437,25 +437,25 @@ section Monotone
 variable {ι R S : Type _} {F : Filter ι} [NeBot F] [CompleteLinearOrder R] [TopologicalSpace R]
   [OrderTopology R] [CompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
 
-/- warning: antitone.map_Limsup_of_continuous_at -> Antitone.map_limsupₛ_of_continuousAt is a dubious translation:
+/- warning: antitone.map_Limsup_of_continuous_at -> Antitone.map_limsSup_of_continuousAt is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Antitone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsupₛ.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsupₛ.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.liminf.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
+  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Antitone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsSup.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsSup.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.liminf.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Antitone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsupₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsupₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.liminf.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
-Case conversion may be inaccurate. Consider using '#align antitone.map_Limsup_of_continuous_at Antitone.map_limsupₛ_of_continuousAtₓ'. -/
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Antitone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsSup.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsSup.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.liminf.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
+Case conversion may be inaccurate. Consider using '#align antitone.map_Limsup_of_continuous_at Antitone.map_limsSup_of_continuousAtₓ'. -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
 /-- An antitone function between complete linear ordered spaces sends a `filter.Limsup`
 to the `filter.liminf` of the image if it is continuous at the `Limsup`. -/
-theorem Antitone.map_limsupₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsupₛ) : f F.limsupₛ = F.liminf f :=
+theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
+    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsSup) : f F.limsSup = F.liminf f :=
   by
   apply le_antisymm
   · have A : { a : R | ∀ᶠ n : R in F, n ≤ a }.Nonempty := ⟨⊤, by simp⟩
     rw [Limsup, f_decr.map_Inf_of_continuous_at' f_cont A]
     apply le_of_forall_lt
     intro c hc
-    simp only [liminf, Liminf, lt_supₛ_iff, eventually_map, Set.mem_setOf_eq, exists_prop,
+    simp only [liminf, Liminf, lt_sSup_iff, eventually_map, Set.mem_setOf_eq, exists_prop,
       Set.mem_image, exists_exists_and_eq_and] at hc⊢
     rcases hc with ⟨d, hd, h'd⟩
     refine' ⟨f d, _, h'd⟩
@@ -501,7 +501,7 @@ theorem Antitone.map_limsupₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R 
       exact f_decr hx.le
     have I : f m < F.liminf f := h'l ⟨l_m, m_lt.le⟩
     exact lt_irrefl _ (B.trans_lt I)
-#align antitone.map_Limsup_of_continuous_at Antitone.map_limsupₛ_of_continuousAt
+#align antitone.map_Limsup_of_continuous_at Antitone.map_limsSup_of_continuousAt
 
 /- warning: antitone.map_limsup_of_continuous_at -> Antitone.map_limsup_of_continuousAt is a dubious translation:
 lean 3 declaration is
@@ -513,22 +513,22 @@ Case conversion may be inaccurate. Consider using '#align antitone.map_limsup_of
 to the `filter.liminf` of the images. -/
 theorem Antitone.map_limsup_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.limsup a)) : f (F.limsup a) = F.liminf (f ∘ a) :=
-  f_decr.map_limsupₛ_of_continuousAt f_cont
+  f_decr.map_limsSup_of_continuousAt f_cont
 #align antitone.map_limsup_of_continuous_at Antitone.map_limsup_of_continuousAt
 
-/- warning: antitone.map_Liminf_of_continuous_at -> Antitone.map_liminfₛ_of_continuousAt is a dubious translation:
+/- warning: antitone.map_Liminf_of_continuous_at -> Antitone.map_limsInf_of_continuousAt is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Antitone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.liminfₛ.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.liminfₛ.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.limsup.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
+  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Antitone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsInf.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsInf.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.limsup.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Antitone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.liminfₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.liminfₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.limsup.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
-Case conversion may be inaccurate. Consider using '#align antitone.map_Liminf_of_continuous_at Antitone.map_liminfₛ_of_continuousAtₓ'. -/
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Antitone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsInf.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsInf.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.limsup.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
+Case conversion may be inaccurate. Consider using '#align antitone.map_Liminf_of_continuous_at Antitone.map_limsInf_of_continuousAtₓ'. -/
 /-- An antitone function between complete linear ordered spaces sends a `filter.Liminf`
 to the `filter.limsup` of the image if it is continuous at the `Liminf`. -/
-theorem Antitone.map_liminfₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_decr : Antitone f) (f_cont : ContinuousAt f F.liminfₛ) : f F.liminfₛ = F.limsup f :=
-  @Antitone.map_limsupₛ_of_continuousAt (OrderDual R) (OrderDual S) _ _ _ _ _ _ _ _ f f_decr.dual
+theorem Antitone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
+    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsInf) : f F.limsInf = F.limsup f :=
+  @Antitone.map_limsSup_of_continuousAt (OrderDual R) (OrderDual S) _ _ _ _ _ _ _ _ f f_decr.dual
     f_cont
-#align antitone.map_Liminf_of_continuous_at Antitone.map_liminfₛ_of_continuousAt
+#align antitone.map_Liminf_of_continuous_at Antitone.map_limsInf_of_continuousAt
 
 /- warning: antitone.map_liminf_of_continuous_at -> Antitone.map_liminf_of_continuousAt is a dubious translation:
 lean 3 declaration is
@@ -540,21 +540,21 @@ Case conversion may be inaccurate. Consider using '#align antitone.map_liminf_of
 to the `filter.limsup` of the images. -/
 theorem Antitone.map_liminf_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.liminf a)) : f (F.liminf a) = F.limsup (f ∘ a) :=
-  f_decr.map_liminfₛ_of_continuousAt f_cont
+  f_decr.map_limsInf_of_continuousAt f_cont
 #align antitone.map_liminf_of_continuous_at Antitone.map_liminf_of_continuousAt
 
-/- warning: monotone.map_Limsup_of_continuous_at -> Monotone.map_limsupₛ_of_continuousAt is a dubious translation:
+/- warning: monotone.map_Limsup_of_continuous_at -> Monotone.map_limsSup_of_continuousAt is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Monotone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsupₛ.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsupₛ.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.limsup.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
+  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Monotone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsSup.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsSup.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.limsup.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Monotone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsupₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsupₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.limsup.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
-Case conversion may be inaccurate. Consider using '#align monotone.map_Limsup_of_continuous_at Monotone.map_limsupₛ_of_continuousAtₓ'. -/
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Monotone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsSup.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsSup.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.limsup.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
+Case conversion may be inaccurate. Consider using '#align monotone.map_Limsup_of_continuous_at Monotone.map_limsSup_of_continuousAtₓ'. -/
 /-- A monotone function between complete linear ordered spaces sends a `filter.Limsup`
 to the `filter.limsup` of the image if it is continuous at the `Limsup`. -/
-theorem Monotone.map_limsupₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsupₛ) : f F.limsupₛ = F.limsup f :=
-  @Antitone.map_limsupₛ_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
-#align monotone.map_Limsup_of_continuous_at Monotone.map_limsupₛ_of_continuousAt
+theorem Monotone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
+    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsSup) : f F.limsSup = F.limsup f :=
+  @Antitone.map_limsSup_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
+#align monotone.map_Limsup_of_continuous_at Monotone.map_limsSup_of_continuousAt
 
 /- warning: monotone.map_limsup_of_continuous_at -> Monotone.map_limsup_of_continuousAt is a dubious translation:
 lean 3 declaration is
@@ -566,21 +566,21 @@ Case conversion may be inaccurate. Consider using '#align monotone.map_limsup_of
 to the `filter.limsup` of the images. -/
 theorem Monotone.map_limsup_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.limsup a)) : f (F.limsup a) = F.limsup (f ∘ a) :=
-  f_incr.map_limsupₛ_of_continuousAt f_cont
+  f_incr.map_limsSup_of_continuousAt f_cont
 #align monotone.map_limsup_of_continuous_at Monotone.map_limsup_of_continuousAt
 
-/- warning: monotone.map_Liminf_of_continuous_at -> Monotone.map_liminfₛ_of_continuousAt is a dubious translation:
+/- warning: monotone.map_Liminf_of_continuous_at -> Monotone.map_limsInf_of_continuousAt is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Monotone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.liminfₛ.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.liminfₛ.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.liminf.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
+  forall {R : Type.{u1}} {S : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u1} R] [_inst_3 : TopologicalSpace.{u1} R] [_inst_4 : OrderTopology.{u1} R _inst_3 (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u2} S] [_inst_6 : TopologicalSpace.{u2} S] [_inst_7 : OrderTopology.{u2} S _inst_6 (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5))))] {F : Filter.{u1} R} [_inst_8 : Filter.NeBot.{u1} R F] {f : R -> S}, (Monotone.{u1, u2} R S (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (PartialOrder.toPreorder.{u2} S (CompleteSemilatticeInf.toPartialOrder.{u2} S (CompleteLattice.toCompleteSemilatticeInf.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)))) f) -> (ContinuousAt.{u1, u2} R S _inst_3 _inst_6 f (Filter.limsInf.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) -> (Eq.{succ u2} S (f (Filter.limsInf.{u1} R (CompleteLattice.toConditionallyCompleteLattice.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) F)) (Filter.liminf.{u2, u1} S R (CompleteLattice.toConditionallyCompleteLattice.{u2} S (CompleteLinearOrder.toCompleteLattice.{u2} S _inst_5)) f F))
 but is expected to have type
-  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Monotone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.liminfₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.liminfₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.liminf.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
-Case conversion may be inaccurate. Consider using '#align monotone.map_Liminf_of_continuous_at Monotone.map_liminfₛ_of_continuousAtₓ'. -/
+  forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Monotone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsInf.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsInf.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.liminf.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
+Case conversion may be inaccurate. Consider using '#align monotone.map_Liminf_of_continuous_at Monotone.map_limsInf_of_continuousAtₓ'. -/
 /-- A monotone function between complete linear ordered spaces sends a `filter.Liminf`
 to the `filter.liminf` of the image if it is continuous at the `Liminf`. -/
-theorem Monotone.map_liminfₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_incr : Monotone f) (f_cont : ContinuousAt f F.liminfₛ) : f F.liminfₛ = F.liminf f :=
-  @Antitone.map_liminfₛ_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
-#align monotone.map_Liminf_of_continuous_at Monotone.map_liminfₛ_of_continuousAt
+theorem Monotone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
+    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsInf) : f F.limsInf = F.liminf f :=
+  @Antitone.map_limsInf_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
+#align monotone.map_Liminf_of_continuous_at Monotone.map_limsInf_of_continuousAt
 
 /- warning: monotone.map_liminf_of_continuous_at -> Monotone.map_liminf_of_continuousAt is a dubious translation:
 lean 3 declaration is
@@ -592,7 +592,7 @@ Case conversion may be inaccurate. Consider using '#align monotone.map_liminf_of
 to the `filter.liminf` of the images. -/
 theorem Monotone.map_liminf_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.liminf a)) : f (F.liminf a) = F.liminf (f ∘ a) :=
-  f_incr.map_liminfₛ_of_continuousAt f_cont
+  f_incr.map_limsInf_of_continuousAt f_cont
 #align monotone.map_liminf_of_continuous_at Monotone.map_liminf_of_continuousAt
 
 end Monotone
@@ -605,32 +605,32 @@ open Filter Set
 
 variable {ι : Type _} {R : Type _} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
-/- warning: infi_eq_of_forall_le_of_tendsto -> infᵢ_eq_of_forall_le_of_tendsto is a dubious translation:
+/- warning: infi_eq_of_forall_le_of_tendsto -> iInf_eq_of_forall_le_of_tendsto is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (infᵢ.{u2, succ u1} R (ConditionallyCompleteLattice.toHasInf.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
+  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iInf.{u2, succ u1} R (ConditionallyCompleteLattice.toHasInf.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
 but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (infᵢ.{u2, succ u1} R (ConditionallyCompleteLattice.toInfSet.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_1)))) ι (fun (i : ι) => as i)) x))
-Case conversion may be inaccurate. Consider using '#align infi_eq_of_forall_le_of_tendsto infᵢ_eq_of_forall_le_of_tendstoₓ'. -/
-theorem infᵢ_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (x_le : ∀ i, x ≤ as i) {F : Filter ι}
+  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) x (as i)) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iInf.{u2, succ u1} R (ConditionallyCompleteLattice.toInfSet.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_1)))) ι (fun (i : ι) => as i)) x))
+Case conversion may be inaccurate. Consider using '#align infi_eq_of_forall_le_of_tendsto iInf_eq_of_forall_le_of_tendstoₓ'. -/
+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 :=
   by
-  refine' infᵢ_eq_of_forall_ge_of_forall_gt_exists_lt (fun i => x_le i) _
+  refine' iInf_eq_of_forall_ge_of_forall_gt_exists_lt (fun i => x_le i) _
   apply fun w x_lt_w => ‹Filter.NeBot F›.nonempty_of_mem (eventually_lt_of_tendsto_lt x_lt_w as_lim)
-#align infi_eq_of_forall_le_of_tendsto infᵢ_eq_of_forall_le_of_tendsto
+#align infi_eq_of_forall_le_of_tendsto iInf_eq_of_forall_le_of_tendsto
 
-/- warning: supr_eq_of_forall_le_of_tendsto -> supᵢ_eq_of_forall_le_of_tendsto is a dubious translation:
+/- warning: supr_eq_of_forall_le_of_tendsto -> iSup_eq_of_forall_le_of_tendsto is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (supᵢ.{u2, succ u1} R (ConditionallyCompleteLattice.toHasSup.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
+  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iSup.{u2, succ u1} R (ConditionallyCompleteLattice.toHasSup.{u2} R (CompleteLattice.toConditionallyCompleteLattice.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))) ι (fun (i : ι) => as i)) x))
 but is expected to have type
-  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (supᵢ.{u2, succ u1} R (ConditionallyCompleteLattice.toSupSet.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_1)))) ι (fun (i : ι) => as i)) x))
-Case conversion may be inaccurate. Consider using '#align supr_eq_of_forall_le_of_tendsto supᵢ_eq_of_forall_le_of_tendstoₓ'. -/
-theorem supᵢ_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (le_x : ∀ i, as i ≤ x) {F : Filter ι}
+  forall {ι : Type.{u1}} {R : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u2} R] [_inst_2 : TopologicalSpace.{u2} R] [_inst_3 : OrderTopology.{u2} R _inst_2 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))] {x : R} {as : ι -> R}, (forall (i : ι), LE.le.{u2} R (Preorder.toLE.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_1))))) (as i) x) -> (forall {F : Filter.{u1} ι} [_inst_4 : Filter.NeBot.{u1} ι F], (Filter.Tendsto.{u1, u2} ι R as F (nhds.{u2} R _inst_2 x)) -> (Eq.{succ u2} R (iSup.{u2, succ u1} R (ConditionallyCompleteLattice.toSupSet.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_1)))) ι (fun (i : ι) => as i)) x))
+Case conversion may be inaccurate. Consider using '#align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendstoₓ'. -/
+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 :=
-  @infᵢ_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
-#align supr_eq_of_forall_le_of_tendsto supᵢ_eq_of_forall_le_of_tendsto
+  @iInf_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
+#align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
-#print unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto /-
-theorem unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
+#print iUnion_Ici_eq_Ioi_of_lt_of_tendsto /-
+theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (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 :=
   by
@@ -638,17 +638,17 @@ theorem unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι →
     intro maybe_x_is
     rcases mem_range.mp maybe_x_is with ⟨i, hi⟩
     simpa only [hi, lt_self_iff_false] using x_lt i
-  rw [← infᵢ_eq_of_forall_le_of_tendsto (fun i => (x_lt i).le) as_lim] at *
-  exact unionᵢ_Ici_eq_Ioi_infᵢ obs
-#align Union_Ici_eq_Ioi_of_lt_of_tendsto unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto
+  rw [← iInf_eq_of_forall_le_of_tendsto (fun i => (x_lt i).le) as_lim] at *
+  exact iUnion_Ici_eq_Ioi_iInf obs
+#align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendsto
 -/
 
-#print unionᵢ_Iic_eq_Iio_of_lt_of_tendsto /-
-theorem unionᵢ_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
+#print iUnion_Iic_eq_Iio_of_lt_of_tendsto /-
+theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (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 :=
-  @unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
-#align Union_Iic_eq_Iio_of_lt_of_tendsto unionᵢ_Iic_eq_Iio_of_lt_of_tendsto
+  @iUnion_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
+#align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendsto
 -/
 
 end InfiAndSupr
@@ -670,8 +670,8 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
           atTop } :=
   by
   ext ω
-  simp only [limsup_eq_infi_supr_of_nat, ge_iff_le, Set.supᵢ_eq_unionᵢ, Set.infᵢ_eq_interᵢ,
-    Set.mem_interᵢ, Set.mem_unionᵢ, exists_prop]
+  simp only [limsup_eq_infi_supr_of_nat, ge_iff_le, Set.iSup_eq_iUnion, Set.iInf_eq_iInter,
+    Set.mem_iInter, Set.mem_iUnion, exists_prop]
   constructor
   · intro hω
     refine'
Diff
@@ -357,6 +357,7 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
 variable [FirstCountableTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+#print eventually_le_limsup /-
 theorem eventually_le_limsup
     (hf : IsBoundedUnder (· ≤ ·) f u := by
       run_tac
@@ -380,8 +381,10 @@ theorem eventually_le_limsup
     contrapose! hy
     exact hx hy
 #align eventually_le_limsup eventually_le_limsup
+-/
 
 /- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+#print eventually_liminf_le /-
 theorem eventually_liminf_le
     (hf : IsBoundedUnder (· ≥ ·) f u := by
       run_tac
@@ -389,6 +392,7 @@ theorem eventually_liminf_le
     ∀ᶠ b in f, f.liminf u ≤ u b :=
   @eventually_le_limsup αᵒᵈ _ _ _ _ _ _ _ _ hf
 #align eventually_liminf_le eventually_liminf_le
+-/
 
 end ConditionallyCompleteLinearOrder
 
@@ -397,6 +401,12 @@ section CompleteLinearOrder
 variable [CompleteLinearOrder α] [TopologicalSpace α] [FirstCountableTopology α] [OrderTopology α]
   {f : Filter β} [CountableInterFilter f] {u : β → α}
 
+/- warning: limsup_eq_bot -> limsup_eq_bot is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] [_inst_4 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1))))] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, Iff (Eq.{succ u1} α (Filter.limsup.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)) u f) (Bot.bot.{u1} α (ConditionallyCompleteLinearOrderBot.toHasBot.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1)))) (Filter.EventuallyEq.{u2, u1} β α f u (Bot.bot.{max u2 u1} (β -> α) (Pi.hasBot.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => ConditionallyCompleteLinearOrderBot.toHasBot.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1)))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] [_inst_4 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1))))] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, Iff (Eq.{succ u1} α (Filter.limsup.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1))) u f) (Bot.bot.{u1} α (ConditionallyCompleteLinearOrderBot.toBot.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1)))) (Filter.EventuallyEq.{u2, u1} β α f u (Bot.bot.{max u1 u2} (β -> α) (Pi.instBotForAll.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => ConditionallyCompleteLinearOrderBot.toBot.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1)))))
+Case conversion may be inaccurate. Consider using '#align limsup_eq_bot limsup_eq_botₓ'. -/
 @[simp]
 theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
   ⟨fun h =>
@@ -407,6 +417,12 @@ theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
     exact limsup_const_bot⟩
 #align limsup_eq_bot limsup_eq_bot
 
+/- warning: liminf_eq_top -> liminf_eq_top is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] [_inst_4 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1))))] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, Iff (Eq.{succ u1} α (Filter.liminf.{u1, u2} α β (CompleteLattice.toConditionallyCompleteLattice.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)) u f) (Top.top.{u1} α (CompleteLattice.toHasTop.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)))) (Filter.EventuallyEq.{u2, u1} β α f u (Top.top.{max u2 u1} (β -> α) (Pi.hasTop.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => CompleteLattice.toHasTop.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : CompleteLinearOrder.{u1} α] [_inst_2 : TopologicalSpace.{u1} α] [_inst_3 : TopologicalSpace.FirstCountableTopology.{u1} α _inst_2] [_inst_4 : OrderTopology.{u1} α _inst_2 (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1))))] {f : Filter.{u2} β} [_inst_5 : CountableInterFilter.{u2} β f] {u : β -> α}, Iff (Eq.{succ u1} α (Filter.liminf.{u1, u2} α β (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} α (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} α _inst_1))) u f) (Top.top.{u1} α (CompleteLattice.toTop.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)))) (Filter.EventuallyEq.{u2, u1} β α f u (Top.top.{max u1 u2} (β -> α) (Pi.instTopForAll.{u2, u1} β (fun (ᾰ : β) => α) (fun (i : β) => CompleteLattice.toTop.{u1} α (CompleteLinearOrder.toCompleteLattice.{u1} α _inst_1)))))
+Case conversion may be inaccurate. Consider using '#align liminf_eq_top liminf_eq_topₓ'. -/
 @[simp]
 theorem liminf_eq_top : f.liminf u = ⊤ ↔ u =ᶠ[f] ⊤ :=
   @limsup_eq_bot αᵒᵈ _ _ _ _ _ _ _ _
@@ -645,7 +661,7 @@ open BigOperators
 lean 3 declaration is
   forall {α : Type.{u1}} (s : Nat -> (Set.{u1} α)), Eq.{succ u1} (Set.{u1} α) (Filter.limsup.{u1, 0} (Set.{u1} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) (setOf.{u1} α (fun (ω : α) => Filter.Tendsto.{0, 0} Nat Nat (fun (n : Nat) => Finset.sum.{0, 0} Nat Nat Nat.addCommMonoid (Finset.range n) (fun (k : Nat) => Set.indicator.{u1, 0} α Nat Nat.hasZero (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (OfNat.ofNat.{u1} (α -> Nat) 1 (OfNat.mk.{u1} (α -> Nat) 1 (One.one.{u1} (α -> Nat) (Pi.instOne.{u1, 0} α (fun (ᾰ : α) => Nat) (fun (i : α) => Nat.hasOne))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))))
 but is expected to have type
-  forall {α : Type.{u1}} (s : Nat -> (Set.{u1} α)), Eq.{succ u1} (Set.{u1} α) (Filter.limsup.{u1, 0} (Set.{u1} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) (setOf.{u1} α (fun (ω : α) => Filter.Tendsto.{0, 0} Nat Nat (fun (n : Nat) => Finset.sum.{0, 0} Nat Nat Nat.addCommMonoid (Finset.range n) (fun (k : Nat) => Set.indicator.{u1, 0} α Nat (LinearOrderedCommMonoidWithZero.toZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (OfNat.ofNat.{u1} (α -> Nat) 1 (One.toOfNat1.{u1} (α -> Nat) (Pi.instOne.{u1, 0} α (fun (a._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.4450 : α) => Nat) (fun (i : α) => CanonicallyOrderedCommSemiring.toOne.{0} Nat Nat.canonicallyOrderedCommSemiring)))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))))
+  forall {α : Type.{u1}} (s : Nat -> (Set.{u1} α)), Eq.{succ u1} (Set.{u1} α) (Filter.limsup.{u1, 0} (Set.{u1} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) (setOf.{u1} α (fun (ω : α) => Filter.Tendsto.{0, 0} Nat Nat (fun (n : Nat) => Finset.sum.{0, 0} Nat Nat Nat.addCommMonoid (Finset.range n) (fun (k : Nat) => Set.indicator.{u1, 0} α Nat (LinearOrderedCommMonoidWithZero.toZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (OfNat.ofNat.{u1} (α -> Nat) 1 (One.toOfNat1.{u1} (α -> Nat) (Pi.instOne.{u1, 0} α (fun (a._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.5073 : α) => Nat) (fun (i : α) => CanonicallyOrderedCommSemiring.toOne.{0} Nat Nat.canonicallyOrderedCommSemiring)))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))))
 Case conversion may be inaccurate. Consider using '#align limsup_eq_tendsto_sum_indicator_nat_at_top limsup_eq_tendsto_sum_indicator_nat_atTopₓ'. -/
 theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     limsup s atTop =
@@ -725,7 +741,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
 lean 3 declaration is
   forall {α : Type.{u1}} (R : Type.{u2}) [_inst_1 : StrictOrderedSemiring.{u2} R] [_inst_2 : Archimedean.{u2} R (OrderedSemiring.toOrderedAddCommMonoid.{u2} R (StrictOrderedSemiring.toOrderedSemiring.{u2} R _inst_1))] (s : Nat -> (Set.{u1} α)), Eq.{succ u1} (Set.{u1} α) (Filter.limsup.{u1, 0} (Set.{u1} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) (setOf.{u1} α (fun (ω : α) => Filter.Tendsto.{0, u2} Nat R (fun (n : Nat) => Finset.sum.{u2, 0} R Nat (OrderedCancelAddCommMonoid.toAddCommMonoid.{u2} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u2} R _inst_1)) (Finset.range n) (fun (k : Nat) => Set.indicator.{u1, u2} α R (MulZeroClass.toHasZero.{u2} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (StrictOrderedSemiring.toSemiring.{u2} R _inst_1))))) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (OfNat.ofNat.{max u1 u2} (α -> R) 1 (OfNat.mk.{max u1 u2} (α -> R) 1 (One.one.{max u1 u2} (α -> R) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => AddMonoidWithOne.toOne.{u2} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u2} R (NonAssocSemiring.toAddCommMonoidWithOne.{u2} R (Semiring.toNonAssocSemiring.{u2} R (StrictOrderedSemiring.toSemiring.{u2} R _inst_1))))))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (Filter.atTop.{u2} R (PartialOrder.toPreorder.{u2} R (OrderedCancelAddCommMonoid.toPartialOrder.{u2} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u2} R _inst_1))))))
 but is expected to have type
-  forall {α : Type.{u2}} (R : Type.{u1}) [_inst_1 : StrictOrderedSemiring.{u1} R] [_inst_2 : Archimedean.{u1} R (OrderedSemiring.toOrderedAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedSemiring.{u1} R _inst_1))] (s : Nat -> (Set.{u2} α)), Eq.{succ u2} (Set.{u2} α) (Filter.limsup.{u2, 0} (Set.{u2} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) (setOf.{u2} α (fun (ω : α) => Filter.Tendsto.{0, u1} Nat R (fun (n : Nat) => Finset.sum.{u1, 0} R Nat (OrderedCancelAddCommMonoid.toAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)) (Finset.range n) (fun (k : Nat) => Set.indicator.{u2, u1} α R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (OfNat.ofNat.{max u2 u1} (α -> R) 1 (One.toOfNat1.{max u2 u1} (α -> R) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.5390 : α) => R) (fun (i : α) => Semiring.toOne.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (Filter.atTop.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1)))))
+  forall {α : Type.{u2}} (R : Type.{u1}) [_inst_1 : StrictOrderedSemiring.{u1} R] [_inst_2 : Archimedean.{u1} R (OrderedSemiring.toOrderedAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedSemiring.{u1} R _inst_1))] (s : Nat -> (Set.{u2} α)), Eq.{succ u2} (Set.{u2} α) (Filter.limsup.{u2, 0} (Set.{u2} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) (setOf.{u2} α (fun (ω : α) => Filter.Tendsto.{0, u1} Nat R (fun (n : Nat) => Finset.sum.{u1, 0} R Nat (OrderedCancelAddCommMonoid.toAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)) (Finset.range n) (fun (k : Nat) => Set.indicator.{u2, u1} α R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (OfNat.ofNat.{max u2 u1} (α -> R) 1 (One.toOfNat1.{max u2 u1} (α -> R) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.6013 : α) => R) (fun (i : α) => Semiring.toOne.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (Filter.atTop.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align limsup_eq_tendsto_sum_indicator_at_top limsup_eq_tendsto_sum_indicator_atTopₓ'. -/
 theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type _) [StrictOrderedSemiring R] [Archimedean R]
     (s : ℕ → Set α) :
Diff
@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module topology.algebra.order.liminf_limsup
-! leanprover-community/mathlib commit b6da1a0b3e7cd83b1f744c49ce48ef8c6307d2f6
+! leanprover-community/mathlib commit 52932b3a083d4142e78a15dc928084a22fea9ba0
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,7 @@ import Mathbin.Algebra.BigOperators.Order
 import Mathbin.Algebra.IndicatorFunction
 import Mathbin.Order.LiminfLimsup
 import Mathbin.Order.Filter.Archimedean
+import Mathbin.Order.Filter.CountableInter
 import Mathbin.Topology.Order.Basic
 
 /-!
@@ -23,7 +24,7 @@ import Mathbin.Topology.Order.Basic
 -/
 
 
-open Filter
+open Filter TopologicalSpace
 
 open Topology Classical
 
@@ -353,8 +354,66 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
 #align tendsto_of_no_upcrossings tendsto_of_no_upcrossings
 -/
 
+variable [FirstCountableTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}
+
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+theorem eventually_le_limsup
+    (hf : IsBoundedUnder (· ≤ ·) f u := by
+      run_tac
+        is_bounded_default) :
+    ∀ᶠ b in f, u b ≤ f.limsup u :=
+  by
+  obtain ha | ha := isTop_or_exists_gt (f.limsup u)
+  · exact eventually_of_forall fun _ => ha _
+  by_cases H : IsGLB (Set.Ioi (f.limsup u)) (f.limsup u)
+  · obtain ⟨u, -, -, hua, hu⟩ := H.exists_seq_antitone_tendsto ha
+    have := fun n => eventually_lt_of_limsup_lt (hu n) hf
+    exact
+      (eventually_countable_forall.2 this).mono fun b hb =>
+        ge_of_tendsto hua <| eventually_of_forall fun n => (hb _).le
+  · obtain ⟨x, hx, xa⟩ : ∃ x, (∀ ⦃b⦄, f.limsup u < b → x ≤ b) ∧ f.limsup u < x :=
+      by
+      simp only [IsGLB, IsGreatest, lowerBounds, upperBounds, Set.mem_Ioi, Set.mem_setOf_eq,
+        not_and, not_forall, not_le, exists_prop] at H
+      exact H fun x hx => le_of_lt hx
+    filter_upwards [eventually_lt_of_limsup_lt xa hf]with y hy
+    contrapose! hy
+    exact hx hy
+#align eventually_le_limsup eventually_le_limsup
+
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+theorem eventually_liminf_le
+    (hf : IsBoundedUnder (· ≥ ·) f u := by
+      run_tac
+        is_bounded_default) :
+    ∀ᶠ b in f, f.liminf u ≤ u b :=
+  @eventually_le_limsup αᵒᵈ _ _ _ _ _ _ _ _ hf
+#align eventually_liminf_le eventually_liminf_le
+
 end ConditionallyCompleteLinearOrder
 
+section CompleteLinearOrder
+
+variable [CompleteLinearOrder α] [TopologicalSpace α] [FirstCountableTopology α] [OrderTopology α]
+  {f : Filter β} [CountableInterFilter f] {u : β → α}
+
+@[simp]
+theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
+  ⟨fun h =>
+    (EventuallyLE.trans eventually_le_limsup <| eventually_of_forall fun _ => h.le).mono fun x hx =>
+      le_antisymm hx bot_le,
+    fun h => by
+    rw [limsup_congr h]
+    exact limsup_const_bot⟩
+#align limsup_eq_bot limsup_eq_bot
+
+@[simp]
+theorem liminf_eq_top : f.liminf u = ⊤ ↔ u =ᶠ[f] ⊤ :=
+  @limsup_eq_bot αᵒᵈ _ _ _ _ _ _ _ _
+#align liminf_eq_top liminf_eq_top
+
+end CompleteLinearOrder
+
 end LiminfLimsup
 
 section Monotone
Diff
@@ -243,7 +243,7 @@ theorem liminfₛ_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 
   le_antisymm
     (calc
       f.liminfₛ ≤ f.limsupₛ := liminfₛ_le_limsupₛ hb_le hb_ge
-      _ ≤ (𝓝 a).limsupₛ := limsupₛ_le_limsupₛ_of_le h hb_ge.isCobounded_flip (isBounded_le_nhds a)
+      _ ≤ (𝓝 a).limsupₛ := (limsupₛ_le_limsupₛ_of_le h hb_ge.isCobounded_flip (isBounded_le_nhds a))
       _ = a := limsupₛ_nhds a
       )
     (calc
@@ -279,8 +279,8 @@ theorem Filter.Tendsto.liminf_eq {f : Filter β} {u : β → α} {a : α} [NeBot
 #align filter.tendsto.liminf_eq Filter.Tendsto.liminf_eq
 -/
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic is_bounded_default -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic is_bounded_default -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 #print tendsto_of_liminf_eq_limsup /-
 /-- If the liminf and the limsup of a function coincide, then the limit of the function
 exists and has the same value -/
@@ -297,8 +297,8 @@ theorem tendsto_of_liminf_eq_limsup {f : Filter β} {u : β → α} {a : α} (hi
 #align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsup
 -/
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic is_bounded_default -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic is_bounded_default -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 #print tendsto_of_le_liminf_of_limsup_le /-
 /-- 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. -/
@@ -319,8 +319,8 @@ theorem tendsto_of_le_liminf_of_limsup_le {f : Filter β} {u : β → α} {a : 
 #align tendsto_of_le_liminf_of_limsup_le tendsto_of_le_liminf_of_limsup_le
 -/
 
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic is_bounded_default -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic is_bounded_default -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic is_bounded_default -/
 #print tendsto_of_no_upcrossings /-
 /-- 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
@@ -368,8 +368,8 @@ lean 3 declaration is
 but is expected to have type
   forall {R : Type.{u2}} {S : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u2} R] [_inst_3 : TopologicalSpace.{u2} R] [_inst_4 : OrderTopology.{u2} R _inst_3 (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))))] [_inst_5 : CompleteLinearOrder.{u1} S] [_inst_6 : TopologicalSpace.{u1} S] [_inst_7 : OrderTopology.{u1} S _inst_6 (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5))))] {F : Filter.{u2} R} [_inst_8 : Filter.NeBot.{u2} R F] {f : R -> S}, (Antitone.{u2, u1} R S (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (PartialOrder.toPreorder.{u1} S (CompleteSemilatticeInf.toPartialOrder.{u1} S (CompleteLattice.toCompleteSemilatticeInf.{u1} S (CompleteLinearOrder.toCompleteLattice.{u1} S _inst_5)))) f) -> (ContinuousAt.{u2, u1} R S _inst_3 _inst_6 f (Filter.limsupₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) -> (Eq.{succ u1} S (f (Filter.limsupₛ.{u2} R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u2} R (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u2} R (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u2} R _inst_2))) F)) (Filter.liminf.{u1, u2} S R (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} S (ConditionallyCompleteLinearOrderBot.toConditionallyCompleteLinearOrder.{u1} S (CompleteLinearOrder.toConditionallyCompleteLinearOrderBot.{u1} S _inst_5))) f F))
 Case conversion may be inaccurate. Consider using '#align antitone.map_Limsup_of_continuous_at Antitone.map_limsupₛ_of_continuousAtₓ'. -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic filter.is_bounded_default -/
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic filter.is_bounded_default -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic filter.is_bounded_default -/
 /-- An antitone function between complete linear ordered spaces sends a `filter.Limsup`
 to the `filter.liminf` of the image if it is continuous at the `Limsup`. -/
 theorem Antitone.map_limsupₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
Diff
@@ -666,7 +666,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
 lean 3 declaration is
   forall {α : Type.{u1}} (R : Type.{u2}) [_inst_1 : StrictOrderedSemiring.{u2} R] [_inst_2 : Archimedean.{u2} R (OrderedSemiring.toOrderedAddCommMonoid.{u2} R (StrictOrderedSemiring.toOrderedSemiring.{u2} R _inst_1))] (s : Nat -> (Set.{u1} α)), Eq.{succ u1} (Set.{u1} α) (Filter.limsup.{u1, 0} (Set.{u1} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))))) (setOf.{u1} α (fun (ω : α) => Filter.Tendsto.{0, u2} Nat R (fun (n : Nat) => Finset.sum.{u2, 0} R Nat (OrderedCancelAddCommMonoid.toAddCommMonoid.{u2} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u2} R _inst_1)) (Finset.range n) (fun (k : Nat) => Set.indicator.{u1, u2} α R (MulZeroClass.toHasZero.{u2} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} R (Semiring.toNonAssocSemiring.{u2} R (StrictOrderedSemiring.toSemiring.{u2} R _inst_1))))) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) k (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (OfNat.ofNat.{max u1 u2} (α -> R) 1 (OfNat.mk.{max u1 u2} (α -> R) 1 (One.one.{max u1 u2} (α -> R) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => R) (fun (i : α) => AddMonoidWithOne.toOne.{u2} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u2} R (NonAssocSemiring.toAddCommMonoidWithOne.{u2} R (Semiring.toNonAssocSemiring.{u2} R (StrictOrderedSemiring.toSemiring.{u2} R _inst_1))))))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring)))) (Filter.atTop.{u2} R (PartialOrder.toPreorder.{u2} R (OrderedCancelAddCommMonoid.toPartialOrder.{u2} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u2} R _inst_1))))))
 but is expected to have type
-  forall {α : Type.{u2}} (R : Type.{u1}) [_inst_1 : StrictOrderedSemiring.{u1} R] [_inst_2 : Archimedean.{u1} R (OrderedSemiring.toOrderedAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedSemiring.{u1} R _inst_1))] (s : Nat -> (Set.{u2} α)), Eq.{succ u2} (Set.{u2} α) (Filter.limsup.{u2, 0} (Set.{u2} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) (setOf.{u2} α (fun (ω : α) => Filter.Tendsto.{0, u1} Nat R (fun (n : Nat) => Finset.sum.{u1, 0} R Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))) (Finset.range n) (fun (k : Nat) => Set.indicator.{u2, u1} α R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (OfNat.ofNat.{max u2 u1} (α -> R) 1 (One.toOfNat1.{max u2 u1} (α -> R) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.5390 : α) => R) (fun (i : α) => Semiring.toOne.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (Filter.atTop.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1)))))
+  forall {α : Type.{u2}} (R : Type.{u1}) [_inst_1 : StrictOrderedSemiring.{u1} R] [_inst_2 : Archimedean.{u1} R (OrderedSemiring.toOrderedAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedSemiring.{u1} R _inst_1))] (s : Nat -> (Set.{u2} α)), Eq.{succ u2} (Set.{u2} α) (Filter.limsup.{u2, 0} (Set.{u2} α) Nat (CompleteLattice.toConditionallyCompleteLattice.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α))))) s (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)))) (setOf.{u2} α (fun (ω : α) => Filter.Tendsto.{0, u1} Nat R (fun (n : Nat) => Finset.sum.{u1, 0} R Nat (OrderedCancelAddCommMonoid.toAddCommMonoid.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)) (Finset.range n) (fun (k : Nat) => Set.indicator.{u2, u1} α R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))) (s (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) k (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (OfNat.ofNat.{max u2 u1} (α -> R) 1 (One.toOfNat1.{max u2 u1} (α -> R) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Topology.Algebra.Order.LiminfLimsup._hyg.5390 : α) => R) (fun (i : α) => Semiring.toOne.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) ω)) (Filter.atTop.{0} Nat (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring))) (Filter.atTop.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align limsup_eq_tendsto_sum_indicator_at_top limsup_eq_tendsto_sum_indicator_atTopₓ'. -/
 theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type _) [StrictOrderedSemiring R] [Archimedean R]
     (s : ℕ → Set α) :

Changes in mathlib4

mathlib3
mathlib4
chore: Rename nat_cast/int_cast/rat_cast to natCast/intCast/ratCast (#11486)

Now that I am defining NNRat.cast, I want a definitive answer to this naming issue. Plenty of lemmas in mathlib already use natCast/intCast/ratCast over nat_cast/int_cast/rat_cast, and this matches with the general expectation that underscore-separated name parts correspond to a single declaration.

Diff
@@ -574,7 +574,7 @@ theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type*) [StrictOrderedSemiring
   simp only [Set.mem_setOf_eq]
   rw [(_ : (fun n ↦ ∑ k in Finset.range n, (s (k + 1)).indicator (1 : α → R) ω) = fun n ↦
     ↑(∑ k in Finset.range n, (s (k + 1)).indicator (1 : α → ℕ) ω))]
-  · exact tendsto_nat_cast_atTop_iff.symm
+  · exact tendsto_natCast_atTop_iff.symm
   · ext n
     simp only [Set.indicator, Pi.one_apply, Finset.sum_boole, Nat.cast_id]
 #align limsup_eq_tendsto_sum_indicator_at_top limsup_eq_tendsto_sum_indicator_atTop
chore: superfluous parentheses (#12116)

Co-authored-by: Moritz Firsching <firsching@google.com>

Diff
@@ -362,7 +362,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
         have : (Set.Ioo c F.limsSup).Nonempty := ⟨x, ⟨hx, this⟩⟩
         simp only [hc, Set.not_nonempty_empty] at this
       apply liminf_le_of_frequently_le _ (bdd_above.isBoundedUnder f_decr)
-      exact (B.mono fun x hx ↦ f_decr hx)
+      exact B.mono fun x hx ↦ f_decr hx
     push_neg at h'
     by_contra! H
     have not_bot : ¬ IsBot F.limsSup := fun maybe_bot ↦
refactor(Topology/Order/Basic): split up large file (#11992)

This splits up the file Mathlib/Topology/Order/Basic.lean (currently > 2000 lines) into several smaller files.

Diff
@@ -10,8 +10,8 @@ import Mathlib.Order.LiminfLimsup
 import Mathlib.Order.Filter.Archimedean
 import Mathlib.Order.Filter.CountableInter
 import Mathlib.Topology.Algebra.Group.Basic
-import Mathlib.Topology.Order.Basic
 import Mathlib.Data.Set.Lattice
+import Mathlib.Topology.Order.Monotone
 
 #align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
 
chore: Sort big operator order lemmas (#11750)

Take the content of

  • some of Algebra.BigOperators.List.Basic
  • some of Algebra.BigOperators.List.Lemmas
  • some of Algebra.BigOperators.Multiset.Basic
  • some of Algebra.BigOperators.Multiset.Lemmas
  • Algebra.BigOperators.Multiset.Order
  • Algebra.BigOperators.Order

and sort it into six files:

Here are the design decisions at play:

  • Pure algebra and big operators algebra shouldn't import (algebraic) order theory. This PR makes that better, but not perfect because we still import Data.Nat.Order.Basic in a few List files.
  • It's Algebra.Order.BigOperators instead of Algebra.BigOperators.Order because algebraic order theory is more of a theory than big operators algebra. Another reason is that algebraic order theory is the only way to mix pure order and pure algebra, while there are more ways to mix pure finiteness and pure algebra than just big operators.
  • There are separate files for group/monoid lemmas vs ring lemmas. Groups/monoids are the natural setup for big operators, so their lemmas shouldn't be mixed with ring lemmas that involves both addition and multiplication. As a result, everything under Algebra.Order.BigOperators.Group should be additivisable (except a few Nat- or Int-specific lemmas). In contrast, things under Algebra.Order.BigOperators.Ring are more prone to having heavy imports.
  • Lemmas are separated according to List vs Multiset vs Finset. This is not strictly necessary, and can be relaxed in cases where there aren't that many lemmas to be had. As an example, I could split out the AbsoluteValue lemmas from Algebra.Order.BigOperators.Ring.Finset to a file Algebra.Order.BigOperators.Ring.AbsoluteValue and it could stay this way until too many lemmas are in this file (or a split is needed for import reasons), in which case we would need files Algebra.Order.BigOperators.Ring.AbsoluteValue.Finset, Algebra.Order.BigOperators.Ring.AbsoluteValue.Multiset, etc...
  • Finsupp big operator and finprod/finsum order lemmas also belong in Algebra.Order.BigOperators. I haven't done so in this PR because the diff is big enough like that.
Diff
@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov, Yaël Dillies
 -/
 import Mathlib.Algebra.BigOperators.Intervals
-import Mathlib.Algebra.BigOperators.Order
+import Mathlib.Algebra.BigOperators.Ring
 import Mathlib.Algebra.Order.Support
 import Mathlib.Order.LiminfLimsup
 import Mathlib.Order.Filter.Archimedean
chore(Order/*): move SupSet, Set.sUnion etc to a new file (#10232)
Diff
@@ -11,6 +11,7 @@ import Mathlib.Order.Filter.Archimedean
 import Mathlib.Order.Filter.CountableInter
 import Mathlib.Topology.Algebra.Group.Basic
 import Mathlib.Topology.Order.Basic
+import Mathlib.Data.Set.Lattice
 
 #align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
 
chore(Topology/Basic): re-use variables; rename a : X to x : X (#9993)

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

Diff
@@ -183,7 +183,7 @@ set_option linter.uppercaseLean3 false in
 
 theorem limsSup_nhds (a : α) : limsSup (𝓝 a) = a :=
   csInf_eq_of_forall_ge_of_forall_gt_exists_lt (isBounded_le_nhds a)
-    (fun a' (h : { n : α | n ≤ a' } ∈ 𝓝 a) ↦ show a ≤ a' from @mem_of_mem_nhds α _ a _ h)
+    (fun a' (h : { n : α | n ≤ a' } ∈ 𝓝 a) ↦ show a ≤ a' from @mem_of_mem_nhds α a _ _ h)
     fun b (hba : a < b) ↦
     show ∃ c, { n : α | n ≤ c } ∈ 𝓝 a ∧ c < b from
       match dense_or_discrete a b with
chore: Sink Algebra.Support down the import tree (#8919)

Function.support is a very basic definition. Nevertheless, it is a pretty heavy import because it imports most objects a support lemma can be written about.

This PR reverses the dependencies between those objects and Function.support, so that the latter can become a much more lightweight import.

Only two import could not easily be reversed, namely the ones to Data.Set.Finite and Order.ConditionallyCompleteLattice.Basic, so I created two new files instead.

I credit:

Diff
@@ -5,11 +5,11 @@ Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov, Yaël Dillies
 -/
 import Mathlib.Algebra.BigOperators.Intervals
 import Mathlib.Algebra.BigOperators.Order
-import Mathlib.Algebra.IndicatorFunction
-import Mathlib.Topology.Algebra.Group.Basic
+import Mathlib.Algebra.Order.Support
 import Mathlib.Order.LiminfLimsup
 import Mathlib.Order.Filter.Archimedean
 import Mathlib.Order.Filter.CountableInter
+import Mathlib.Topology.Algebra.Group.Basic
 import Mathlib.Topology.Order.Basic
 
 #align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
chore: rename by_contra' to by_contra! (#8797)

To fit with the "please try harder" convention of ! tactics.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

Diff
@@ -263,7 +263,7 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
   · exact ⟨sInf ∅, tendsto_bot⟩
   refine' ⟨limsup u f, _⟩
   apply tendsto_of_le_liminf_of_limsup_le _ le_rfl h h'
-  by_contra' hlt
+  by_contra! hlt
   obtain ⟨a, ⟨⟨la, au⟩, as⟩⟩ : ∃ a, (f.liminf u < a ∧ a < f.limsup u) ∧ a ∈ s :=
     dense_iff_inter_open.1 hs (Set.Ioo (f.liminf u) (f.limsup u)) isOpen_Ioo
       (Set.nonempty_Ioo.2 hlt)
@@ -357,13 +357,13 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
       have B : ∃ᶠ n in F, F.limsSup ≤ n := by
         apply (frequently_lt_of_lt_limsSup cobdd c_lt).mono
         intro x hx
-        by_contra'
+        by_contra!
         have : (Set.Ioo c F.limsSup).Nonempty := ⟨x, ⟨hx, this⟩⟩
         simp only [hc, Set.not_nonempty_empty] at this
       apply liminf_le_of_frequently_le _ (bdd_above.isBoundedUnder f_decr)
       exact (B.mono fun x hx ↦ f_decr hx)
     push_neg at h'
-    by_contra' H
+    by_contra! H
     have not_bot : ¬ IsBot F.limsSup := fun maybe_bot ↦
       lt_irrefl (F.liminf f) <| lt_of_le_of_lt
         (liminf_le_of_frequently_le (frequently_of_forall (fun r ↦ f_decr (maybe_bot r)))
@@ -546,7 +546,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
       exact zero_lt_one
   · rintro hω i
     rw [Set.mem_setOf_eq, tendsto_atTop_atTop] at hω
-    by_contra' hcon
+    by_contra! hcon
     obtain ⟨j, h⟩ := hω (i + 1)
     have : (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i := by
       have hle : ∀ j ≤ i, (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i := by
chore: use by_contra' instead of by_contra + push_neg (#8798)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

Diff
@@ -546,8 +546,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
       exact zero_lt_one
   · rintro hω i
     rw [Set.mem_setOf_eq, tendsto_atTop_atTop] at hω
-    by_contra hcon
-    push_neg at hcon
+    by_contra' hcon
     obtain ⟨j, h⟩ := hω (i + 1)
     have : (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i := by
       have hle : ∀ j ≤ i, (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i := by
chore: Golf BoundedGENhdsClass (α × β) instance (#8085)

and the correspond pi instance.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

Diff
@@ -82,14 +82,14 @@ theorem Filter.Tendsto.isCoboundedUnder_ge [NeBot f] (h : Tendsto u f (𝓝 a))
 
 instance : BoundedGENhdsClass αᵒᵈ := ⟨@isBounded_le_nhds α _ _ _⟩
 
-instance : BoundedLENhdsClass (α × β) := by
+instance Prod.instBoundedLENhdsClass : BoundedLENhdsClass (α × β) := by
   refine ⟨fun x ↦ ?_⟩
   obtain ⟨a, ha⟩ := isBounded_le_nhds x.1
   obtain ⟨b, hb⟩ := isBounded_le_nhds x.2
   rw [← @Prod.mk.eta _ _ x, nhds_prod_eq]
   exact ⟨(a, b), ha.prod_mk hb⟩
 
-instance [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
+instance Pi.instBoundedLENhdsClass [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
     [∀ i, BoundedLENhdsClass (π i)] : BoundedLENhdsClass (∀ i, π i) := by
   refine' ⟨fun x ↦ _⟩
   rw [nhds_pi]
@@ -130,19 +130,12 @@ theorem Filter.Tendsto.isCoboundedUnder_le [NeBot f] (h : Tendsto u f (𝓝 a))
 
 instance : BoundedLENhdsClass αᵒᵈ := ⟨@isBounded_ge_nhds α _ _ _⟩
 
-instance : BoundedGENhdsClass (α × β) := by
-  refine ⟨fun x ↦ ?_⟩
-  obtain ⟨a, ha⟩ := isBounded_ge_nhds x.1
-  obtain ⟨b, hb⟩ := isBounded_ge_nhds x.2
-  rw [← @Prod.mk.eta _ _ x, nhds_prod_eq]
-  exact ⟨(a, b), ha.prod_mk hb⟩
+instance Prod.instBoundedGENhdsClass : BoundedGENhdsClass (α × β) :=
+  ⟨(Prod.instBoundedLENhdsClass (α := αᵒᵈ) (β := βᵒᵈ)).isBounded_le_nhds⟩
 
-instance [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
-    [∀ i, BoundedGENhdsClass (π i)] : BoundedGENhdsClass (∀ i, π i) := by
-  refine' ⟨fun x ↦ _⟩
-  rw [nhds_pi]
-  choose f hf using fun i ↦ isBounded_ge_nhds (x i)
-  exact ⟨f, eventually_pi hf⟩
+instance Pi.instBoundedGENhdsClass [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
+    [∀ i, BoundedGENhdsClass (π i)] : BoundedGENhdsClass (∀ i, π i) :=
+  ⟨(Pi.instBoundedLENhdsClass (π := fun i ↦ (π i)ᵒᵈ)).isBounded_le_nhds⟩
 
 end BoundedGENhdsClass
 
feat: Eventual boundedness of neighborhoods (#8009)

Forward port https://github.com/leanprover-community/mathlib/pull/18629

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

Diff
@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov
+Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov, Yaël Dillies
 -/
 import Mathlib.Algebra.BigOperators.Intervals
 import Mathlib.Algebra.BigOperators.Order
@@ -12,44 +12,62 @@ import Mathlib.Order.Filter.Archimedean
 import Mathlib.Order.Filter.CountableInter
 import Mathlib.Topology.Order.Basic
 
-#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ffde2d8a6e689149e44fd95fa862c23a57f8c780"
+#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
 
 /-!
 # Lemmas about liminf and limsup in an order topology.
+
+## Main declarations
+
+* `BoundedLENhdsClass`: Typeclass stating that neighborhoods are eventually bounded above.
+* `BoundedGENhdsClass`: Typeclass stating that neighborhoods are eventually bounded below.
+
+## Implementation notes
+
+The same lemmas are true in `ℝ`, `ℝ × ℝ`, `ι → ℝ`, `EuclideanSpace ι ℝ`. To avoid code
+duplication, we provide an ad hoc axiomatisation of the properties we need.
 -/
 
 
 open Filter TopologicalSpace
 
-open Topology Classical
+open scoped Topology Classical
 
 universe u v
 
-variable {α : Type u} {β : Type v}
+variable {ι α β R S : Type*} {π : ι → Type*}
 
-section LiminfLimsup
+/-- Ad hoc typeclass stating that neighborhoods are eventually bounded above. -/
+class BoundedLENhdsClass (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where
+  isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·)
+#align bounded_le_nhds_class BoundedLENhdsClass
+
+/-- Ad hoc typeclass stating that neighborhoods are eventually bounded below. -/
+class BoundedGENhdsClass (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where
+  isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·)
+#align bounded_ge_nhds_class BoundedGENhdsClass
 
-section OrderClosedTopology
+section Preorder
+variable [Preorder α] [Preorder β] [TopologicalSpace α] [TopologicalSpace β]
 
-variable [SemilatticeSup α] [TopologicalSpace α] [OrderTopology α]
+section BoundedLENhdsClass
+variable [BoundedLENhdsClass α] [BoundedLENhdsClass β] {f : Filter ι} {u : ι → α} {a : α}
 
 theorem isBounded_le_nhds (a : α) : (𝓝 a).IsBounded (· ≤ ·) :=
-  (isTop_or_exists_gt a).elim (fun h ↦ ⟨a, eventually_of_forall h⟩) fun ⟨b, hb⟩ ↦
-    ⟨b, ge_mem_nhds hb⟩
+  BoundedLENhdsClass.isBounded_le_nhds _
 #align is_bounded_le_nhds isBounded_le_nhds
 
-theorem Filter.Tendsto.isBoundedUnder_le {f : Filter β} {u : β → α} {a : α}
-    (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≤ ·) u :=
+theorem Filter.Tendsto.isBoundedUnder_le (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≤ ·) u :=
   (isBounded_le_nhds a).mono h
 #align filter.tendsto.is_bounded_under_le Filter.Tendsto.isBoundedUnder_le
 
-theorem Filter.Tendsto.bddAbove_range_of_cofinite {u : β → α} {a : α}
+theorem Filter.Tendsto.bddAbove_range_of_cofinite [IsDirected α (· ≤ ·)]
     (h : Tendsto u cofinite (𝓝 a)) : BddAbove (Set.range u) :=
   h.isBoundedUnder_le.bddAbove_range_of_cofinite
 #align filter.tendsto.bdd_above_range_of_cofinite Filter.Tendsto.bddAbove_range_of_cofinite
 
-theorem Filter.Tendsto.bddAbove_range {u : ℕ → α} {a : α} (h : Tendsto u atTop (𝓝 a)) :
-    BddAbove (Set.range u) :=
+theorem Filter.Tendsto.bddAbove_range [IsDirected α (· ≤ ·)] {u : ℕ → α}
+    (h : Tendsto u atTop (𝓝 a)) : BddAbove (Set.range u) :=
   h.isBoundedUnder_le.bddAbove_range
 #align filter.tendsto.bdd_above_range Filter.Tendsto.bddAbove_range
 
@@ -57,33 +75,47 @@ theorem isCobounded_ge_nhds (a : α) : (𝓝 a).IsCobounded (· ≥ ·) :=
   (isBounded_le_nhds a).isCobounded_flip
 #align is_cobounded_ge_nhds isCobounded_ge_nhds
 
-theorem Filter.Tendsto.isCoboundedUnder_ge {f : Filter β} {u : β → α} {a : α} [NeBot f]
-    (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≥ ·) u :=
+theorem Filter.Tendsto.isCoboundedUnder_ge [NeBot f] (h : Tendsto u f (𝓝 a)) :
+    f.IsCoboundedUnder (· ≥ ·) u :=
   h.isBoundedUnder_le.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
 
-end OrderClosedTopology
+instance : BoundedGENhdsClass αᵒᵈ := ⟨@isBounded_le_nhds α _ _ _⟩
 
-section OrderClosedTopology
+instance : BoundedLENhdsClass (α × β) := by
+  refine ⟨fun x ↦ ?_⟩
+  obtain ⟨a, ha⟩ := isBounded_le_nhds x.1
+  obtain ⟨b, hb⟩ := isBounded_le_nhds x.2
+  rw [← @Prod.mk.eta _ _ x, nhds_prod_eq]
+  exact ⟨(a, b), ha.prod_mk hb⟩
 
-variable [SemilatticeInf α] [TopologicalSpace α] [OrderTopology α]
+instance [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
+    [∀ i, BoundedLENhdsClass (π i)] : BoundedLENhdsClass (∀ i, π i) := by
+  refine' ⟨fun x ↦ _⟩
+  rw [nhds_pi]
+  choose f hf using fun i ↦ isBounded_le_nhds (x i)
+  exact ⟨f, eventually_pi hf⟩
+
+end BoundedLENhdsClass
+
+section BoundedGENhdsClass
+variable [BoundedGENhdsClass α] [BoundedGENhdsClass β] {f : Filter ι} {u : ι → α} {a : α}
 
 theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·) :=
-  isBounded_le_nhds (α := αᵒᵈ) a
+  BoundedGENhdsClass.isBounded_ge_nhds _
 #align is_bounded_ge_nhds isBounded_ge_nhds
 
-theorem Filter.Tendsto.isBoundedUnder_ge {f : Filter β} {u : β → α} {a : α}
-    (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≥ ·) u :=
+theorem Filter.Tendsto.isBoundedUnder_ge (h : Tendsto u f (𝓝 a)) : f.IsBoundedUnder (· ≥ ·) u :=
   (isBounded_ge_nhds a).mono h
 #align filter.tendsto.is_bounded_under_ge Filter.Tendsto.isBoundedUnder_ge
 
-theorem Filter.Tendsto.bddBelow_range_of_cofinite {u : β → α} {a : α}
+theorem Filter.Tendsto.bddBelow_range_of_cofinite [IsDirected α (· ≥ ·)]
     (h : Tendsto u cofinite (𝓝 a)) : BddBelow (Set.range u) :=
   h.isBoundedUnder_ge.bddBelow_range_of_cofinite
 #align filter.tendsto.bdd_below_range_of_cofinite Filter.Tendsto.bddBelow_range_of_cofinite
 
-theorem Filter.Tendsto.bddBelow_range {u : ℕ → α} {a : α} (h : Tendsto u atTop (𝓝 a)) :
-    BddBelow (Set.range u) :=
+theorem Filter.Tendsto.bddBelow_range [IsDirected α (· ≥ ·)] {u : ℕ → α}
+    (h : Tendsto u atTop (𝓝 a)) : BddBelow (Set.range u) :=
   h.isBoundedUnder_ge.bddBelow_range
 #align filter.tendsto.bdd_below_range Filter.Tendsto.bddBelow_range
 
@@ -91,12 +123,57 @@ theorem isCobounded_le_nhds (a : α) : (𝓝 a).IsCobounded (· ≤ ·) :=
   (isBounded_ge_nhds a).isCobounded_flip
 #align is_cobounded_le_nhds isCobounded_le_nhds
 
-theorem Filter.Tendsto.isCoboundedUnder_le {f : Filter β} {u : β → α} {a : α} [NeBot f]
-    (h : Tendsto u f (𝓝 a)) : f.IsCoboundedUnder (· ≤ ·) u :=
+theorem Filter.Tendsto.isCoboundedUnder_le [NeBot f] (h : Tendsto u f (𝓝 a)) :
+    f.IsCoboundedUnder (· ≤ ·) u :=
   h.isBoundedUnder_ge.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
 
-end OrderClosedTopology
+instance : BoundedLENhdsClass αᵒᵈ := ⟨@isBounded_ge_nhds α _ _ _⟩
+
+instance : BoundedGENhdsClass (α × β) := by
+  refine ⟨fun x ↦ ?_⟩
+  obtain ⟨a, ha⟩ := isBounded_ge_nhds x.1
+  obtain ⟨b, hb⟩ := isBounded_ge_nhds x.2
+  rw [← @Prod.mk.eta _ _ x, nhds_prod_eq]
+  exact ⟨(a, b), ha.prod_mk hb⟩
+
+instance [Finite ι] [∀ i, Preorder (π i)] [∀ i, TopologicalSpace (π i)]
+    [∀ i, BoundedGENhdsClass (π i)] : BoundedGENhdsClass (∀ i, π i) := by
+  refine' ⟨fun x ↦ _⟩
+  rw [nhds_pi]
+  choose f hf using fun i ↦ isBounded_ge_nhds (x i)
+  exact ⟨f, eventually_pi hf⟩
+
+end BoundedGENhdsClass
+
+-- See note [lower instance priority]
+instance (priority := 100) OrderTop.to_BoundedLENhdsClass [OrderTop α] : BoundedLENhdsClass α :=
+  ⟨fun _a ↦ isBounded_le_of_top⟩
+#align order_top.to_bounded_le_nhds_class OrderTop.to_BoundedLENhdsClass
+
+-- See note [lower instance priority]
+instance (priority := 100) OrderBot.to_BoundedGENhdsClass [OrderBot α] : BoundedGENhdsClass α :=
+  ⟨fun _a ↦ isBounded_ge_of_bot⟩
+#align order_bot.to_bounded_ge_nhds_class OrderBot.to_BoundedGENhdsClass
+
+-- See note [lower instance priority]
+instance (priority := 100) OrderTopology.to_BoundedLENhdsClass [IsDirected α (· ≤ ·)]
+    [OrderTopology α] : BoundedLENhdsClass α :=
+  ⟨fun a ↦
+    ((isTop_or_exists_gt a).elim fun h ↦ ⟨a, eventually_of_forall h⟩) <|
+      Exists.imp fun _b ↦ ge_mem_nhds⟩
+#align order_topology.to_bounded_le_nhds_class OrderTopology.to_BoundedLENhdsClass
+
+-- See note [lower instance priority]
+instance (priority := 100) OrderTopology.to_BoundedGENhdsClass [IsDirected α (· ≥ ·)]
+    [OrderTopology α] : BoundedGENhdsClass α :=
+  ⟨fun a ↦ ((isBot_or_exists_lt a).elim fun h ↦ ⟨a, eventually_of_forall h⟩) <|
+    Exists.imp fun _b ↦ le_mem_nhds⟩
+#align order_topology.to_bounded_ge_nhds_class OrderTopology.to_BoundedGENhdsClass
+
+end Preorder
+
+section LiminfLimsup
 
 section ConditionallyCompleteLinearOrder
 
@@ -258,7 +335,7 @@ end LiminfLimsup
 
 section Monotone
 
-variable {ι R S : Type*} {F : Filter ι} [NeBot F]
+variable {F : Filter ι} [NeBot F]
   [ConditionallyCompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
   [ConditionallyCompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
 
@@ -399,7 +476,7 @@ open Topology
 
 open Filter Set
 
-variable {ι : Type*} {R : Type*} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
+variable [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
 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 := by
@@ -412,7 +489,7 @@ theorem iSup_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (le_x : ∀ i, a
   iInf_eq_of_forall_le_of_tendsto (R := Rᵒᵈ) le_x as_lim
 #align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
-theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type*} (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
+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 := by
   have obs : x ∉ range as := by
@@ -426,7 +503,7 @@ theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type*} (x : R) {as : ι → R}
   exact iUnion_Ici_eq_Ioi_iInf obs
 #align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendsto
 
-theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type*} (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
+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 :=
   iUnion_Ici_eq_Ioi_of_lt_of_tendsto (R := Rᵒᵈ) x lt_x as_lim
@@ -512,10 +589,7 @@ theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type*) [StrictOrderedSemiring
 end Indicator
 
 section LiminfLimsupAddSub
-
-set_option autoImplicit true
-
-variable {R : Type*} [ConditionallyCompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
+variable [ConditionallyCompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
 /-- `liminf (c + xᵢ) = c + liminf xᵢ`. -/
 lemma limsup_const_add (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
feat: let push_neg replace not (Set.Nonempty s) with s = emptyset (#8000)

Co-authored-by: Kyle Miller <kmill31415@gmail.com>

Diff
@@ -303,7 +303,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
       simpa [IsBot] using not_bot
     obtain ⟨m, l_m, m_lt⟩ : (Set.Ioo l F.limsSup).Nonempty := by
       contrapose! h'
-      refine' ⟨l, l_lt, by rwa [Set.not_nonempty_iff_eq_empty] at h'⟩
+      exact ⟨l, l_lt, h'⟩
     have B : F.liminf f ≤ f m := by
       apply liminf_le_of_frequently_le _ _
       · apply (frequently_lt_of_lt_limsSup cobdd m_lt).mono
chore: swap primes on forall_apply_eq_imp_iff (#7705)

Two pairs of the form foo and foo', where foo' is the simp lemma (and hence used in many simp onlys) and foo is not used at all.

Swap the primes, so that when it is time (now!) to upstream the lemma we actually use, it doesn't need to have a prime...

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

Diff
@@ -449,7 +449,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     refine' tendsto_atTop_atTop_of_monotone' (fun n m hnm ↦ Finset.sum_mono_set_of_nonneg
       (fun i ↦ Set.indicator_nonneg (fun _ _ ↦ zero_le_one) _) (Finset.range_mono hnm)) _
     rintro ⟨i, h⟩
-    simp only [mem_upperBounds, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff'] at h
+    simp only [mem_upperBounds, Set.mem_range, forall_exists_index, forall_apply_eq_imp_iff] at h
     induction' i with k hk
     · obtain ⟨j, hj₁, hj₂⟩ := hω 1
       refine' not_lt.2 (h <| j + 1)
chore: Generalise and move liminf/limsup lemmas (#6846)

Forward-ports https://github.com/leanprover-community/mathlib/pull/18628

Diff
@@ -12,7 +12,7 @@ import Mathlib.Order.Filter.Archimedean
 import Mathlib.Order.Filter.CountableInter
 import Mathlib.Topology.Order.Basic
 
-#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"52932b3a083d4142e78a15dc928084a22fea9ba0"
+#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"ffde2d8a6e689149e44fd95fa862c23a57f8c780"
 
 /-!
 # Lemmas about liminf and limsup in an order topology.
@@ -62,21 +62,6 @@ theorem Filter.Tendsto.isCoboundedUnder_ge {f : Filter β} {u : β → α} {a :
   h.isBoundedUnder_le.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
 
-theorem isBounded_le_atBot (α : Type*) [hα : Nonempty α] [Preorder α] :
-    (atBot : Filter α).IsBounded (· ≤ ·) :=
-  isBounded_iff.2 ⟨Set.Iic hα.some, mem_atBot _, hα.some, fun _ hx ↦ hx⟩
-#align is_bounded_le_at_bot isBounded_le_atBot
-
-theorem Filter.Tendsto.isBoundedUnder_le_atBot {α : Type*} [Nonempty α] [Preorder α] {f : Filter β}
-    {u : β → α} (h : Tendsto u f atBot) : f.IsBoundedUnder (· ≤ ·) u :=
-  (isBounded_le_atBot α).mono h
-#align filter.tendsto.is_bounded_under_le_at_bot Filter.Tendsto.isBoundedUnder_le_atBot
-
-theorem bddAbove_range_of_tendsto_atTop_atBot {α : Type*} [Nonempty α] [SemilatticeSup α]
-    {u : ℕ → α} (hx : Tendsto u atTop atBot) : BddAbove (Set.range u) :=
-  (Filter.Tendsto.isBoundedUnder_le_atBot hx).bddAbove_range
-#align bdd_above_range_of_tendsto_at_top_at_bot bddAbove_range_of_tendsto_atTop_atBot
-
 end OrderClosedTopology
 
 section OrderClosedTopology
@@ -111,41 +96,11 @@ theorem Filter.Tendsto.isCoboundedUnder_le {f : Filter β} {u : β → α} {a :
   h.isBoundedUnder_ge.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
 
-theorem isBounded_ge_atTop (α : Type*) [Nonempty α] [Preorder α] :
-    (atTop : Filter α).IsBounded (· ≥ ·) :=
-  isBounded_le_atBot αᵒᵈ
-#align is_bounded_ge_at_top isBounded_ge_atTop
-
-theorem Filter.Tendsto.isBoundedUnder_ge_atTop {α : Type*} [Nonempty α] [Preorder α] {f : Filter β}
-    {u : β → α} (h : Tendsto u f atTop) : f.IsBoundedUnder (· ≥ ·) u :=
-  (isBounded_ge_atTop α).mono h
-#align filter.tendsto.is_bounded_under_ge_at_top Filter.Tendsto.isBoundedUnder_ge_atTop
-
-theorem bddBelow_range_of_tendsto_atTop_atTop {α : Type*} [Nonempty α] [SemilatticeInf α]
-    {u : ℕ → α} (hx : Tendsto u atTop atTop) : BddBelow (Set.range u) :=
-  (Filter.Tendsto.isBoundedUnder_ge_atTop hx).bddBelow_range
-#align bdd_below_range_of_tendsto_at_top_at_top bddBelow_range_of_tendsto_atTop_atTop
-
 end OrderClosedTopology
 
 section ConditionallyCompleteLinearOrder
 
-variable [ConditionallyCompleteLinearOrder α]
-
-theorem lt_mem_sets_of_limsSup_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
-    ∀ᶠ a in f, a < b :=
-  let ⟨_, (h : ∀ᶠ a in f, a ≤ _), hcb⟩ := exists_lt_of_csInf_lt h l
-  mem_of_superset h fun _ hac ↦ lt_of_le_of_lt hac hcb
-set_option linter.uppercaseLean3 false in
-#align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_lt
-
-theorem gt_mem_sets_of_limsInf_gt :
-    ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a :=
-  @lt_mem_sets_of_limsSup_lt αᵒᵈ _
-set_option linter.uppercaseLean3 false in
-#align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_limsInf_gt
-
-variable [TopologicalSpace α] [OrderTopology α]
+variable [ConditionallyCompleteLinearOrder α] [TopologicalSpace α] [OrderTopology α]
 
 /-- 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. -/
fix: disable autoImplicit globally (#6528)

Autoimplicits are highly controversial and also defeat the performance-improving work in #6474.

The intent of this PR is to make autoImplicit opt-in on a per-file basis, by disabling it in the lakefile and enabling it again with set_option autoImplicit true in the few files that rely on it.

That also keeps this PR small, as opposed to attempting to "fix" files to not need it any more.

I claim that many of the uses of autoImplicit in these files are accidental; situations such as:

  • Assuming variables are in scope, but pasting the lemma in the wrong section
  • Pasting in a lemma from a scratch file without checking to see if the variable names are consistent with the rest of the file
  • Making a copy-paste error between lemmas and forgetting to add an explicit arguments.

Having set_option autoImplicit false as the default prevents these types of mistake being made in the 90% of files where autoImplicits are not used at all, and causes them to be caught by CI during review.

I think there were various points during the port where we encouraged porters to delete the universes u v lines; I think having autoparams for universe variables only would cover a lot of the cases we actually use them, while avoiding any real shortcomings.

A Zulip poll (after combining overlapping votes accordingly) was in favor of this change with 5:5:18 as the no:dontcare:yes vote ratio.

While this PR was being reviewed, a handful of files gained some more likely-accidental autoImplicits. In these places, set_option autoImplicit true has been placed locally within a section, rather than at the top of the file.

Diff
@@ -558,6 +558,8 @@ end Indicator
 
 section LiminfLimsupAddSub
 
+set_option autoImplicit true
+
 variable {R : Type*} [ConditionallyCompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
 /-- `liminf (c + xᵢ) = c + liminf xᵢ`. -/
feat: lemma limsup_const_add + 7 variants (#6455)

Add 8 lemmas: limsup_const_add, ..., liminf_sub_const.

The 4 lemmas about add are proven with typeclass assumptions which apply to , ℝ≥0, and ℝ≥0∞ (at least). The 4 lemmas about sub are proven with typeclass assumptions which apply to and ℝ≥0 (at least). For ℝ≥0∞, we add separate implementations of these latter 4 lemmas ENNReal.liminf_sub_const, ...

Co-authored-by: kkytola <39528102+kkytola@users.noreply.github.com>

Diff
@@ -6,6 +6,7 @@ Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov
 import Mathlib.Algebra.BigOperators.Intervals
 import Mathlib.Algebra.BigOperators.Order
 import Mathlib.Algebra.IndicatorFunction
+import Mathlib.Topology.Algebra.Group.Basic
 import Mathlib.Order.LiminfLimsup
 import Mathlib.Order.Filter.Archimedean
 import Mathlib.Order.Filter.CountableInter
@@ -554,3 +555,79 @@ theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type*) [StrictOrderedSemiring
 #align limsup_eq_tendsto_sum_indicator_at_top limsup_eq_tendsto_sum_indicator_atTop
 
 end Indicator
+
+section LiminfLimsupAddSub
+
+variable {R : Type*} [ConditionallyCompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
+
+/-- `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) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
+    Filter.limsup (fun i ↦ c + f i) F = c + Filter.limsup f F :=
+  (Monotone.map_limsSup_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ c + x)
+    (fun _ _ h ↦ add_le_add_left h c) (continuous_add_left c).continuousAt bdd_above bdd_below).symm
+
+/-- `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) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
+    Filter.limsup (fun i ↦ f i + c) F = Filter.limsup f F + c :=
+  (Monotone.map_limsSup_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ x + c)
+    (fun _ _ h ↦ add_le_add_right h c)
+    (continuous_add_right c).continuousAt bdd_above bdd_below).symm
+
+/-- `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)
+    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
+    Filter.liminf (fun i ↦ c + f i) F = c + Filter.liminf f F :=
+  (Monotone.map_limsInf_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ c + x)
+    (fun _ _ h ↦ add_le_add_left h c) (continuous_add_left c).continuousAt bdd_above bdd_below).symm
+
+/-- `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)
+    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
+    Filter.liminf (fun i ↦ f i + c) F = Filter.liminf f F + c :=
+  (Monotone.map_limsInf_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ x + c)
+    (fun _ _ h ↦ add_le_add_right h c)
+    (continuous_add_right c).continuousAt bdd_above bdd_below).symm
+
+/-- `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)
+    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
+    Filter.limsup (fun i ↦ c - f i) F = c - Filter.liminf f F :=
+  (Antitone.map_limsInf_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ c - x)
+    (fun _ _ h ↦ tsub_le_tsub_left h c)
+    (continuous_sub_left c).continuousAt bdd_above bdd_below).symm
+
+/-- `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) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
+    Filter.limsup (fun i ↦ f i - c) F = Filter.limsup f F - c :=
+  (Monotone.map_limsSup_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ x - c)
+    (fun _ _ h ↦ tsub_le_tsub_right h c)
+    (continuous_sub_right c).continuousAt bdd_above bdd_below).symm
+
+/-- `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) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
+    Filter.liminf (fun i ↦ c - f i) F = c - Filter.limsup f F :=
+  (Antitone.map_limsSup_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ c - x)
+    (fun _ _ h ↦ tsub_le_tsub_left h c)
+    (continuous_sub_left c).continuousAt bdd_above bdd_below).symm
+
+/-- `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)
+    (bdd_above : F.IsBoundedUnder (· ≤ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
+    Filter.liminf (fun i ↦ f i - c) F = Filter.liminf f F - c :=
+  (Monotone.map_limsInf_of_continuousAt (F := F.map f) (f := fun (x : R) ↦ x - c)
+    (fun _ _ h ↦ tsub_le_tsub_right h c)
+    (continuous_sub_right c).continuousAt bdd_above bdd_below).symm
+
+end LiminfLimsupAddSub -- section
chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

Diff
@@ -61,17 +61,17 @@ theorem Filter.Tendsto.isCoboundedUnder_ge {f : Filter β} {u : β → α} {a :
   h.isBoundedUnder_le.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_ge Filter.Tendsto.isCoboundedUnder_ge
 
-theorem isBounded_le_atBot (α : Type _) [hα : Nonempty α] [Preorder α] :
+theorem isBounded_le_atBot (α : Type*) [hα : Nonempty α] [Preorder α] :
     (atBot : Filter α).IsBounded (· ≤ ·) :=
   isBounded_iff.2 ⟨Set.Iic hα.some, mem_atBot _, hα.some, fun _ hx ↦ hx⟩
 #align is_bounded_le_at_bot isBounded_le_atBot
 
-theorem Filter.Tendsto.isBoundedUnder_le_atBot {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
+theorem Filter.Tendsto.isBoundedUnder_le_atBot {α : Type*} [Nonempty α] [Preorder α] {f : Filter β}
     {u : β → α} (h : Tendsto u f atBot) : f.IsBoundedUnder (· ≤ ·) u :=
   (isBounded_le_atBot α).mono h
 #align filter.tendsto.is_bounded_under_le_at_bot Filter.Tendsto.isBoundedUnder_le_atBot
 
-theorem bddAbove_range_of_tendsto_atTop_atBot {α : Type _} [Nonempty α] [SemilatticeSup α]
+theorem bddAbove_range_of_tendsto_atTop_atBot {α : Type*} [Nonempty α] [SemilatticeSup α]
     {u : ℕ → α} (hx : Tendsto u atTop atBot) : BddAbove (Set.range u) :=
   (Filter.Tendsto.isBoundedUnder_le_atBot hx).bddAbove_range
 #align bdd_above_range_of_tendsto_at_top_at_bot bddAbove_range_of_tendsto_atTop_atBot
@@ -110,17 +110,17 @@ theorem Filter.Tendsto.isCoboundedUnder_le {f : Filter β} {u : β → α} {a :
   h.isBoundedUnder_ge.isCobounded_flip
 #align filter.tendsto.is_cobounded_under_le Filter.Tendsto.isCoboundedUnder_le
 
-theorem isBounded_ge_atTop (α : Type _) [Nonempty α] [Preorder α] :
+theorem isBounded_ge_atTop (α : Type*) [Nonempty α] [Preorder α] :
     (atTop : Filter α).IsBounded (· ≥ ·) :=
   isBounded_le_atBot αᵒᵈ
 #align is_bounded_ge_at_top isBounded_ge_atTop
 
-theorem Filter.Tendsto.isBoundedUnder_ge_atTop {α : Type _} [Nonempty α] [Preorder α] {f : Filter β}
+theorem Filter.Tendsto.isBoundedUnder_ge_atTop {α : Type*} [Nonempty α] [Preorder α] {f : Filter β}
     {u : β → α} (h : Tendsto u f atTop) : f.IsBoundedUnder (· ≥ ·) u :=
   (isBounded_ge_atTop α).mono h
 #align filter.tendsto.is_bounded_under_ge_at_top Filter.Tendsto.isBoundedUnder_ge_atTop
 
-theorem bddBelow_range_of_tendsto_atTop_atTop {α : Type _} [Nonempty α] [SemilatticeInf α]
+theorem bddBelow_range_of_tendsto_atTop_atTop {α : Type*} [Nonempty α] [SemilatticeInf α]
     {u : ℕ → α} (hx : Tendsto u atTop atTop) : BddBelow (Set.range u) :=
   (Filter.Tendsto.isBoundedUnder_ge_atTop hx).bddBelow_range
 #align bdd_below_range_of_tendsto_at_top_at_top bddBelow_range_of_tendsto_atTop_atTop
@@ -302,7 +302,7 @@ end LiminfLimsup
 
 section Monotone
 
-variable {ι R S : Type _} {F : Filter ι} [NeBot F]
+variable {ι R S : Type*} {F : Filter ι} [NeBot F]
   [ConditionallyCompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
   [ConditionallyCompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
 
@@ -443,7 +443,7 @@ open Topology
 
 open Filter Set
 
-variable {ι : Type _} {R : Type _} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
+variable {ι : Type*} {R : Type*} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
 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 := by
@@ -456,7 +456,7 @@ theorem iSup_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (le_x : ∀ i, a
   iInf_eq_of_forall_le_of_tendsto (R := Rᵒᵈ) le_x as_lim
 #align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
-theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
+theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type*} (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 := by
   have obs : x ∉ range as := by
@@ -470,7 +470,7 @@ theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R}
   exact iUnion_Ici_eq_Ioi_iInf obs
 #align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendsto
 
-theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
+theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type*} (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 :=
   iUnion_Ici_eq_Ioi_of_lt_of_tendsto (R := Rᵒᵈ) x lt_x as_lim
@@ -540,7 +540,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     exact not_le.2 (lt_of_lt_of_le i.lt_succ_self <| h _ le_rfl) this
 #align limsup_eq_tendsto_sum_indicator_nat_at_top limsup_eq_tendsto_sum_indicator_nat_atTop
 
-theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type _) [StrictOrderedSemiring R] [Archimedean R]
+theorem limsup_eq_tendsto_sum_indicator_atTop (R : Type*) [StrictOrderedSemiring R] [Archimedean R]
     (s : ℕ → Set α) : limsup s atTop = { ω | Tendsto
       (fun n ↦ ∑ k in Finset.range n, (s (k + 1)).indicator (1 : α → R) ω) atTop atTop } := by
   rw [limsup_eq_tendsto_sum_indicator_nat_atTop s]
feat: Add ConditionallyCompleteLinearOder versions of Monotone.map_limsSup_of_continuousAt etc. (#6107)

Generalize some existing lemmas from CompleteLinearOrders to ConditionallyCompleteLinearOrders, adding the appropriate boundedness assumptions:

  • Monotone.map_limsSup_of_continuousAt + its 3 order-dual variants
  • Monotone.map_limsup_of_continuousAt + its 3 order-dual variants
  • Monotone.map_sSup_of_continuousAt' + its 3 order-dual variants
  • Monotone.map_iSup_of_continuousAt' + its 3 order-dual variants

For the first two to work automatically still on CompleteLinearOrders, the existing macro tactic isBoundedDefault about boundedness of filters is used. For the last two to work automatically still on CompleteLinearOrders, a similar new macro tactic bddDefault about boundedness of sets is included in the PR.

Co-authored-by: kkytola <39528102+kkytola@users.noreply.github.com>

Diff
@@ -83,7 +83,7 @@ section OrderClosedTopology
 variable [SemilatticeInf α] [TopologicalSpace α] [OrderTopology α]
 
 theorem isBounded_ge_nhds (a : α) : (𝓝 a).IsBounded (· ≥ ·) :=
-  @isBounded_le_nhds αᵒᵈ _ _ _ a
+  isBounded_le_nhds (α := αᵒᵈ) a
 #align is_bounded_ge_nhds isBounded_ge_nhds
 
 theorem Filter.Tendsto.isBoundedUnder_ge {f : Filter β} {u : β → α} {a : α}
@@ -167,7 +167,7 @@ set_option linter.uppercaseLean3 false in
 #align Limsup_nhds limsSup_nhds
 
 theorem limsInf_nhds : ∀ a : α, limsInf (𝓝 a) = a :=
-  @limsSup_nhds αᵒᵈ _ _ _
+  limsSup_nhds (α := αᵒᵈ)
 set_option linter.uppercaseLean3 false in
 #align Liminf_nhds limsInf_nhds
 
@@ -188,7 +188,7 @@ set_option linter.uppercaseLean3 false in
 
 /-- 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 :=
-  @limsInf_eq_of_le_nhds αᵒᵈ _ _ _
+  limsInf_eq_of_le_nhds (α := αᵒᵈ)
 set_option linter.uppercaseLean3 false in
 #align Limsup_eq_of_le_nhds limsSup_eq_of_le_nhds
 
@@ -271,7 +271,7 @@ theorem eventually_le_limsup (hf : IsBoundedUnder (· ≤ ·) f u := by isBounde
 
 theorem eventually_liminf_le (hf : IsBoundedUnder (· ≥ ·) f u := by isBoundedDefault) :
     ∀ᶠ b in f, f.liminf u ≤ u b :=
-  @eventually_le_limsup αᵒᵈ _ _ _ _ _ _ _ _ hf
+  eventually_le_limsup (α := αᵒᵈ) hf
 #align eventually_liminf_le eventually_liminf_le
 
 end ConditionallyCompleteLinearOrder
@@ -293,7 +293,7 @@ theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
 
 @[simp]
 theorem liminf_eq_top : f.liminf u = ⊤ ↔ u =ᶠ[f] ⊤ :=
-  @limsup_eq_bot αᵒᵈ _ _ _ _ _ _ _ _
+  limsup_eq_bot (α := αᵒᵈ)
 #align liminf_eq_top liminf_eq_top
 
 end CompleteLinearOrder
@@ -302,106 +302,137 @@ end LiminfLimsup
 
 section Monotone
 
-variable {ι R S : Type _} {F : Filter ι} [NeBot F] [CompleteLinearOrder R] [TopologicalSpace R]
-  [OrderTopology R] [CompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
+variable {ι R S : Type _} {F : Filter ι} [NeBot F]
+  [ConditionallyCompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
+  [ConditionallyCompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
 
-/-- An antitone function between complete linear ordered spaces sends a `Filter.limsSup`
-to the `Filter.liminf` of the image if it is continuous at the `limsSup`. -/
+/-- 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 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) : f F.limsSup = F.liminf f := by
+    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsSup)
+    (bdd_above : F.IsBounded (· ≤ ·) := by isBoundedDefault)
+    (bdd_below : F.IsBounded (· ≥ ·) := by isBoundedDefault) :
+    f F.limsSup = F.liminf f := by
+  have cobdd : F.IsCobounded (· ≤ ·) := bdd_below.isCobounded_flip
   apply le_antisymm
-  · have A : { a : R | ∀ᶠ n : R in F, n ≤ a }.Nonempty := ⟨⊤, by simp⟩
-    rw [limsSup, f_decr.map_sInf_of_continuousAt' f_cont A]
+  · rw [limsSup, f_decr.map_sInf_of_continuousAt' f_cont bdd_above cobdd]
     apply le_of_forall_lt
     intro c hc
-    simp only [liminf, limsInf, lt_sSup_iff, eventually_map, Set.mem_setOf_eq, exists_prop,
-      Set.mem_image, exists_exists_and_eq_and] at hc ⊢
-    rcases hc with ⟨d, hd, h'd⟩
-    refine' ⟨f d, _, h'd⟩
-    filter_upwards [hd]with x hx using f_decr hx
-  · rcases eq_or_lt_of_le (bot_le : ⊥ ≤ F.limsSup) with (h | limsSup_ne_bot)
-    · rw [← h]
-      apply liminf_le_of_frequently_le _
-      apply frequently_of_forall
-      intro x
-      exact f_decr bot_le
-    by_cases h' : ∃ c, c < F.limsSup ∧ Set.Ioo c F.limsSup = ∅
+    simp only [liminf, limsInf, eventually_map] at hc ⊢
+    obtain ⟨d, hd, h'd⟩ :=
+      exists_lt_of_lt_csSup (bdd_above.recOn fun x hx ↦ ⟨f x, Set.mem_image_of_mem f hx⟩) hc
+    apply lt_csSup_of_lt ?_ ?_ h'd
+    · exact (Antitone.isBoundedUnder_le_comp f_decr bdd_below).isCoboundedUnder_flip
+    · rcases hd with ⟨e, ⟨he, fe_eq_d⟩⟩
+      filter_upwards [he] with x hx using (fe_eq_d.symm ▸ f_decr hx)
+  · by_cases h' : ∃ c, c < F.limsSup ∧ Set.Ioo c F.limsSup = ∅
     · rcases h' with ⟨c, c_lt, hc⟩
       have B : ∃ᶠ n in F, F.limsSup ≤ n := by
-        apply (frequently_lt_of_lt_limsSup (by isBoundedDefault) c_lt).mono
+        apply (frequently_lt_of_lt_limsSup cobdd c_lt).mono
         intro x hx
         by_contra'
         have : (Set.Ioo c F.limsSup).Nonempty := ⟨x, ⟨hx, this⟩⟩
         simp only [hc, Set.not_nonempty_empty] at this
-      apply liminf_le_of_frequently_le _
-      exact B.mono fun x hx ↦ f_decr hx
+      apply liminf_le_of_frequently_le _ (bdd_above.isBoundedUnder f_decr)
+      exact (B.mono fun x hx ↦ f_decr hx)
+    push_neg at h'
     by_contra' H
+    have not_bot : ¬ IsBot F.limsSup := fun maybe_bot ↦
+      lt_irrefl (F.liminf f) <| lt_of_le_of_lt
+        (liminf_le_of_frequently_le (frequently_of_forall (fun r ↦ f_decr (maybe_bot r)))
+          (bdd_above.isBoundedUnder f_decr)) H
     obtain ⟨l, l_lt, h'l⟩ : ∃ l < F.limsSup, Set.Ioc l F.limsSup ⊆ { x : R | f x < F.liminf f }
-    exact exists_Ioc_subset_of_mem_nhds ((tendsto_order.1 f_cont.tendsto).2 _ H) ⟨⊥, limsSup_ne_bot⟩
+    · apply exists_Ioc_subset_of_mem_nhds ((tendsto_order.1 f_cont.tendsto).2 _ H)
+      simpa [IsBot] using not_bot
     obtain ⟨m, l_m, m_lt⟩ : (Set.Ioo l F.limsSup).Nonempty := by
       contrapose! h'
       refine' ⟨l, l_lt, by rwa [Set.not_nonempty_iff_eq_empty] at h'⟩
     have B : F.liminf f ≤ f m := by
-      apply liminf_le_of_frequently_le _
-      apply (frequently_lt_of_lt_limsSup (by isBoundedDefault) m_lt).mono
-      intro x hx
-      exact f_decr hx.le
+      apply liminf_le_of_frequently_le _ _
+      · apply (frequently_lt_of_lt_limsSup cobdd m_lt).mono
+        exact fun x hx ↦ f_decr hx.le
+      · exact IsBounded.isBoundedUnder f_decr bdd_above
     have I : f m < F.liminf f := h'l ⟨l_m, m_lt.le⟩
     exact lt_irrefl _ (B.trans_lt I)
 set_option linter.uppercaseLean3 false in
 #align antitone.map_Limsup_of_continuous_at Antitone.map_limsSup_of_continuousAt
 
-/-- A continuous antitone function between complete linear ordered spaces sends a `Filter.limsup`
-to the `Filter.liminf` of the images. -/
+/-- 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
+below). -/
 theorem Antitone.map_limsup_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
-    (f_cont : ContinuousAt f (F.limsup a)) : f (F.limsup a) = F.liminf (f ∘ a) :=
-  f_decr.map_limsSup_of_continuousAt f_cont
+    (f_cont : ContinuousAt f (F.limsup a))
+    (bdd_above : F.IsBoundedUnder (· ≤ ·) a := by isBoundedDefault)
+    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
+    f (F.limsup a) = F.liminf (f ∘ a) :=
+  f_decr.map_limsSup_of_continuousAt f_cont bdd_above bdd_below
 #align antitone.map_limsup_of_continuous_at Antitone.map_limsup_of_continuousAt
 
-/-- An antitone function between complete linear ordered spaces sends a `Filter.limsInf`
-to the `Filter.limsup` of the image if it is continuous at the `limsInf`. -/
+/-- 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 above and below). -/
 theorem Antitone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsInf) : f F.limsInf = F.limsup f :=
-  @Antitone.map_limsSup_of_continuousAt (OrderDual R) (OrderDual S) _ _ _ _ _ _ _ _ f f_decr.dual
-    f_cont
+    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsInf)
+    (bdd_above : F.IsBounded (· ≤ ·) := by isBoundedDefault)
+    (bdd_below : F.IsBounded (· ≥ ·) := by isBoundedDefault) : f F.limsInf = F.limsup f :=
+  Antitone.map_limsSup_of_continuousAt (R := Rᵒᵈ) (S := Sᵒᵈ) f_decr.dual f_cont bdd_below bdd_above
 set_option linter.uppercaseLean3 false in
 #align antitone.map_Liminf_of_continuous_at Antitone.map_limsInf_of_continuousAt
 
-/-- A continuous antitone function between complete linear ordered spaces sends a `Filter.liminf`
-to the `Filter.limsup` of the images. -/
+/-- 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 above and
+below). -/
 theorem Antitone.map_liminf_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
-    (f_cont : ContinuousAt f (F.liminf a)) : f (F.liminf a) = F.limsup (f ∘ a) :=
-  f_decr.map_limsInf_of_continuousAt f_cont
+    (f_cont : ContinuousAt f (F.liminf a))
+    (bdd_above : F.IsBoundedUnder (· ≤ ·) a := by isBoundedDefault)
+    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
+    f (F.liminf a) = F.limsup (f ∘ a) :=
+  f_decr.map_limsInf_of_continuousAt f_cont bdd_above bdd_below
 #align antitone.map_liminf_of_continuous_at Antitone.map_liminf_of_continuousAt
 
-/-- A monotone function between complete linear ordered spaces sends a `Filter.limsSup`
-to the `Filter.limsup` of the image if it is continuous at the `limsSup`. -/
+/-- 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 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) : f F.limsSup = F.limsup f :=
-  @Antitone.map_limsSup_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
+    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsSup)
+    (bdd_above : F.IsBounded (· ≤ ·) := by isBoundedDefault)
+    (bdd_below : F.IsBounded (· ≥ ·) := by isBoundedDefault) : f F.limsSup = F.limsup f :=
+  Antitone.map_limsSup_of_continuousAt (S := Sᵒᵈ) f_incr f_cont bdd_above bdd_below
 set_option linter.uppercaseLean3 false in
 #align monotone.map_Limsup_of_continuous_at Monotone.map_limsSup_of_continuousAt
 
-/-- A continuous monotone function between complete linear ordered spaces sends a `Filter.limsup`
-to the `Filter.limsup` of the images. -/
+/-- 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
+below). -/
 theorem Monotone.map_limsup_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
-    (f_cont : ContinuousAt f (F.limsup a)) : f (F.limsup a) = F.limsup (f ∘ a) :=
-  f_incr.map_limsSup_of_continuousAt f_cont
+    (f_cont : ContinuousAt f (F.limsup a))
+    (bdd_above : F.IsBoundedUnder (· ≤ ·) a := by isBoundedDefault)
+    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
+    f (F.limsup a) = F.limsup (f ∘ a) :=
+  f_incr.map_limsSup_of_continuousAt f_cont bdd_above bdd_below
 #align monotone.map_limsup_of_continuous_at Monotone.map_limsup_of_continuousAt
 
-/-- A monotone function between complete linear ordered spaces sends a `Filter.limsInf`
-to the `Filter.liminf` of the image if it is continuous at the `limsInf`. -/
+/-- 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 above and below). -/
 theorem Monotone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsInf) : f F.limsInf = F.liminf f :=
-  @Antitone.map_limsInf_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
+    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsInf)
+    (bdd_above : F.IsBounded (· ≤ ·) := by isBoundedDefault)
+    (bdd_below : F.IsBounded (· ≥ ·) := by isBoundedDefault) : f F.limsInf = F.liminf f :=
+  Antitone.map_limsSup_of_continuousAt (R := Rᵒᵈ) f_incr.dual f_cont bdd_below bdd_above
 set_option linter.uppercaseLean3 false in
 #align monotone.map_Liminf_of_continuous_at Monotone.map_limsInf_of_continuousAt
 
-/-- A continuous monotone function between complete linear ordered spaces sends a `Filter.liminf`
-to the `Filter.liminf` of the images. -/
+/-- 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 above and
+below). -/
 theorem Monotone.map_liminf_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
-    (f_cont : ContinuousAt f (F.liminf a)) : f (F.liminf a) = F.liminf (f ∘ a) :=
-  f_incr.map_limsInf_of_continuousAt f_cont
+    (f_cont : ContinuousAt f (F.liminf a))
+    (bdd_above : F.IsBoundedUnder (· ≤ ·) a := by isBoundedDefault)
+    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
+    f (F.liminf a) = F.liminf (f ∘ a) :=
+  f_incr.map_limsInf_of_continuousAt f_cont bdd_above bdd_below
 #align monotone.map_liminf_of_continuous_at Monotone.map_liminf_of_continuousAt
 
 end Monotone
@@ -422,7 +453,7 @@ theorem iInf_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (x_le : ∀ i, x
 
 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 :=
-  @iInf_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
+  iInf_eq_of_forall_le_of_tendsto (R := Rᵒᵈ) le_x as_lim
 #align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
 theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
@@ -442,7 +473,7 @@ theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R}
 theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (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 :=
-  @iUnion_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
+  iUnion_Ici_eq_Ioi_of_lt_of_tendsto (R := Rᵒᵈ) x lt_x as_lim
 #align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendsto
 
 end InfiAndSupr
chore: script to replace headers with #align_import statements (#5979)

Open in Gitpod

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

Diff
@@ -2,11 +2,6 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov
-
-! This file was ported from Lean 3 source module topology.algebra.order.liminf_limsup
-! leanprover-community/mathlib commit 52932b3a083d4142e78a15dc928084a22fea9ba0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.BigOperators.Intervals
 import Mathlib.Algebra.BigOperators.Order
@@ -16,6 +11,8 @@ import Mathlib.Order.Filter.Archimedean
 import Mathlib.Order.Filter.CountableInter
 import Mathlib.Topology.Order.Basic
 
+#align_import topology.algebra.order.liminf_limsup from "leanprover-community/mathlib"@"52932b3a083d4142e78a15dc928084a22fea9ba0"
+
 /-!
 # Lemmas about liminf and limsup in an order topology.
 -/
fix: precedences of ⨆⋃⋂⨅ (#5614)
Diff
@@ -418,19 +418,19 @@ open Filter Set
 variable {ι : Type _} {R : Type _} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
 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 := by
+    [Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) : ⨅ i, as i = x := by
   refine' iInf_eq_of_forall_ge_of_forall_gt_exists_lt (fun i ↦ x_le i) _
   apply fun w x_lt_w ↦ ‹Filter.NeBot F›.nonempty_of_mem (eventually_lt_of_tendsto_lt x_lt_w as_lim)
 #align infi_eq_of_forall_le_of_tendsto iInf_eq_of_forall_le_of_tendsto
 
 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 :=
+    [Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) : ⨆ i, as i = x :=
   @iInf_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
 #align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
 theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (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 := by
+    ⋃ i : ι, Ici (as i) = Ioi x := by
   have obs : x ∉ range as := by
     intro maybe_x_is
     rcases mem_range.mp maybe_x_is with ⟨i, hi⟩
@@ -444,7 +444,7 @@ theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R}
 
 theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (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 :=
+    ⋃ i : ι, Iic (as i) = Iio x :=
   @iUnion_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
 #align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendsto
 
feat: add Filter.eq_or_neBot (#5230)

Also add Filter.limsup_bot, Filter.liminf_bot, and golf some proofs using new lemmas.

Diff
@@ -236,10 +236,8 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
     (h : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
     (h' : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) :
     ∃ c : α, Tendsto u f (𝓝 c) := by
-  by_cases hbot : f = ⊥;
-  · rw [hbot]
-    exact ⟨sInf ∅, tendsto_bot⟩
-  haveI : NeBot f := ⟨hbot⟩
+  rcases f.eq_or_neBot with rfl | hbot
+  · exact ⟨sInf ∅, tendsto_bot⟩
   refine' ⟨limsup u f, _⟩
   apply tendsto_of_le_liminf_of_limsup_le _ le_rfl h h'
   by_contra' hlt
chore: clean up spacing around at and goals (#5387)

Changes are of the form

  • some_tactic at h⊢ -> some_tactic at h ⊢
  • some_tactic at h -> some_tactic at h
Diff
@@ -320,7 +320,7 @@ theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R →
     apply le_of_forall_lt
     intro c hc
     simp only [liminf, limsInf, lt_sSup_iff, eventually_map, Set.mem_setOf_eq, exists_prop,
-      Set.mem_image, exists_exists_and_eq_and] at hc⊢
+      Set.mem_image, exists_exists_and_eq_and] at hc ⊢
     rcases hc with ⟨d, hd, h'd⟩
     refine' ⟨f d, _, h'd⟩
     filter_upwards [hd]with x hx using f_decr hx
@@ -477,7 +477,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
       rw [Nat.sub_add_cancel hj₁, Set.indicator_of_mem hj₂]
       exact zero_lt_one
     · rw [imp_false] at hk
-      push_neg  at hk
+      push_neg at hk
       obtain ⟨i, hi⟩ := hk
       obtain ⟨j, hj₁, hj₂⟩ := hω (i + 1)
       replace hi : (∑ k in Finset.range i, (s (k + 1)).indicator 1 ω) = k + 1 :=
@@ -495,7 +495,7 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
   · rintro hω i
     rw [Set.mem_setOf_eq, tendsto_atTop_atTop] at hω
     by_contra hcon
-    push_neg  at hcon
+    push_neg at hcon
     obtain ⟨j, h⟩ := hω (i + 1)
     have : (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i := by
       have hle : ∀ j ≤ i, (∑ k in Finset.range j, (s (k + 1)).indicator 1 ω) ≤ i := by
chore: Rename to sSup/iSup (#3938)

As discussed on Zulip

Renames

  • supₛsSup
  • infₛsInf
  • supᵢiSup
  • infᵢiInf
  • bsupₛbsSup
  • binfₛbsInf
  • bsupᵢbiSup
  • binfᵢbiInf
  • csupₛcsSup
  • cinfₛcsInf
  • csupᵢciSup
  • cinfᵢciInf
  • unionₛsUnion
  • interₛsInter
  • unionᵢiUnion
  • interᵢiInter
  • bunionₛbsUnion
  • binterₛbsInter
  • bunionᵢbiUnion
  • binterᵢbiInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

Diff
@@ -134,32 +134,32 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α]
 
-theorem lt_mem_sets_of_limsupₛ_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsupₛ < b) :
+theorem lt_mem_sets_of_limsSup_lt {f : Filter α} {b} (h : f.IsBounded (· ≤ ·)) (l : f.limsSup < b) :
     ∀ᶠ a in f, a < b :=
-  let ⟨_, (h : ∀ᶠ a in f, a ≤ _), hcb⟩ := exists_lt_of_cinfₛ_lt h l
+  let ⟨_, (h : ∀ᶠ a in f, a ≤ _), hcb⟩ := exists_lt_of_csInf_lt h l
   mem_of_superset h fun _ hac ↦ lt_of_le_of_lt hac hcb
 set_option linter.uppercaseLean3 false in
-#align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsupₛ_lt
+#align lt_mem_sets_of_Limsup_lt lt_mem_sets_of_limsSup_lt
 
-theorem gt_mem_sets_of_liminfₛ_gt :
-    ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.liminfₛ → ∀ᶠ a in f, b < a :=
-  @lt_mem_sets_of_limsupₛ_lt αᵒᵈ _
+theorem gt_mem_sets_of_limsInf_gt :
+    ∀ {f : Filter α} {b}, f.IsBounded (· ≥ ·) → b < f.limsInf → ∀ᶠ a in f, b < a :=
+  @lt_mem_sets_of_limsSup_lt αᵒᵈ _
 set_option linter.uppercaseLean3 false in
-#align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_liminfₛ_gt
+#align gt_mem_sets_of_Liminf_gt gt_mem_sets_of_limsInf_gt
 
 variable [TopologicalSpace α] [OrderTopology α]
 
 /-- 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_limsupₛ_eq_liminfₛ {f : Filter α} {a : α} (hl : f.IsBounded (· ≤ ·))
-    (hg : f.IsBounded (· ≥ ·)) (hs : f.limsupₛ = a) (hi : f.liminfₛ = a) : f ≤ 𝓝 a :=
-  tendsto_order.2 ⟨fun _ hb ↦ gt_mem_sets_of_liminfₛ_gt hg <| hi.symm ▸ hb,
-    fun _ hb ↦ lt_mem_sets_of_limsupₛ_lt hl <| hs.symm ▸ hb⟩
+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 :=
+  tendsto_order.2 ⟨fun _ hb ↦ gt_mem_sets_of_limsInf_gt hg <| hi.symm ▸ hb,
+    fun _ hb ↦ lt_mem_sets_of_limsSup_lt hl <| hs.symm ▸ hb⟩
 set_option linter.uppercaseLean3 false in
-#align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsupₛ_eq_liminfₛ
+#align le_nhds_of_Limsup_eq_Liminf le_nhds_of_limsSup_eq_limsInf
 
-theorem limsupₛ_nhds (a : α) : limsupₛ (𝓝 a) = a :=
-  cinfₛ_eq_of_forall_ge_of_forall_gt_exists_lt (isBounded_le_nhds a)
+theorem limsSup_nhds (a : α) : limsSup (𝓝 a) = a :=
+  csInf_eq_of_forall_ge_of_forall_gt_exists_lt (isBounded_le_nhds a)
     (fun a' (h : { n : α | n ≤ a' } ∈ 𝓝 a) ↦ show a ≤ a' from @mem_of_mem_nhds α _ a _ h)
     fun b (hba : a < b) ↦
     show ∃ c, { n : α | n ≤ c } ∈ 𝓝 a ∧ c < b from
@@ -167,44 +167,44 @@ theorem limsupₛ_nhds (a : α) : limsupₛ (𝓝 a) = a :=
       | Or.inl ⟨c, hac, hcb⟩ => ⟨c, ge_mem_nhds hac, hcb⟩
       | Or.inr ⟨_, h⟩ => ⟨a, (𝓝 a).sets_of_superset (gt_mem_nhds hba) h, hba⟩
 set_option linter.uppercaseLean3 false in
-#align Limsup_nhds limsupₛ_nhds
+#align Limsup_nhds limsSup_nhds
 
-theorem liminfₛ_nhds : ∀ a : α, liminfₛ (𝓝 a) = a :=
-  @limsupₛ_nhds αᵒᵈ _ _ _
+theorem limsInf_nhds : ∀ a : α, limsInf (𝓝 a) = a :=
+  @limsSup_nhds αᵒᵈ _ _ _
 set_option linter.uppercaseLean3 false in
-#align Liminf_nhds liminfₛ_nhds
+#align Liminf_nhds limsInf_nhds
 
 /-- If a filter is converging, its limsup coincides with its limit. -/
-theorem liminfₛ_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝 a) : f.liminfₛ = a :=
+theorem limsInf_eq_of_le_nhds {f : Filter α} {a : α} [NeBot f] (h : f ≤ 𝓝 a) : f.limsInf = a :=
   have hb_ge : IsBounded (· ≥ ·) f := (isBounded_ge_nhds a).mono h
   have hb_le : IsBounded (· ≤ ·) f := (isBounded_le_nhds a).mono h
   le_antisymm
     (calc
-      f.liminfₛ ≤ f.limsupₛ := liminfₛ_le_limsupₛ hb_le hb_ge
-      _ ≤ (𝓝 a).limsupₛ := limsupₛ_le_limsupₛ_of_le h hb_ge.isCobounded_flip (isBounded_le_nhds a)
-      _ = a := limsupₛ_nhds a)
+      f.limsInf ≤ f.limsSup := limsInf_le_limsSup hb_le hb_ge
+      _ ≤ (𝓝 a).limsSup := limsSup_le_limsSup_of_le h hb_ge.isCobounded_flip (isBounded_le_nhds a)
+      _ = a := limsSup_nhds a)
     (calc
-      a = (𝓝 a).liminfₛ := (liminfₛ_nhds a).symm
-      _ ≤ f.liminfₛ := liminfₛ_le_liminfₛ_of_le h (isBounded_ge_nhds a) hb_le.isCobounded_flip)
+      a = (𝓝 a).limsInf := (limsInf_nhds a).symm
+      _ ≤ f.limsInf := limsInf_le_limsInf_of_le h (isBounded_ge_nhds a) hb_le.isCobounded_flip)
 set_option linter.uppercaseLean3 false in
-#align Liminf_eq_of_le_nhds liminfₛ_eq_of_le_nhds
+#align Liminf_eq_of_le_nhds limsInf_eq_of_le_nhds
 
 /-- If a filter is converging, its liminf coincides with its limit. -/
-theorem limsupₛ_eq_of_le_nhds : ∀ {f : Filter α} {a : α} [NeBot f], f ≤ 𝓝 a → f.limsupₛ = a :=
-  @liminfₛ_eq_of_le_nhds αᵒᵈ _ _ _
+theorem limsSup_eq_of_le_nhds : ∀ {f : Filter α} {a : α} [NeBot f], f ≤ 𝓝 a → f.limsSup = a :=
+  @limsInf_eq_of_le_nhds αᵒᵈ _ _ _
 set_option linter.uppercaseLean3 false in
-#align Limsup_eq_of_le_nhds limsupₛ_eq_of_le_nhds
+#align Limsup_eq_of_le_nhds limsSup_eq_of_le_nhds
 
 /-- 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 :=
-  limsupₛ_eq_of_le_nhds h
+  limsSup_eq_of_le_nhds h
 #align filter.tendsto.limsup_eq Filter.Tendsto.limsup_eq
 
 /-- 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 :=
-  liminfₛ_eq_of_le_nhds h
+  limsInf_eq_of_le_nhds h
 #align filter.tendsto.liminf_eq Filter.Tendsto.liminf_eq
 
 /-- If the liminf and the limsup of a function coincide, then the limit of the function
@@ -212,7 +212,7 @@ 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) :=
-  le_nhds_of_limsupₛ_eq_liminfₛ h h' hsup hinf
+  le_nhds_of_limsSup_eq_limsInf h h' hsup hinf
 #align tendsto_of_liminf_eq_limsup tendsto_of_liminf_eq_limsup
 
 /-- If a number `a` is less than or equal to the `liminf` of a function `f` at some filter
@@ -238,7 +238,7 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
     ∃ c : α, Tendsto u f (𝓝 c) := by
   by_cases hbot : f = ⊥;
   · rw [hbot]
-    exact ⟨infₛ ∅, tendsto_bot⟩
+    exact ⟨sInf ∅, tendsto_bot⟩
   haveI : NeBot f := ⟨hbot⟩
   refine' ⟨limsup u f, _⟩
   apply tendsto_of_le_liminf_of_limsup_le _ le_rfl h h'
@@ -310,103 +310,103 @@ section Monotone
 variable {ι R S : Type _} {F : Filter ι} [NeBot F] [CompleteLinearOrder R] [TopologicalSpace R]
   [OrderTopology R] [CompleteLinearOrder S] [TopologicalSpace S] [OrderTopology S]
 
-/-- An antitone function between complete linear ordered spaces sends a `Filter.limsupₛ`
-to the `Filter.liminf` of the image if it is continuous at the `limsupₛ`. -/
-theorem Antitone.map_limsupₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsupₛ) : f F.limsupₛ = F.liminf f := by
+/-- An antitone function between complete linear ordered spaces sends a `Filter.limsSup`
+to the `Filter.liminf` of the image if it is continuous at the `limsSup`. -/
+theorem Antitone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
+    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsSup) : f F.limsSup = F.liminf f := by
   apply le_antisymm
   · have A : { a : R | ∀ᶠ n : R in F, n ≤ a }.Nonempty := ⟨⊤, by simp⟩
-    rw [limsupₛ, f_decr.map_infₛ_of_continuousAt' f_cont A]
+    rw [limsSup, f_decr.map_sInf_of_continuousAt' f_cont A]
     apply le_of_forall_lt
     intro c hc
-    simp only [liminf, liminfₛ, lt_supₛ_iff, eventually_map, Set.mem_setOf_eq, exists_prop,
+    simp only [liminf, limsInf, lt_sSup_iff, eventually_map, Set.mem_setOf_eq, exists_prop,
       Set.mem_image, exists_exists_and_eq_and] at hc⊢
     rcases hc with ⟨d, hd, h'd⟩
     refine' ⟨f d, _, h'd⟩
     filter_upwards [hd]with x hx using f_decr hx
-  · rcases eq_or_lt_of_le (bot_le : ⊥ ≤ F.limsupₛ) with (h | limsupₛ_ne_bot)
+  · rcases eq_or_lt_of_le (bot_le : ⊥ ≤ F.limsSup) with (h | limsSup_ne_bot)
     · rw [← h]
       apply liminf_le_of_frequently_le _
       apply frequently_of_forall
       intro x
       exact f_decr bot_le
-    by_cases h' : ∃ c, c < F.limsupₛ ∧ Set.Ioo c F.limsupₛ = ∅
+    by_cases h' : ∃ c, c < F.limsSup ∧ Set.Ioo c F.limsSup = ∅
     · rcases h' with ⟨c, c_lt, hc⟩
-      have B : ∃ᶠ n in F, F.limsupₛ ≤ n := by
-        apply (frequently_lt_of_lt_limsupₛ (by isBoundedDefault) c_lt).mono
+      have B : ∃ᶠ n in F, F.limsSup ≤ n := by
+        apply (frequently_lt_of_lt_limsSup (by isBoundedDefault) c_lt).mono
         intro x hx
         by_contra'
-        have : (Set.Ioo c F.limsupₛ).Nonempty := ⟨x, ⟨hx, this⟩⟩
+        have : (Set.Ioo c F.limsSup).Nonempty := ⟨x, ⟨hx, this⟩⟩
         simp only [hc, Set.not_nonempty_empty] at this
       apply liminf_le_of_frequently_le _
       exact B.mono fun x hx ↦ f_decr hx
     by_contra' H
-    obtain ⟨l, l_lt, h'l⟩ : ∃ l < F.limsupₛ, Set.Ioc l F.limsupₛ ⊆ { x : R | f x < F.liminf f }
-    exact exists_Ioc_subset_of_mem_nhds ((tendsto_order.1 f_cont.tendsto).2 _ H) ⟨⊥, limsupₛ_ne_bot⟩
-    obtain ⟨m, l_m, m_lt⟩ : (Set.Ioo l F.limsupₛ).Nonempty := by
+    obtain ⟨l, l_lt, h'l⟩ : ∃ l < F.limsSup, Set.Ioc l F.limsSup ⊆ { x : R | f x < F.liminf f }
+    exact exists_Ioc_subset_of_mem_nhds ((tendsto_order.1 f_cont.tendsto).2 _ H) ⟨⊥, limsSup_ne_bot⟩
+    obtain ⟨m, l_m, m_lt⟩ : (Set.Ioo l F.limsSup).Nonempty := by
       contrapose! h'
       refine' ⟨l, l_lt, by rwa [Set.not_nonempty_iff_eq_empty] at h'⟩
     have B : F.liminf f ≤ f m := by
       apply liminf_le_of_frequently_le _
-      apply (frequently_lt_of_lt_limsupₛ (by isBoundedDefault) m_lt).mono
+      apply (frequently_lt_of_lt_limsSup (by isBoundedDefault) m_lt).mono
       intro x hx
       exact f_decr hx.le
     have I : f m < F.liminf f := h'l ⟨l_m, m_lt.le⟩
     exact lt_irrefl _ (B.trans_lt I)
 set_option linter.uppercaseLean3 false in
-#align antitone.map_Limsup_of_continuous_at Antitone.map_limsupₛ_of_continuousAt
+#align antitone.map_Limsup_of_continuous_at Antitone.map_limsSup_of_continuousAt
 
 /-- A continuous antitone function between complete linear ordered spaces sends a `Filter.limsup`
 to the `Filter.liminf` of the images. -/
 theorem Antitone.map_limsup_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.limsup a)) : f (F.limsup a) = F.liminf (f ∘ a) :=
-  f_decr.map_limsupₛ_of_continuousAt f_cont
+  f_decr.map_limsSup_of_continuousAt f_cont
 #align antitone.map_limsup_of_continuous_at Antitone.map_limsup_of_continuousAt
 
-/-- An antitone function between complete linear ordered spaces sends a `Filter.liminfₛ`
-to the `Filter.limsup` of the image if it is continuous at the `liminfₛ`. -/
-theorem Antitone.map_liminfₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_decr : Antitone f) (f_cont : ContinuousAt f F.liminfₛ) : f F.liminfₛ = F.limsup f :=
-  @Antitone.map_limsupₛ_of_continuousAt (OrderDual R) (OrderDual S) _ _ _ _ _ _ _ _ f f_decr.dual
+/-- An antitone function between complete linear ordered spaces sends a `Filter.limsInf`
+to the `Filter.limsup` of the image if it is continuous at the `limsInf`. -/
+theorem Antitone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
+    (f_decr : Antitone f) (f_cont : ContinuousAt f F.limsInf) : f F.limsInf = F.limsup f :=
+  @Antitone.map_limsSup_of_continuousAt (OrderDual R) (OrderDual S) _ _ _ _ _ _ _ _ f f_decr.dual
     f_cont
 set_option linter.uppercaseLean3 false in
-#align antitone.map_Liminf_of_continuous_at Antitone.map_liminfₛ_of_continuousAt
+#align antitone.map_Liminf_of_continuous_at Antitone.map_limsInf_of_continuousAt
 
 /-- A continuous antitone function between complete linear ordered spaces sends a `Filter.liminf`
 to the `Filter.limsup` of the images. -/
 theorem Antitone.map_liminf_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.liminf a)) : f (F.liminf a) = F.limsup (f ∘ a) :=
-  f_decr.map_liminfₛ_of_continuousAt f_cont
+  f_decr.map_limsInf_of_continuousAt f_cont
 #align antitone.map_liminf_of_continuous_at Antitone.map_liminf_of_continuousAt
 
-/-- A monotone function between complete linear ordered spaces sends a `Filter.limsupₛ`
-to the `Filter.limsup` of the image if it is continuous at the `limsupₛ`. -/
-theorem Monotone.map_limsupₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsupₛ) : f F.limsupₛ = F.limsup f :=
-  @Antitone.map_limsupₛ_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
+/-- A monotone function between complete linear ordered spaces sends a `Filter.limsSup`
+to the `Filter.limsup` of the image if it is continuous at the `limsSup`. -/
+theorem Monotone.map_limsSup_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
+    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsSup) : f F.limsSup = F.limsup f :=
+  @Antitone.map_limsSup_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
 set_option linter.uppercaseLean3 false in
-#align monotone.map_Limsup_of_continuous_at Monotone.map_limsupₛ_of_continuousAt
+#align monotone.map_Limsup_of_continuous_at Monotone.map_limsSup_of_continuousAt
 
 /-- A continuous monotone function between complete linear ordered spaces sends a `Filter.limsup`
 to the `Filter.limsup` of the images. -/
 theorem Monotone.map_limsup_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.limsup a)) : f (F.limsup a) = F.limsup (f ∘ a) :=
-  f_incr.map_limsupₛ_of_continuousAt f_cont
+  f_incr.map_limsSup_of_continuousAt f_cont
 #align monotone.map_limsup_of_continuous_at Monotone.map_limsup_of_continuousAt
 
-/-- A monotone function between complete linear ordered spaces sends a `Filter.liminfₛ`
-to the `Filter.liminf` of the image if it is continuous at the `liminfₛ`. -/
-theorem Monotone.map_liminfₛ_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
-    (f_incr : Monotone f) (f_cont : ContinuousAt f F.liminfₛ) : f F.liminfₛ = F.liminf f :=
-  @Antitone.map_liminfₛ_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
+/-- A monotone function between complete linear ordered spaces sends a `Filter.limsInf`
+to the `Filter.liminf` of the image if it is continuous at the `limsInf`. -/
+theorem Monotone.map_limsInf_of_continuousAt {F : Filter R} [NeBot F] {f : R → S}
+    (f_incr : Monotone f) (f_cont : ContinuousAt f F.limsInf) : f F.limsInf = F.liminf f :=
+  @Antitone.map_limsInf_of_continuousAt R (OrderDual S) _ _ _ _ _ _ _ _ f f_incr f_cont
 set_option linter.uppercaseLean3 false in
-#align monotone.map_Liminf_of_continuous_at Monotone.map_liminfₛ_of_continuousAt
+#align monotone.map_Liminf_of_continuous_at Monotone.map_limsInf_of_continuousAt
 
 /-- A continuous monotone function between complete linear ordered spaces sends a `Filter.liminf`
 to the `Filter.liminf` of the images. -/
 theorem Monotone.map_liminf_of_continuousAt {f : R → S} (f_incr : Monotone f) (a : ι → R)
     (f_cont : ContinuousAt f (F.liminf a)) : f (F.liminf a) = F.liminf (f ∘ a) :=
-  f_incr.map_liminfₛ_of_continuousAt f_cont
+  f_incr.map_limsInf_of_continuousAt f_cont
 #align monotone.map_liminf_of_continuous_at Monotone.map_liminf_of_continuousAt
 
 end Monotone
@@ -419,18 +419,18 @@ open Filter Set
 
 variable {ι : Type _} {R : Type _} [CompleteLinearOrder R] [TopologicalSpace R] [OrderTopology R]
 
-theorem infᵢ_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (x_le : ∀ i, x ≤ as i) {F : Filter ι}
+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 := by
-  refine' infᵢ_eq_of_forall_ge_of_forall_gt_exists_lt (fun i ↦ x_le i) _
+  refine' iInf_eq_of_forall_ge_of_forall_gt_exists_lt (fun i ↦ x_le i) _
   apply fun w x_lt_w ↦ ‹Filter.NeBot F›.nonempty_of_mem (eventually_lt_of_tendsto_lt x_lt_w as_lim)
-#align infi_eq_of_forall_le_of_tendsto infᵢ_eq_of_forall_le_of_tendsto
+#align infi_eq_of_forall_le_of_tendsto iInf_eq_of_forall_le_of_tendsto
 
-theorem supᵢ_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (le_x : ∀ i, as i ≤ x) {F : Filter ι}
+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 :=
-  @infᵢ_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
-#align supr_eq_of_forall_le_of_tendsto supᵢ_eq_of_forall_le_of_tendsto
+  @iInf_eq_of_forall_le_of_tendsto ι (OrderDual R) _ _ _ x as le_x F _ as_lim
+#align supr_eq_of_forall_le_of_tendsto iSup_eq_of_forall_le_of_tendsto
 
-theorem unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (x_lt : ∀ i, x < as i)
+theorem iUnion_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (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 := by
   have obs : x ∉ range as := by
@@ -438,17 +438,17 @@ theorem unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι →
     rcases mem_range.mp maybe_x_is with ⟨i, hi⟩
     simpa only [hi, lt_self_iff_false] using x_lt i
   -- Porting note: `rw at *` was too destructive. Let's only rewrite `obs` and the goal.
-  have := infᵢ_eq_of_forall_le_of_tendsto (fun i ↦ (x_lt i).le) as_lim
+  have := iInf_eq_of_forall_le_of_tendsto (fun i ↦ (x_lt i).le) as_lim
   rw [← this] at obs
   rw [← this]
-  exact unionᵢ_Ici_eq_Ioi_infᵢ obs
-#align Union_Ici_eq_Ioi_of_lt_of_tendsto unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto
+  exact iUnion_Ici_eq_Ioi_iInf obs
+#align Union_Ici_eq_Ioi_of_lt_of_tendsto iUnion_Ici_eq_Ioi_of_lt_of_tendsto
 
-theorem unionᵢ_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (x : R) {as : ι → R} (lt_x : ∀ i, as i < x)
+theorem iUnion_Iic_eq_Iio_of_lt_of_tendsto {ι : Type _} (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 :=
-  @unionᵢ_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
-#align Union_Iic_eq_Iio_of_lt_of_tendsto unionᵢ_Iic_eq_Iio_of_lt_of_tendsto
+  @iUnion_Ici_eq_Ioi_of_lt_of_tendsto (OrderDual R) _ _ _ ι x as lt_x F _ as_lim
+#align Union_Iic_eq_Iio_of_lt_of_tendsto iUnion_Iic_eq_Iio_of_lt_of_tendsto
 
 end InfiAndSupr
 
@@ -460,8 +460,8 @@ theorem limsup_eq_tendsto_sum_indicator_nat_atTop (s : ℕ → Set α) :
     limsup s atTop = { ω | Tendsto
       (fun n ↦ ∑ k in Finset.range n, (s (k + 1)).indicator (1 : α → ℕ) ω) atTop atTop } := by
   ext ω
-  simp only [limsup_eq_infᵢ_supᵢ_of_nat, ge_iff_le, Set.supᵢ_eq_unionᵢ, Set.infᵢ_eq_interᵢ,
-    Set.mem_interᵢ, Set.mem_unionᵢ, exists_prop]
+  simp only [limsup_eq_iInf_iSup_of_nat, ge_iff_le, Set.iSup_eq_iUnion, Set.iInf_eq_iInter,
+    Set.mem_iInter, Set.mem_iUnion, exists_prop]
   constructor
   · intro hω
     refine' tendsto_atTop_atTop_of_monotone' (fun n m hnm ↦ Finset.sum_mono_set_of_nonneg
Diff
@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mario Carneiro, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module topology.algebra.order.liminf_limsup
-! leanprover-community/mathlib commit 98e83c3d541c77cdb7da20d79611a780ff8e7d90
+! leanprover-community/mathlib commit 52932b3a083d4142e78a15dc928084a22fea9ba0
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,7 @@ import Mathlib.Algebra.BigOperators.Order
 import Mathlib.Algebra.IndicatorFunction
 import Mathlib.Order.LiminfLimsup
 import Mathlib.Order.Filter.Archimedean
+import Mathlib.Order.Filter.CountableInter
 import Mathlib.Topology.Order.Basic
 
 /-!
@@ -20,7 +21,7 @@ import Mathlib.Topology.Order.Basic
 -/
 
 
-open Filter
+open Filter TopologicalSpace
 
 open Topology Classical
 
@@ -252,8 +253,56 @@ theorem tendsto_of_no_upcrossings [DenselyOrdered α] {f : Filter β} {u : β 
   exact H a as b bs ab ⟨A, B⟩
 #align tendsto_of_no_upcrossings tendsto_of_no_upcrossings
 
+variable [FirstCountableTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}
+
+theorem eventually_le_limsup (hf : IsBoundedUnder (· ≤ ·) f u := by isBoundedDefault) :
+    ∀ᶠ b in f, u b ≤ f.limsup u := by
+  obtain ha | ha := isTop_or_exists_gt (f.limsup u)
+  · exact eventually_of_forall fun _ => ha _
+  by_cases H : IsGLB (Set.Ioi (f.limsup u)) (f.limsup u)
+  · obtain ⟨u, -, -, hua, hu⟩ := H.exists_seq_antitone_tendsto ha
+    have := fun n => eventually_lt_of_limsup_lt (hu n) hf
+    exact
+      (eventually_countable_forall.2 this).mono fun b hb =>
+        ge_of_tendsto hua <| eventually_of_forall fun n => (hb _).le
+  · obtain ⟨x, hx, xa⟩ : ∃ x, (∀ ⦃b⦄, f.limsup u < b → x ≤ b) ∧ f.limsup u < x := by
+      simp only [IsGLB, IsGreatest, lowerBounds, upperBounds, Set.mem_Ioi, Set.mem_setOf_eq,
+        not_and, not_forall, not_le, exists_prop] at H
+      exact H fun x => le_of_lt
+    filter_upwards [eventually_lt_of_limsup_lt xa hf] with y hy
+    contrapose! hy
+    exact hx hy
+#align eventually_le_limsup eventually_le_limsup
+
+theorem eventually_liminf_le (hf : IsBoundedUnder (· ≥ ·) f u := by isBoundedDefault) :
+    ∀ᶠ b in f, f.liminf u ≤ u b :=
+  @eventually_le_limsup αᵒᵈ _ _ _ _ _ _ _ _ hf
+#align eventually_liminf_le eventually_liminf_le
+
 end ConditionallyCompleteLinearOrder
 
+section CompleteLinearOrder
+
+variable [CompleteLinearOrder α] [TopologicalSpace α] [FirstCountableTopology α] [OrderTopology α]
+  {f : Filter β} [CountableInterFilter f] {u : β → α}
+
+@[simp]
+theorem limsup_eq_bot : f.limsup u = ⊥ ↔ u =ᶠ[f] ⊥ :=
+  ⟨fun h =>
+    (EventuallyLE.trans eventually_le_limsup <| eventually_of_forall fun _ => h.le).mono fun x hx =>
+      le_antisymm hx bot_le,
+    fun h => by
+    rw [limsup_congr h]
+    exact limsup_const_bot⟩
+#align limsup_eq_bot limsup_eq_bot
+
+@[simp]
+theorem liminf_eq_top : f.liminf u = ⊤ ↔ u =ᶠ[f] ⊤ :=
+  @limsup_eq_bot αᵒᵈ _ _ _ _ _ _ _ _
+#align liminf_eq_top liminf_eq_top
+
+end CompleteLinearOrder
+
 end LiminfLimsup
 
 section Monotone
feat: port Topology.Algebra.Order.LiminfLimsup (#2161)

Dependencies 8 + 339

340 files ported (97.7%)
149530 lines ported (96.8%)
Show graph

The unported dependencies are