order.filter.extr ⟷ Mathlib.Order.Filter.Extr

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

@@ -265,7 +265,7 @@ theorem isMaxFilter_dual_iff : IsMaxFilter (toDual ∘ f) l a ↔ IsMinFilter f
 
 #print isExtrFilter_dual_iff /-
 theorem isExtrFilter_dual_iff : IsExtrFilter (toDual ∘ f) l a ↔ IsExtrFilter f l a :=
-  or_comm' _ _
+  or_comm _ _
 #align is_extr_filter_dual_iff isExtrFilter_dual_iff
 -/
 
@@ -295,7 +295,7 @@ theorem isMaxOn_dual_iff : IsMaxOn (toDual ∘ f) s a ↔ IsMinOn f s a :=
 
 #print isExtrOn_dual_iff /-
 theorem isExtrOn_dual_iff : IsExtrOn (toDual ∘ f) s a ↔ IsExtrOn f s a :=
-  or_comm' _ _
+  or_comm _ _
 #align is_extr_on_dual_iff isExtrOn_dual_iff
 -/
 

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

@@ -3,7 +3,7 @@ Copyright (c) 2019 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Mathbin.Order.Filter.Basic
+import Order.Filter.Basic
 
 #align_import order.filter.extr from "leanprover-community/mathlib"@"63f84d91dd847f50bae04a01071f3a5491934e36"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

@@ -269,15 +269,15 @@ theorem isExtrFilter_dual_iff : IsExtrFilter (toDual ∘ f) l a ↔ IsExtrFilter
 #align is_extr_filter_dual_iff isExtrFilter_dual_iff
 -/
 
-alias isMinFilter_dual_iff ↔ IsMinFilter.undual IsMaxFilter.dual
+alias ⟨IsMinFilter.undual, IsMaxFilter.dual⟩ := isMinFilter_dual_iff
 #align is_min_filter.undual IsMinFilter.undual
 #align is_max_filter.dual IsMaxFilter.dual
 
-alias isMaxFilter_dual_iff ↔ IsMaxFilter.undual IsMinFilter.dual
+alias ⟨IsMaxFilter.undual, IsMinFilter.dual⟩ := isMaxFilter_dual_iff
 #align is_max_filter.undual IsMaxFilter.undual
 #align is_min_filter.dual IsMinFilter.dual
 
-alias isExtrFilter_dual_iff ↔ IsExtrFilter.undual IsExtrFilter.dual
+alias ⟨IsExtrFilter.undual, IsExtrFilter.dual⟩ := isExtrFilter_dual_iff
 #align is_extr_filter.undual IsExtrFilter.undual
 #align is_extr_filter.dual IsExtrFilter.dual
 
@@ -299,15 +299,15 @@ theorem isExtrOn_dual_iff : IsExtrOn (toDual ∘ f) s a ↔ IsExtrOn f s a :=
 #align is_extr_on_dual_iff isExtrOn_dual_iff
 -/
 
-alias isMinOn_dual_iff ↔ IsMinOn.undual IsMaxOn.dual
+alias ⟨IsMinOn.undual, IsMaxOn.dual⟩ := isMinOn_dual_iff
 #align is_min_on.undual IsMinOn.undual
 #align is_max_on.dual IsMaxOn.dual
 
-alias isMaxOn_dual_iff ↔ IsMaxOn.undual IsMinOn.dual
+alias ⟨IsMaxOn.undual, IsMinOn.dual⟩ := isMaxOn_dual_iff
 #align is_max_on.undual IsMaxOn.undual
 #align is_min_on.dual IsMinOn.dual
 
-alias isExtrOn_dual_iff ↔ IsExtrOn.undual IsExtrOn.dual
+alias ⟨IsExtrOn.undual, IsExtrOn.dual⟩ := isExtrOn_dual_iff
 #align is_extr_on.undual IsExtrOn.undual
 #align is_extr_on.dual IsExtrOn.dual
 

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

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module order.filter.extr
-! leanprover-community/mathlib commit 63f84d91dd847f50bae04a01071f3a5491934e36
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.Basic
 
+#align_import order.filter.extr from "leanprover-community/mathlib"@"63f84d91dd847f50bae04a01071f3a5491934e36"
+
 /-!
 # Minimum and maximum w.r.t. a filter and on a aet
 

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

@@ -317,29 +317,41 @@ alias isExtrOn_dual_iff ↔ IsExtrOn.undual IsExtrOn.dual
 /-! ### Operations on the filter/set -/
 
 
+#print IsMinFilter.filter_mono /-
 theorem IsMinFilter.filter_mono (h : IsMinFilter f l a) (hl : l' ≤ l) : IsMinFilter f l' a :=
   hl h
 #align is_min_filter.filter_mono IsMinFilter.filter_mono
+-/
 
+#print IsMaxFilter.filter_mono /-
 theorem IsMaxFilter.filter_mono (h : IsMaxFilter f l a) (hl : l' ≤ l) : IsMaxFilter f l' a :=
   hl h
 #align is_max_filter.filter_mono IsMaxFilter.filter_mono
+-/
 
+#print IsExtrFilter.filter_mono /-
 theorem IsExtrFilter.filter_mono (h : IsExtrFilter f l a) (hl : l' ≤ l) : IsExtrFilter f l' a :=
   h.elim (fun h => (h.filter_mono hl).isExtr) fun h => (h.filter_mono hl).isExtr
 #align is_extr_filter.filter_mono IsExtrFilter.filter_mono
+-/
 
+#print IsMinFilter.filter_inf /-
 theorem IsMinFilter.filter_inf (h : IsMinFilter f l a) (l') : IsMinFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
 #align is_min_filter.filter_inf IsMinFilter.filter_inf
+-/
 
+#print IsMaxFilter.filter_inf /-
 theorem IsMaxFilter.filter_inf (h : IsMaxFilter f l a) (l') : IsMaxFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
 #align is_max_filter.filter_inf IsMaxFilter.filter_inf
+-/
 
+#print IsExtrFilter.filter_inf /-
 theorem IsExtrFilter.filter_inf (h : IsExtrFilter f l a) (l') : IsExtrFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
 #align is_extr_filter.filter_inf IsExtrFilter.filter_inf
+-/
 
 #print IsMinOn.on_subset /-
 theorem IsMinOn.on_subset (hf : IsMinOn f t a) (h : s ⊆ t) : IsMinOn f s a :=
@@ -359,17 +371,23 @@ theorem IsExtrOn.on_subset (hf : IsExtrOn f t a) (h : s ⊆ t) : IsExtrOn f s a
 #align is_extr_on.on_subset IsExtrOn.on_subset
 -/
 
+#print IsMinOn.inter /-
 theorem IsMinOn.inter (hf : IsMinOn f s a) (t) : IsMinOn f (s ∩ t) a :=
   hf.on_subset (inter_subset_left s t)
 #align is_min_on.inter IsMinOn.inter
+-/
 
+#print IsMaxOn.inter /-
 theorem IsMaxOn.inter (hf : IsMaxOn f s a) (t) : IsMaxOn f (s ∩ t) a :=
   hf.on_subset (inter_subset_left s t)
 #align is_max_on.inter IsMaxOn.inter
+-/
 
+#print IsExtrOn.inter /-
 theorem IsExtrOn.inter (hf : IsExtrOn f s a) (t) : IsExtrOn f (s ∩ t) a :=
   hf.on_subset (inter_subset_left s t)
 #align is_extr_on.inter IsExtrOn.inter
+-/
 
 /-! ### Composition with (anti)monotone functions -/
 
@@ -566,25 +584,33 @@ section OrderedAddCommMonoid
 
 variable [OrderedAddCommMonoid β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
+#print IsMinFilter.add /-
 theorem IsMinFilter.add (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => f x + g x) l a :=
   show IsMinFilter (fun x => f x + g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => add_le_add hx hy) hg
 #align is_min_filter.add IsMinFilter.add
+-/
 
+#print IsMaxFilter.add /-
 theorem IsMaxFilter.add (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => f x + g x) l a :=
   show IsMaxFilter (fun x => f x + g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => add_le_add hx hy) hg
 #align is_max_filter.add IsMaxFilter.add
+-/
 
+#print IsMinOn.add /-
 theorem IsMinOn.add (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x + g x) s a :=
   hf.add hg
 #align is_min_on.add IsMinOn.add
+-/
 
+#print IsMaxOn.add /-
 theorem IsMaxOn.add (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x + g x) s a :=
   hf.add hg
 #align is_max_on.add IsMaxOn.add
+-/
 
 end OrderedAddCommMonoid
 
@@ -595,45 +621,65 @@ section OrderedAddCommGroup
 
 variable [OrderedAddCommGroup β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
+#print IsMinFilter.neg /-
 theorem IsMinFilter.neg (hf : IsMinFilter f l a) : IsMaxFilter (fun x => -f x) l a :=
   hf.comp_antitone fun x y hx => neg_le_neg hx
 #align is_min_filter.neg IsMinFilter.neg
+-/
 
+#print IsMaxFilter.neg /-
 theorem IsMaxFilter.neg (hf : IsMaxFilter f l a) : IsMinFilter (fun x => -f x) l a :=
   hf.comp_antitone fun x y hx => neg_le_neg hx
 #align is_max_filter.neg IsMaxFilter.neg
+-/
 
+#print IsExtrFilter.neg /-
 theorem IsExtrFilter.neg (hf : IsExtrFilter f l a) : IsExtrFilter (fun x => -f x) l a :=
   hf.elim (fun hf => hf.neg.isExtr) fun hf => hf.neg.isExtr
 #align is_extr_filter.neg IsExtrFilter.neg
+-/
 
+#print IsMinOn.neg /-
 theorem IsMinOn.neg (hf : IsMinOn f s a) : IsMaxOn (fun x => -f x) s a :=
   hf.comp_antitone fun x y hx => neg_le_neg hx
 #align is_min_on.neg IsMinOn.neg
+-/
 
+#print IsMaxOn.neg /-
 theorem IsMaxOn.neg (hf : IsMaxOn f s a) : IsMinOn (fun x => -f x) s a :=
   hf.comp_antitone fun x y hx => neg_le_neg hx
 #align is_max_on.neg IsMaxOn.neg
+-/
 
+#print IsExtrOn.neg /-
 theorem IsExtrOn.neg (hf : IsExtrOn f s a) : IsExtrOn (fun x => -f x) s a :=
   hf.elim (fun hf => hf.neg.isExtr) fun hf => hf.neg.isExtr
 #align is_extr_on.neg IsExtrOn.neg
+-/
 
+#print IsMinFilter.sub /-
 theorem IsMinFilter.sub (hf : IsMinFilter f l a) (hg : IsMaxFilter g l a) :
     IsMinFilter (fun x => f x - g x) l a := by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_min_filter.sub IsMinFilter.sub
+-/
 
+#print IsMaxFilter.sub /-
 theorem IsMaxFilter.sub (hf : IsMaxFilter f l a) (hg : IsMinFilter g l a) :
     IsMaxFilter (fun x => f x - g x) l a := by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_max_filter.sub IsMaxFilter.sub
+-/
 
+#print IsMinOn.sub /-
 theorem IsMinOn.sub (hf : IsMinOn f s a) (hg : IsMaxOn g s a) : IsMinOn (fun x => f x - g x) s a :=
   by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_min_on.sub IsMinOn.sub
+-/
 
+#print IsMaxOn.sub /-
 theorem IsMaxOn.sub (hf : IsMaxOn f s a) (hg : IsMinOn g s a) : IsMaxOn (fun x => f x - g x) s a :=
   by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_max_on.sub IsMaxOn.sub
+-/
 
 end OrderedAddCommGroup
 
@@ -644,25 +690,33 @@ section SemilatticeSup
 
 variable [SemilatticeSup β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
+#print IsMinFilter.sup /-
 theorem IsMinFilter.sup (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => f x ⊔ g x) l a :=
   show IsMinFilter (fun x => f x ⊔ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => sup_le_sup hx hy) hg
 #align is_min_filter.sup IsMinFilter.sup
+-/
 
+#print IsMaxFilter.sup /-
 theorem IsMaxFilter.sup (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => f x ⊔ g x) l a :=
   show IsMaxFilter (fun x => f x ⊔ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => sup_le_sup hx hy) hg
 #align is_max_filter.sup IsMaxFilter.sup
+-/
 
+#print IsMinOn.sup /-
 theorem IsMinOn.sup (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊔ g x) s a :=
   hf.sup hg
 #align is_min_on.sup IsMinOn.sup
+-/
 
+#print IsMaxOn.sup /-
 theorem IsMaxOn.sup (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊔ g x) s a :=
   hf.sup hg
 #align is_max_on.sup IsMaxOn.sup
+-/
 
 end SemilatticeSup
 
@@ -670,25 +724,33 @@ section SemilatticeInf
 
 variable [SemilatticeInf β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
+#print IsMinFilter.inf /-
 theorem IsMinFilter.inf (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => f x ⊓ g x) l a :=
   show IsMinFilter (fun x => f x ⊓ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => inf_le_inf hx hy) hg
 #align is_min_filter.inf IsMinFilter.inf
+-/
 
+#print IsMaxFilter.inf /-
 theorem IsMaxFilter.inf (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => f x ⊓ g x) l a :=
   show IsMaxFilter (fun x => f x ⊓ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => inf_le_inf hx hy) hg
 #align is_max_filter.inf IsMaxFilter.inf
+-/
 
+#print IsMinOn.inf /-
 theorem IsMinOn.inf (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊓ g x) s a :=
   hf.inf hg
 #align is_min_on.inf IsMinOn.inf
+-/
 
+#print IsMaxOn.inf /-
 theorem IsMaxOn.inf (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊓ g x) s a :=
   hf.inf hg
 #align is_max_on.inf IsMaxOn.inf
+-/
 
 end SemilatticeInf
 
@@ -699,49 +761,65 @@ section LinearOrder
 
 variable [LinearOrder β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
+#print IsMinFilter.min /-
 theorem IsMinFilter.min (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => min (f x) (g x)) l a :=
   show IsMinFilter (fun x => min (f x) (g x)) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => min_le_min hx hy) hg
 #align is_min_filter.min IsMinFilter.min
+-/
 
+#print IsMaxFilter.min /-
 theorem IsMaxFilter.min (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => min (f x) (g x)) l a :=
   show IsMaxFilter (fun x => min (f x) (g x)) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => min_le_min hx hy) hg
 #align is_max_filter.min IsMaxFilter.min
+-/
 
+#print IsMinOn.min /-
 theorem IsMinOn.min (hf : IsMinOn f s a) (hg : IsMinOn g s a) :
     IsMinOn (fun x => min (f x) (g x)) s a :=
   hf.min hg
 #align is_min_on.min IsMinOn.min
+-/
 
+#print IsMaxOn.min /-
 theorem IsMaxOn.min (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) :
     IsMaxOn (fun x => min (f x) (g x)) s a :=
   hf.min hg
 #align is_max_on.min IsMaxOn.min
+-/
 
+#print IsMinFilter.max /-
 theorem IsMinFilter.max (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => max (f x) (g x)) l a :=
   show IsMinFilter (fun x => max (f x) (g x)) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => max_le_max hx hy) hg
 #align is_min_filter.max IsMinFilter.max
+-/
 
+#print IsMaxFilter.max /-
 theorem IsMaxFilter.max (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => max (f x) (g x)) l a :=
   show IsMaxFilter (fun x => max (f x) (g x)) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => max_le_max hx hy) hg
 #align is_max_filter.max IsMaxFilter.max
+-/
 
+#print IsMinOn.max /-
 theorem IsMinOn.max (hf : IsMinOn f s a) (hg : IsMinOn g s a) :
     IsMinOn (fun x => max (f x) (g x)) s a :=
   hf.max hg
 #align is_min_on.max IsMinOn.max
+-/
 
+#print IsMaxOn.max /-
 theorem IsMaxOn.max (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) :
     IsMaxOn (fun x => max (f x) (g x)) s a :=
   hf.max hg
 #align is_max_on.max IsMaxOn.max
+-/
 
 end LinearOrder
 
@@ -750,6 +828,7 @@ section Eventually
 /-! ### Relation with `eventually` comparisons of two functions -/
 
 
+#print Filter.EventuallyLE.isMaxFilter /-
 theorem Filter.EventuallyLE.isMaxFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : g ≤ᶠ[l] f) (hfga : f a = g a) (h : IsMaxFilter f l a) :
     IsMaxFilter g l a := by
@@ -757,44 +836,59 @@ theorem Filter.EventuallyLE.isMaxFilter {α β : Type _} [Preorder β] {f g : α
   rw [← hfga]
   exact le_trans hgf hf
 #align filter.eventually_le.is_max_filter Filter.EventuallyLE.isMaxFilter
+-/
 
+#print IsMaxFilter.congr /-
 theorem IsMaxFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsMaxFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter g l a :=
   HEq.symm.le.IsMaxFilter hfga h
 #align is_max_filter.congr IsMaxFilter.congr
+-/
 
+#print Filter.EventuallyEq.isMaxFilter_iff /-
 theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter f l a ↔ IsMaxFilter g l a :=
   ⟨fun h => h.congr HEq hfga, fun h => h.congr HEq.symm hfga.symm⟩
 #align filter.eventually_eq.is_max_filter_iff Filter.EventuallyEq.isMaxFilter_iff
+-/
 
+#print Filter.EventuallyLE.isMinFilter /-
 theorem Filter.EventuallyLE.isMinFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : f ≤ᶠ[l] g) (hfga : f a = g a) (h : IsMinFilter f l a) :
     IsMinFilter g l a :=
   @Filter.EventuallyLE.isMaxFilter _ βᵒᵈ _ _ _ _ _ hle hfga h
 #align filter.eventually_le.is_min_filter Filter.EventuallyLE.isMinFilter
+-/
 
+#print IsMinFilter.congr /-
 theorem IsMinFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsMinFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter g l a :=
   HEq.le.IsMinFilter hfga h
 #align is_min_filter.congr IsMinFilter.congr
+-/
 
+#print Filter.EventuallyEq.isMinFilter_iff /-
 theorem Filter.EventuallyEq.isMinFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter f l a ↔ IsMinFilter g l a :=
   ⟨fun h => h.congr HEq hfga, fun h => h.congr HEq.symm hfga.symm⟩
 #align filter.eventually_eq.is_min_filter_iff Filter.EventuallyEq.isMinFilter_iff
+-/
 
+#print IsExtrFilter.congr /-
 theorem IsExtrFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsExtrFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsExtrFilter g l a :=
   by
   rw [IsExtrFilter] at *
   rwa [← heq.is_max_filter_iff hfga, ← heq.is_min_filter_iff hfga]
 #align is_extr_filter.congr IsExtrFilter.congr
+-/
 
+#print Filter.EventuallyEq.isExtrFilter_iff /-
 theorem Filter.EventuallyEq.isExtrFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsExtrFilter f l a ↔ IsExtrFilter g l a :=
   ⟨fun h => h.congr HEq hfga, fun h => h.congr HEq.symm hfga.symm⟩
 #align filter.eventually_eq.is_extr_filter_iff Filter.EventuallyEq.isExtrFilter_iff
+-/
 
 end Eventually
 
@@ -805,14 +899,18 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {f : β → α} {s : Set β} {x₀ : β}
 
+#print IsMaxOn.iSup_eq /-
 theorem IsMaxOn.iSup_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : (⨆ x : s, f x) = f x₀ :=
   haveI : Nonempty s := ⟨⟨x₀, hx₀⟩⟩
   ciSup_eq_of_forall_le_of_forall_lt_exists_gt (fun x => h x.Prop) fun w hw => ⟨⟨x₀, hx₀⟩, hw⟩
 #align is_max_on.supr_eq IsMaxOn.iSup_eq
+-/
 
+#print IsMinOn.iInf_eq /-
 theorem IsMinOn.iInf_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : (⨅ x : s, f x) = f x₀ :=
   @IsMaxOn.iSup_eq αᵒᵈ β _ _ _ _ hx₀ h
 #align is_min_on.infi_eq IsMinOn.iInf_eq
+-/
 
 end ConditionallyCompleteLinearOrder
 

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

@@ -86,7 +86,7 @@ variable {α : Type u} {β : Type v} {γ : Type w} {δ : Type x}
 
 open Set Filter
 
-open Filter
+open scoped Filter
 
 section Preorder
 
@@ -147,21 +147,29 @@ theorem IsExtrOn.elim {p : Prop} : IsExtrOn f s a → (IsMinOn f s a → p) →
 #align is_extr_on.elim IsExtrOn.elim
 -/
 
+#print isMinOn_iff /-
 theorem isMinOn_iff : IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x :=
   Iff.rfl
 #align is_min_on_iff isMinOn_iff
+-/
 
+#print isMaxOn_iff /-
 theorem isMaxOn_iff : IsMaxOn f s a ↔ ∀ x ∈ s, f x ≤ f a :=
   Iff.rfl
 #align is_max_on_iff isMaxOn_iff
+-/
 
+#print isMinOn_univ_iff /-
 theorem isMinOn_univ_iff : IsMinOn f univ a ↔ ∀ x, f a ≤ f x :=
   univ_subset_iff.trans eq_univ_iff_forall
 #align is_min_on_univ_iff isMinOn_univ_iff
+-/
 
+#print isMaxOn_univ_iff /-
 theorem isMaxOn_univ_iff : IsMaxOn f univ a ↔ ∀ x, f x ≤ f a :=
   univ_subset_iff.trans eq_univ_iff_forall
 #align is_max_on_univ_iff isMaxOn_univ_iff
+-/
 
 #print IsMinFilter.tendsto_principal_Ici /-
 theorem IsMinFilter.tendsto_principal_Ici (h : IsMinFilter f l a) : Tendsto f l (𝓟 <| Ici (f a)) :=
@@ -450,30 +458,38 @@ theorem IsExtrOn.comp_antitone (hf : IsExtrOn f s a) {g : β → γ} (hg : Antit
 #align is_extr_on.comp_antitone IsExtrOn.comp_antitone
 -/
 
+#print IsMinFilter.bicomp_mono /-
 theorem IsMinFilter.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMinFilter f l a) {g : α → γ}
     (hg : IsMinFilter g l a) : IsMinFilter (fun x => op (f x) (g x)) l a :=
   mem_of_superset (inter_mem hf hg) fun x ⟨hfx, hgx⟩ => hop hfx hgx
 #align is_min_filter.bicomp_mono IsMinFilter.bicomp_mono
+-/
 
+#print IsMaxFilter.bicomp_mono /-
 theorem IsMaxFilter.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxFilter f l a) {g : α → γ}
     (hg : IsMaxFilter g l a) : IsMaxFilter (fun x => op (f x) (g x)) l a :=
   mem_of_superset (inter_mem hf hg) fun x ⟨hfx, hgx⟩ => hop hfx hgx
 #align is_max_filter.bicomp_mono IsMaxFilter.bicomp_mono
+-/
 
+#print IsMinOn.bicomp_mono /-
 -- No `extr` version because we need `hf` and `hg` to be of the same kind
 theorem IsMinOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMinOn f s a) {g : α → γ}
     (hg : IsMinOn g s a) : IsMinOn (fun x => op (f x) (g x)) s a :=
   hf.bicomp_mono hop hg
 #align is_min_on.bicomp_mono IsMinOn.bicomp_mono
+-/
 
+#print IsMaxOn.bicomp_mono /-
 theorem IsMaxOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxOn f s a) {g : α → γ}
     (hg : IsMaxOn g s a) : IsMaxOn (fun x => op (f x) (g x)) s a :=
   hf.bicomp_mono hop hg
 #align is_max_on.bicomp_mono IsMaxOn.bicomp_mono
+-/
 
 /-! ### Composition with `tendsto` -/
 

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

@@ -147,42 +147,18 @@ theorem IsExtrOn.elim {p : Prop} : IsExtrOn f s a → (IsMinOn f s a → p) →
 #align is_extr_on.elim IsExtrOn.elim
 -/
 
-/- warning: is_min_on_iff -> isMinOn_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, Iff (IsMinOn.{u1, u2} α β _inst_1 f s a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1) (f a) (f x)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, Iff (IsMinOn.{u1, u2} α β _inst_1 f s a) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) (f a) (f x)))
-Case conversion may be inaccurate. Consider using '#align is_min_on_iff isMinOn_iffₓ'. -/
 theorem isMinOn_iff : IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x :=
   Iff.rfl
 #align is_min_on_iff isMinOn_iff
 
-/- warning: is_max_on_iff -> isMaxOn_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, Iff (IsMaxOn.{u1, u2} α β _inst_1 f s a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1) (f x) (f a)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, Iff (IsMaxOn.{u1, u2} α β _inst_1 f s a) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) (f x) (f a)))
-Case conversion may be inaccurate. Consider using '#align is_max_on_iff isMaxOn_iffₓ'. -/
 theorem isMaxOn_iff : IsMaxOn f s a ↔ ∀ x ∈ s, f x ≤ f a :=
   Iff.rfl
 #align is_max_on_iff isMaxOn_iff
 
-/- warning: is_min_on_univ_iff -> isMinOn_univ_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {a : α}, Iff (IsMinOn.{u1, u2} α β _inst_1 f (Set.univ.{u1} α) a) (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1) (f a) (f x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {a : α}, Iff (IsMinOn.{u1, u2} α β _inst_1 f (Set.univ.{u1} α) a) (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) (f a) (f x))
-Case conversion may be inaccurate. Consider using '#align is_min_on_univ_iff isMinOn_univ_iffₓ'. -/
 theorem isMinOn_univ_iff : IsMinOn f univ a ↔ ∀ x, f a ≤ f x :=
   univ_subset_iff.trans eq_univ_iff_forall
 #align is_min_on_univ_iff isMinOn_univ_iff
 
-/- warning: is_max_on_univ_iff -> isMaxOn_univ_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {a : α}, Iff (IsMaxOn.{u1, u2} α β _inst_1 f (Set.univ.{u1} α) a) (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1) (f x) (f a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {a : α}, Iff (IsMaxOn.{u1, u2} α β _inst_1 f (Set.univ.{u1} α) a) (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) (f x) (f a))
-Case conversion may be inaccurate. Consider using '#align is_max_on_univ_iff isMaxOn_univ_iffₓ'. -/
 theorem isMaxOn_univ_iff : IsMaxOn f univ a ↔ ∀ x, f x ≤ f a :=
   univ_subset_iff.trans eq_univ_iff_forall
 #align is_max_on_univ_iff isMaxOn_univ_iff
@@ -333,62 +309,26 @@ alias isExtrOn_dual_iff ↔ IsExtrOn.undual IsExtrOn.dual
 /-! ### Operations on the filter/set -/
 
 
-/- warning: is_min_filter.filter_mono -> IsMinFilter.filter_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsMinFilter.{u1, u2} α β _inst_1 f l' a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l' l) -> (IsMinFilter.{u1, u2} α β _inst_1 f l' a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.filter_mono IsMinFilter.filter_monoₓ'. -/
 theorem IsMinFilter.filter_mono (h : IsMinFilter f l a) (hl : l' ≤ l) : IsMinFilter f l' a :=
   hl h
 #align is_min_filter.filter_mono IsMinFilter.filter_mono
 
-/- warning: is_max_filter.filter_mono -> IsMaxFilter.filter_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l' a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l' l) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l' a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.filter_mono IsMaxFilter.filter_monoₓ'. -/
 theorem IsMaxFilter.filter_mono (h : IsMaxFilter f l a) (hl : l' ≤ l) : IsMaxFilter f l' a :=
   hl h
 #align is_max_filter.filter_mono IsMaxFilter.filter_mono
 
-/- warning: is_extr_filter.filter_mono -> IsExtrFilter.filter_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsExtrFilter.{u1, u2} α β _inst_1 f l' a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l' l) -> (IsExtrFilter.{u1, u2} α β _inst_1 f l' a)
-Case conversion may be inaccurate. Consider using '#align is_extr_filter.filter_mono IsExtrFilter.filter_monoₓ'. -/
 theorem IsExtrFilter.filter_mono (h : IsExtrFilter f l a) (hl : l' ≤ l) : IsExtrFilter f l' a :=
   h.elim (fun h => (h.filter_mono hl).isExtr) fun h => (h.filter_mono hl).isExtr
 #align is_extr_filter.filter_mono IsExtrFilter.filter_mono
 
-/- warning: is_min_filter.filter_inf -> IsMinFilter.filter_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMinFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMinFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l l') a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.filter_inf IsMinFilter.filter_infₓ'. -/
 theorem IsMinFilter.filter_inf (h : IsMinFilter f l a) (l') : IsMinFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
 #align is_min_filter.filter_inf IsMinFilter.filter_inf
 
-/- warning: is_max_filter.filter_inf -> IsMaxFilter.filter_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMaxFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMaxFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l l') a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.filter_inf IsMaxFilter.filter_infₓ'. -/
 theorem IsMaxFilter.filter_inf (h : IsMaxFilter f l a) (l') : IsMaxFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
 #align is_max_filter.filter_inf IsMaxFilter.filter_inf
 
-/- warning: is_extr_filter.filter_inf -> IsExtrFilter.filter_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsExtrFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsExtrFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l l') a)
-Case conversion may be inaccurate. Consider using '#align is_extr_filter.filter_inf IsExtrFilter.filter_infₓ'. -/
 theorem IsExtrFilter.filter_inf (h : IsExtrFilter f l a) (l') : IsExtrFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
 #align is_extr_filter.filter_inf IsExtrFilter.filter_inf
@@ -411,32 +351,14 @@ theorem IsExtrOn.on_subset (hf : IsExtrOn f t a) (h : s ⊆ t) : IsExtrOn f s a
 #align is_extr_on.on_subset IsExtrOn.on_subset
 -/
 
-/- warning: is_min_on.inter -> IsMinOn.inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, (IsMinOn.{u1, u2} α β _inst_1 f s a) -> (forall (t : Set.{u1} α), IsMinOn.{u1, u2} α β _inst_1 f (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, (IsMinOn.{u1, u2} α β _inst_1 f s a) -> (forall (t : Set.{u1} α), IsMinOn.{u1, u2} α β _inst_1 f (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) a)
-Case conversion may be inaccurate. Consider using '#align is_min_on.inter IsMinOn.interₓ'. -/
 theorem IsMinOn.inter (hf : IsMinOn f s a) (t) : IsMinOn f (s ∩ t) a :=
   hf.on_subset (inter_subset_left s t)
 #align is_min_on.inter IsMinOn.inter
 
-/- warning: is_max_on.inter -> IsMaxOn.inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, (IsMaxOn.{u1, u2} α β _inst_1 f s a) -> (forall (t : Set.{u1} α), IsMaxOn.{u1, u2} α β _inst_1 f (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, (IsMaxOn.{u1, u2} α β _inst_1 f s a) -> (forall (t : Set.{u1} α), IsMaxOn.{u1, u2} α β _inst_1 f (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) a)
-Case conversion may be inaccurate. Consider using '#align is_max_on.inter IsMaxOn.interₓ'. -/
 theorem IsMaxOn.inter (hf : IsMaxOn f s a) (t) : IsMaxOn f (s ∩ t) a :=
   hf.on_subset (inter_subset_left s t)
 #align is_max_on.inter IsMaxOn.inter
 
-/- warning: is_extr_on.inter -> IsExtrOn.inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, (IsExtrOn.{u1, u2} α β _inst_1 f s a) -> (forall (t : Set.{u1} α), IsExtrOn.{u1, u2} α β _inst_1 f (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t) a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, (IsExtrOn.{u1, u2} α β _inst_1 f s a) -> (forall (t : Set.{u1} α), IsExtrOn.{u1, u2} α β _inst_1 f (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t) a)
-Case conversion may be inaccurate. Consider using '#align is_extr_on.inter IsExtrOn.interₓ'. -/
 theorem IsExtrOn.inter (hf : IsExtrOn f s a) (t) : IsExtrOn f (s ∩ t) a :=
   hf.on_subset (inter_subset_left s t)
 #align is_extr_on.inter IsExtrOn.inter
@@ -528,36 +450,18 @@ theorem IsExtrOn.comp_antitone (hf : IsExtrOn f s a) {g : β → γ} (hg : Antit
 #align is_extr_on.comp_antitone IsExtrOn.comp_antitone
 -/
 
-/- warning: is_min_filter.bicomp_mono -> IsMinFilter.bicomp_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {l : Filter.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1)) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ _inst_2)) (LE.le.{u4} δ (Preorder.toHasLe.{u4} δ _inst_3))) op op) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall {g : α -> γ}, (IsMinFilter.{u1, u3} α γ _inst_2 g l a) -> (IsMinFilter.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) l a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {l : Filter.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2557 : β) (x._@.Mathlib.Order.Filter.Extr._hyg.2559 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Extr._hyg.2557 x._@.Mathlib.Order.Filter.Extr._hyg.2559) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2575 : γ) (x._@.Mathlib.Order.Filter.Extr._hyg.2577 : γ) => LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_2) x._@.Mathlib.Order.Filter.Extr._hyg.2575 x._@.Mathlib.Order.Filter.Extr._hyg.2577) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2590 : δ) (x._@.Mathlib.Order.Filter.Extr._hyg.2592 : δ) => LE.le.{u4} δ (Preorder.toLE.{u4} δ _inst_3) x._@.Mathlib.Order.Filter.Extr._hyg.2590 x._@.Mathlib.Order.Filter.Extr._hyg.2592)) op op) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall {g : α -> γ}, (IsMinFilter.{u1, u3} α γ _inst_2 g l a) -> (IsMinFilter.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) l a))
-Case conversion may be inaccurate. Consider using '#align is_min_filter.bicomp_mono IsMinFilter.bicomp_monoₓ'. -/
 theorem IsMinFilter.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMinFilter f l a) {g : α → γ}
     (hg : IsMinFilter g l a) : IsMinFilter (fun x => op (f x) (g x)) l a :=
   mem_of_superset (inter_mem hf hg) fun x ⟨hfx, hgx⟩ => hop hfx hgx
 #align is_min_filter.bicomp_mono IsMinFilter.bicomp_mono
 
-/- warning: is_max_filter.bicomp_mono -> IsMaxFilter.bicomp_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {l : Filter.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1)) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ _inst_2)) (LE.le.{u4} δ (Preorder.toHasLe.{u4} δ _inst_3))) op op) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall {g : α -> γ}, (IsMaxFilter.{u1, u3} α γ _inst_2 g l a) -> (IsMaxFilter.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) l a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {l : Filter.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2707 : β) (x._@.Mathlib.Order.Filter.Extr._hyg.2709 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Extr._hyg.2707 x._@.Mathlib.Order.Filter.Extr._hyg.2709) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2725 : γ) (x._@.Mathlib.Order.Filter.Extr._hyg.2727 : γ) => LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_2) x._@.Mathlib.Order.Filter.Extr._hyg.2725 x._@.Mathlib.Order.Filter.Extr._hyg.2727) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2740 : δ) (x._@.Mathlib.Order.Filter.Extr._hyg.2742 : δ) => LE.le.{u4} δ (Preorder.toLE.{u4} δ _inst_3) x._@.Mathlib.Order.Filter.Extr._hyg.2740 x._@.Mathlib.Order.Filter.Extr._hyg.2742)) op op) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall {g : α -> γ}, (IsMaxFilter.{u1, u3} α γ _inst_2 g l a) -> (IsMaxFilter.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) l a))
-Case conversion may be inaccurate. Consider using '#align is_max_filter.bicomp_mono IsMaxFilter.bicomp_monoₓ'. -/
 theorem IsMaxFilter.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxFilter f l a) {g : α → γ}
     (hg : IsMaxFilter g l a) : IsMaxFilter (fun x => op (f x) (g x)) l a :=
   mem_of_superset (inter_mem hf hg) fun x ⟨hfx, hgx⟩ => hop hfx hgx
 #align is_max_filter.bicomp_mono IsMaxFilter.bicomp_mono
 
-/- warning: is_min_on.bicomp_mono -> IsMinOn.bicomp_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {s : Set.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1)) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ _inst_2)) (LE.le.{u4} δ (Preorder.toHasLe.{u4} δ _inst_3))) op op) -> (IsMinOn.{u1, u2} α β _inst_1 f s a) -> (forall {g : α -> γ}, (IsMinOn.{u1, u3} α γ _inst_2 g s a) -> (IsMinOn.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) s a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {s : Set.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2857 : β) (x._@.Mathlib.Order.Filter.Extr._hyg.2859 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Extr._hyg.2857 x._@.Mathlib.Order.Filter.Extr._hyg.2859) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2875 : γ) (x._@.Mathlib.Order.Filter.Extr._hyg.2877 : γ) => LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_2) x._@.Mathlib.Order.Filter.Extr._hyg.2875 x._@.Mathlib.Order.Filter.Extr._hyg.2877) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2890 : δ) (x._@.Mathlib.Order.Filter.Extr._hyg.2892 : δ) => LE.le.{u4} δ (Preorder.toLE.{u4} δ _inst_3) x._@.Mathlib.Order.Filter.Extr._hyg.2890 x._@.Mathlib.Order.Filter.Extr._hyg.2892)) op op) -> (IsMinOn.{u1, u2} α β _inst_1 f s a) -> (forall {g : α -> γ}, (IsMinOn.{u1, u3} α γ _inst_2 g s a) -> (IsMinOn.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) s a))
-Case conversion may be inaccurate. Consider using '#align is_min_on.bicomp_mono IsMinOn.bicomp_monoₓ'. -/
 -- No `extr` version because we need `hf` and `hg` to be of the same kind
 theorem IsMinOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMinOn f s a) {g : α → γ}
@@ -565,12 +469,6 @@ theorem IsMinOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
   hf.bicomp_mono hop hg
 #align is_min_on.bicomp_mono IsMinOn.bicomp_mono
 
-/- warning: is_max_on.bicomp_mono -> IsMaxOn.bicomp_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {s : Set.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1)) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ _inst_2)) (LE.le.{u4} δ (Preorder.toHasLe.{u4} δ _inst_3))) op op) -> (IsMaxOn.{u1, u2} α β _inst_1 f s a) -> (forall {g : α -> γ}, (IsMaxOn.{u1, u3} α γ _inst_2 g s a) -> (IsMaxOn.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) s a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {s : Set.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2981 : β) (x._@.Mathlib.Order.Filter.Extr._hyg.2983 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Extr._hyg.2981 x._@.Mathlib.Order.Filter.Extr._hyg.2983) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2999 : γ) (x._@.Mathlib.Order.Filter.Extr._hyg.3001 : γ) => LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_2) x._@.Mathlib.Order.Filter.Extr._hyg.2999 x._@.Mathlib.Order.Filter.Extr._hyg.3001) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.3014 : δ) (x._@.Mathlib.Order.Filter.Extr._hyg.3016 : δ) => LE.le.{u4} δ (Preorder.toLE.{u4} δ _inst_3) x._@.Mathlib.Order.Filter.Extr._hyg.3014 x._@.Mathlib.Order.Filter.Extr._hyg.3016)) op op) -> (IsMaxOn.{u1, u2} α β _inst_1 f s a) -> (forall {g : α -> γ}, (IsMaxOn.{u1, u3} α γ _inst_2 g s a) -> (IsMaxOn.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) s a))
-Case conversion may be inaccurate. Consider using '#align is_max_on.bicomp_mono IsMaxOn.bicomp_monoₓ'. -/
 theorem IsMaxOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxOn f s a) {g : α → γ}
     (hg : IsMaxOn g s a) : IsMaxOn (fun x => op (f x) (g x)) s a :=
@@ -652,46 +550,22 @@ section OrderedAddCommMonoid
 
 variable [OrderedAddCommMonoid β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
-/- warning: is_min_filter.add -> IsMinFilter.add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommMonoid.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β (OrderedAddCommMonoid.toAddCommMonoid.{u2} β _inst_1))))) (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommMonoid.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β (OrderedAddCommMonoid.toAddCommMonoid.{u2} β _inst_1))))) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.add IsMinFilter.addₓ'. -/
 theorem IsMinFilter.add (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => f x + g x) l a :=
   show IsMinFilter (fun x => f x + g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => add_le_add hx hy) hg
 #align is_min_filter.add IsMinFilter.add
 
-/- warning: is_max_filter.add -> IsMaxFilter.add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommMonoid.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β (OrderedAddCommMonoid.toAddCommMonoid.{u2} β _inst_1))))) (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommMonoid.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β (OrderedAddCommMonoid.toAddCommMonoid.{u2} β _inst_1))))) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.add IsMaxFilter.addₓ'. -/
 theorem IsMaxFilter.add (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => f x + g x) l a :=
   show IsMaxFilter (fun x => f x + g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => add_le_add hx hy) hg
 #align is_max_filter.add IsMaxFilter.add
 
-/- warning: is_min_on.add -> IsMinOn.add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommMonoid.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β (OrderedAddCommMonoid.toAddCommMonoid.{u2} β _inst_1))))) (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommMonoid.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β (OrderedAddCommMonoid.toAddCommMonoid.{u2} β _inst_1))))) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_min_on.add IsMinOn.addₓ'. -/
 theorem IsMinOn.add (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x + g x) s a :=
   hf.add hg
 #align is_min_on.add IsMinOn.add
 
-/- warning: is_max_on.add -> IsMaxOn.add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommMonoid.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β (OrderedAddCommMonoid.toAddCommMonoid.{u2} β _inst_1))))) (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommMonoid.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommMonoid.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HAdd.hAdd.{u2, u2, u2} β β β (instHAdd.{u2} β (AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (AddCommMonoid.toAddMonoid.{u2} β (OrderedAddCommMonoid.toAddCommMonoid.{u2} β _inst_1))))) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_max_on.add IsMaxOn.addₓ'. -/
 theorem IsMaxOn.add (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x + g x) s a :=
   hf.add hg
 #align is_max_on.add IsMaxOn.add
@@ -705,102 +579,42 @@ section OrderedAddCommGroup
 
 variable [OrderedAddCommGroup β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
-/- warning: is_min_filter.neg -> IsMinFilter.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))) (f x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))))) (f x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.neg IsMinFilter.negₓ'. -/
 theorem IsMinFilter.neg (hf : IsMinFilter f l a) : IsMaxFilter (fun x => -f x) l a :=
   hf.comp_antitone fun x y hx => neg_le_neg hx
 #align is_min_filter.neg IsMinFilter.neg
 
-/- warning: is_max_filter.neg -> IsMaxFilter.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))) (f x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))))) (f x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.neg IsMaxFilter.negₓ'. -/
 theorem IsMaxFilter.neg (hf : IsMaxFilter f l a) : IsMinFilter (fun x => -f x) l a :=
   hf.comp_antitone fun x y hx => neg_le_neg hx
 #align is_max_filter.neg IsMaxFilter.neg
 
-/- warning: is_extr_filter.neg -> IsExtrFilter.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {l : Filter.{u1} α}, (IsExtrFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsExtrFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))) (f x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {l : Filter.{u1} α}, (IsExtrFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsExtrFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))))) (f x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_extr_filter.neg IsExtrFilter.negₓ'. -/
 theorem IsExtrFilter.neg (hf : IsExtrFilter f l a) : IsExtrFilter (fun x => -f x) l a :=
   hf.elim (fun hf => hf.neg.isExtr) fun hf => hf.neg.isExtr
 #align is_extr_filter.neg IsExtrFilter.neg
 
-/- warning: is_min_on.neg -> IsMinOn.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))) (f x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))))) (f x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_min_on.neg IsMinOn.negₓ'. -/
 theorem IsMinOn.neg (hf : IsMinOn f s a) : IsMaxOn (fun x => -f x) s a :=
   hf.comp_antitone fun x y hx => neg_le_neg hx
 #align is_min_on.neg IsMinOn.neg
 
-/- warning: is_max_on.neg -> IsMaxOn.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))) (f x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))))) (f x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_max_on.neg IsMaxOn.negₓ'. -/
 theorem IsMaxOn.neg (hf : IsMaxOn f s a) : IsMinOn (fun x => -f x) s a :=
   hf.comp_antitone fun x y hx => neg_le_neg hx
 #align is_max_on.neg IsMaxOn.neg
 
-/- warning: is_extr_on.neg -> IsExtrOn.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {s : Set.{u1} α}, (IsExtrOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsExtrOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))) (f x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {a : α} {s : Set.{u1} α}, (IsExtrOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsExtrOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Neg.neg.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))))) (f x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_extr_on.neg IsExtrOn.negₓ'. -/
 theorem IsExtrOn.neg (hf : IsExtrOn f s a) : IsExtrOn (fun x => -f x) s a :=
   hf.elim (fun hf => hf.neg.isExtr) fun hf => hf.neg.isExtr
 #align is_extr_on.neg IsExtrOn.neg
 
-/- warning: is_min_filter.sub -> IsMinFilter.sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β (SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))) (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β (SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.sub IsMinFilter.subₓ'. -/
 theorem IsMinFilter.sub (hf : IsMinFilter f l a) (hg : IsMaxFilter g l a) :
     IsMinFilter (fun x => f x - g x) l a := by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_min_filter.sub IsMinFilter.sub
 
-/- warning: is_max_filter.sub -> IsMaxFilter.sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β (SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))) (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β (SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.sub IsMaxFilter.subₓ'. -/
 theorem IsMaxFilter.sub (hf : IsMaxFilter f l a) (hg : IsMinFilter g l a) :
     IsMaxFilter (fun x => f x - g x) l a := by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_max_filter.sub IsMaxFilter.sub
 
-/- warning: is_min_on.sub -> IsMinOn.sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β (SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))) (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β (SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_min_on.sub IsMinOn.subₓ'. -/
 theorem IsMinOn.sub (hf : IsMinOn f s a) (hg : IsMaxOn g s a) : IsMinOn (fun x => f x - g x) s a :=
   by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_min_on.sub IsMinOn.sub
 
-/- warning: is_max_on.sub -> IsMaxOn.sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β (SubNegMonoid.toHasSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))) (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : OrderedAddCommGroup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (OrderedAddCommGroup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => HSub.hSub.{u2, u2, u2} β β β (instHSub.{u2} β (SubNegMonoid.toSub.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_max_on.sub IsMaxOn.subₓ'. -/
 theorem IsMaxOn.sub (hf : IsMaxOn f s a) (hg : IsMinOn g s a) : IsMaxOn (fun x => f x - g x) s a :=
   by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_max_on.sub IsMaxOn.sub
@@ -814,46 +628,22 @@ section SemilatticeSup
 
 variable [SemilatticeSup β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
-/- warning: is_min_filter.sup -> IsMinFilter.sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β _inst_1) (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β _inst_1) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.sup IsMinFilter.supₓ'. -/
 theorem IsMinFilter.sup (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => f x ⊔ g x) l a :=
   show IsMinFilter (fun x => f x ⊔ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => sup_le_sup hx hy) hg
 #align is_min_filter.sup IsMinFilter.sup
 
-/- warning: is_max_filter.sup -> IsMaxFilter.sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β _inst_1) (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β _inst_1) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.sup IsMaxFilter.supₓ'. -/
 theorem IsMaxFilter.sup (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => f x ⊔ g x) l a :=
   show IsMaxFilter (fun x => f x ⊔ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => sup_le_sup hx hy) hg
 #align is_max_filter.sup IsMaxFilter.sup
 
-/- warning: is_min_on.sup -> IsMinOn.sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β _inst_1) (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β _inst_1) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_min_on.sup IsMinOn.supₓ'. -/
 theorem IsMinOn.sup (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊔ g x) s a :=
   hf.sup hg
 #align is_min_on.sup IsMinOn.sup
 
-/- warning: is_max_on.sup -> IsMaxOn.sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β _inst_1) (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β _inst_1) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_max_on.sup IsMaxOn.supₓ'. -/
 theorem IsMaxOn.sup (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊔ g x) s a :=
   hf.sup hg
 #align is_max_on.sup IsMaxOn.sup
@@ -864,46 +654,22 @@ section SemilatticeInf
 
 variable [SemilatticeInf β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
-/- warning: is_min_filter.inf -> IsMinFilter.inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β _inst_1) (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toInf.{u2} β _inst_1) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.inf IsMinFilter.infₓ'. -/
 theorem IsMinFilter.inf (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => f x ⊓ g x) l a :=
   show IsMinFilter (fun x => f x ⊓ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => inf_le_inf hx hy) hg
 #align is_min_filter.inf IsMinFilter.inf
 
-/- warning: is_max_filter.inf -> IsMaxFilter.inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β _inst_1) (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toInf.{u2} β _inst_1) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.inf IsMaxFilter.infₓ'. -/
 theorem IsMaxFilter.inf (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => f x ⊓ g x) l a :=
   show IsMaxFilter (fun x => f x ⊓ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => inf_le_inf hx hy) hg
 #align is_max_filter.inf IsMaxFilter.inf
 
-/- warning: is_min_on.inf -> IsMinOn.inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β _inst_1) (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toInf.{u2} β _inst_1) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_min_on.inf IsMinOn.infₓ'. -/
 theorem IsMinOn.inf (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊓ g x) s a :=
   hf.inf hg
 #align is_min_on.inf IsMinOn.inf
 
-/- warning: is_max_on.inf -> IsMaxOn.inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β _inst_1) (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toInf.{u2} β _inst_1) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_max_on.inf IsMaxOn.infₓ'. -/
 theorem IsMaxOn.inf (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊓ g x) s a :=
   hf.inf hg
 #align is_max_on.inf IsMaxOn.inf
@@ -917,93 +683,45 @@ section LinearOrder
 
 variable [LinearOrder β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
-/- warning: is_min_filter.min -> IsMinFilter.min is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) (fun (x : α) => LinearOrder.min.{u2} β _inst_1 (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) (fun (x : α) => Min.min.{u2} β (LinearOrder.toMin.{u2} β _inst_1) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.min IsMinFilter.minₓ'. -/
 theorem IsMinFilter.min (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => min (f x) (g x)) l a :=
   show IsMinFilter (fun x => min (f x) (g x)) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => min_le_min hx hy) hg
 #align is_min_filter.min IsMinFilter.min
 
-/- warning: is_max_filter.min -> IsMaxFilter.min is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) (fun (x : α) => LinearOrder.min.{u2} β _inst_1 (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) (fun (x : α) => Min.min.{u2} β (LinearOrder.toMin.{u2} β _inst_1) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.min IsMaxFilter.minₓ'. -/
 theorem IsMaxFilter.min (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => min (f x) (g x)) l a :=
   show IsMaxFilter (fun x => min (f x) (g x)) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => min_le_min hx hy) hg
 #align is_max_filter.min IsMaxFilter.min
 
-/- warning: is_min_on.min -> IsMinOn.min is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) (fun (x : α) => LinearOrder.min.{u2} β _inst_1 (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) (fun (x : α) => Min.min.{u2} β (LinearOrder.toMin.{u2} β _inst_1) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_min_on.min IsMinOn.minₓ'. -/
 theorem IsMinOn.min (hf : IsMinOn f s a) (hg : IsMinOn g s a) :
     IsMinOn (fun x => min (f x) (g x)) s a :=
   hf.min hg
 #align is_min_on.min IsMinOn.min
 
-/- warning: is_max_on.min -> IsMaxOn.min is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) (fun (x : α) => LinearOrder.min.{u2} β _inst_1 (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) (fun (x : α) => Min.min.{u2} β (LinearOrder.toMin.{u2} β _inst_1) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_max_on.min IsMaxOn.minₓ'. -/
 theorem IsMaxOn.min (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) :
     IsMaxOn (fun x => min (f x) (g x)) s a :=
   hf.min hg
 #align is_max_on.min IsMaxOn.min
 
-/- warning: is_min_filter.max -> IsMinFilter.max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) (fun (x : α) => LinearOrder.max.{u2} β _inst_1 (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) (fun (x : α) => Max.max.{u2} β (LinearOrder.toMax.{u2} β _inst_1) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.max IsMinFilter.maxₓ'. -/
 theorem IsMinFilter.max (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => max (f x) (g x)) l a :=
   show IsMinFilter (fun x => max (f x) (g x)) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => max_le_max hx hy) hg
 #align is_min_filter.max IsMinFilter.max
 
-/- warning: is_max_filter.max -> IsMaxFilter.max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) (fun (x : α) => LinearOrder.max.{u2} β _inst_1 (f x) (g x)) l a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) (fun (x : α) => Max.max.{u2} β (LinearOrder.toMax.{u2} β _inst_1) (f x) (g x)) l a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.max IsMaxFilter.maxₓ'. -/
 theorem IsMaxFilter.max (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => max (f x) (g x)) l a :=
   show IsMaxFilter (fun x => max (f x) (g x)) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => max_le_max hx hy) hg
 #align is_max_filter.max IsMaxFilter.max
 
-/- warning: is_min_on.max -> IsMinOn.max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) (fun (x : α) => LinearOrder.max.{u2} β _inst_1 (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) (fun (x : α) => Max.max.{u2} β (LinearOrder.toMax.{u2} β _inst_1) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_min_on.max IsMinOn.maxₓ'. -/
 theorem IsMinOn.max (hf : IsMinOn f s a) (hg : IsMinOn g s a) :
     IsMinOn (fun x => max (f x) (g x)) s a :=
   hf.max hg
 #align is_min_on.max IsMinOn.max
 
-/- warning: is_max_on.max -> IsMaxOn.max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_1)))) (fun (x : α) => LinearOrder.max.{u2} β _inst_1 (f x) (g x)) s a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β _inst_1))))) (fun (x : α) => Max.max.{u2} β (LinearOrder.toMax.{u2} β _inst_1) (f x) (g x)) s a)
-Case conversion may be inaccurate. Consider using '#align is_max_on.max IsMaxOn.maxₓ'. -/
 theorem IsMaxOn.max (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) :
     IsMaxOn (fun x => max (f x) (g x)) s a :=
   hf.max hg
@@ -1016,12 +734,6 @@ section Eventually
 /-! ### Relation with `eventually` comparisons of two functions -/
 
 
-/- warning: filter.eventually_le.is_max_filter -> Filter.EventuallyLE.isMaxFilter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l g f) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (IsMaxFilter.{u1, u2} α β _inst_1 g l a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β _inst_1) l g f) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMaxFilter.{u2, u1} α β _inst_1 f l a) -> (IsMaxFilter.{u2, u1} α β _inst_1 g l a)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.is_max_filter Filter.EventuallyLE.isMaxFilterₓ'. -/
 theorem Filter.EventuallyLE.isMaxFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : g ≤ᶠ[l] f) (hfga : f a = g a) (h : IsMaxFilter f l a) :
     IsMaxFilter g l a := by
@@ -1030,68 +742,32 @@ theorem Filter.EventuallyLE.isMaxFilter {α β : Type _} [Preorder β] {f g : α
   exact le_trans hgf hf
 #align filter.eventually_le.is_max_filter Filter.EventuallyLE.isMaxFilter
 
-/- warning: is_max_filter.congr -> IsMaxFilter.congr is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMaxFilter.{u1, u2} α β _inst_1 g l a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (IsMaxFilter.{u2, u1} α β _inst_1 f l a) -> (Filter.EventuallyEq.{u2, u1} α β l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMaxFilter.{u2, u1} α β _inst_1 g l a)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.congr IsMaxFilter.congrₓ'. -/
 theorem IsMaxFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsMaxFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter g l a :=
   HEq.symm.le.IsMaxFilter hfga h
 #align is_max_filter.congr IsMaxFilter.congr
 
-/- warning: filter.eventually_eq.is_max_filter_iff -> Filter.EventuallyEq.isMaxFilter_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (Iff (IsMaxFilter.{u1, u2} α β _inst_1 f l a) (IsMaxFilter.{u1, u2} α β _inst_1 g l a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyEq.{u2, u1} α β l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (Iff (IsMaxFilter.{u2, u1} α β _inst_1 f l a) (IsMaxFilter.{u2, u1} α β _inst_1 g l a))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.is_max_filter_iff Filter.EventuallyEq.isMaxFilter_iffₓ'. -/
 theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter f l a ↔ IsMaxFilter g l a :=
   ⟨fun h => h.congr HEq hfga, fun h => h.congr HEq.symm hfga.symm⟩
 #align filter.eventually_eq.is_max_filter_iff Filter.EventuallyEq.isMaxFilter_iff
 
-/- warning: filter.eventually_le.is_min_filter -> Filter.EventuallyLE.isMinFilter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (IsMinFilter.{u1, u2} α β _inst_1 g l a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β _inst_1) l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMinFilter.{u2, u1} α β _inst_1 f l a) -> (IsMinFilter.{u2, u1} α β _inst_1 g l a)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.is_min_filter Filter.EventuallyLE.isMinFilterₓ'. -/
 theorem Filter.EventuallyLE.isMinFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : f ≤ᶠ[l] g) (hfga : f a = g a) (h : IsMinFilter f l a) :
     IsMinFilter g l a :=
   @Filter.EventuallyLE.isMaxFilter _ βᵒᵈ _ _ _ _ _ hle hfga h
 #align filter.eventually_le.is_min_filter Filter.EventuallyLE.isMinFilter
 
-/- warning: is_min_filter.congr -> IsMinFilter.congr is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMinFilter.{u1, u2} α β _inst_1 g l a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (IsMinFilter.{u2, u1} α β _inst_1 f l a) -> (Filter.EventuallyEq.{u2, u1} α β l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMinFilter.{u2, u1} α β _inst_1 g l a)
-Case conversion may be inaccurate. Consider using '#align is_min_filter.congr IsMinFilter.congrₓ'. -/
 theorem IsMinFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsMinFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter g l a :=
   HEq.le.IsMinFilter hfga h
 #align is_min_filter.congr IsMinFilter.congr
 
-/- warning: filter.eventually_eq.is_min_filter_iff -> Filter.EventuallyEq.isMinFilter_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (Iff (IsMinFilter.{u1, u2} α β _inst_1 f l a) (IsMinFilter.{u1, u2} α β _inst_1 g l a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyEq.{u2, u1} α β l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (Iff (IsMinFilter.{u2, u1} α β _inst_1 f l a) (IsMinFilter.{u2, u1} α β _inst_1 g l a))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.is_min_filter_iff Filter.EventuallyEq.isMinFilter_iffₓ'. -/
 theorem Filter.EventuallyEq.isMinFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter f l a ↔ IsMinFilter g l a :=
   ⟨fun h => h.congr HEq hfga, fun h => h.congr HEq.symm hfga.symm⟩
 #align filter.eventually_eq.is_min_filter_iff Filter.EventuallyEq.isMinFilter_iff
 
-/- warning: is_extr_filter.congr -> IsExtrFilter.congr is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (IsExtrFilter.{u1, u2} α β _inst_1 g l a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (IsExtrFilter.{u2, u1} α β _inst_1 f l a) -> (Filter.EventuallyEq.{u2, u1} α β l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (IsExtrFilter.{u2, u1} α β _inst_1 g l a)
-Case conversion may be inaccurate. Consider using '#align is_extr_filter.congr IsExtrFilter.congrₓ'. -/
 theorem IsExtrFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsExtrFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsExtrFilter g l a :=
   by
@@ -1099,12 +775,6 @@ theorem IsExtrFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a :
   rwa [← heq.is_max_filter_iff hfga, ← heq.is_min_filter_iff hfga]
 #align is_extr_filter.congr IsExtrFilter.congr
 
-/- warning: filter.eventually_eq.is_extr_filter_iff -> Filter.EventuallyEq.isExtrFilter_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyEq.{u1, u2} α β l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (Iff (IsExtrFilter.{u1, u2} α β _inst_1 f l a) (IsExtrFilter.{u1, u2} α β _inst_1 g l a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyEq.{u2, u1} α β l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (Iff (IsExtrFilter.{u2, u1} α β _inst_1 f l a) (IsExtrFilter.{u2, u1} α β _inst_1 g l a))
-Case conversion may be inaccurate. Consider using '#align filter.eventually_eq.is_extr_filter_iff Filter.EventuallyEq.isExtrFilter_iffₓ'. -/
 theorem Filter.EventuallyEq.isExtrFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsExtrFilter f l a ↔ IsExtrFilter g l a :=
   ⟨fun h => h.congr HEq hfga, fun h => h.congr HEq.symm hfga.symm⟩
@@ -1119,23 +789,11 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {f : β → α} {s : Set β} {x₀ : β}
 
-/- warning: is_max_on.supr_eq -> IsMaxOn.iSup_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x₀ s) -> (IsMaxOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (iSup.{u1, succ u2} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) (fun (x : coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) => f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x s))))) x))) (f x₀))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x₀ s) -> (IsMaxOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (iSup.{u1, succ u2} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.Elem.{u2} β s) (fun (x : Set.Elem.{u2} β s) => f (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x s) x))) (f x₀))
-Case conversion may be inaccurate. Consider using '#align is_max_on.supr_eq IsMaxOn.iSup_eqₓ'. -/
 theorem IsMaxOn.iSup_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : (⨆ x : s, f x) = f x₀ :=
   haveI : Nonempty s := ⟨⟨x₀, hx₀⟩⟩
   ciSup_eq_of_forall_le_of_forall_lt_exists_gt (fun x => h x.Prop) fun w hw => ⟨⟨x₀, hx₀⟩, hw⟩
 #align is_max_on.supr_eq IsMaxOn.iSup_eq
 
-/- warning: is_min_on.infi_eq -> IsMinOn.iInf_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x₀ s) -> (IsMinOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (iInf.{u1, succ u2} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) (fun (x : coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) => f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x s))))) x))) (f x₀))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x₀ s) -> (IsMinOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (iInf.{u1, succ u2} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.Elem.{u2} β s) (fun (x : Set.Elem.{u2} β s) => f (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x s) x))) (f x₀))
-Case conversion may be inaccurate. Consider using '#align is_min_on.infi_eq IsMinOn.iInf_eqₓ'. -/
 theorem IsMinOn.iInf_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : (⨅ x : s, f x) = f x₀ :=
   @IsMaxOn.iSup_eq αᵒᵈ β _ _ _ _ hx₀ h
 #align is_min_on.infi_eq IsMinOn.iInf_eq

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

@@ -147,29 +147,45 @@ theorem IsExtrOn.elim {p : Prop} : IsExtrOn f s a → (IsMinOn f s a → p) →
 #align is_extr_on.elim IsExtrOn.elim
 -/
 
-#print isMinOn_iff /-
+/- warning: is_min_on_iff -> isMinOn_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, Iff (IsMinOn.{u1, u2} α β _inst_1 f s a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1) (f a) (f x)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, Iff (IsMinOn.{u1, u2} α β _inst_1 f s a) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) (f a) (f x)))
+Case conversion may be inaccurate. Consider using '#align is_min_on_iff isMinOn_iffₓ'. -/
 theorem isMinOn_iff : IsMinOn f s a ↔ ∀ x ∈ s, f a ≤ f x :=
   Iff.rfl
 #align is_min_on_iff isMinOn_iff
--/
 
-#print isMaxOn_iff /-
+/- warning: is_max_on_iff -> isMaxOn_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, Iff (IsMaxOn.{u1, u2} α β _inst_1 f s a) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1) (f x) (f a)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α} {a : α}, Iff (IsMaxOn.{u1, u2} α β _inst_1 f s a) (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) (f x) (f a)))
+Case conversion may be inaccurate. Consider using '#align is_max_on_iff isMaxOn_iffₓ'. -/
 theorem isMaxOn_iff : IsMaxOn f s a ↔ ∀ x ∈ s, f x ≤ f a :=
   Iff.rfl
 #align is_max_on_iff isMaxOn_iff
--/
 
-#print isMinOn_univ_iff /-
+/- warning: is_min_on_univ_iff -> isMinOn_univ_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {a : α}, Iff (IsMinOn.{u1, u2} α β _inst_1 f (Set.univ.{u1} α) a) (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1) (f a) (f x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {a : α}, Iff (IsMinOn.{u1, u2} α β _inst_1 f (Set.univ.{u1} α) a) (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) (f a) (f x))
+Case conversion may be inaccurate. Consider using '#align is_min_on_univ_iff isMinOn_univ_iffₓ'. -/
 theorem isMinOn_univ_iff : IsMinOn f univ a ↔ ∀ x, f a ≤ f x :=
   univ_subset_iff.trans eq_univ_iff_forall
 #align is_min_on_univ_iff isMinOn_univ_iff
--/
 
-#print isMaxOn_univ_iff /-
+/- warning: is_max_on_univ_iff -> isMaxOn_univ_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {a : α}, Iff (IsMaxOn.{u1, u2} α β _inst_1 f (Set.univ.{u1} α) a) (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1) (f x) (f a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {a : α}, Iff (IsMaxOn.{u1, u2} α β _inst_1 f (Set.univ.{u1} α) a) (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) (f x) (f a))
+Case conversion may be inaccurate. Consider using '#align is_max_on_univ_iff isMaxOn_univ_iffₓ'. -/
 theorem isMaxOn_univ_iff : IsMaxOn f univ a ↔ ∀ x, f x ≤ f a :=
   univ_subset_iff.trans eq_univ_iff_forall
 #align is_max_on_univ_iff isMaxOn_univ_iff
--/
 
 #print IsMinFilter.tendsto_principal_Ici /-
 theorem IsMinFilter.tendsto_principal_Ici (h : IsMinFilter f l a) : Tendsto f l (𝓟 <| Ici (f a)) :=
@@ -319,7 +335,7 @@ alias isExtrOn_dual_iff ↔ IsExtrOn.undual IsExtrOn.dual
 
 /- warning: is_min_filter.filter_mono -> IsMinFilter.filter_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsMinFilter.{u1, u2} α β _inst_1 f l' a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsMinFilter.{u1, u2} α β _inst_1 f l' a)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l' l) -> (IsMinFilter.{u1, u2} α β _inst_1 f l' a)
 Case conversion may be inaccurate. Consider using '#align is_min_filter.filter_mono IsMinFilter.filter_monoₓ'. -/
@@ -329,7 +345,7 @@ theorem IsMinFilter.filter_mono (h : IsMinFilter f l a) (hl : l' ≤ l) : IsMinF
 
 /- warning: is_max_filter.filter_mono -> IsMaxFilter.filter_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l' a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l' a)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l' l) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l' a)
 Case conversion may be inaccurate. Consider using '#align is_max_filter.filter_mono IsMaxFilter.filter_monoₓ'. -/
@@ -339,7 +355,7 @@ theorem IsMaxFilter.filter_mono (h : IsMaxFilter f l a) (hl : l' ≤ l) : IsMaxF
 
 /- warning: is_extr_filter.filter_mono -> IsExtrFilter.filter_mono is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsExtrFilter.{u1, u2} α β _inst_1 f l' a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toHasLe.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.partialOrder.{u1} α))) l' l) -> (IsExtrFilter.{u1, u2} α β _inst_1 f l' a)
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α} {l' : Filter.{u1} α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (LE.le.{u1} (Filter.{u1} α) (Preorder.toLE.{u1} (Filter.{u1} α) (PartialOrder.toPreorder.{u1} (Filter.{u1} α) (Filter.instPartialOrderFilter.{u1} α))) l' l) -> (IsExtrFilter.{u1, u2} α β _inst_1 f l' a)
 Case conversion may be inaccurate. Consider using '#align is_extr_filter.filter_mono IsExtrFilter.filter_monoₓ'. -/
@@ -512,38 +528,54 @@ theorem IsExtrOn.comp_antitone (hf : IsExtrOn f s a) {g : β → γ} (hg : Antit
 #align is_extr_on.comp_antitone IsExtrOn.comp_antitone
 -/
 
-#print IsMinFilter.bicomp_mono /-
+/- warning: is_min_filter.bicomp_mono -> IsMinFilter.bicomp_mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {l : Filter.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1)) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ _inst_2)) (LE.le.{u4} δ (Preorder.toHasLe.{u4} δ _inst_3))) op op) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall {g : α -> γ}, (IsMinFilter.{u1, u3} α γ _inst_2 g l a) -> (IsMinFilter.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) l a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {l : Filter.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2557 : β) (x._@.Mathlib.Order.Filter.Extr._hyg.2559 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Extr._hyg.2557 x._@.Mathlib.Order.Filter.Extr._hyg.2559) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2575 : γ) (x._@.Mathlib.Order.Filter.Extr._hyg.2577 : γ) => LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_2) x._@.Mathlib.Order.Filter.Extr._hyg.2575 x._@.Mathlib.Order.Filter.Extr._hyg.2577) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2590 : δ) (x._@.Mathlib.Order.Filter.Extr._hyg.2592 : δ) => LE.le.{u4} δ (Preorder.toLE.{u4} δ _inst_3) x._@.Mathlib.Order.Filter.Extr._hyg.2590 x._@.Mathlib.Order.Filter.Extr._hyg.2592)) op op) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall {g : α -> γ}, (IsMinFilter.{u1, u3} α γ _inst_2 g l a) -> (IsMinFilter.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) l a))
+Case conversion may be inaccurate. Consider using '#align is_min_filter.bicomp_mono IsMinFilter.bicomp_monoₓ'. -/
 theorem IsMinFilter.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMinFilter f l a) {g : α → γ}
     (hg : IsMinFilter g l a) : IsMinFilter (fun x => op (f x) (g x)) l a :=
   mem_of_superset (inter_mem hf hg) fun x ⟨hfx, hgx⟩ => hop hfx hgx
 #align is_min_filter.bicomp_mono IsMinFilter.bicomp_mono
--/
 
-#print IsMaxFilter.bicomp_mono /-
+/- warning: is_max_filter.bicomp_mono -> IsMaxFilter.bicomp_mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {l : Filter.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1)) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ _inst_2)) (LE.le.{u4} δ (Preorder.toHasLe.{u4} δ _inst_3))) op op) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall {g : α -> γ}, (IsMaxFilter.{u1, u3} α γ _inst_2 g l a) -> (IsMaxFilter.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) l a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {l : Filter.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2707 : β) (x._@.Mathlib.Order.Filter.Extr._hyg.2709 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Extr._hyg.2707 x._@.Mathlib.Order.Filter.Extr._hyg.2709) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2725 : γ) (x._@.Mathlib.Order.Filter.Extr._hyg.2727 : γ) => LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_2) x._@.Mathlib.Order.Filter.Extr._hyg.2725 x._@.Mathlib.Order.Filter.Extr._hyg.2727) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2740 : δ) (x._@.Mathlib.Order.Filter.Extr._hyg.2742 : δ) => LE.le.{u4} δ (Preorder.toLE.{u4} δ _inst_3) x._@.Mathlib.Order.Filter.Extr._hyg.2740 x._@.Mathlib.Order.Filter.Extr._hyg.2742)) op op) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall {g : α -> γ}, (IsMaxFilter.{u1, u3} α γ _inst_2 g l a) -> (IsMaxFilter.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) l a))
+Case conversion may be inaccurate. Consider using '#align is_max_filter.bicomp_mono IsMaxFilter.bicomp_monoₓ'. -/
 theorem IsMaxFilter.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxFilter f l a) {g : α → γ}
     (hg : IsMaxFilter g l a) : IsMaxFilter (fun x => op (f x) (g x)) l a :=
   mem_of_superset (inter_mem hf hg) fun x ⟨hfx, hgx⟩ => hop hfx hgx
 #align is_max_filter.bicomp_mono IsMaxFilter.bicomp_mono
--/
 
-#print IsMinOn.bicomp_mono /-
+/- warning: is_min_on.bicomp_mono -> IsMinOn.bicomp_mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {s : Set.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1)) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ _inst_2)) (LE.le.{u4} δ (Preorder.toHasLe.{u4} δ _inst_3))) op op) -> (IsMinOn.{u1, u2} α β _inst_1 f s a) -> (forall {g : α -> γ}, (IsMinOn.{u1, u3} α γ _inst_2 g s a) -> (IsMinOn.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) s a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {s : Set.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2857 : β) (x._@.Mathlib.Order.Filter.Extr._hyg.2859 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Extr._hyg.2857 x._@.Mathlib.Order.Filter.Extr._hyg.2859) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2875 : γ) (x._@.Mathlib.Order.Filter.Extr._hyg.2877 : γ) => LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_2) x._@.Mathlib.Order.Filter.Extr._hyg.2875 x._@.Mathlib.Order.Filter.Extr._hyg.2877) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2890 : δ) (x._@.Mathlib.Order.Filter.Extr._hyg.2892 : δ) => LE.le.{u4} δ (Preorder.toLE.{u4} δ _inst_3) x._@.Mathlib.Order.Filter.Extr._hyg.2890 x._@.Mathlib.Order.Filter.Extr._hyg.2892)) op op) -> (IsMinOn.{u1, u2} α β _inst_1 f s a) -> (forall {g : α -> γ}, (IsMinOn.{u1, u3} α γ _inst_2 g s a) -> (IsMinOn.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) s a))
+Case conversion may be inaccurate. Consider using '#align is_min_on.bicomp_mono IsMinOn.bicomp_monoₓ'. -/
 -- No `extr` version because we need `hf` and `hg` to be of the same kind
 theorem IsMinOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMinOn f s a) {g : α → γ}
     (hg : IsMinOn g s a) : IsMinOn (fun x => op (f x) (g x)) s a :=
   hf.bicomp_mono hop hg
 #align is_min_on.bicomp_mono IsMinOn.bicomp_mono
--/
 
-#print IsMaxOn.bicomp_mono /-
+/- warning: is_max_on.bicomp_mono -> IsMaxOn.bicomp_mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {s : Set.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_1)) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (LE.le.{u3} γ (Preorder.toHasLe.{u3} γ _inst_2)) (LE.le.{u4} δ (Preorder.toHasLe.{u4} δ _inst_3))) op op) -> (IsMaxOn.{u1, u2} α β _inst_1 f s a) -> (forall {g : α -> γ}, (IsMaxOn.{u1, u3} α γ _inst_2 g s a) -> (IsMaxOn.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) s a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u2} β] [_inst_2 : Preorder.{u3} γ] {f : α -> β} {s : Set.{u1} α} {a : α} [_inst_3 : Preorder.{u4} δ] {op : β -> γ -> δ}, (Relator.LiftFun.{succ u2, succ u2, max (succ u3) (succ u4), max (succ u3) (succ u4)} β β (γ -> δ) (γ -> δ) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2981 : β) (x._@.Mathlib.Order.Filter.Extr._hyg.2983 : β) => LE.le.{u2} β (Preorder.toLE.{u2} β _inst_1) x._@.Mathlib.Order.Filter.Extr._hyg.2981 x._@.Mathlib.Order.Filter.Extr._hyg.2983) (Relator.LiftFun.{succ u3, succ u3, succ u4, succ u4} γ γ δ δ (fun (x._@.Mathlib.Order.Filter.Extr._hyg.2999 : γ) (x._@.Mathlib.Order.Filter.Extr._hyg.3001 : γ) => LE.le.{u3} γ (Preorder.toLE.{u3} γ _inst_2) x._@.Mathlib.Order.Filter.Extr._hyg.2999 x._@.Mathlib.Order.Filter.Extr._hyg.3001) (fun (x._@.Mathlib.Order.Filter.Extr._hyg.3014 : δ) (x._@.Mathlib.Order.Filter.Extr._hyg.3016 : δ) => LE.le.{u4} δ (Preorder.toLE.{u4} δ _inst_3) x._@.Mathlib.Order.Filter.Extr._hyg.3014 x._@.Mathlib.Order.Filter.Extr._hyg.3016)) op op) -> (IsMaxOn.{u1, u2} α β _inst_1 f s a) -> (forall {g : α -> γ}, (IsMaxOn.{u1, u3} α γ _inst_2 g s a) -> (IsMaxOn.{u1, u4} α δ _inst_3 (fun (x : α) => op (f x) (g x)) s a))
+Case conversion may be inaccurate. Consider using '#align is_max_on.bicomp_mono IsMaxOn.bicomp_monoₓ'. -/
 theorem IsMaxOn.bicomp_mono [Preorder δ] {op : β → γ → δ}
     (hop : ((· ≤ ·) ⇒ (· ≤ ·) ⇒ (· ≤ ·)) op op) (hf : IsMaxOn f s a) {g : α → γ}
     (hg : IsMaxOn g s a) : IsMaxOn (fun x => op (f x) (g x)) s a :=
   hf.bicomp_mono hop hg
 #align is_max_on.bicomp_mono IsMaxOn.bicomp_mono
--/
 
 /-! ### Composition with `tendsto` -/
 
@@ -986,7 +1018,7 @@ section Eventually
 
 /- warning: filter.eventually_le.is_max_filter -> Filter.EventuallyLE.isMaxFilter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l g f) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (IsMaxFilter.{u1, u2} α β _inst_1 g l a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l g f) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (IsMaxFilter.{u1, u2} α β _inst_1 g l a)
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β _inst_1) l g f) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMaxFilter.{u2, u1} α β _inst_1 f l a) -> (IsMaxFilter.{u2, u1} α β _inst_1 g l a)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.is_max_filter Filter.EventuallyLE.isMaxFilterₓ'. -/
@@ -1022,7 +1054,7 @@ theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type _} [Preorder β] {f g
 
 /- warning: filter.eventually_le.is_min_filter -> Filter.EventuallyLE.isMinFilter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (IsMinFilter.{u1, u2} α β _inst_1 g l a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toHasLe.{u2} β _inst_1) l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (IsMinFilter.{u1, u2} α β _inst_1 g l a)
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β _inst_1) l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMinFilter.{u2, u1} α β _inst_1 f l a) -> (IsMinFilter.{u2, u1} α β _inst_1 g l a)
 Case conversion may be inaccurate. Consider using '#align filter.eventually_le.is_min_filter Filter.EventuallyLE.isMinFilterₓ'. -/

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

@@ -1087,26 +1087,26 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {f : β → α} {s : Set β} {x₀ : β}
 
-/- warning: is_max_on.supr_eq -> IsMaxOn.supᵢ_eq is a dubious translation:
+/- warning: is_max_on.supr_eq -> IsMaxOn.iSup_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x₀ s) -> (IsMaxOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (supᵢ.{u1, succ u2} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) (fun (x : coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) => f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x s))))) x))) (f x₀))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x₀ s) -> (IsMaxOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (iSup.{u1, succ u2} α (ConditionallyCompleteLattice.toHasSup.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) (fun (x : coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) => f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x s))))) x))) (f x₀))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x₀ s) -> (IsMaxOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (supᵢ.{u1, succ u2} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.Elem.{u2} β s) (fun (x : Set.Elem.{u2} β s) => f (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x s) x))) (f x₀))
-Case conversion may be inaccurate. Consider using '#align is_max_on.supr_eq IsMaxOn.supᵢ_eqₓ'. -/
-theorem IsMaxOn.supᵢ_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : (⨆ x : s, f x) = f x₀ :=
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x₀ s) -> (IsMaxOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (iSup.{u1, succ u2} α (ConditionallyCompleteLattice.toSupSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.Elem.{u2} β s) (fun (x : Set.Elem.{u2} β s) => f (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x s) x))) (f x₀))
+Case conversion may be inaccurate. Consider using '#align is_max_on.supr_eq IsMaxOn.iSup_eqₓ'. -/
+theorem IsMaxOn.iSup_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : (⨆ x : s, f x) = f x₀ :=
   haveI : Nonempty s := ⟨⟨x₀, hx₀⟩⟩
-  csupᵢ_eq_of_forall_le_of_forall_lt_exists_gt (fun x => h x.Prop) fun w hw => ⟨⟨x₀, hx₀⟩, hw⟩
-#align is_max_on.supr_eq IsMaxOn.supᵢ_eq
+  ciSup_eq_of_forall_le_of_forall_lt_exists_gt (fun x => h x.Prop) fun w hw => ⟨⟨x₀, hx₀⟩, hw⟩
+#align is_max_on.supr_eq IsMaxOn.iSup_eq
 
-/- warning: is_min_on.infi_eq -> IsMinOn.infᵢ_eq is a dubious translation:
+/- warning: is_min_on.infi_eq -> IsMinOn.iInf_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x₀ s) -> (IsMinOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (infᵢ.{u1, succ u2} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) (fun (x : coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) => f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x s))))) x))) (f x₀))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x₀ s) -> (IsMinOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (iInf.{u1, succ u2} α (ConditionallyCompleteLattice.toHasInf.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) (fun (x : coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) => f ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) s) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x s))))) x))) (f x₀))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x₀ s) -> (IsMinOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (infᵢ.{u1, succ u2} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.Elem.{u2} β s) (fun (x : Set.Elem.{u2} β s) => f (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x s) x))) (f x₀))
-Case conversion may be inaccurate. Consider using '#align is_min_on.infi_eq IsMinOn.infᵢ_eqₓ'. -/
-theorem IsMinOn.infᵢ_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : (⨅ x : s, f x) = f x₀ :=
-  @IsMaxOn.supᵢ_eq αᵒᵈ β _ _ _ _ hx₀ h
-#align is_min_on.infi_eq IsMinOn.infᵢ_eq
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : ConditionallyCompleteLinearOrder.{u1} α] {f : β -> α} {s : Set.{u2} β} {x₀ : β}, (Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x₀ s) -> (IsMinOn.{u2, u1} β α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (ConditionallyCompleteLattice.toLattice.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1))))) f s x₀) -> (Eq.{succ u1} α (iInf.{u1, succ u2} α (ConditionallyCompleteLattice.toInfSet.{u1} α (ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice.{u1} α _inst_1)) (Set.Elem.{u2} β s) (fun (x : Set.Elem.{u2} β s) => f (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x s) x))) (f x₀))
+Case conversion may be inaccurate. Consider using '#align is_min_on.infi_eq IsMinOn.iInf_eqₓ'. -/
+theorem IsMinOn.iInf_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : (⨅ x : s, f x) = f x₀ :=
+  @IsMaxOn.iSup_eq αᵒᵈ β _ _ _ _ hx₀ h
+#align is_min_on.infi_eq IsMinOn.iInf_eq
 
 end ConditionallyCompleteLinearOrder
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

@@ -984,19 +984,19 @@ section Eventually
 /-! ### Relation with `eventually` comparisons of two functions -/
 
 
-/- warning: filter.eventually_le.is_max_filter -> Filter.EventuallyLe.isMaxFilter is a dubious translation:
+/- warning: filter.eventually_le.is_max_filter -> Filter.EventuallyLE.isMaxFilter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l g f) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (IsMaxFilter.{u1, u2} α β _inst_1 g l a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l g f) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (IsMaxFilter.{u1, u2} α β _inst_1 g l a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyLe.{u2, u1} α β (Preorder.toLE.{u1} β _inst_1) l g f) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMaxFilter.{u2, u1} α β _inst_1 f l a) -> (IsMaxFilter.{u2, u1} α β _inst_1 g l a)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.is_max_filter Filter.EventuallyLe.isMaxFilterₓ'. -/
-theorem Filter.EventuallyLe.isMaxFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β _inst_1) l g f) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMaxFilter.{u2, u1} α β _inst_1 f l a) -> (IsMaxFilter.{u2, u1} α β _inst_1 g l a)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.is_max_filter Filter.EventuallyLE.isMaxFilterₓ'. -/
+theorem Filter.EventuallyLE.isMaxFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : g ≤ᶠ[l] f) (hfga : f a = g a) (h : IsMaxFilter f l a) :
     IsMaxFilter g l a := by
   refine' hle.mp (h.mono fun x hf hgf => _)
   rw [← hfga]
   exact le_trans hgf hf
-#align filter.eventually_le.is_max_filter Filter.EventuallyLe.isMaxFilter
+#align filter.eventually_le.is_max_filter Filter.EventuallyLE.isMaxFilter
 
 /- warning: is_max_filter.congr -> IsMaxFilter.congr is a dubious translation:
 lean 3 declaration is
@@ -1020,17 +1020,17 @@ theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type _} [Preorder β] {f g
   ⟨fun h => h.congr HEq hfga, fun h => h.congr HEq.symm hfga.symm⟩
 #align filter.eventually_eq.is_max_filter_iff Filter.EventuallyEq.isMaxFilter_iff
 
-/- warning: filter.eventually_le.is_min_filter -> Filter.EventuallyLe.isMinFilter is a dubious translation:
+/- warning: filter.eventually_le.is_min_filter -> Filter.EventuallyLE.isMinFilter is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLe.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (IsMinFilter.{u1, u2} α β _inst_1 g l a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (Filter.EventuallyLE.{u1, u2} α β (Preorder.toLE.{u2} β _inst_1) l f g) -> (Eq.{succ u2} β (f a) (g a)) -> (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (IsMinFilter.{u1, u2} α β _inst_1 g l a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyLe.{u2, u1} α β (Preorder.toLE.{u1} β _inst_1) l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMinFilter.{u2, u1} α β _inst_1 f l a) -> (IsMinFilter.{u2, u1} α β _inst_1 g l a)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_le.is_min_filter Filter.EventuallyLe.isMinFilterₓ'. -/
-theorem Filter.EventuallyLe.isMinFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u2} α}, (Filter.EventuallyLE.{u2, u1} α β (Preorder.toLE.{u1} β _inst_1) l f g) -> (Eq.{succ u1} β (f a) (g a)) -> (IsMinFilter.{u2, u1} α β _inst_1 f l a) -> (IsMinFilter.{u2, u1} α β _inst_1 g l a)
+Case conversion may be inaccurate. Consider using '#align filter.eventually_le.is_min_filter Filter.EventuallyLE.isMinFilterₓ'. -/
+theorem Filter.EventuallyLE.isMinFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : f ≤ᶠ[l] g) (hfga : f a = g a) (h : IsMinFilter f l a) :
     IsMinFilter g l a :=
-  @Filter.EventuallyLe.isMaxFilter _ βᵒᵈ _ _ _ _ _ hle hfga h
-#align filter.eventually_le.is_min_filter Filter.EventuallyLe.isMinFilter
+  @Filter.EventuallyLE.isMaxFilter _ βᵒᵈ _ _ _ _ _ hle hfga h
+#align filter.eventually_le.is_min_filter Filter.EventuallyLE.isMinFilter
 
 /- warning: is_min_filter.congr -> IsMinFilter.congr is a dubious translation:
 lean 3 declaration is

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

@@ -349,9 +349,9 @@ theorem IsExtrFilter.filter_mono (h : IsExtrFilter f l a) (hl : l' ≤ l) : IsEx
 
 /- warning: is_min_filter.filter_inf -> IsMinFilter.filter_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMinFilter.{u1, u2} α β _inst_1 f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMinFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMinFilter.{u1, u2} α β _inst_1 f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l l') a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMinFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMinFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l l') a)
 Case conversion may be inaccurate. Consider using '#align is_min_filter.filter_inf IsMinFilter.filter_infₓ'. -/
 theorem IsMinFilter.filter_inf (h : IsMinFilter f l a) (l') : IsMinFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
@@ -359,9 +359,9 @@ theorem IsMinFilter.filter_inf (h : IsMinFilter f l a) (l') : IsMinFilter f (l 
 
 /- warning: is_max_filter.filter_inf -> IsMaxFilter.filter_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMaxFilter.{u1, u2} α β _inst_1 f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMaxFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMaxFilter.{u1, u2} α β _inst_1 f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l l') a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsMaxFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsMaxFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l l') a)
 Case conversion may be inaccurate. Consider using '#align is_max_filter.filter_inf IsMaxFilter.filter_infₓ'. -/
 theorem IsMaxFilter.filter_inf (h : IsMaxFilter f l a) (l') : IsMaxFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
@@ -369,9 +369,9 @@ theorem IsMaxFilter.filter_inf (h : IsMaxFilter f l a) (l') : IsMaxFilter f (l 
 
 /- warning: is_extr_filter.filter_inf -> IsExtrFilter.filter_inf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsExtrFilter.{u1, u2} α β _inst_1 f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsExtrFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.hasInf.{u1} α) l l') a)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsExtrFilter.{u1, u2} α β _inst_1 f (HasInf.inf.{u1} (Filter.{u1} α) (Filter.instHasInfFilter.{u1} α) l l') a)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u2} β] {f : α -> β} {l : Filter.{u1} α} {a : α}, (IsExtrFilter.{u1, u2} α β _inst_1 f l a) -> (forall (l' : Filter.{u1} α), IsExtrFilter.{u1, u2} α β _inst_1 f (Inf.inf.{u1} (Filter.{u1} α) (Filter.instInfFilter.{u1} α) l l') a)
 Case conversion may be inaccurate. Consider using '#align is_extr_filter.filter_inf IsExtrFilter.filter_infₓ'. -/
 theorem IsExtrFilter.filter_inf (h : IsExtrFilter f l a) (l') : IsExtrFilter f (l ⊓ l') a :=
   h.filter_mono inf_le_left
@@ -782,33 +782,49 @@ section SemilatticeSup
 
 variable [SemilatticeSup β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
-#print IsMinFilter.sup /-
+/- warning: is_min_filter.sup -> IsMinFilter.sup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β _inst_1) (f x) (g x)) l a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β _inst_1) (f x) (g x)) l a)
+Case conversion may be inaccurate. Consider using '#align is_min_filter.sup IsMinFilter.supₓ'. -/
 theorem IsMinFilter.sup (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => f x ⊔ g x) l a :=
   show IsMinFilter (fun x => f x ⊔ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => sup_le_sup hx hy) hg
 #align is_min_filter.sup IsMinFilter.sup
--/
 
-#print IsMaxFilter.sup /-
+/- warning: is_max_filter.sup -> IsMaxFilter.sup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β _inst_1) (f x) (g x)) l a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β _inst_1) (f x) (g x)) l a)
+Case conversion may be inaccurate. Consider using '#align is_max_filter.sup IsMaxFilter.supₓ'. -/
 theorem IsMaxFilter.sup (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => f x ⊔ g x) l a :=
   show IsMaxFilter (fun x => f x ⊔ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => sup_le_sup hx hy) hg
 #align is_max_filter.sup IsMaxFilter.sup
--/
 
-#print IsMinOn.sup /-
+/- warning: is_min_on.sup -> IsMinOn.sup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β _inst_1) (f x) (g x)) s a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β _inst_1) (f x) (g x)) s a)
+Case conversion may be inaccurate. Consider using '#align is_min_on.sup IsMinOn.supₓ'. -/
 theorem IsMinOn.sup (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊔ g x) s a :=
   hf.sup hg
 #align is_min_on.sup IsMinOn.sup
--/
 
-#print IsMaxOn.sup /-
+/- warning: is_max_on.sup -> IsMaxOn.sup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toHasSup.{u2} β _inst_1) (f x) (g x)) s a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeSup.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Sup.sup.{u2} β (SemilatticeSup.toSup.{u2} β _inst_1) (f x) (g x)) s a)
+Case conversion may be inaccurate. Consider using '#align is_max_on.sup IsMaxOn.supₓ'. -/
 theorem IsMaxOn.sup (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊔ g x) s a :=
   hf.sup hg
 #align is_max_on.sup IsMaxOn.sup
--/
 
 end SemilatticeSup
 
@@ -816,33 +832,49 @@ section SemilatticeInf
 
 variable [SemilatticeInf β] {f g : α → β} {a : α} {s : Set α} {l : Filter α}
 
-#print IsMinFilter.inf /-
+/- warning: is_min_filter.inf -> IsMinFilter.inf is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β _inst_1) (f x) (g x)) l a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMinFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toInf.{u2} β _inst_1) (f x) (g x)) l a)
+Case conversion may be inaccurate. Consider using '#align is_min_filter.inf IsMinFilter.infₓ'. -/
 theorem IsMinFilter.inf (hf : IsMinFilter f l a) (hg : IsMinFilter g l a) :
     IsMinFilter (fun x => f x ⊓ g x) l a :=
   show IsMinFilter (fun x => f x ⊓ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => inf_le_inf hx hy) hg
 #align is_min_filter.inf IsMinFilter.inf
--/
 
-#print IsMaxFilter.inf /-
+/- warning: is_max_filter.inf -> IsMaxFilter.inf is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β _inst_1) (f x) (g x)) l a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {l : Filter.{u1} α}, (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g l a) -> (IsMaxFilter.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toInf.{u2} β _inst_1) (f x) (g x)) l a)
+Case conversion may be inaccurate. Consider using '#align is_max_filter.inf IsMaxFilter.infₓ'. -/
 theorem IsMaxFilter.inf (hf : IsMaxFilter f l a) (hg : IsMaxFilter g l a) :
     IsMaxFilter (fun x => f x ⊓ g x) l a :=
   show IsMaxFilter (fun x => f x ⊓ g x) l a from
     hf.bicomp_mono (fun x x' hx y y' hy => inf_le_inf hx hy) hg
 #align is_max_filter.inf IsMaxFilter.inf
--/
 
-#print IsMinOn.inf /-
+/- warning: is_min_on.inf -> IsMinOn.inf is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β _inst_1) (f x) (g x)) s a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMinOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toInf.{u2} β _inst_1) (f x) (g x)) s a)
+Case conversion may be inaccurate. Consider using '#align is_min_on.inf IsMinOn.infₓ'. -/
 theorem IsMinOn.inf (hf : IsMinOn f s a) (hg : IsMinOn g s a) : IsMinOn (fun x => f x ⊓ g x) s a :=
   hf.inf hg
 #align is_min_on.inf IsMinOn.inf
--/
 
-#print IsMaxOn.inf /-
+/- warning: is_max_on.inf -> IsMaxOn.inf is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toHasInf.{u2} β _inst_1) (f x) (g x)) s a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeInf.{u2} β] {f : α -> β} {g : α -> β} {a : α} {s : Set.{u1} α}, (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) f s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) g s a) -> (IsMaxOn.{u1, u2} α β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β _inst_1)) (fun (x : α) => Inf.inf.{u2} β (SemilatticeInf.toInf.{u2} β _inst_1) (f x) (g x)) s a)
+Case conversion may be inaccurate. Consider using '#align is_max_on.inf IsMaxOn.infₓ'. -/
 theorem IsMaxOn.inf (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊓ g x) s a :=
   hf.inf hg
 #align is_max_on.inf IsMaxOn.inf
--/
 
 end SemilatticeInf
 

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

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -86,7 +86,6 @@ open Filter
 section Preorder
 
 variable [Preorder β] [Preorder γ]
-
 variable (f : α → β) (s : Set α) (l : Filter α) (a : α)
 
 /-! ### Definitions -/

if Is{Min,Max}On, and clarify Is{Min,Max}Filter slightly.

@@ -92,12 +92,12 @@ variable (f : α → β) (s : Set α) (l : Filter α) (a : α)
 /-! ### Definitions -/
 
 
-/-- `IsMinFilter f l a` means that `f a ≤ f x` in some `l`-neighborhood of `a` -/
+/-- `IsMinFilter f l a` means that `f a ≤ f x` for all `x` in some `l`-neighborhood of `a` -/
 def IsMinFilter : Prop :=
   ∀ᶠ x in l, f a ≤ f x
 #align is_min_filter IsMinFilter
 
-/-- `is_maxFilter f l a` means that `f x ≤ f a` in some `l`-neighborhood of `a` -/
+/-- `is_maxFilter f l a` means that `f x ≤ f a` for all `x` in some `l`-neighborhood of `a` -/
 def IsMaxFilter : Prop :=
   ∀ᶠ x in l, f x ≤ f a
 #align is_max_filter IsMaxFilter
@@ -107,12 +107,12 @@ def IsExtrFilter : Prop :=
   IsMinFilter f l a ∨ IsMaxFilter f l a
 #align is_extr_filter IsExtrFilter
 
-/-- `IsMinOn f s a` means that `f a ≤ f x` for all `x ∈ a`. Note that we do not assume `a ∈ s`. -/
+/-- `IsMinOn f s a` means that `f a ≤ f x` for all `x ∈ s`. Note that we do not assume `a ∈ s`. -/
 def IsMinOn :=
   IsMinFilter f (𝓟 s) a
 #align is_min_on IsMinOn
 
-/-- `IsMaxOn f s a` means that `f x ≤ f a` for all `x ∈ a`. Note that we do not assume `a ∈ s`. -/
+/-- `IsMaxOn f s a` means that `f x ≤ f a` for all `x ∈ s`. Note that we do not assume `a ∈ s`. -/
 def IsMaxOn :=
   IsMaxFilter f (𝓟 s) a
 #align is_max_on IsMaxOn

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

@@ -508,12 +508,14 @@ theorem IsMaxFilter.sub (hf : IsMaxFilter f l a) (hg : IsMinFilter g l a) :
     IsMaxFilter (fun x => f x - g x) l a := by simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_max_filter.sub IsMaxFilter.sub
 
-theorem IsMinOn.sub (hf : IsMinOn f s a) (hg : IsMaxOn g s a) : IsMinOn (fun x => f x - g x) s a :=
-  by simpa only [sub_eq_add_neg] using hf.add hg.neg
+theorem IsMinOn.sub (hf : IsMinOn f s a) (hg : IsMaxOn g s a) :
+    IsMinOn (fun x => f x - g x) s a := by
+  simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_min_on.sub IsMinOn.sub
 
-theorem IsMaxOn.sub (hf : IsMaxOn f s a) (hg : IsMinOn g s a) : IsMaxOn (fun x => f x - g x) s a :=
-  by simpa only [sub_eq_add_neg] using hf.add hg.neg
+theorem IsMaxOn.sub (hf : IsMaxOn f s a) (hg : IsMinOn g s a) :
+    IsMaxOn (fun x => f x - g x) s a := by
+  simpa only [sub_eq_add_neg] using hf.add hg.neg
 #align is_max_on.sub IsMaxOn.sub
 
 end OrderedAddCommGroup

@@ -215,15 +215,15 @@ theorem isExtrFilter_dual_iff : IsExtrFilter (toDual ∘ f) l a ↔ IsExtrFilter
   or_comm
 #align is_extr_filter_dual_iff isExtrFilter_dual_iff
 
-alias isMinFilter_dual_iff ↔ IsMinFilter.undual IsMaxFilter.dual
+alias ⟨IsMinFilter.undual, IsMaxFilter.dual⟩ := isMinFilter_dual_iff
 #align is_min_filter.undual IsMinFilter.undual
 #align is_max_filter.dual IsMaxFilter.dual
 
-alias isMaxFilter_dual_iff ↔ IsMaxFilter.undual IsMinFilter.dual
+alias ⟨IsMaxFilter.undual, IsMinFilter.dual⟩ := isMaxFilter_dual_iff
 #align is_max_filter.undual IsMaxFilter.undual
 #align is_min_filter.dual IsMinFilter.dual
 
-alias isExtrFilter_dual_iff ↔ IsExtrFilter.undual IsExtrFilter.dual
+alias ⟨IsExtrFilter.undual, IsExtrFilter.dual⟩ := isExtrFilter_dual_iff
 #align is_extr_filter.undual IsExtrFilter.undual
 #align is_extr_filter.dual IsExtrFilter.dual
 
@@ -239,15 +239,15 @@ theorem isExtrOn_dual_iff : IsExtrOn (toDual ∘ f) s a ↔ IsExtrOn f s a :=
   or_comm
 #align is_extr_on_dual_iff isExtrOn_dual_iff
 
-alias isMinOn_dual_iff ↔ IsMinOn.undual IsMaxOn.dual
+alias ⟨IsMinOn.undual, IsMaxOn.dual⟩ := isMinOn_dual_iff
 #align is_min_on.undual IsMinOn.undual
 #align is_max_on.dual IsMaxOn.dual
 
-alias isMaxOn_dual_iff ↔ IsMaxOn.undual IsMinOn.dual
+alias ⟨IsMaxOn.undual, IsMinOn.dual⟩ := isMaxOn_dual_iff
 #align is_max_on.undual IsMaxOn.undual
 #align is_min_on.dual IsMinOn.dual
 
-alias isExtrOn_dual_iff ↔ IsExtrOn.undual IsExtrOn.dual
+alias ⟨IsExtrOn.undual, IsExtrOn.dual⟩ := isExtrOn_dual_iff
 #align is_extr_on.undual IsExtrOn.undual
 #align is_extr_on.dual IsExtrOn.dual
 

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

This has nice performance benefits.

@@ -631,7 +631,7 @@ section Eventually
 /-! ### Relation with `eventually` comparisons of two functions -/
 
 
-theorem Filter.EventuallyLE.isMaxFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+theorem Filter.EventuallyLE.isMaxFilter {α β : Type*} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : g ≤ᶠ[l] f) (hfga : f a = g a) (h : IsMaxFilter f l a) :
     IsMaxFilter g l a := by
   refine' hle.mp (h.mono fun x hf hgf => _)
@@ -639,39 +639,39 @@ theorem Filter.EventuallyLE.isMaxFilter {α β : Type _} [Preorder β] {f g : α
   exact le_trans hgf hf
 #align filter.eventually_le.is_max_filter Filter.EventuallyLE.isMaxFilter
 
-theorem IsMaxFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
+theorem IsMaxFilter.congr {α β : Type*} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsMaxFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter g l a :=
   heq.symm.le.isMaxFilter hfga h
 #align is_max_filter.congr IsMaxFilter.congr
 
-theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type*} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter f l a ↔ IsMaxFilter g l a :=
   ⟨fun h => h.congr heq hfga, fun h => h.congr heq.symm hfga.symm⟩
 #align filter.eventually_eq.is_max_filter_iff Filter.EventuallyEq.isMaxFilter_iff
 
-theorem Filter.EventuallyLE.isMinFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+theorem Filter.EventuallyLE.isMinFilter {α β : Type*} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : f ≤ᶠ[l] g) (hfga : f a = g a) (h : IsMinFilter f l a) :
     IsMinFilter g l a :=
   @Filter.EventuallyLE.isMaxFilter _ βᵒᵈ _ _ _ _ _ hle hfga h
 #align filter.eventually_le.is_min_filter Filter.EventuallyLE.isMinFilter
 
-theorem IsMinFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
+theorem IsMinFilter.congr {α β : Type*} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsMinFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter g l a :=
   heq.le.isMinFilter hfga h
 #align is_min_filter.congr IsMinFilter.congr
 
-theorem Filter.EventuallyEq.isMinFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+theorem Filter.EventuallyEq.isMinFilter_iff {α β : Type*} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter f l a ↔ IsMinFilter g l a :=
   ⟨fun h => h.congr heq hfga, fun h => h.congr heq.symm hfga.symm⟩
 #align filter.eventually_eq.is_min_filter_iff Filter.EventuallyEq.isMinFilter_iff
 
-theorem IsExtrFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
+theorem IsExtrFilter.congr {α β : Type*} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsExtrFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsExtrFilter g l a := by
   rw [IsExtrFilter] at *
   rwa [← heq.isMaxFilter_iff hfga, ← heq.isMinFilter_iff hfga]
 #align is_extr_filter.congr IsExtrFilter.congr
 
-theorem Filter.EventuallyEq.isExtrFilter_iff {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+theorem Filter.EventuallyEq.isExtrFilter_iff {α β : Type*} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsExtrFilter f l a ↔ IsExtrFilter g l a :=
   ⟨fun h => h.congr heq hfga, fun h => h.congr heq.symm hfga.symm⟩
 #align filter.eventually_eq.is_extr_filter_iff Filter.EventuallyEq.isExtrFilter_iff

@@ -50,7 +50,7 @@ Similar predicates with `on` suffix are particular cases for `l = 𝓟 s`.
   then it is an extremum of the same type for their sum;
 * `is**.neg` : if `x` is an extremum for `f`, then it is an extremum
   of the opposite type for `-f`;
-* `is**.sub` : if `x` is an a minimum for `f` and a maximum for `g`,
+* `is**.sub` : if `x` is a minimum for `f` and a maximum for `g`,
   then it is a minimum for `f - g` and a maximum for `g - f`;
 * `is**.max`, `is**.min`, `is**.sup`, `is**.inf` : similarly for `is**.add`
   for pointwise `max`, `min`, `sup`, `inf`, respectively.

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2019 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module order.filter.extr
-! leanprover-community/mathlib commit 1f0096e6caa61e9c849ec2adbd227e960e9dff58
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.Basic
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
 
+#align_import order.filter.extr from "leanprover-community/mathlib"@"1f0096e6caa61e9c849ec2adbd227e960e9dff58"
+
 /-!
 # Minimum and maximum w.r.t. a filter and on a set
 

@@ -688,12 +688,12 @@ section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {f : β → α} {s : Set β} {x₀ : β}
 
-theorem IsMaxOn.iSup_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : (⨆ x : s, f x) = f x₀ :=
+theorem IsMaxOn.iSup_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : ⨆ x : s, f x = f x₀ :=
   haveI : Nonempty s := ⟨⟨x₀, hx₀⟩⟩
   ciSup_eq_of_forall_le_of_forall_lt_exists_gt (fun x => h x.2) fun _w hw => ⟨⟨x₀, hx₀⟩, hw⟩
 #align is_max_on.supr_eq IsMaxOn.iSup_eq
 
-theorem IsMinOn.iInf_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : (⨅ x : s, f x) = f x₀ :=
+theorem IsMinOn.iInf_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : ⨅ x : s, f x = f x₀ :=
   @IsMaxOn.iSup_eq αᵒᵈ β _ _ _ _ hx₀ h
 #align is_min_on.infi_eq IsMinOn.iInf_eq
 

These are all doc fixes

@@ -12,7 +12,7 @@ import Mathlib.Order.Filter.Basic
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
 
 /-!
-# Minimum and maximum w.r.t. a filter and on a aet
+# Minimum and maximum w.r.t. a filter and on a set
 
 ## Main Definitions
 

Run codespell Mathlib and keep some suggestions.

@@ -32,7 +32,7 @@ Similar predicates with `on` suffix are particular cases for `l = 𝓟 s`.
 * `is*Filter.filter_mono` : replace the filter with a smaller one;
 * `is*Filter.filter_inf` : replace a filter `l` with `l ⊓ l'`;
 * `is*On.on_subset` : restrict to a smaller set;
-* `is*Pn.inter` : replace a set `s` wtih `s ∩ t`.
+* `is*Pn.inter` : replace a set `s` with `s ∩ t`.
 
 ### Composition
 

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>

@@ -681,20 +681,20 @@ theorem Filter.EventuallyEq.isExtrFilter_iff {α β : Type _} [Preorder β] {f g
 
 end Eventually
 
-/-! ### `isMaxOn`/`isMinOn` imply `csupᵢ`/`cinfᵢ` -/
+/-! ### `isMaxOn`/`isMinOn` imply `ciSup`/`ciInf` -/
 
 
 section ConditionallyCompleteLinearOrder
 
 variable [ConditionallyCompleteLinearOrder α] {f : β → α} {s : Set β} {x₀ : β}
 
-theorem IsMaxOn.supᵢ_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : (⨆ x : s, f x) = f x₀ :=
+theorem IsMaxOn.iSup_eq (hx₀ : x₀ ∈ s) (h : IsMaxOn f s x₀) : (⨆ x : s, f x) = f x₀ :=
   haveI : Nonempty s := ⟨⟨x₀, hx₀⟩⟩
-  csupᵢ_eq_of_forall_le_of_forall_lt_exists_gt (fun x => h x.2) fun _w hw => ⟨⟨x₀, hx₀⟩, hw⟩
-#align is_max_on.supr_eq IsMaxOn.supᵢ_eq
+  ciSup_eq_of_forall_le_of_forall_lt_exists_gt (fun x => h x.2) fun _w hw => ⟨⟨x₀, hx₀⟩, hw⟩
+#align is_max_on.supr_eq IsMaxOn.iSup_eq
 
-theorem IsMinOn.infᵢ_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : (⨅ x : s, f x) = f x₀ :=
-  @IsMaxOn.supᵢ_eq αᵒᵈ β _ _ _ _ hx₀ h
-#align is_min_on.infi_eq IsMinOn.infᵢ_eq
+theorem IsMinOn.iInf_eq (hx₀ : x₀ ∈ s) (h : IsMinOn f s x₀) : (⨅ x : s, f x) = f x₀ :=
+  @IsMaxOn.iSup_eq αᵒᵈ β _ _ _ _ hx₀ h
+#align is_min_on.infi_eq IsMinOn.iInf_eq
 
 end ConditionallyCompleteLinearOrder

@@ -634,13 +634,13 @@ section Eventually
 /-! ### Relation with `eventually` comparisons of two functions -/
 
 
-theorem Filter.EventuallyLe.isMaxFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+theorem Filter.EventuallyLE.isMaxFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : g ≤ᶠ[l] f) (hfga : f a = g a) (h : IsMaxFilter f l a) :
     IsMaxFilter g l a := by
   refine' hle.mp (h.mono fun x hf hgf => _)
   rw [← hfga]
   exact le_trans hgf hf
-#align filter.eventually_le.is_max_filter Filter.EventuallyLe.isMaxFilter
+#align filter.eventually_le.is_max_filter Filter.EventuallyLE.isMaxFilter
 
 theorem IsMaxFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsMaxFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMaxFilter g l a :=
@@ -652,11 +652,11 @@ theorem Filter.EventuallyEq.isMaxFilter_iff {α β : Type _} [Preorder β] {f g
   ⟨fun h => h.congr heq hfga, fun h => h.congr heq.symm hfga.symm⟩
 #align filter.eventually_eq.is_max_filter_iff Filter.EventuallyEq.isMaxFilter_iff
 
-theorem Filter.EventuallyLe.isMinFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
+theorem Filter.EventuallyLE.isMinFilter {α β : Type _} [Preorder β] {f g : α → β} {a : α}
     {l : Filter α} (hle : f ≤ᶠ[l] g) (hfga : f a = g a) (h : IsMinFilter f l a) :
     IsMinFilter g l a :=
-  @Filter.EventuallyLe.isMaxFilter _ βᵒᵈ _ _ _ _ _ hle hfga h
-#align filter.eventually_le.is_min_filter Filter.EventuallyLe.isMinFilter
+  @Filter.EventuallyLE.isMaxFilter _ βᵒᵈ _ _ _ _ _ hle hfga h
+#align filter.eventually_le.is_min_filter Filter.EventuallyLE.isMinFilter
 
 theorem IsMinFilter.congr {α β : Type _} [Preorder β] {f g : α → β} {a : α} {l : Filter α}
     (h : IsMinFilter f l a) (heq : f =ᶠ[l] g) (hfga : f a = g a) : IsMinFilter g l a :=

This mighta been the easiest port so far. Just a couple translation errors. Only weird thing is that it was not able to infer what a ConditionallyCompleteLinearOrder was, so I added import Mathlib.Order.ConditionallyCompleteLattice.Basic. Is that legal?