data.analysis.filter ⟷ Mathlib.Data.Analysis.Filter

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -431,6 +431,12 @@ theorem tendsto_iff (f : α → β) {l₁ : Filter α} {l₂ : Filter β} (L₁
 #print Filter.Realizer.ne_bot_iff /-
 theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ, (F.f a).Nonempty := by
   classical
+  rw [not_iff_comm, ← le_bot_iff, F.le_iff realizer.bot, Classical.not_forall]
+  simp only [Set.not_nonempty_iff_eq_empty]
+  exact
+    ⟨fun ⟨x, e⟩ _ => ⟨x, le_of_eq e⟩, fun h =>
+      let ⟨x, h⟩ := h ()
+      ⟨x, le_bot_iff.1 h⟩⟩
 #align filter.realizer.ne_bot_iff Filter.Realizer.ne_bot_iff
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -431,12 +431,6 @@ theorem tendsto_iff (f : α → β) {l₁ : Filter α} {l₂ : Filter β} (L₁
 #print Filter.Realizer.ne_bot_iff /-
 theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ, (F.f a).Nonempty := by
   classical
-  rw [not_iff_comm, ← le_bot_iff, F.le_iff realizer.bot, Classical.not_forall]
-  simp only [Set.not_nonempty_iff_eq_empty]
-  exact
-    ⟨fun ⟨x, e⟩ _ => ⟨x, le_of_eq e⟩, fun h =>
-      let ⟨x, h⟩ := h ()
-      ⟨x, le_bot_iff.1 h⟩⟩
 #align filter.realizer.ne_bot_iff Filter.Realizer.ne_bot_iff
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/b1abe23ae96fef89ad30d9f4362c307f72a55010

@@ -431,7 +431,7 @@ theorem tendsto_iff (f : α → β) {l₁ : Filter α} {l₂ : Filter β} (L₁
 #print Filter.Realizer.ne_bot_iff /-
 theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ, (F.f a).Nonempty := by
   classical
-  rw [not_iff_comm, ← le_bot_iff, F.le_iff realizer.bot, not_forall]
+  rw [not_iff_comm, ← le_bot_iff, F.le_iff realizer.bot, Classical.not_forall]
   simp only [Set.not_nonempty_iff_eq_empty]
   exact
     ⟨fun ⟨x, e⟩ _ => ⟨x, le_of_eq e⟩, fun h =>

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,7 +3,7 @@ Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
 -/
-import Mathbin.Order.Filter.Cofinite
+import Order.Filter.Cofinite
 
 #align_import data.analysis.filter from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,14 +2,11 @@
 Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
-
-! This file was ported from Lean 3 source module data.analysis.filter
-! leanprover-community/mathlib commit 34ee86e6a59d911a8e4f89b68793ee7577ae79c7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.Cofinite
 
+#align_import data.analysis.filter from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
+
 /-!
 # Computational realization of filters (experimental)
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -59,10 +59,12 @@ variable [PartialOrder α] (F : CFilter α σ)
 instance : CoeFun (CFilter α σ) fun _ => σ → α :=
   ⟨CFilter.f⟩
 
+#print CFilter.coe_mk /-
 @[simp]
 theorem coe_mk (f pt inf h₁ h₂ a) : (@CFilter.mk α σ _ f pt inf h₁ h₂) a = f a :=
   rfl
 #align cfilter.coe_mk CFilter.coe_mk
+-/
 
 #print CFilter.ofEquiv /-
 /-- Map a cfilter to an equivalent representation type. -/
@@ -76,13 +78,16 @@ def ofEquiv (E : σ ≃ τ) : CFilter α σ → CFilter α τ
 #align cfilter.of_equiv CFilter.ofEquiv
 -/
 
+#print CFilter.ofEquiv_val /-
 @[simp]
 theorem ofEquiv_val (E : σ ≃ τ) (F : CFilter α σ) (a : τ) : F.of_equiv E a = F (E.symm a) := by
   cases F <;> rfl
 #align cfilter.of_equiv_val CFilter.ofEquiv_val
+-/
 
 end
 
+#print CFilter.toFilter /-
 /-- The filter represented by a `cfilter` is the collection of supersets of
   elements of the filter base. -/
 def toFilter (F : CFilter (Set α) σ) : Filter α
@@ -94,11 +99,14 @@ def toFilter (F : CFilter (Set α) σ) : Filter α
     ⟨F.inf a b,
       subset_inter (Subset.trans (F.inf_le_left _ _) h₁) (Subset.trans (F.inf_le_right _ _) h₂)⟩
 #align cfilter.to_filter CFilter.toFilter
+-/
 
+#print CFilter.mem_toFilter_sets /-
 @[simp]
 theorem mem_toFilter_sets (F : CFilter (Set α) σ) {a : Set α} : a ∈ F.toFilter ↔ ∃ b, F b ⊆ a :=
   Iff.rfl
 #align cfilter.mem_to_filter_sets CFilter.mem_toFilter_sets
+-/
 
 end CFilter
 
@@ -111,16 +119,20 @@ structure Filter.Realizer (f : Filter α) where
 #align filter.realizer Filter.Realizer
 -/
 
+#print CFilter.toRealizer /-
 /-- A `cfilter` realizes the filter it generates. -/
 protected def CFilter.toRealizer (F : CFilter (Set α) σ) : F.toFilter.Realizer :=
   ⟨σ, F, rfl⟩
 #align cfilter.to_realizer CFilter.toRealizer
+-/
 
 namespace Filter.Realizer
 
+#print Filter.Realizer.mem_sets /-
 theorem mem_sets {f : Filter α} (F : f.Realizer) {a : Set α} : a ∈ f ↔ ∃ b, F.f b ⊆ a := by
   cases F <;> subst f <;> simp
 #align filter.realizer.mem_sets Filter.Realizer.mem_sets
+-/
 
 #print Filter.Realizer.ofEq /-
 /-- Transfer a realizer along an equality of filter. This has better definitional equalities than
@@ -155,15 +167,19 @@ def ofEquiv {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) : f.Realizer :=
 #align filter.realizer.of_equiv Filter.Realizer.ofEquiv
 -/
 
+#print Filter.Realizer.ofEquiv_σ /-
 @[simp]
 theorem ofEquiv_σ {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) : (F.of_equiv E).σ = τ :=
   rfl
 #align filter.realizer.of_equiv_σ Filter.Realizer.ofEquiv_σ
+-/
 
+#print Filter.Realizer.ofEquiv_F /-
 @[simp]
 theorem ofEquiv_F {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ) :
     (F.of_equiv E).f s = F.f (E.symm s) := by delta of_equiv <;> simp
 #align filter.realizer.of_equiv_F Filter.Realizer.ofEquiv_F
+-/
 
 #print Filter.Realizer.principal /-
 /-- `unit` is a realizer for the principal filter -/
@@ -185,18 +201,22 @@ theorem principal_σ (s : Set α) : (Realizer.principal s).σ = Unit :=
 #align filter.realizer.principal_σ Filter.Realizer.principal_σ
 -/
 
+#print Filter.Realizer.principal_F /-
 @[simp]
 theorem principal_F (s : Set α) (u : Unit) : (Realizer.principal s).f u = s :=
   rfl
 #align filter.realizer.principal_F Filter.Realizer.principal_F
+-/
 
 instance (s : Set α) : Inhabited (principal s).Realizer :=
   ⟨Realizer.principal s⟩
 
+#print Filter.Realizer.top /-
 /-- `unit` is a realizer for the top filter -/
 protected def top : (⊤ : Filter α).Realizer :=
   (Realizer.principal _).of_eq principal_univ
 #align filter.realizer.top Filter.Realizer.top
+-/
 
 #print Filter.Realizer.top_σ /-
 @[simp]
@@ -205,15 +225,19 @@ theorem top_σ : (@Realizer.top α).σ = Unit :=
 #align filter.realizer.top_σ Filter.Realizer.top_σ
 -/
 
+#print Filter.Realizer.top_F /-
 @[simp]
 theorem top_F (u : Unit) : (@Realizer.top α).f u = univ :=
   rfl
 #align filter.realizer.top_F Filter.Realizer.top_F
+-/
 
+#print Filter.Realizer.bot /-
 /-- `unit` is a realizer for the bottom filter -/
 protected def bot : (⊥ : Filter α).Realizer :=
   (Realizer.principal _).of_eq principal_empty
 #align filter.realizer.bot Filter.Realizer.bot
+-/
 
 #print Filter.Realizer.bot_σ /-
 @[simp]
@@ -222,10 +246,12 @@ theorem bot_σ : (@Realizer.bot α).σ = Unit :=
 #align filter.realizer.bot_σ Filter.Realizer.bot_σ
 -/
 
+#print Filter.Realizer.bot_F /-
 @[simp]
 theorem bot_F (u : Unit) : (@Realizer.bot α).f u = ∅ :=
   rfl
 #align filter.realizer.bot_F Filter.Realizer.bot_F
+-/
 
 #print Filter.Realizer.map /-
 /-- Construct a realizer for `map m f` given a realizer for `f` -/
@@ -240,15 +266,19 @@ protected def map (m : α → β) {f : Filter α} (F : f.Realizer) : (map m f).R
 #align filter.realizer.map Filter.Realizer.map
 -/
 
+#print Filter.Realizer.map_σ /-
 @[simp]
 theorem map_σ (m : α → β) {f : Filter α} (F : f.Realizer) : (F.map m).σ = F.σ :=
   rfl
 #align filter.realizer.map_σ Filter.Realizer.map_σ
+-/
 
+#print Filter.Realizer.map_F /-
 @[simp]
 theorem map_F (m : α → β) {f : Filter α} (F : f.Realizer) (s) : (F.map m).f s = image m (F.f s) :=
   rfl
 #align filter.realizer.map_F Filter.Realizer.map_F
+-/
 
 #print Filter.Realizer.comap /-
 /-- Construct a realizer for `comap m f` given a realizer for `f` -/
@@ -268,6 +298,7 @@ protected def comap (m : α → β) {f : Filter β} (F : f.Realizer) : (comap m
 #align filter.realizer.comap Filter.Realizer.comap
 -/
 
+#print Filter.Realizer.sup /-
 /-- Construct a realizer for the sup of two filters -/
 protected def sup {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊔ g).Realizer :=
   ⟨F.σ × G.σ,
@@ -287,7 +318,9 @@ protected def sup {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊔ g
                 ⟨t, subset.trans (subset_union_right _ _) h⟩⟩,
               fun ⟨⟨s, h₁⟩, ⟨t, h₂⟩⟩ => ⟨s, t, union_subset h₁ h₂⟩⟩⟩
 #align filter.realizer.sup Filter.Realizer.sup
+-/
 
+#print Filter.Realizer.inf /-
 /-- Construct a realizer for the inf of two filters -/
 protected def inf {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊓ g).Realizer :=
   ⟨F.σ × G.σ,
@@ -309,6 +342,7 @@ protected def inf {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊓ g
     · rintro ⟨s, ⟨a, ha⟩, t, ⟨b, hb⟩, rfl⟩
       exact ⟨a, b, inter_subset_inter ha hb⟩⟩
 #align filter.realizer.inf Filter.Realizer.inf
+-/
 
 #print Filter.Realizer.cofinite /-
 /-- Construct a realizer for the cofinite filter -/
@@ -379,6 +413,7 @@ protected def prod {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f.Prod
 #align filter.realizer.prod Filter.Realizer.prod
 -/
 
+#print Filter.Realizer.le_iff /-
 theorem le_iff {f g : Filter α} (F : f.Realizer) (G : g.Realizer) :
     f ≤ g ↔ ∀ b : G.σ, ∃ a : F.σ, F.f a ≤ G.f b :=
   ⟨fun H t => F.mem_sets.1 (H (G.mem_sets.2 ⟨t, Subset.refl _⟩)), fun H x h =>
@@ -387,12 +422,16 @@ theorem le_iff {f g : Filter α} (F : f.Realizer) (G : g.Realizer) :
       let ⟨t, h₂⟩ := H s
       ⟨t, Subset.trans h₂ h₁⟩⟩
 #align filter.realizer.le_iff Filter.Realizer.le_iff
+-/
 
+#print Filter.Realizer.tendsto_iff /-
 theorem tendsto_iff (f : α → β) {l₁ : Filter α} {l₂ : Filter β} (L₁ : l₁.Realizer)
     (L₂ : l₂.Realizer) : Tendsto f l₁ l₂ ↔ ∀ b, ∃ a, ∀ x ∈ L₁.f a, f x ∈ L₂.f b :=
   (le_iff (L₁.map f) L₂).trans <| forall_congr' fun b => exists_congr fun a => image_subset_iff
 #align filter.realizer.tendsto_iff Filter.Realizer.tendsto_iff
+-/
 
+#print Filter.Realizer.ne_bot_iff /-
 theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ, (F.f a).Nonempty := by
   classical
   rw [not_iff_comm, ← le_bot_iff, F.le_iff realizer.bot, not_forall]
@@ -402,6 +441,7 @@ theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ
       let ⟨x, h⟩ := h ()
       ⟨x, le_bot_iff.1 h⟩⟩
 #align filter.realizer.ne_bot_iff Filter.Realizer.ne_bot_iff
+-/
 
 end Filter.Realizer
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -87,7 +87,7 @@ end
   elements of the filter base. -/
 def toFilter (F : CFilter (Set α) σ) : Filter α
     where
-  sets := { a | ∃ b, F b ⊆ a }
+  sets := {a | ∃ b, F b ⊆ a}
   univ_sets := ⟨F.pt, subset_univ _⟩
   sets_of_superset := fun x y ⟨b, h⟩ s => ⟨b, Subset.trans h s⟩
   inter_sets := fun x y ⟨a, h₁⟩ ⟨b, h₂⟩ =>
@@ -314,7 +314,7 @@ protected def inf {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊓ g
 /-- Construct a realizer for the cofinite filter -/
 protected def cofinite [DecidableEq α] : (@cofinite α).Realizer :=
   ⟨Finset α,
-    { f := fun s => { a | a ∉ s }
+    { f := fun s => {a | a ∉ s}
       pt := ∅
       inf := (· ∪ ·)
       inf_le_left := fun s t a => mt (Finset.mem_union_left _)
@@ -395,12 +395,12 @@ theorem tendsto_iff (f : α → β) {l₁ : Filter α} {l₂ : Filter β} (L₁
 
 theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ, (F.f a).Nonempty := by
   classical
-    rw [not_iff_comm, ← le_bot_iff, F.le_iff realizer.bot, not_forall]
-    simp only [Set.not_nonempty_iff_eq_empty]
-    exact
-      ⟨fun ⟨x, e⟩ _ => ⟨x, le_of_eq e⟩, fun h =>
-        let ⟨x, h⟩ := h ()
-        ⟨x, le_bot_iff.1 h⟩⟩
+  rw [not_iff_comm, ← le_bot_iff, F.le_iff realizer.bot, not_forall]
+  simp only [Set.not_nonempty_iff_eq_empty]
+  exact
+    ⟨fun ⟨x, e⟩ _ => ⟨x, le_of_eq e⟩, fun h =>
+      let ⟨x, h⟩ := h ()
+      ⟨x, le_bot_iff.1 h⟩⟩
 #align filter.realizer.ne_bot_iff Filter.Realizer.ne_bot_iff
 
 end Filter.Realizer

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -330,7 +330,7 @@ protected def cofinite [DecidableEq α] : (@cofinite α).Realizer :=
 /-- Construct a realizer for filter bind -/
 protected def bind {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G : ∀ i, (m i).Realizer) :
     (f.bind m).Realizer :=
-  ⟨Σs : F.σ, ∀ i ∈ F.f s, (G i).σ,
+  ⟨Σ s : F.σ, ∀ i ∈ F.f s, (G i).σ,
     { f := fun ⟨s, f⟩ => ⋃ i ∈ F.f s, (G i).f (f i H)
       pt := ⟨F.f.pt, fun i H => (G i).f.pt⟩
       inf := fun ⟨a, f⟩ ⟨b, f'⟩ =>
@@ -367,7 +367,7 @@ protected def iSup {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i,
     (Realizer.bind Realizer.top F).of_eq <|
       filter_eq <| Set.ext <| by simp [Filter.bind, eq_univ_iff_forall, supr_sets_eq]
   F'.of_equiv <|
-    show (Σu : Unit, ∀ i : α, True → (F i).σ) ≃ ∀ i, (F i).σ from
+    show (Σ u : Unit, ∀ i : α, True → (F i).σ) ≃ ∀ i, (F i).σ from
       ⟨fun ⟨_, f⟩ i => f i ⟨⟩, fun f => ⟨(), fun i _ => f i⟩, fun ⟨⟨⟩, f⟩ => by
         dsimp <;> congr <;> simp, fun f => rfl⟩
 #align filter.realizer.Sup Filter.Realizer.iSupₓ

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -59,12 +59,6 @@ variable [PartialOrder α] (F : CFilter α σ)
 instance : CoeFun (CFilter α σ) fun _ => σ → α :=
   ⟨CFilter.f⟩
 
-/- warning: cfilter.coe_mk -> CFilter.coe_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {σ : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] (f : σ -> α) (pt : σ) (inf : σ -> σ -> σ) (h₁ : forall (a : σ) (b : σ), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (f (inf a b)) (f a)) (h₂ : forall (a : σ) (b : σ), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (f (inf a b)) (f b)) (a : σ), Eq.{succ u1} α (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} α σ _inst_1) (fun (_x : CFilter.{u1, u2} α σ _inst_1) => σ -> α) (CFilter.hasCoeToFun.{u1, u2} α σ _inst_1) (CFilter.mk.{u1, u2} α σ _inst_1 f pt inf h₁ h₂) a) (f a)
-but is expected to have type
-  forall {α : Type.{u2}} {σ : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] (f : σ -> α) (pt : σ) (inf : σ -> σ -> σ) (h₁ : forall (a : σ) (b : σ), LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (f (inf a b)) (f a)) (h₂ : forall (a : σ) (b : σ), LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (f (inf a b)) (f b)) (a : σ), Eq.{succ u2} α (CFilter.f.{u2, u1} α σ _inst_1 (CFilter.mk.{u2, u1} α σ _inst_1 f pt inf h₁ h₂) a) (f a)
-Case conversion may be inaccurate. Consider using '#align cfilter.coe_mk CFilter.coe_mkₓ'. -/
 @[simp]
 theorem coe_mk (f pt inf h₁ h₂ a) : (@CFilter.mk α σ _ f pt inf h₁ h₂) a = f a :=
   rfl
@@ -82,12 +76,6 @@ def ofEquiv (E : σ ≃ τ) : CFilter α σ → CFilter α τ
 #align cfilter.of_equiv CFilter.ofEquiv
 -/
 
-/- warning: cfilter.of_equiv_val -> CFilter.ofEquiv_val is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {σ : Type.{u2}} {τ : Type.{u3}} [_inst_1 : PartialOrder.{u1} α] (E : Equiv.{succ u2, succ u3} σ τ) (F : CFilter.{u1, u2} α σ _inst_1) (a : τ), Eq.{succ u1} α (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} α τ _inst_1) (fun (_x : CFilter.{u1, u3} α τ _inst_1) => τ -> α) (CFilter.hasCoeToFun.{u1, u3} α τ _inst_1) (CFilter.ofEquiv.{u1, u2, u3} α σ τ _inst_1 E F) a) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} α σ _inst_1) (fun (_x : CFilter.{u1, u2} α σ _inst_1) => σ -> α) (CFilter.hasCoeToFun.{u1, u2} α σ _inst_1) F (coeFn.{max 1 (max (succ u3) (succ u2)) (succ u2) (succ u3), max (succ u3) (succ u2)} (Equiv.{succ u3, succ u2} τ σ) (fun (_x : Equiv.{succ u3, succ u2} τ σ) => τ -> σ) (Equiv.hasCoeToFun.{succ u3, succ u2} τ σ) (Equiv.symm.{succ u2, succ u3} σ τ E) a))
-but is expected to have type
-  forall {α : Type.{u1}} {σ : Type.{u3}} {τ : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] (E : Equiv.{succ u3, succ u2} σ τ) (F : CFilter.{u1, u3} α σ _inst_1) (a : τ), Eq.{succ u1} α (CFilter.f.{u1, u2} α τ _inst_1 (CFilter.ofEquiv.{u1, u3, u2} α σ τ _inst_1 E F) a) (CFilter.f.{u1, u3} α σ _inst_1 F (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (Equiv.{succ u2, succ u3} τ σ) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : τ) => σ) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u3} τ σ) (Equiv.symm.{succ u3, succ u2} σ τ E) a))
-Case conversion may be inaccurate. Consider using '#align cfilter.of_equiv_val CFilter.ofEquiv_valₓ'. -/
 @[simp]
 theorem ofEquiv_val (E : σ ≃ τ) (F : CFilter α σ) (a : τ) : F.of_equiv E a = F (E.symm a) := by
   cases F <;> rfl
@@ -95,12 +83,6 @@ theorem ofEquiv_val (E : σ ≃ τ) (F : CFilter α σ) (a : τ) : F.of_equiv E
 
 end
 
-/- warning: cfilter.to_filter -> CFilter.toFilter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {σ : Type.{u2}}, (CFilter.{u1, u2} (Set.{u1} α) σ (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) -> (Filter.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} {σ : Type.{u2}}, (CFilter.{u1, u2} (Set.{u1} α) σ (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) -> (Filter.{u1} α)
-Case conversion may be inaccurate. Consider using '#align cfilter.to_filter CFilter.toFilterₓ'. -/
 /-- The filter represented by a `cfilter` is the collection of supersets of
   elements of the filter base. -/
 def toFilter (F : CFilter (Set α) σ) : Filter α
@@ -113,12 +95,6 @@ def toFilter (F : CFilter (Set α) σ) : Filter α
       subset_inter (Subset.trans (F.inf_le_left _ _) h₁) (Subset.trans (F.inf_le_right _ _) h₂)⟩
 #align cfilter.to_filter CFilter.toFilter
 
-/- warning: cfilter.mem_to_filter_sets -> CFilter.mem_toFilter_sets is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {σ : Type.{u2}} (F : CFilter.{u1, u2} (Set.{u1} α) σ (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) {a : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) a (CFilter.toFilter.{u1, u2} α σ F)) (Exists.{succ u2} σ (fun (b : σ) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) σ (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) σ (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => σ -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) σ (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) F b) a))
-but is expected to have type
-  forall {α : Type.{u2}} {σ : Type.{u1}} (F : CFilter.{u2, u1} (Set.{u2} α) σ (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α))))))) {a : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) a (CFilter.toFilter.{u2, u1} α σ F)) (Exists.{succ u1} σ (fun (b : σ) => HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) (CFilter.f.{u2, u1} (Set.{u2} α) σ (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) F b) a))
-Case conversion may be inaccurate. Consider using '#align cfilter.mem_to_filter_sets CFilter.mem_toFilter_setsₓ'. -/
 @[simp]
 theorem mem_toFilter_sets (F : CFilter (Set α) σ) {a : Set α} : a ∈ F.toFilter ↔ ∃ b, F b ⊆ a :=
   Iff.rfl
@@ -135,12 +111,6 @@ structure Filter.Realizer (f : Filter α) where
 #align filter.realizer Filter.Realizer
 -/
 
-/- warning: cfilter.to_realizer -> CFilter.toRealizer is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {σ : Type.{u2}} (F : CFilter.{u1, u2} (Set.{u1} α) σ (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))), Filter.Realizer.{u1, u2} α (CFilter.toFilter.{u1, u2} α σ F)
-but is expected to have type
-  forall {α : Type.{u1}} {σ : Type.{u2}} (F : CFilter.{u1, u2} (Set.{u1} α) σ (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))), Filter.Realizer.{u1, u2} α (CFilter.toFilter.{u1, u2} α σ F)
-Case conversion may be inaccurate. Consider using '#align cfilter.to_realizer CFilter.toRealizerₓ'. -/
 /-- A `cfilter` realizes the filter it generates. -/
 protected def CFilter.toRealizer (F : CFilter (Set α) σ) : F.toFilter.Realizer :=
   ⟨σ, F, rfl⟩
@@ -148,12 +118,6 @@ protected def CFilter.toRealizer (F : CFilter (Set α) σ) : F.toFilter.Realizer
 
 namespace Filter.Realizer
 
-/- warning: filter.realizer.mem_sets -> Filter.Realizer.mem_sets is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} (F : Filter.Realizer.{u1, u2} α f) {a : Set.{u1} α}, Iff (Membership.Mem.{u1, u1} (Set.{u1} α) (Filter.{u1} α) (Filter.hasMem.{u1} α) a f) (Exists.{succ u2} (Filter.Realizer.σ.{u1, u2} α f F) (fun (b : Filter.Realizer.σ.{u1, u2} α f F) => HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u2} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u2} α f F) b) a))
-but is expected to have type
-  forall {α : Type.{u2}} {f : Filter.{u2} α} (F : Filter.Realizer.{u2, u1} α f) {a : Set.{u2} α}, Iff (Membership.mem.{u2, u2} (Set.{u2} α) (Filter.{u2} α) (instMembershipSetFilter.{u2} α) a f) (Exists.{succ u1} (Filter.Realizer.σ.{u2, u1} α f F) (fun (b : Filter.Realizer.σ.{u2, u1} α f F) => HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) (CFilter.f.{u2, u1} (Set.{u2} α) (Filter.Realizer.σ.{u2, u1} α f F) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) (Filter.Realizer.F.{u2, u1} α f F) b) a))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.mem_sets Filter.Realizer.mem_setsₓ'. -/
 theorem mem_sets {f : Filter α} (F : f.Realizer) {a : Set α} : a ∈ f ↔ ∃ b, F.f b ⊆ a := by
   cases F <;> subst f <;> simp
 #align filter.realizer.mem_sets Filter.Realizer.mem_sets
@@ -191,23 +155,11 @@ def ofEquiv {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) : f.Realizer :=
 #align filter.realizer.of_equiv Filter.Realizer.ofEquiv
 -/
 
-/- warning: filter.realizer.of_equiv_σ -> Filter.Realizer.ofEquiv_σ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {τ : Type.{u2}} {f : Filter.{u1} α} (F : Filter.Realizer.{u1, u3} α f) (E : Equiv.{succ u3, succ u2} (Filter.Realizer.σ.{u1, u3} α f F) τ), Eq.{succ (succ u2)} Type.{u2} (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) τ
-but is expected to have type
-  forall {α : Type.{u3}} {τ : Type.{u1}} {f : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (E : Equiv.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ), Eq.{succ (succ u1)} Type.{u1} (Filter.Realizer.σ.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) τ
-Case conversion may be inaccurate. Consider using '#align filter.realizer.of_equiv_σ Filter.Realizer.ofEquiv_σₓ'. -/
 @[simp]
 theorem ofEquiv_σ {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) : (F.of_equiv E).σ = τ :=
   rfl
 #align filter.realizer.of_equiv_σ Filter.Realizer.ofEquiv_σ
 
-/- warning: filter.realizer.of_equiv_F -> Filter.Realizer.ofEquiv_F is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {τ : Type.{u2}} {f : Filter.{u1} α} (F : Filter.Realizer.{u1, u3} α f) (E : Equiv.{succ u3, succ u2} (Filter.Realizer.σ.{u1, u3} α f F) τ) (s : τ), Eq.{succ u1} (Set.{u1} α) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) s) (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u3} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u3} α f F) (coeFn.{max 1 (max (succ u2) (succ u3)) (succ u3) (succ u2), max (succ u2) (succ u3)} (Equiv.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) (fun (_x : Equiv.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) => τ -> (Filter.Realizer.σ.{u1, u3} α f F)) (Equiv.hasCoeToFun.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) (Equiv.symm.{succ u3, succ u2} (Filter.Realizer.σ.{u1, u3} α f F) τ E) s))
-but is expected to have type
-  forall {α : Type.{u3}} {τ : Type.{u1}} {f : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (E : Equiv.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ) (s : τ), Eq.{succ u3} (Set.{u3} α) (CFilter.f.{u3, u1} (Set.{u3} α) (Filter.Realizer.σ.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) s) (CFilter.f.{u3, u2} (Set.{u3} α) (Filter.Realizer.σ.{u3, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u2} α f F) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : τ) => Filter.Realizer.σ.{u3, u2} α f F) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) (Equiv.symm.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ E) s))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.of_equiv_F Filter.Realizer.ofEquiv_Fₓ'. -/
 @[simp]
 theorem ofEquiv_F {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ) :
     (F.of_equiv E).f s = F.f (E.symm s) := by delta of_equiv <;> simp
@@ -233,12 +185,6 @@ theorem principal_σ (s : Set α) : (Realizer.principal s).σ = Unit :=
 #align filter.realizer.principal_σ Filter.Realizer.principal_σ
 -/
 
-/- warning: filter.realizer.principal_F -> Filter.Realizer.principal_F is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α) (u : Unit), Eq.{succ u1} (Set.{u1} α) (coeFn.{succ u1, succ u1} (CFilter.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Filter.principal.{u1} α s) (Filter.Realizer.principal.{u1} α s)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Filter.principal.{u1} α s) (Filter.Realizer.principal.{u1} α s)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, 0} α (Filter.principal.{u1} α s) (Filter.Realizer.principal.{u1} α s)) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Filter.principal.{u1} α s) (Filter.Realizer.principal.{u1} α s)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, 0} α (Filter.principal.{u1} α s) (Filter.Realizer.principal.{u1} α s)) u) s
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) (u : Unit), Eq.{succ u1} (Set.{u1} α) (CFilter.f.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Filter.principal.{u1} α s) (Filter.Realizer.principal.{u1} α s)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Filter.Realizer.F.{u1, 0} α (Filter.principal.{u1} α s) (Filter.Realizer.principal.{u1} α s)) u) s
-Case conversion may be inaccurate. Consider using '#align filter.realizer.principal_F Filter.Realizer.principal_Fₓ'. -/
 @[simp]
 theorem principal_F (s : Set α) (u : Unit) : (Realizer.principal s).f u = s :=
   rfl
@@ -247,12 +193,6 @@ theorem principal_F (s : Set α) (u : Unit) : (Realizer.principal s).f u = s :=
 instance (s : Set α) : Inhabited (principal s).Realizer :=
   ⟨Realizer.principal s⟩
 
-/- warning: filter.realizer.top -> Filter.Realizer.top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Filter.Realizer.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}}, Filter.Realizer.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.top Filter.Realizer.topₓ'. -/
 /-- `unit` is a realizer for the top filter -/
 protected def top : (⊤ : Filter α).Realizer :=
   (Realizer.principal _).of_eq principal_univ
@@ -265,23 +205,11 @@ theorem top_σ : (@Realizer.top α).σ = Unit :=
 #align filter.realizer.top_σ Filter.Realizer.top_σ
 -/
 
-/- warning: filter.realizer.top_F -> Filter.Realizer.top_F is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (u : Unit), Eq.{succ u1} (Set.{u1} α) (coeFn.{succ u1, succ u1} (CFilter.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) (Filter.Realizer.top.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) (Filter.Realizer.top.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) (Filter.Realizer.top.{u1} α)) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) (Filter.Realizer.top.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.hasTop.{u1} α)) (Filter.Realizer.top.{u1} α)) u) (Set.univ.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} (u : Unit), Eq.{succ u1} (Set.{u1} α) (CFilter.f.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)) (Filter.Realizer.top.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Filter.Realizer.F.{u1, 0} α (Top.top.{u1} (Filter.{u1} α) (Filter.instTopFilter.{u1} α)) (Filter.Realizer.top.{u1} α)) u) (Set.univ.{u1} α)
-Case conversion may be inaccurate. Consider using '#align filter.realizer.top_F Filter.Realizer.top_Fₓ'. -/
 @[simp]
 theorem top_F (u : Unit) : (@Realizer.top α).f u = univ :=
   rfl
 #align filter.realizer.top_F Filter.Realizer.top_F
 
-/- warning: filter.realizer.bot -> Filter.Realizer.bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Filter.Realizer.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}}, Filter.Realizer.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.bot Filter.Realizer.botₓ'. -/
 /-- `unit` is a realizer for the bottom filter -/
 protected def bot : (⊥ : Filter α).Realizer :=
   (Realizer.principal _).of_eq principal_empty
@@ -294,12 +222,6 @@ theorem bot_σ : (@Realizer.bot α).σ = Unit :=
 #align filter.realizer.bot_σ Filter.Realizer.bot_σ
 -/
 
-/- warning: filter.realizer.bot_F -> Filter.Realizer.bot_F is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (u : Unit), Eq.{succ u1} (Set.{u1} α) (coeFn.{succ u1, succ u1} (CFilter.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.Realizer.bot.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.Realizer.bot.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.Realizer.bot.{u1} α)) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.Realizer.bot.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))) (Filter.Realizer.bot.{u1} α)) u) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} (u : Unit), Eq.{succ u1} (Set.{u1} α) (CFilter.f.{u1, 0} (Set.{u1} α) (Filter.Realizer.σ.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) (Filter.Realizer.bot.{u1} α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Filter.Realizer.F.{u1, 0} α (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toBot.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))) (Filter.Realizer.bot.{u1} α)) u) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.bot_F Filter.Realizer.bot_Fₓ'. -/
 @[simp]
 theorem bot_F (u : Unit) : (@Realizer.bot α).f u = ∅ :=
   rfl
@@ -318,23 +240,11 @@ protected def map (m : α → β) {f : Filter α} (F : f.Realizer) : (map m f).R
 #align filter.realizer.map Filter.Realizer.map
 -/
 
-/- warning: filter.realizer.map_σ -> Filter.Realizer.map_σ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (m : α -> β) {f : Filter.{u1} α} (F : Filter.Realizer.{u1, u3} α f), Eq.{succ (succ u3)} Type.{u3} (Filter.Realizer.σ.{u2, u3} β (Filter.map.{u1, u2} α β m f) (Filter.Realizer.map.{u1, u2, u3} α β m f F)) (Filter.Realizer.σ.{u1, u3} α f F)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} (m : α -> β) {f : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f), Eq.{succ (succ u2)} Type.{u2} (Filter.Realizer.σ.{u1, u2} β (Filter.map.{u3, u1} α β m f) (Filter.Realizer.map.{u3, u1, u2} α β m f F)) (Filter.Realizer.σ.{u3, u2} α f F)
-Case conversion may be inaccurate. Consider using '#align filter.realizer.map_σ Filter.Realizer.map_σₓ'. -/
 @[simp]
 theorem map_σ (m : α → β) {f : Filter α} (F : f.Realizer) : (F.map m).σ = F.σ :=
   rfl
 #align filter.realizer.map_σ Filter.Realizer.map_σ
 
-/- warning: filter.realizer.map_F -> Filter.Realizer.map_F is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (m : α -> β) {f : Filter.{u1} α} (F : Filter.Realizer.{u1, u3} α f) (s : Filter.Realizer.σ.{u2, u3} β (Filter.map.{u1, u2} α β m f) (Filter.Realizer.map.{u1, u2, u3} α β m f F)), Eq.{succ u2} (Set.{u2} β) (coeFn.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (CFilter.{u2, u3} (Set.{u2} β) (Filter.Realizer.σ.{u2, u3} β (Filter.map.{u1, u2} α β m f) (Filter.Realizer.map.{u1, u2, u3} α β m f F)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (_x : CFilter.{u2, u3} (Set.{u2} β) (Filter.Realizer.σ.{u2, u3} β (Filter.map.{u1, u2} α β m f) (Filter.Realizer.map.{u1, u2, u3} α β m f F)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) => (Filter.Realizer.σ.{u2, u3} β (Filter.map.{u1, u2} α β m f) (Filter.Realizer.map.{u1, u2, u3} α β m f F)) -> (Set.{u2} β)) (CFilter.hasCoeToFun.{u2, u3} (Set.{u2} β) (Filter.Realizer.σ.{u2, u3} β (Filter.map.{u1, u2} α β m f) (Filter.Realizer.map.{u1, u2, u3} α β m f F)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (Filter.Realizer.f.{u2, u3} β (Filter.map.{u1, u2} α β m f) (Filter.Realizer.map.{u1, u2, u3} α β m f F)) s) (Set.image.{u1, u2} α β m (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u3} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u3} α f F) s))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} (m : α -> β) {f : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (s : Filter.Realizer.σ.{u1, u2} β (Filter.map.{u3, u1} α β m f) (Filter.Realizer.map.{u3, u1, u2} α β m f F)), Eq.{succ u1} (Set.{u1} β) (CFilter.f.{u1, u2} (Set.{u1} β) (Filter.Realizer.σ.{u1, u2} β (Filter.map.{u3, u1} α β m f) (Filter.Realizer.map.{u3, u1, u2} α β m f F)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β)))))) (Filter.Realizer.F.{u1, u2} β (Filter.map.{u3, u1} α β m f) (Filter.Realizer.map.{u3, u1, u2} α β m f F)) s) (Set.image.{u3, u1} α β m (CFilter.f.{u3, u2} (Set.{u3} α) (Filter.Realizer.σ.{u3, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u2} α f F) s))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.map_F Filter.Realizer.map_Fₓ'. -/
 @[simp]
 theorem map_F (m : α → β) {f : Filter α} (F : f.Realizer) (s) : (F.map m).f s = image m (F.f s) :=
   rfl
@@ -358,12 +268,6 @@ protected def comap (m : α → β) {f : Filter β} (F : f.Realizer) : (comap m
 #align filter.realizer.comap Filter.Realizer.comap
 -/
 
-/- warning: filter.realizer.sup -> Filter.Realizer.sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u2 u3} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u3 u2} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.sup Filter.Realizer.supₓ'. -/
 /-- Construct a realizer for the sup of two filters -/
 protected def sup {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊔ g).Realizer :=
   ⟨F.σ × G.σ,
@@ -384,12 +288,6 @@ protected def sup {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊔ g
               fun ⟨⟨s, h₁⟩, ⟨t, h₂⟩⟩ => ⟨s, t, union_subset h₁ h₂⟩⟩⟩
 #align filter.realizer.sup Filter.Realizer.sup
 
-/- warning: filter.realizer.inf -> Filter.Realizer.inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u2 u3} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u3 u2} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.inf Filter.Realizer.infₓ'. -/
 /-- Construct a realizer for the inf of two filters -/
 protected def inf {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊓ g).Realizer :=
   ⟨F.σ × G.σ,
@@ -481,12 +379,6 @@ protected def prod {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f.Prod
 #align filter.realizer.prod Filter.Realizer.prod
 -/
 
-/- warning: filter.realizer.le_iff -> Filter.Realizer.le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} (F : Filter.Realizer.{u1, u2} α f) (G : Filter.Realizer.{u1, u3} α g), Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) (forall (b : Filter.Realizer.σ.{u1, u3} α g G), Exists.{succ u2} (Filter.Realizer.σ.{u1, u2} α f F) (fun (a : Filter.Realizer.σ.{u1, u2} α f F) => LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u2} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u2} α f F) a) (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u3} α g G) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u3} α g G) b)))
-but is expected to have type
-  forall {α : Type.{u3}} {f : Filter.{u3} α} {g : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (G : Filter.Realizer.{u3, u1} α g), Iff (LE.le.{u3} (Filter.{u3} α) (Preorder.toLE.{u3} (Filter.{u3} α) (PartialOrder.toPreorder.{u3} (Filter.{u3} α) (Filter.instPartialOrderFilter.{u3} α))) f g) (forall (b : Filter.Realizer.σ.{u3, u1} α g G), Exists.{succ u2} (Filter.Realizer.σ.{u3, u2} α f F) (fun (a : Filter.Realizer.σ.{u3, u2} α f F) => LE.le.{u3} (Set.{u3} α) (Set.instLESet.{u3} α) (CFilter.f.{u3, u2} (Set.{u3} α) (Filter.Realizer.σ.{u3, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u2} α f F) a) (CFilter.f.{u3, u1} (Set.{u3} α) (Filter.Realizer.σ.{u3, u1} α g G) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u1} α g G) b)))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.le_iff Filter.Realizer.le_iffₓ'. -/
 theorem le_iff {f g : Filter α} (F : f.Realizer) (G : g.Realizer) :
     f ≤ g ↔ ∀ b : G.σ, ∃ a : F.σ, F.f a ≤ G.f b :=
   ⟨fun H t => F.mem_sets.1 (H (G.mem_sets.2 ⟨t, Subset.refl _⟩)), fun H x h =>
@@ -496,23 +388,11 @@ theorem le_iff {f g : Filter α} (F : f.Realizer) (G : g.Realizer) :
       ⟨t, Subset.trans h₂ h₁⟩⟩
 #align filter.realizer.le_iff Filter.Realizer.le_iff
 
-/- warning: filter.realizer.tendsto_iff -> Filter.Realizer.tendsto_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) {l₁ : Filter.{u1} α} {l₂ : Filter.{u2} β} (L₁ : Filter.Realizer.{u1, u3} α l₁) (L₂ : Filter.Realizer.{u2, u4} β l₂), Iff (Filter.Tendsto.{u1, u2} α β f l₁ l₂) (forall (b : Filter.Realizer.σ.{u2, u4} β l₂ L₂), Exists.{succ u3} (Filter.Realizer.σ.{u1, u3} α l₁ L₁) (fun (a : Filter.Realizer.σ.{u1, u3} α l₁ L₁) => forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α l₁ L₁) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α l₁ L₁) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u3} α l₁ L₁) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α l₁ L₁) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u3} α l₁ L₁) a)) -> (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (f x) (coeFn.{max (succ u2) (succ u4), max (succ u4) (succ u2)} (CFilter.{u2, u4} (Set.{u2} β) (Filter.Realizer.σ.{u2, u4} β l₂ L₂) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (_x : CFilter.{u2, u4} (Set.{u2} β) (Filter.Realizer.σ.{u2, u4} β l₂ L₂) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) => (Filter.Realizer.σ.{u2, u4} β l₂ L₂) -> (Set.{u2} β)) (CFilter.hasCoeToFun.{u2, u4} (Set.{u2} β) (Filter.Realizer.σ.{u2, u4} β l₂ L₂) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (Filter.Realizer.f.{u2, u4} β l₂ L₂) b))))
-but is expected to have type
-  forall {α : Type.{u4}} {β : Type.{u3}} (f : α -> β) {l₁ : Filter.{u4} α} {l₂ : Filter.{u3} β} (L₁ : Filter.Realizer.{u4, u2} α l₁) (L₂ : Filter.Realizer.{u3, u1} β l₂), Iff (Filter.Tendsto.{u4, u3} α β f l₁ l₂) (forall (b : Filter.Realizer.σ.{u3, u1} β l₂ L₂), Exists.{succ u2} (Filter.Realizer.σ.{u4, u2} α l₁ L₁) (fun (a : Filter.Realizer.σ.{u4, u2} α l₁ L₁) => forall (x : α), (Membership.mem.{u4, u4} α (Set.{u4} α) (Set.instMembershipSet.{u4} α) x (CFilter.f.{u4, u2} (Set.{u4} α) (Filter.Realizer.σ.{u4, u2} α l₁ L₁) (CompleteSemilatticeInf.toPartialOrder.{u4} (Set.{u4} α) (CompleteLattice.toCompleteSemilatticeInf.{u4} (Set.{u4} α) (Order.Coframe.toCompleteLattice.{u4} (Set.{u4} α) (CompleteDistribLattice.toCoframe.{u4} (Set.{u4} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u4} (Set.{u4} α) (Set.instCompleteBooleanAlgebraSet.{u4} α)))))) (Filter.Realizer.F.{u4, u2} α l₁ L₁) a)) -> (Membership.mem.{u3, u3} β (Set.{u3} β) (Set.instMembershipSet.{u3} β) (f x) (CFilter.f.{u3, u1} (Set.{u3} β) (Filter.Realizer.σ.{u3, u1} β l₂ L₂) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} β) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} β) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} β) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} β) (Set.instCompleteBooleanAlgebraSet.{u3} β)))))) (Filter.Realizer.F.{u3, u1} β l₂ L₂) b))))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.tendsto_iff Filter.Realizer.tendsto_iffₓ'. -/
 theorem tendsto_iff (f : α → β) {l₁ : Filter α} {l₂ : Filter β} (L₁ : l₁.Realizer)
     (L₂ : l₂.Realizer) : Tendsto f l₁ l₂ ↔ ∀ b, ∃ a, ∀ x ∈ L₁.f a, f x ∈ L₂.f b :=
   (le_iff (L₁.map f) L₂).trans <| forall_congr' fun b => exists_congr fun a => image_subset_iff
 #align filter.realizer.tendsto_iff Filter.Realizer.tendsto_iff
 
-/- warning: filter.realizer.ne_bot_iff -> Filter.Realizer.ne_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} (F : Filter.Realizer.{u1, u2} α f), Iff (Ne.{succ u1} (Filter.{u1} α) f (Bot.bot.{u1} (Filter.{u1} α) (CompleteLattice.toHasBot.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α)))) (forall (a : Filter.Realizer.σ.{u1, u2} α f F), Set.Nonempty.{u1} α (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u2} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u2} α f F) a))
-but is expected to have type
-  forall {α : Type.{u2}} {f : Filter.{u2} α} (F : Filter.Realizer.{u2, u1} α f), Iff (Ne.{succ u2} (Filter.{u2} α) f (Bot.bot.{u2} (Filter.{u2} α) (CompleteLattice.toBot.{u2} (Filter.{u2} α) (Filter.instCompleteLatticeFilter.{u2} α)))) (forall (a : Filter.Realizer.σ.{u2, u1} α f F), Set.Nonempty.{u2} α (CFilter.f.{u2, u1} (Set.{u2} α) (Filter.Realizer.σ.{u2, u1} α f F) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} α) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} α) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} α) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} α) (Set.instCompleteBooleanAlgebraSet.{u2} α)))))) (Filter.Realizer.F.{u2, u1} α f F) a))
-Case conversion may be inaccurate. Consider using '#align filter.realizer.ne_bot_iff Filter.Realizer.ne_bot_iffₓ'. -/
 theorem ne_bot_iff {f : Filter α} (F : f.Realizer) : f ≠ ⊥ ↔ ∀ a : F.σ, (F.f a).Nonempty := by
   classical
     rw [not_iff_comm, ← le_bot_iff, F.le_iff realizer.bot, not_forall]

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

@@ -86,7 +86,7 @@ def ofEquiv (E : σ ≃ τ) : CFilter α σ → CFilter α τ
 lean 3 declaration is
   forall {α : Type.{u1}} {σ : Type.{u2}} {τ : Type.{u3}} [_inst_1 : PartialOrder.{u1} α] (E : Equiv.{succ u2, succ u3} σ τ) (F : CFilter.{u1, u2} α σ _inst_1) (a : τ), Eq.{succ u1} α (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} α τ _inst_1) (fun (_x : CFilter.{u1, u3} α τ _inst_1) => τ -> α) (CFilter.hasCoeToFun.{u1, u3} α τ _inst_1) (CFilter.ofEquiv.{u1, u2, u3} α σ τ _inst_1 E F) a) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} α σ _inst_1) (fun (_x : CFilter.{u1, u2} α σ _inst_1) => σ -> α) (CFilter.hasCoeToFun.{u1, u2} α σ _inst_1) F (coeFn.{max 1 (max (succ u3) (succ u2)) (succ u2) (succ u3), max (succ u3) (succ u2)} (Equiv.{succ u3, succ u2} τ σ) (fun (_x : Equiv.{succ u3, succ u2} τ σ) => τ -> σ) (Equiv.hasCoeToFun.{succ u3, succ u2} τ σ) (Equiv.symm.{succ u2, succ u3} σ τ E) a))
 but is expected to have type
-  forall {α : Type.{u1}} {σ : Type.{u3}} {τ : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] (E : Equiv.{succ u3, succ u2} σ τ) (F : CFilter.{u1, u3} α σ _inst_1) (a : τ), Eq.{succ u1} α (CFilter.f.{u1, u2} α τ _inst_1 (CFilter.ofEquiv.{u1, u3, u2} α σ τ _inst_1 E F) a) (CFilter.f.{u1, u3} α σ _inst_1 F (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (Equiv.{succ u2, succ u3} τ σ) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : τ) => σ) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u3} τ σ) (Equiv.symm.{succ u3, succ u2} σ τ E) a))
+  forall {α : Type.{u1}} {σ : Type.{u3}} {τ : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] (E : Equiv.{succ u3, succ u2} σ τ) (F : CFilter.{u1, u3} α σ _inst_1) (a : τ), Eq.{succ u1} α (CFilter.f.{u1, u2} α τ _inst_1 (CFilter.ofEquiv.{u1, u3, u2} α σ τ _inst_1 E F) a) (CFilter.f.{u1, u3} α σ _inst_1 F (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (Equiv.{succ u2, succ u3} τ σ) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : τ) => σ) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u3} τ σ) (Equiv.symm.{succ u3, succ u2} σ τ E) a))
 Case conversion may be inaccurate. Consider using '#align cfilter.of_equiv_val CFilter.ofEquiv_valₓ'. -/
 @[simp]
 theorem ofEquiv_val (E : σ ≃ τ) (F : CFilter α σ) (a : τ) : F.of_equiv E a = F (E.symm a) := by
@@ -206,7 +206,7 @@ theorem ofEquiv_σ {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) : (F.of_eq
 lean 3 declaration is
   forall {α : Type.{u1}} {τ : Type.{u2}} {f : Filter.{u1} α} (F : Filter.Realizer.{u1, u3} α f) (E : Equiv.{succ u3, succ u2} (Filter.Realizer.σ.{u1, u3} α f F) τ) (s : τ), Eq.{succ u1} (Set.{u1} α) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) s) (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u3} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u3} α f F) (coeFn.{max 1 (max (succ u2) (succ u3)) (succ u3) (succ u2), max (succ u2) (succ u3)} (Equiv.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) (fun (_x : Equiv.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) => τ -> (Filter.Realizer.σ.{u1, u3} α f F)) (Equiv.hasCoeToFun.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) (Equiv.symm.{succ u3, succ u2} (Filter.Realizer.σ.{u1, u3} α f F) τ E) s))
 but is expected to have type
-  forall {α : Type.{u3}} {τ : Type.{u1}} {f : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (E : Equiv.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ) (s : τ), Eq.{succ u3} (Set.{u3} α) (CFilter.f.{u3, u1} (Set.{u3} α) (Filter.Realizer.σ.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) s) (CFilter.f.{u3, u2} (Set.{u3} α) (Filter.Realizer.σ.{u3, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u2} α f F) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : τ) => Filter.Realizer.σ.{u3, u2} α f F) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) (Equiv.symm.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ E) s))
+  forall {α : Type.{u3}} {τ : Type.{u1}} {f : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (E : Equiv.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ) (s : τ), Eq.{succ u3} (Set.{u3} α) (CFilter.f.{u3, u1} (Set.{u3} α) (Filter.Realizer.σ.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) s) (CFilter.f.{u3, u2} (Set.{u3} α) (Filter.Realizer.σ.{u3, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u2} α f F) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : τ) => Filter.Realizer.σ.{u3, u2} α f F) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) (Equiv.symm.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ E) s))
 Case conversion may be inaccurate. Consider using '#align filter.realizer.of_equiv_F Filter.Realizer.ofEquiv_Fₓ'. -/
 @[simp]
 theorem ofEquiv_F {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -61,7 +61,7 @@ instance : CoeFun (CFilter α σ) fun _ => σ → α :=
 
 /- warning: cfilter.coe_mk -> CFilter.coe_mk is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {σ : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] (f : σ -> α) (pt : σ) (inf : σ -> σ -> σ) (h₁ : forall (a : σ) (b : σ), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (f (inf a b)) (f a)) (h₂ : forall (a : σ) (b : σ), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (f (inf a b)) (f b)) (a : σ), Eq.{succ u1} α (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} α σ _inst_1) (fun (_x : CFilter.{u1, u2} α σ _inst_1) => σ -> α) (CFilter.hasCoeToFun.{u1, u2} α σ _inst_1) (CFilter.mk.{u1, u2} α σ _inst_1 f pt inf h₁ h₂) a) (f a)
+  forall {α : Type.{u1}} {σ : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] (f : σ -> α) (pt : σ) (inf : σ -> σ -> σ) (h₁ : forall (a : σ) (b : σ), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (f (inf a b)) (f a)) (h₂ : forall (a : σ) (b : σ), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (f (inf a b)) (f b)) (a : σ), Eq.{succ u1} α (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} α σ _inst_1) (fun (_x : CFilter.{u1, u2} α σ _inst_1) => σ -> α) (CFilter.hasCoeToFun.{u1, u2} α σ _inst_1) (CFilter.mk.{u1, u2} α σ _inst_1 f pt inf h₁ h₂) a) (f a)
 but is expected to have type
   forall {α : Type.{u2}} {σ : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] (f : σ -> α) (pt : σ) (inf : σ -> σ -> σ) (h₁ : forall (a : σ) (b : σ), LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (f (inf a b)) (f a)) (h₂ : forall (a : σ) (b : σ), LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) (f (inf a b)) (f b)) (a : σ), Eq.{succ u2} α (CFilter.f.{u2, u1} α σ _inst_1 (CFilter.mk.{u2, u1} α σ _inst_1 f pt inf h₁ h₂) a) (f a)
 Case conversion may be inaccurate. Consider using '#align cfilter.coe_mk CFilter.coe_mkₓ'. -/
@@ -483,7 +483,7 @@ protected def prod {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f.Prod
 
 /- warning: filter.realizer.le_iff -> Filter.Realizer.le_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} (F : Filter.Realizer.{u1, u2} α f) (G : Filter.Realizer.{u1, u3} α g), Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) (forall (b : Filter.Realizer.σ.{u1, u3} α g G), Exists.{succ u2} (Filter.Realizer.σ.{u1, u2} α f F) (fun (a : Filter.Realizer.σ.{u1, u2} α f F) => LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u2} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u2} α f F) a) (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u3} α g G) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u3} α g G) b)))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α} (F : Filter.Realizer.{u1, u2} α f) (G : Filter.Realizer.{u1, u3} α g), Iff (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) f g) (forall (b : Filter.Realizer.σ.{u1, u3} α g G), Exists.{succ u2} (Filter.Realizer.σ.{u1, u2} α f F) (fun (a : Filter.Realizer.σ.{u1, u2} α f F) => LE.le.{u1} (Set.{u1} α) (Set.hasLe.{u1} α) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u2} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u2} α f F) a) (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u3} α g G) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α g G) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u3} α g G) b)))
 but is expected to have type
   forall {α : Type.{u3}} {f : Filter.{u3} α} {g : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (G : Filter.Realizer.{u3, u1} α g), Iff (LE.le.{u3} (Filter.{u3} α) (Preorder.toLE.{u3} (Filter.{u3} α) (PartialOrder.toPreorder.{u3} (Filter.{u3} α) (Filter.instPartialOrderFilter.{u3} α))) f g) (forall (b : Filter.Realizer.σ.{u3, u1} α g G), Exists.{succ u2} (Filter.Realizer.σ.{u3, u2} α f F) (fun (a : Filter.Realizer.σ.{u3, u2} α f F) => LE.le.{u3} (Set.{u3} α) (Set.instLESet.{u3} α) (CFilter.f.{u3, u2} (Set.{u3} α) (Filter.Realizer.σ.{u3, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u2} α f F) a) (CFilter.f.{u3, u1} (Set.{u3} α) (Filter.Realizer.σ.{u3, u1} α g G) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u1} α g G) b)))
 Case conversion may be inaccurate. Consider using '#align filter.realizer.le_iff Filter.Realizer.le_iffₓ'. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -464,7 +464,7 @@ protected def bind {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G :
 -/
 
 /-- Construct a realizer for indexed supremum -/
-protected def supᵢ {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i, f i).Realizer :=
+protected def iSup {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i, f i).Realizer :=
   let F' : (⨆ i, f i).Realizer :=
     (Realizer.bind Realizer.top F).of_eq <|
       filter_eq <| Set.ext <| by simp [Filter.bind, eq_univ_iff_forall, supr_sets_eq]
@@ -472,7 +472,7 @@ protected def supᵢ {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i
     show (Σu : Unit, ∀ i : α, True → (F i).σ) ≃ ∀ i, (F i).σ from
       ⟨fun ⟨_, f⟩ i => f i ⟨⟩, fun f => ⟨(), fun i _ => f i⟩, fun ⟨⟨⟩, f⟩ => by
         dsimp <;> congr <;> simp, fun f => rfl⟩
-#align filter.realizer.Sup Filter.Realizer.supᵢₓ
+#align filter.realizer.Sup Filter.Realizer.iSupₓ
 
 #print Filter.Realizer.prod /-
 /-- Construct a realizer for the product of filters -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

@@ -86,7 +86,7 @@ def ofEquiv (E : σ ≃ τ) : CFilter α σ → CFilter α τ
 lean 3 declaration is
   forall {α : Type.{u1}} {σ : Type.{u2}} {τ : Type.{u3}} [_inst_1 : PartialOrder.{u1} α] (E : Equiv.{succ u2, succ u3} σ τ) (F : CFilter.{u1, u2} α σ _inst_1) (a : τ), Eq.{succ u1} α (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} α τ _inst_1) (fun (_x : CFilter.{u1, u3} α τ _inst_1) => τ -> α) (CFilter.hasCoeToFun.{u1, u3} α τ _inst_1) (CFilter.ofEquiv.{u1, u2, u3} α σ τ _inst_1 E F) a) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} α σ _inst_1) (fun (_x : CFilter.{u1, u2} α σ _inst_1) => σ -> α) (CFilter.hasCoeToFun.{u1, u2} α σ _inst_1) F (coeFn.{max 1 (max (succ u3) (succ u2)) (succ u2) (succ u3), max (succ u3) (succ u2)} (Equiv.{succ u3, succ u2} τ σ) (fun (_x : Equiv.{succ u3, succ u2} τ σ) => τ -> σ) (Equiv.hasCoeToFun.{succ u3, succ u2} τ σ) (Equiv.symm.{succ u2, succ u3} σ τ E) a))
 but is expected to have type
-  forall {α : Type.{u1}} {σ : Type.{u3}} {τ : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] (E : Equiv.{succ u3, succ u2} σ τ) (F : CFilter.{u1, u3} α σ _inst_1) (a : τ), Eq.{succ u1} α (CFilter.f.{u1, u2} α τ _inst_1 (CFilter.ofEquiv.{u1, u3, u2} α σ τ _inst_1 E F) a) (CFilter.f.{u1, u3} α σ _inst_1 F (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (Equiv.{succ u2, succ u3} τ σ) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : τ) => σ) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u3} τ σ) (Equiv.symm.{succ u3, succ u2} σ τ E) a))
+  forall {α : Type.{u1}} {σ : Type.{u3}} {τ : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] (E : Equiv.{succ u3, succ u2} σ τ) (F : CFilter.{u1, u3} α σ _inst_1) (a : τ), Eq.{succ u1} α (CFilter.f.{u1, u2} α τ _inst_1 (CFilter.ofEquiv.{u1, u3, u2} α σ τ _inst_1 E F) a) (CFilter.f.{u1, u3} α σ _inst_1 F (FunLike.coe.{max (succ u3) (succ u2), succ u2, succ u3} (Equiv.{succ u2, succ u3} τ σ) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : τ) => σ) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u3} τ σ) (Equiv.symm.{succ u3, succ u2} σ τ E) a))
 Case conversion may be inaccurate. Consider using '#align cfilter.of_equiv_val CFilter.ofEquiv_valₓ'. -/
 @[simp]
 theorem ofEquiv_val (E : σ ≃ τ) (F : CFilter α σ) (a : τ) : F.of_equiv E a = F (E.symm a) := by
@@ -206,7 +206,7 @@ theorem ofEquiv_σ {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) : (F.of_eq
 lean 3 declaration is
   forall {α : Type.{u1}} {τ : Type.{u2}} {f : Filter.{u1} α} (F : Filter.Realizer.{u1, u3} α f) (E : Equiv.{succ u3, succ u2} (Filter.Realizer.σ.{u1, u3} α f F) τ) (s : τ), Eq.{succ u1} (Set.{u1} α) (coeFn.{max (succ u1) (succ u2), max (succ u2) (succ u1)} (CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u2} (Set.{u1} α) (Filter.Realizer.σ.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u2} α f (Filter.Realizer.ofEquiv.{u1, u2, u3} α τ f F E)) s) (coeFn.{max (succ u1) (succ u3), max (succ u3) (succ u1)} (CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (fun (_x : CFilter.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) => (Filter.Realizer.σ.{u1, u3} α f F) -> (Set.{u1} α)) (CFilter.hasCoeToFun.{u1, u3} (Set.{u1} α) (Filter.Realizer.σ.{u1, u3} α f F) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Filter.Realizer.f.{u1, u3} α f F) (coeFn.{max 1 (max (succ u2) (succ u3)) (succ u3) (succ u2), max (succ u2) (succ u3)} (Equiv.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) (fun (_x : Equiv.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) => τ -> (Filter.Realizer.σ.{u1, u3} α f F)) (Equiv.hasCoeToFun.{succ u2, succ u3} τ (Filter.Realizer.σ.{u1, u3} α f F)) (Equiv.symm.{succ u3, succ u2} (Filter.Realizer.σ.{u1, u3} α f F) τ E) s))
 but is expected to have type
-  forall {α : Type.{u3}} {τ : Type.{u1}} {f : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (E : Equiv.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ) (s : τ), Eq.{succ u3} (Set.{u3} α) (CFilter.f.{u3, u1} (Set.{u3} α) (Filter.Realizer.σ.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) s) (CFilter.f.{u3, u2} (Set.{u3} α) (Filter.Realizer.σ.{u3, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u2} α f F) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : τ) => Filter.Realizer.σ.{u3, u2} α f F) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) (Equiv.symm.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ E) s))
+  forall {α : Type.{u3}} {τ : Type.{u1}} {f : Filter.{u3} α} (F : Filter.Realizer.{u3, u2} α f) (E : Equiv.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ) (s : τ), Eq.{succ u3} (Set.{u3} α) (CFilter.f.{u3, u1} (Set.{u3} α) (Filter.Realizer.σ.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u1} α f (Filter.Realizer.ofEquiv.{u3, u1, u2} α τ f F E)) s) (CFilter.f.{u3, u2} (Set.{u3} α) (Filter.Realizer.σ.{u3, u2} α f F) (CompleteSemilatticeInf.toPartialOrder.{u3} (Set.{u3} α) (CompleteLattice.toCompleteSemilatticeInf.{u3} (Set.{u3} α) (Order.Coframe.toCompleteLattice.{u3} (Set.{u3} α) (CompleteDistribLattice.toCoframe.{u3} (Set.{u3} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u3} (Set.{u3} α) (Set.instCompleteBooleanAlgebraSet.{u3} α)))))) (Filter.Realizer.F.{u3, u2} α f F) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) τ (fun (_x : τ) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : τ) => Filter.Realizer.σ.{u3, u2} α f F) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} τ (Filter.Realizer.σ.{u3, u2} α f F)) (Equiv.symm.{succ u2, succ u1} (Filter.Realizer.σ.{u3, u2} α f F) τ E) s))
 Case conversion may be inaccurate. Consider using '#align filter.realizer.of_equiv_F Filter.Realizer.ofEquiv_Fₓ'. -/
 @[simp]
 theorem ofEquiv_F {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/9da1b3534b65d9661eb8f42443598a92bbb49211

@@ -360,9 +360,9 @@ protected def comap (m : α → β) {f : Filter β} (F : f.Realizer) : (comap m
 
 /- warning: filter.realizer.sup -> Filter.Realizer.sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u2 u3} α (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u2 u3} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.completeLattice.{u1} α))))) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u3 u2} α (HasSup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toHasSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u3 u2} α (Sup.sup.{u1} (Filter.{u1} α) (SemilatticeSup.toSup.{u1} (Filter.{u1} α) (Lattice.toSemilatticeSup.{u1} (Filter.{u1} α) (ConditionallyCompleteLattice.toLattice.{u1} (Filter.{u1} α) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} α) (Filter.instCompleteLatticeFilter.{u1} α))))) f g))
 Case conversion may be inaccurate. Consider using '#align filter.realizer.sup Filter.Realizer.supₓ'. -/
 /-- Construct a realizer for the sup of two filters -/
 protected def sup {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊔ g).Realizer :=
@@ -386,9 +386,9 @@ protected def sup {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊔ g
 
 /- warning: filter.realizer.inf -> Filter.Realizer.inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u2 u3} α (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u2 u3} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) f g))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u3 u2} α (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) f g))
+  forall {α : Type.{u1}} {f : Filter.{u1} α} {g : Filter.{u1} α}, (Filter.Realizer.{u1, u2} α f) -> (Filter.Realizer.{u1, u3} α g) -> (Filter.Realizer.{u1, max u3 u2} α (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) f g))
 Case conversion may be inaccurate. Consider using '#align filter.realizer.inf Filter.Realizer.infₓ'. -/
 /-- Construct a realizer for the inf of two filters -/
 protected def inf {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊓ g).Realizer :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

A PR accompanying #12339.

Zulip discussion

@@ -268,8 +268,8 @@ protected def inf {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊓ g
       constructor
       · rintro ⟨s, t, h⟩
         apply mem_inf_of_inter _ _ h
-        use s
-        use t
+        · use s
+        · use t
       · rintro ⟨_, ⟨a, ha⟩, _, ⟨b, hb⟩, rfl⟩
         exact ⟨a, b, inter_subset_inter ha hb⟩⟩
 #align filter.realizer.inf Filter.Realizer.inf

Classifies by adding issue number #11215 to porting notes claiming "TODO".

@@ -22,7 +22,7 @@ This file provides infrastructure to compute with filters.
 
 open Set Filter
 
--- Porting note: TODO write doc strings
+-- Porting note (#11215): TODO write doc strings
 /-- A `CFilter α σ` is a realization of a filter (base) on `α`,
   represented by a type `σ` together with operations for the top element and
   the binary `inf` operation. -/
@@ -94,7 +94,7 @@ theorem mem_toFilter_sets (F : CFilter (Set α) σ) {a : Set α} : a ∈ F.toFil
 
 end CFilter
 
--- Porting note: TODO write doc strings
+-- Porting note (#11215): TODO write doc strings
 /-- A realizer for filter `f` is a cfilter which generates `f`. -/
 structure Filter.Realizer (f : Filter α) where
   σ : Type*

This prepares for the introduction of a non-dependent synonym of FunLike, which helps a lot with keeping #8386 readable.

This is entirely search-and-replace in 680197f combined with manual fixes in 4145626, e900597 and b8428f8. The commands that generated this change:

sed -i 's/\bFunLike\b/DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoFunLike\b/toDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/import Mathlib.Data.DFunLike/import Mathlib.Data.FunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bHom_FunLike\b/Hom_DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean     
sed -i 's/\binstFunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bfunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoo many metavariables to apply `fun_like.has_coe_to_fun`/too many metavariables to apply `DFunLike.hasCoeToFun`/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean

Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

@@ -53,7 +53,7 @@ instance : CoeFun (CFilter α σ) fun _ ↦ σ → α :=
   ⟨CFilter.f⟩
 
 /- Porting note: Due to the CoeFun instance, the lhs of this lemma has a variable (f) as its head
-symbol (simpnf linter problem). Replacing it with a FunLike instance would not be mathematically
+symbol (simpnf linter problem). Replacing it with a DFunLike instance would not be mathematically
 meaningful here, since the coercion to f cannot be injective, hence need to remove @[simp]. -/
 -- @[simp]
 theorem coe_mk (f pt inf h₁ h₂ a) : (@CFilter.mk α σ _ f pt inf h₁ h₂) a = f a :=

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

This has nice performance benefits.

@@ -26,7 +26,7 @@ open Set Filter
 /-- A `CFilter α σ` is a realization of a filter (base) on `α`,
   represented by a type `σ` together with operations for the top element and
   the binary `inf` operation. -/
-structure CFilter (α σ : Type _) [PartialOrder α] where
+structure CFilter (α σ : Type*) [PartialOrder α] where
   f : σ → α
   pt : σ
   inf : σ → σ → σ
@@ -34,7 +34,7 @@ structure CFilter (α σ : Type _) [PartialOrder α] where
   inf_le_right : ∀ a b : σ, f (inf a b) ≤ f b
 #align cfilter CFilter
 
-variable {α : Type _} {β : Type _} {σ : Type _} {τ : Type _}
+variable {α : Type*} {β : Type*} {σ : Type*} {τ : Type*}
 
 instance [Inhabited α] [SemilatticeInf α] : Inhabited (CFilter α α) :=
   ⟨{  f := id
@@ -97,7 +97,7 @@ end CFilter
 -- Porting note: TODO write doc strings
 /-- A realizer for filter `f` is a cfilter which generates `f`. -/
 structure Filter.Realizer (f : Filter α) where
-  σ : Type _
+  σ : Type*
   F : CFilter (Set α) σ
   eq : F.toFilter = f
 #align filter.realizer Filter.Realizer

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
-
-! This file was ported from Lean 3 source module data.analysis.filter
-! leanprover-community/mathlib commit f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.Cofinite
 
+#align_import data.analysis.filter from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
+
 /-!
 # Computational realization of filters (experimental)
 

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

@@ -75,7 +75,7 @@ def ofEquiv (E : σ ≃ τ) : CFilter α σ → CFilter α τ
 
 @[simp]
 theorem ofEquiv_val (E : σ ≃ τ) (F : CFilter α σ) (a : τ) : F.ofEquiv E a = F (E.symm a) := by
-  cases F ; rfl
+  cases F; rfl
 #align cfilter.of_equiv_val CFilter.ofEquiv_val
 
 end
@@ -113,7 +113,7 @@ protected def CFilter.toRealizer (F : CFilter (Set α) σ) : F.toFilter.Realizer
 namespace Filter.Realizer
 
 theorem mem_sets {f : Filter α} (F : f.Realizer) {a : Set α} : a ∈ f ↔ ∃ b, F.F b ⊆ a := by
-  cases F ; subst f ; rfl
+  cases F; subst f; rfl
 #align filter.realizer.mem_sets Filter.Realizer.mem_sets
 
 /-- Transfer a realizer along an equality of filter. This has better definitional equalities than
@@ -242,7 +242,7 @@ protected def comap (m : α → β) {f : Filter β} (F : f.Realizer) : (comap m
       inf_le_left := fun _ _ ↦ preimage_mono (F.F.inf_le_left _ _)
       inf_le_right := fun _ _ ↦ preimage_mono (F.F.inf_le_right _ _) },
     filter_eq <| Set.ext fun _ ↦ by
-      cases F ; subst f
+      cases F; subst f
       exact ⟨fun ⟨s, h⟩ ↦ ⟨_, ⟨s, Subset.refl _⟩, h⟩,
         fun ⟨_, ⟨s, h⟩, h₂⟩ ↦ ⟨s, Subset.trans (preimage_mono h) h₂⟩⟩⟩
 #align filter.realizer.comap Filter.Realizer.comap
@@ -255,7 +255,7 @@ protected def sup {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊔ g
       inf := fun ⟨a, a'⟩ ⟨b, b'⟩ ↦ (F.F.inf a b, G.F.inf a' b')
       inf_le_left := fun _ _ ↦ union_subset_union (F.F.inf_le_left _ _) (G.F.inf_le_left _ _)
       inf_le_right := fun _ _ ↦ union_subset_union (F.F.inf_le_right _ _) (G.F.inf_le_right _ _) },
-    filter_eq <| Set.ext fun _ ↦ by cases F ; cases G ; substs f g ; simp [CFilter.toFilter]⟩
+    filter_eq <| Set.ext fun _ ↦ by cases F; cases G; substs f g; simp [CFilter.toFilter]⟩
 #align filter.realizer.sup Filter.Realizer.sup
 
 /-- Construct a realizer for the inf of two filters -/
@@ -307,7 +307,7 @@ protected def bind {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G :
         simp only [mem_iUnion, forall_exists_index]
         exact fun i h₁ h₂ ↦ ⟨i, F.F.inf_le_right _ _ h₁, (G i).F.inf_le_right _ _ h₂⟩ },
     filter_eq <| Set.ext fun _ ↦ by
-      cases' F with _ F _ ; subst f
+      cases' F with _ F _; subst f
       simp only [CFilter.toFilter, iUnion_subset_iff, Sigma.exists, Filter.mem_sets, mem_bind]
       exact
         ⟨fun ⟨s, f, h⟩ ↦

Add a #compile inductive command to compile the recursors of an inductive type, which works by creating a recursive definition and using @[csimp].

Co-authored-by: Parth Shastri <31370288+cppio@users.noreply.github.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -122,9 +122,8 @@ def ofEq {f g : Filter α} (e : f = g) (F : f.Realizer) : g.Realizer :=
   ⟨F.σ, F.F, F.eq.trans e⟩
 #align filter.realizer.of_eq Filter.Realizer.ofEq
 
--- Porting note: Added `noncomputable`
 /-- A filter realizes itself. -/
-noncomputable def ofFilter (f : Filter α) : f.Realizer :=
+def ofFilter (f : Filter α) : f.Realizer :=
   ⟨f.sets,
     { f := Subtype.val
       pt := ⟨univ, univ_mem⟩

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>

@@ -302,14 +302,14 @@ protected def bind {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G :
         ⟨F.F.inf a b, fun i h ↦
           (G i).F.inf (f i (F.F.inf_le_left _ _ h)) (f' i (F.F.inf_le_right _ _ h))⟩
       inf_le_left := fun _ _ _ ↦ by
-        simp only [mem_unionᵢ, forall_exists_index]
+        simp only [mem_iUnion, forall_exists_index]
         exact fun i h₁ h₂ ↦ ⟨i, F.F.inf_le_left _ _ h₁, (G i).F.inf_le_left _ _ h₂⟩
       inf_le_right := fun _ _ _ ↦ by
-        simp only [mem_unionᵢ, forall_exists_index]
+        simp only [mem_iUnion, forall_exists_index]
         exact fun i h₁ h₂ ↦ ⟨i, F.F.inf_le_right _ _ h₁, (G i).F.inf_le_right _ _ h₂⟩ },
     filter_eq <| Set.ext fun _ ↦ by
       cases' F with _ F _ ; subst f
-      simp only [CFilter.toFilter, unionᵢ_subset_iff, Sigma.exists, Filter.mem_sets, mem_bind]
+      simp only [CFilter.toFilter, iUnion_subset_iff, Sigma.exists, Filter.mem_sets, mem_bind]
       exact
         ⟨fun ⟨s, f, h⟩ ↦
           ⟨F s, ⟨s, Subset.refl _⟩, fun i H ↦ (G i).mem_sets.2 ⟨f i H, fun _ h' ↦ h i H h'⟩⟩,
@@ -318,16 +318,16 @@ protected def bind {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G :
           ⟨s, fun i h ↦ f' ⟨i, h⟩, fun _ H _ m ↦ h' ⟨_, H⟩ m⟩⟩⟩
 #align filter.realizer.bind Filter.Realizer.bind
 
--- Porting note: `supᵢ` had a long dubious translation message. I added `ₓ` to be safe.
+-- Porting note: `iSup` had a long dubious translation message. I added `ₓ` to be safe.
 /-- Construct a realizer for indexed supremum -/
-protected def supᵢ {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i, f i).Realizer :=
+protected def iSup {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i, f i).Realizer :=
   let F' : (⨆ i, f i).Realizer :=
     (Realizer.bind Realizer.top F).ofEq <|
-      filter_eq <| Set.ext <| by simp [Filter.bind, eq_univ_iff_forall, supᵢ_sets_eq]
+      filter_eq <| Set.ext <| by simp [Filter.bind, eq_univ_iff_forall, iSup_sets_eq]
   F'.ofEquiv <|
     show (Σ_ : Unit, ∀ i : α, True → (F i).σ) ≃ ∀ i, (F i).σ from
       ⟨fun ⟨_, f⟩ i ↦ f i ⟨⟩, fun f ↦ ⟨(), fun i _ ↦ f i⟩, fun _ ↦ rfl, fun _ ↦ rfl⟩
-#align filter.realizer.Sup Filter.Realizer.supᵢₓ
+#align filter.realizer.Sup Filter.Realizer.iSupₓ
 
 /-- Construct a realizer for the product of filters -/
 protected def prod {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f.prod g).Realizer :=

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -268,14 +268,14 @@ protected def inf {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f ⊓ g
       inf_le_left := fun _ _ ↦ inter_subset_inter (F.F.inf_le_left _ _) (G.F.inf_le_left _ _)
       inf_le_right := fun _ _ ↦ inter_subset_inter (F.F.inf_le_right _ _) (G.F.inf_le_right _ _) },
     by
-    cases F ; cases G ; substs f g ; simp only [CFilter.toFilter, Prod.exists] ; ext
-    constructor
-    · rintro ⟨s, t, h⟩
-      apply mem_inf_of_inter _ _ h
-      use s
-      use t
-    · rintro ⟨_, ⟨a, ha⟩, _, ⟨b, hb⟩, rfl⟩
-      exact ⟨a, b, inter_subset_inter ha hb⟩⟩
+      cases F; cases G; substs f g; simp only [CFilter.toFilter, Prod.exists]; ext
+      constructor
+      · rintro ⟨s, t, h⟩
+        apply mem_inf_of_inter _ _ h
+        use s
+        use t
+      · rintro ⟨_, ⟨a, ha⟩, _, ⟨b, hb⟩, rfl⟩
+        exact ⟨a, b, inter_subset_inter ha hb⟩⟩
 #align filter.realizer.inf Filter.Realizer.inf
 
 /-- Construct a realizer for the cofinite filter -/

@@ -318,16 +318,16 @@ protected def bind {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G :
           ⟨s, fun i h ↦ f' ⟨i, h⟩, fun _ H _ m ↦ h' ⟨_, H⟩ m⟩⟩⟩
 #align filter.realizer.bind Filter.Realizer.bind
 
--- Porting note: `Sup` had a long dubious translation message. I added `ₓ` to be safe.
+-- Porting note: `supᵢ` had a long dubious translation message. I added `ₓ` to be safe.
 /-- Construct a realizer for indexed supremum -/
-protected def Sup {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i, f i).Realizer :=
+protected def supᵢ {f : α → Filter β} (F : ∀ i, (f i).Realizer) : (⨆ i, f i).Realizer :=
   let F' : (⨆ i, f i).Realizer :=
     (Realizer.bind Realizer.top F).ofEq <|
       filter_eq <| Set.ext <| by simp [Filter.bind, eq_univ_iff_forall, supᵢ_sets_eq]
   F'.ofEquiv <|
     show (Σ_ : Unit, ∀ i : α, True → (F i).σ) ≃ ∀ i, (F i).σ from
       ⟨fun ⟨_, f⟩ i ↦ f i ⟨⟩, fun f ↦ ⟨(), fun i _ ↦ f i⟩, fun _ ↦ rfl, fun _ ↦ rfl⟩
-#align filter.realizer.Sup Filter.Realizer.Supₓ
+#align filter.realizer.Sup Filter.Realizer.supᵢₓ
 
 /-- Construct a realizer for the product of filters -/
 protected def prod {f g : Filter α} (F : f.Realizer) (G : g.Realizer) : (f.prod g).Realizer :=

Co-authored-by: Lukas Miaskiwskyi <lukas.mias@gmail.com>