order.filter.filter_product ⟷ Mathlib.Order.Filter.FilterProduct

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

@@ -42,7 +42,7 @@ local notation "β*" => Germ (φ : Filter α) β
 
 instance [DivisionSemiring β] : DivisionSemiring β* :=
   { Germ.semiring, Germ.divInvMonoid,
-    Germ.nontrivial with
+    Germ.instNontrivial with
     mul_inv_cancel := fun f =>
       inductionOn f fun f hf =>
         coe_eq.2 <|
@@ -189,7 +189,7 @@ instance [OrderedCommRing β] : OrderedCommRing β* :=
 
 instance [StrictOrderedSemiring β] : StrictOrderedSemiring β* :=
   { Germ.orderedSemiring, Germ.orderedCancelAddCommMonoid,
-    Germ.nontrivial with
+    Germ.instNontrivial with
     mul_lt_mul_of_pos_left := fun x y z =>
       inductionOn₃ x y z fun f g h hfg hh =>
         coe_lt.2 <| (coe_lt.1 hh).mp <| (coe_lt.1 hfg).mono fun a => mul_lt_mul_of_pos_left

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

@@ -3,8 +3,8 @@ Copyright (c) 2019 Abhimanyu Pallavi Sudhir. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Abhimanyu Pallavi Sudhir, Yury Kudryashov
 -/
-import Mathbin.Order.Filter.Ultrafilter
-import Mathbin.Order.Filter.Germ
+import Order.Filter.Ultrafilter
+import Order.Filter.Germ
 
 #align_import order.filter.filter_product from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
 

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

@@ -181,7 +181,7 @@ instance [OrderedRing β] : OrderedRing β* :=
   { Germ.ring,
     Germ.orderedAddCommGroup with
     zero_le_one := const_le zero_le_one
-    mul_nonneg := fun x y =>
+    hMul_nonneg := fun x y =>
       inductionOn₂ x y fun f g hf hg => hg.mp <| hf.mono fun a => mul_nonneg }
 
 instance [OrderedCommRing β] : OrderedCommRing β* :=

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

@@ -2,15 +2,12 @@
 Copyright (c) 2019 Abhimanyu Pallavi Sudhir. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Abhimanyu Pallavi Sudhir, Yury Kudryashov
-
-! This file was ported from Lean 3 source module order.filter.filter_product
-! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.Ultrafilter
 import Mathbin.Order.Filter.Germ
 
+#align_import order.filter.filter_product from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
+
 /-!
 # Ultraproducts
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9240e8be927a0955b9a82c6c85ef499ee3a626b8

@@ -263,7 +263,7 @@ theorem const_min [LinearOrder β] (x y : β) : (↑(min x y : β) : β*) = min
 
 #print Filter.Germ.const_abs /-
 @[simp]
-theorem const_abs [LinearOrderedAddCommGroup β] (x : β) : (↑(|x|) : β*) = |↑x| := by
+theorem const_abs [LinearOrderedAddCommGroup β] (x : β) : (↑|x| : β*) = |↑x| := by
   rw [abs_def, map_const]
 #align filter.germ.const_abs Filter.Germ.const_abs
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

@@ -88,7 +88,7 @@ theorem const_lt_iff [Preorder β] {x y : β} : (↑x : β*) < ↑y ↔ x < y :=
 -/
 
 #print Filter.Germ.lt_def /-
-theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) := by ext (⟨f⟩⟨g⟩);
+theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) := by ext ⟨f⟩ ⟨g⟩;
   exact coe_lt
 #align filter.germ.lt_def Filter.Germ.lt_def
 -/

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

@@ -35,14 +35,12 @@ open scoped Classical
 
 namespace Filter
 
--- mathport name: «expr∀* , »
 local notation3"∀* "(...)", "r:(scoped p => Filter.Eventually p φ) => r
 
 namespace Germ
 
 open Ultrafilter
 
--- mathport name: «exprβ*»
 local notation "β*" => Germ (φ : Filter α) β
 
 instance [DivisionSemiring β] : DivisionSemiring β* :=
@@ -225,38 +223,50 @@ noncomputable instance [LinearOrderedField β] : LinearOrderedField β* :=
 noncomputable instance [LinearOrderedCommRing β] : LinearOrderedCommRing β* :=
   { Germ.linearOrderedRing, Germ.commMonoid with }
 
+#print Filter.Germ.max_def /-
 theorem max_def [LinearOrder β] (x y : β*) : max x y = map₂ max x y :=
   inductionOn₂ x y fun a b => by
     cases le_total (a : β*) b
     · rw [max_eq_right h, map₂_coe, coe_eq]; exact h.mono fun i hi => (max_eq_right hi).symm
     · rw [max_eq_left h, map₂_coe, coe_eq]; exact h.mono fun i hi => (max_eq_left hi).symm
 #align filter.germ.max_def Filter.Germ.max_def
+-/
 
+#print Filter.Germ.min_def /-
 theorem min_def [K : LinearOrder β] (x y : β*) : min x y = map₂ min x y :=
   inductionOn₂ x y fun a b => by
     cases le_total (a : β*) b
     · rw [min_eq_left h, map₂_coe, coe_eq]; exact h.mono fun i hi => (min_eq_left hi).symm
     · rw [min_eq_right h, map₂_coe, coe_eq]; exact h.mono fun i hi => (min_eq_right hi).symm
 #align filter.germ.min_def Filter.Germ.min_def
+-/
 
+#print Filter.Germ.abs_def /-
 theorem abs_def [LinearOrderedAddCommGroup β] (x : β*) : |x| = map abs x :=
   inductionOn x fun a => rfl
 #align filter.germ.abs_def Filter.Germ.abs_def
+-/
 
+#print Filter.Germ.const_max /-
 @[simp]
 theorem const_max [LinearOrder β] (x y : β) : (↑(max x y : β) : β*) = max ↑x ↑y := by
   rw [max_def, map₂_const]
 #align filter.germ.const_max Filter.Germ.const_max
+-/
 
+#print Filter.Germ.const_min /-
 @[simp]
 theorem const_min [LinearOrder β] (x y : β) : (↑(min x y : β) : β*) = min ↑x ↑y := by
   rw [min_def, map₂_const]
 #align filter.germ.const_min Filter.Germ.const_min
+-/
 
+#print Filter.Germ.const_abs /-
 @[simp]
 theorem const_abs [LinearOrderedAddCommGroup β] (x : β) : (↑(|x|) : β*) = |↑x| := by
   rw [abs_def, map_const]
 #align filter.germ.const_abs Filter.Germ.const_abs
+-/
 
 end Germ
 

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

@@ -31,7 +31,7 @@ universe u v
 
 variable {α : Type u} {β : Type v} {φ : Ultrafilter α}
 
-open Classical
+open scoped Classical
 
 namespace Filter
 
@@ -64,26 +64,36 @@ instance [Semifield β] : Semifield β* :=
 instance [Field β] : Field β* :=
   { Germ.commRing, Germ.divisionRing with }
 
+#print Filter.Germ.coe_lt /-
 theorem coe_lt [Preorder β] {f g : α → β} : (f : β*) < g ↔ ∀* x, f x < g x := by
   simp only [lt_iff_le_not_le, eventually_and, coe_le, eventually_not, eventually_le]
 #align filter.germ.coe_lt Filter.Germ.coe_lt
+-/
 
+#print Filter.Germ.coe_pos /-
 theorem coe_pos [Preorder β] [Zero β] {f : α → β} : 0 < (f : β*) ↔ ∀* x, 0 < f x :=
   coe_lt
 #align filter.germ.coe_pos Filter.Germ.coe_pos
+-/
 
+#print Filter.Germ.const_lt /-
 theorem const_lt [Preorder β] {x y : β} : x < y → (↑x : β*) < ↑y :=
   coe_lt.mpr ∘ liftRel_const
 #align filter.germ.const_lt Filter.Germ.const_lt
+-/
 
+#print Filter.Germ.const_lt_iff /-
 @[simp, norm_cast]
 theorem const_lt_iff [Preorder β] {x y : β} : (↑x : β*) < ↑y ↔ x < y :=
   coe_lt.trans liftRel_const_iff
 #align filter.germ.const_lt_iff Filter.Germ.const_lt_iff
+-/
 
+#print Filter.Germ.lt_def /-
 theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) := by ext (⟨f⟩⟨g⟩);
   exact coe_lt
 #align filter.germ.lt_def Filter.Germ.lt_def
+-/
 
 instance [Sup β] : Sup β* :=
   ⟨map₂ (· ⊔ ·)⟩

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

@@ -64,53 +64,23 @@ instance [Semifield β] : Semifield β* :=
 instance [Field β] : Field β* :=
   { Germ.commRing, Germ.divisionRing with }
 
-/- warning: filter.germ.coe_lt -> Filter.Germ.coe_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasCoeT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)))) f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasCoeT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)))) g)) (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) (f x) (g x)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) (Filter.Germ.ofFun.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) f) (Filter.Germ.ofFun.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) g)) (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) (f x) (g x)) (Ultrafilter.toFilter.{u1} α φ))
-Case conversion may be inaccurate. Consider using '#align filter.germ.coe_lt Filter.Germ.coe_ltₓ'. -/
 theorem coe_lt [Preorder β] {f g : α → β} : (f : β*) < g ↔ ∀* x, f x < g x := by
   simp only [lt_iff_le_not_le, eventually_and, coe_le, eventually_not, eventually_le]
 #align filter.germ.coe_lt Filter.Germ.coe_lt
 
-/- warning: filter.germ.coe_pos -> Filter.Germ.coe_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] [_inst_2 : Zero.{u2} β] {f : α -> β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1)) (OfNat.ofNat.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) 0 (OfNat.mk.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) 0 (Zero.zero.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasZero.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β _inst_2)))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasCoeT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)))) f)) (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β _inst_2))) (f x)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] [_inst_2 : Zero.{u2} β] {f : α -> β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) (OfNat.ofNat.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) 0 (Zero.toOfNat0.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.zero.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β _inst_2))) (Filter.Germ.ofFun.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) f)) (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β _inst_2)) (f x)) (Ultrafilter.toFilter.{u1} α φ))
-Case conversion may be inaccurate. Consider using '#align filter.germ.coe_pos Filter.Germ.coe_posₓ'. -/
 theorem coe_pos [Preorder β] [Zero β] {f : α → β} : 0 < (f : β*) ↔ ∀* x, 0 < f x :=
   coe_lt
 #align filter.germ.coe_pos Filter.Germ.coe_pos
 
-/- warning: filter.germ.const_lt -> Filter.Germ.const_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {x : β} {y : β}, (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) x y) -> (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1)) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) x) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {x : β} {y : β}, (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) x y) -> (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) y))
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_lt Filter.Germ.const_ltₓ'. -/
 theorem const_lt [Preorder β] {x y : β} : x < y → (↑x : β*) < ↑y :=
   coe_lt.mpr ∘ liftRel_const
 #align filter.germ.const_lt Filter.Germ.const_lt
 
-/- warning: filter.germ.const_lt_iff -> Filter.Germ.const_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {x : β} {y : β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1)) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) x) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) y)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) x y)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {x : β} {y : β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) y)) (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) x y)
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_lt_iff Filter.Germ.const_lt_iffₓ'. -/
 @[simp, norm_cast]
 theorem const_lt_iff [Preorder β] {x y : β} : (↑x : β*) < ↑y ↔ x < y :=
   coe_lt.trans liftRel_const_iff
 #align filter.germ.const_lt_iff Filter.Germ.const_lt_iff
 
-/- warning: filter.germ.lt_def -> Filter.Germ.lt_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β], Eq.{succ (max u1 u2)} ((Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) -> (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) -> Prop) (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1))) (Filter.Germ.LiftRel.{u1, u2, u2} α β β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β], Eq.{max (succ u1) (succ u2)} ((Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) -> (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) -> Prop) (fun (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6816 : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6818 : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) => LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) x._@.Mathlib.Order.Filter.FilterProduct._hyg.6816 x._@.Mathlib.Order.Filter.FilterProduct._hyg.6818) (Filter.Germ.LiftRel.{u1, u2, u2} α β β (Ultrafilter.toFilter.{u1} α φ) (fun (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6832 : β) (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6834 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) x._@.Mathlib.Order.Filter.FilterProduct._hyg.6832 x._@.Mathlib.Order.Filter.FilterProduct._hyg.6834))
-Case conversion may be inaccurate. Consider using '#align filter.germ.lt_def Filter.Germ.lt_defₓ'. -/
 theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) := by ext (⟨f⟩⟨g⟩);
   exact coe_lt
 #align filter.germ.lt_def Filter.Germ.lt_def
@@ -245,12 +215,6 @@ noncomputable instance [LinearOrderedField β] : LinearOrderedField β* :=
 noncomputable instance [LinearOrderedCommRing β] : LinearOrderedCommRing β* :=
   { Germ.linearOrderedRing, Germ.commMonoid with }
 
-/- warning: filter.germ.max_def -> Filter.Germ.max_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrder.{u2} β] (x : Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (y : Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β), Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (LinearOrder.max.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.linearOrder.{u1, u2} α β φ _inst_1) x y) (Filter.Germ.map₂.{u1, u2, u2, u2} α β β β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) (LinearOrder.max.{u2} β _inst_1) x y)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrder.{u2} β] (x : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (y : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Max.max.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (LinearOrder.toMax.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.linearOrder.{u1, u2} α β φ _inst_1)) x y) (Filter.Germ.map₂.{u1, u2, u2, u2} α β β β (Ultrafilter.toFilter.{u1} α φ) (Max.max.{u2} β (LinearOrder.toMax.{u2} β _inst_1)) x y)
-Case conversion may be inaccurate. Consider using '#align filter.germ.max_def Filter.Germ.max_defₓ'. -/
 theorem max_def [LinearOrder β] (x y : β*) : max x y = map₂ max x y :=
   inductionOn₂ x y fun a b => by
     cases le_total (a : β*) b
@@ -258,12 +222,6 @@ theorem max_def [LinearOrder β] (x y : β*) : max x y = map₂ max x y :=
     · rw [max_eq_left h, map₂_coe, coe_eq]; exact h.mono fun i hi => (max_eq_left hi).symm
 #align filter.germ.max_def Filter.Germ.max_def
 
-/- warning: filter.germ.min_def -> Filter.Germ.min_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [K : LinearOrder.{u2} β] (x : Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (y : Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β), Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (LinearOrder.min.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.linearOrder.{u1, u2} α β φ K) x y) (Filter.Germ.map₂.{u1, u2, u2, u2} α β β β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) (LinearOrder.min.{u2} β K) x y)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [K : LinearOrder.{u2} β] (x : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (y : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Min.min.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (LinearOrder.toMin.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.linearOrder.{u1, u2} α β φ K)) x y) (Filter.Germ.map₂.{u1, u2, u2, u2} α β β β (Ultrafilter.toFilter.{u1} α φ) (Min.min.{u2} β (LinearOrder.toMin.{u2} β K)) x y)
-Case conversion may be inaccurate. Consider using '#align filter.germ.min_def Filter.Germ.min_defₓ'. -/
 theorem min_def [K : LinearOrder β] (x y : β*) : min x y = map₂ min x y :=
   inductionOn₂ x y fun a b => by
     cases le_total (a : β*) b
@@ -271,44 +229,20 @@ theorem min_def [K : LinearOrder β] (x y : β*) : min x y = map₂ min x y :=
     · rw [min_eq_right h, map₂_coe, coe_eq]; exact h.mono fun i hi => (min_eq_right hi).symm
 #align filter.germ.min_def Filter.Germ.min_def
 
-/- warning: filter.germ.abs_def -> Filter.Germ.abs_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β), Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasNeg.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))) (Filter.Germ.hasSup.{u1, u2} α β φ (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) x) (Filter.Germ.map.{u1, u2, u2} α β β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))) (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) x)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.neg.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))))) (Filter.Germ.sup.{u1, u2} α β φ (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) x) (Filter.Germ.map.{u1, u2, u2} α β β (Ultrafilter.toFilter.{u1} α φ) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))))) (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) x)
-Case conversion may be inaccurate. Consider using '#align filter.germ.abs_def Filter.Germ.abs_defₓ'. -/
 theorem abs_def [LinearOrderedAddCommGroup β] (x : β*) : |x| = map abs x :=
   inductionOn x fun a => rfl
 #align filter.germ.abs_def Filter.Germ.abs_def
 
-/- warning: filter.germ.const_max -> Filter.Germ.const_max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrder.{u2} β] (x : β) (y : β), Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) (LinearOrder.max.{u2} β _inst_1 x y)) (LinearOrder.max.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.linearOrder.{u1, u2} α β φ _inst_1) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) x) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrder.{u2} β] (x : β) (y : β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) (Max.max.{u2} β (LinearOrder.toMax.{u2} β _inst_1) x y)) (Max.max.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (LinearOrder.toMax.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.linearOrder.{u1, u2} α β φ _inst_1)) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) y))
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_max Filter.Germ.const_maxₓ'. -/
 @[simp]
 theorem const_max [LinearOrder β] (x y : β) : (↑(max x y : β) : β*) = max ↑x ↑y := by
   rw [max_def, map₂_const]
 #align filter.germ.const_max Filter.Germ.const_max
 
-/- warning: filter.germ.const_min -> Filter.Germ.const_min is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrder.{u2} β] (x : β) (y : β), Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) (LinearOrder.min.{u2} β _inst_1 x y)) (LinearOrder.min.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.linearOrder.{u1, u2} α β φ _inst_1) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) x) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) y))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrder.{u2} β] (x : β) (y : β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) (Min.min.{u2} β (LinearOrder.toMin.{u2} β _inst_1) x y)) (Min.min.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (LinearOrder.toMin.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.linearOrder.{u1, u2} α β φ _inst_1)) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) y))
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_min Filter.Germ.const_minₓ'. -/
 @[simp]
 theorem const_min [LinearOrder β] (x y : β) : (↑(min x y : β) : β*) = min ↑x ↑y := by
   rw [min_def, map₂_const]
 #align filter.germ.const_min Filter.Germ.const_min
 
-/- warning: filter.germ.const_abs -> Filter.Germ.const_abs is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : β), Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))) (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))) x)) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasNeg.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))) (Filter.Germ.hasSup.{u1, u2} α β φ (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))))) (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) x)) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.neg.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))))) (Filter.Germ.sup.{u1, u2} α β φ (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x))
-Case conversion may be inaccurate. Consider using '#align filter.germ.const_abs Filter.Germ.const_absₓ'. -/
 @[simp]
 theorem const_abs [LinearOrderedAddCommGroup β] (x : β) : (↑(|x|) : β*) = |↑x| := by
   rw [abs_def, map_const]

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

@@ -111,9 +111,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β], Eq.{max (succ u1) (succ u2)} ((Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) -> (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) -> Prop) (fun (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6816 : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6818 : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) => LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) x._@.Mathlib.Order.Filter.FilterProduct._hyg.6816 x._@.Mathlib.Order.Filter.FilterProduct._hyg.6818) (Filter.Germ.LiftRel.{u1, u2, u2} α β β (Ultrafilter.toFilter.{u1} α φ) (fun (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6832 : β) (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6834 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) x._@.Mathlib.Order.Filter.FilterProduct._hyg.6832 x._@.Mathlib.Order.Filter.FilterProduct._hyg.6834))
 Case conversion may be inaccurate. Consider using '#align filter.germ.lt_def Filter.Germ.lt_defₓ'. -/
-theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) :=
-  by
-  ext (⟨f⟩⟨g⟩)
+theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) := by ext (⟨f⟩⟨g⟩);
   exact coe_lt
 #align filter.germ.lt_def Filter.Germ.lt_def
 
@@ -256,10 +254,8 @@ Case conversion may be inaccurate. Consider using '#align filter.germ.max_def Fi
 theorem max_def [LinearOrder β] (x y : β*) : max x y = map₂ max x y :=
   inductionOn₂ x y fun a b => by
     cases le_total (a : β*) b
-    · rw [max_eq_right h, map₂_coe, coe_eq]
-      exact h.mono fun i hi => (max_eq_right hi).symm
-    · rw [max_eq_left h, map₂_coe, coe_eq]
-      exact h.mono fun i hi => (max_eq_left hi).symm
+    · rw [max_eq_right h, map₂_coe, coe_eq]; exact h.mono fun i hi => (max_eq_right hi).symm
+    · rw [max_eq_left h, map₂_coe, coe_eq]; exact h.mono fun i hi => (max_eq_left hi).symm
 #align filter.germ.max_def Filter.Germ.max_def
 
 /- warning: filter.germ.min_def -> Filter.Germ.min_def is a dubious translation:
@@ -271,10 +267,8 @@ Case conversion may be inaccurate. Consider using '#align filter.germ.min_def Fi
 theorem min_def [K : LinearOrder β] (x y : β*) : min x y = map₂ min x y :=
   inductionOn₂ x y fun a b => by
     cases le_total (a : β*) b
-    · rw [min_eq_left h, map₂_coe, coe_eq]
-      exact h.mono fun i hi => (min_eq_left hi).symm
-    · rw [min_eq_right h, map₂_coe, coe_eq]
-      exact h.mono fun i hi => (min_eq_right hi).symm
+    · rw [min_eq_left h, map₂_coe, coe_eq]; exact h.mono fun i hi => (min_eq_left hi).symm
+    · rw [min_eq_right h, map₂_coe, coe_eq]; exact h.mono fun i hi => (min_eq_right hi).symm
 #align filter.germ.min_def Filter.Germ.min_def
 
 /- warning: filter.germ.abs_def -> Filter.Germ.abs_def is a dubious translation:

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

@@ -64,38 +64,58 @@ instance [Semifield β] : Semifield β* :=
 instance [Field β] : Field β* :=
   { Germ.commRing, Germ.divisionRing with }
 
-#print Filter.Germ.coe_lt /-
+/- warning: filter.germ.coe_lt -> Filter.Germ.coe_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1)) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasCoeT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)))) f) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasCoeT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)))) g)) (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) (f x) (g x)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) (Filter.Germ.ofFun.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) f) (Filter.Germ.ofFun.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) g)) (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) (f x) (g x)) (Ultrafilter.toFilter.{u1} α φ))
+Case conversion may be inaccurate. Consider using '#align filter.germ.coe_lt Filter.Germ.coe_ltₓ'. -/
 theorem coe_lt [Preorder β] {f g : α → β} : (f : β*) < g ↔ ∀* x, f x < g x := by
   simp only [lt_iff_le_not_le, eventually_and, coe_le, eventually_not, eventually_le]
 #align filter.germ.coe_lt Filter.Germ.coe_lt
--/
 
-#print Filter.Germ.coe_pos /-
+/- warning: filter.germ.coe_pos -> Filter.Germ.coe_pos is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] [_inst_2 : Zero.{u2} β] {f : α -> β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1)) (OfNat.ofNat.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) 0 (OfNat.mk.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) 0 (Zero.zero.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasZero.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β _inst_2)))) ((fun (a : Sort.{max (succ u1) (succ u2)}) (b : Type.{max u1 u2}) [self : HasLiftT.{max (succ u1) (succ u2), succ (max u1 u2)} a b] => self.0) (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (HasLiftT.mk.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (CoeTCₓ.coe.{max (succ u1) (succ u2), succ (max u1 u2)} (α -> β) (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasCoeT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)))) f)) (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) (OfNat.ofNat.{u2} β 0 (OfNat.mk.{u2} β 0 (Zero.zero.{u2} β _inst_2))) (f x)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] [_inst_2 : Zero.{u2} β] {f : α -> β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) (OfNat.ofNat.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) 0 (Zero.toOfNat0.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.zero.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β _inst_2))) (Filter.Germ.ofFun.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) f)) (Filter.Eventually.{u1} α (fun (x : α) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) (OfNat.ofNat.{u2} β 0 (Zero.toOfNat0.{u2} β _inst_2)) (f x)) (Ultrafilter.toFilter.{u1} α φ))
+Case conversion may be inaccurate. Consider using '#align filter.germ.coe_pos Filter.Germ.coe_posₓ'. -/
 theorem coe_pos [Preorder β] [Zero β] {f : α → β} : 0 < (f : β*) ↔ ∀* x, 0 < f x :=
   coe_lt
 #align filter.germ.coe_pos Filter.Germ.coe_pos
--/
 
-#print Filter.Germ.const_lt /-
+/- warning: filter.germ.const_lt -> Filter.Germ.const_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {x : β} {y : β}, (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) x y) -> (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1)) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) x) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) y))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {x : β} {y : β}, (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) x y) -> (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) y))
+Case conversion may be inaccurate. Consider using '#align filter.germ.const_lt Filter.Germ.const_ltₓ'. -/
 theorem const_lt [Preorder β] {x y : β} : x < y → (↑x : β*) < ↑y :=
   coe_lt.mpr ∘ liftRel_const
 #align filter.germ.const_lt Filter.Germ.const_lt
--/
 
-#print Filter.Germ.const_lt_iff /-
+/- warning: filter.germ.const_lt_iff -> Filter.Germ.const_lt_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {x : β} {y : β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1)) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) x) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) y)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1) x y)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β] {x : β} {y : β}, Iff (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) y)) (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) x y)
+Case conversion may be inaccurate. Consider using '#align filter.germ.const_lt_iff Filter.Germ.const_lt_iffₓ'. -/
 @[simp, norm_cast]
 theorem const_lt_iff [Preorder β] {x y : β} : (↑x : β*) < ↑y ↔ x < y :=
   coe_lt.trans liftRel_const_iff
 #align filter.germ.const_lt_iff Filter.Germ.const_lt_iff
--/
 
-#print Filter.Germ.lt_def /-
+/- warning: filter.germ.lt_def -> Filter.Germ.lt_def is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β], Eq.{succ (max u1 u2)} ((Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) -> (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) -> Prop) (LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Preorder.toHasLt.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.preorder.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) _inst_1))) (Filter.Germ.LiftRel.{u1, u2, u2} α β β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : Preorder.{u2} β], Eq.{max (succ u1) (succ u2)} ((Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) -> (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) -> Prop) (fun (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6816 : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6818 : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) => LT.lt.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Preorder.toLT.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.preorder.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) _inst_1)) x._@.Mathlib.Order.Filter.FilterProduct._hyg.6816 x._@.Mathlib.Order.Filter.FilterProduct._hyg.6818) (Filter.Germ.LiftRel.{u1, u2, u2} α β β (Ultrafilter.toFilter.{u1} α φ) (fun (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6832 : β) (x._@.Mathlib.Order.Filter.FilterProduct._hyg.6834 : β) => LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_1) x._@.Mathlib.Order.Filter.FilterProduct._hyg.6832 x._@.Mathlib.Order.Filter.FilterProduct._hyg.6834))
+Case conversion may be inaccurate. Consider using '#align filter.germ.lt_def Filter.Germ.lt_defₓ'. -/
 theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) :=
   by
   ext (⟨f⟩⟨g⟩)
   exact coe_lt
 #align filter.germ.lt_def Filter.Germ.lt_def
--/
 
 instance [Sup β] : Sup β* :=
   ⟨map₂ (· ⊔ ·)⟩

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

@@ -97,22 +97,22 @@ theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (·
 #align filter.germ.lt_def Filter.Germ.lt_def
 -/
 
-instance [HasSup β] : HasSup β* :=
+instance [Sup β] : Sup β* :=
   ⟨map₂ (· ⊔ ·)⟩
 
-instance [HasInf β] : HasInf β* :=
+instance [Inf β] : Inf β* :=
   ⟨map₂ (· ⊓ ·)⟩
 
 #print Filter.Germ.const_sup /-
 @[simp, norm_cast]
-theorem const_sup [HasSup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : β*) :=
+theorem const_sup [Sup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : β*) :=
   rfl
 #align filter.germ.const_sup Filter.Germ.const_sup
 -/
 
 #print Filter.Germ.const_inf /-
 @[simp, norm_cast]
-theorem const_inf [HasInf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : β*) :=
+theorem const_inf [Inf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : β*) :=
   rfl
 #align filter.germ.const_inf Filter.Germ.const_inf
 -/
@@ -261,7 +261,7 @@ theorem min_def [K : LinearOrder β] (x y : β*) : min x y = map₂ min x y :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β), Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasNeg.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))) (Filter.Germ.hasSup.{u1, u2} α β φ (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) x) (Filter.Germ.map.{u1, u2, u2} α β β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))) (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) x)
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.neg.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))))) (Filter.Germ.hasSup.{u1, u2} α β φ (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) x) (Filter.Germ.map.{u1, u2, u2} α β β (Ultrafilter.toFilter.{u1} α φ) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))))) (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) x)
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.neg.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))))) (Filter.Germ.sup.{u1, u2} α β φ (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) x) (Filter.Germ.map.{u1, u2, u2} α β β (Ultrafilter.toFilter.{u1} α φ) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))))) (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) x)
 Case conversion may be inaccurate. Consider using '#align filter.germ.abs_def Filter.Germ.abs_defₓ'. -/
 theorem abs_def [LinearOrderedAddCommGroup β] (x : β*) : |x| = map abs x :=
   inductionOn x fun a => rfl
@@ -293,7 +293,7 @@ theorem const_min [LinearOrder β] (x y : β) : (↑(min x y : β) : β*) = min
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : β), Eq.{succ (max u1 u2)} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))) (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))) x)) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasNeg.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (AddCommGroup.toAddGroup.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))) (Filter.Germ.hasSup.{u1, u2} α β φ (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (LinearOrder.toLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) ((fun (a : Type.{u2}) (b : Type.{max u1 u2}) [self : HasLiftT.{succ u2, succ (max u1 u2)} a b] => self.0) β (Filter.Germ.{u1, u2} α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ) β) (Filter.Germ.hasLiftT.{u1, u2} α β ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Ultrafilter.{u1} α) (Filter.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Ultrafilter.{u1} α) (Filter.{u1} α) (Ultrafilter.Filter.hasCoeT.{u1} α))) φ)) x))
 but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))))) (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) x)) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.neg.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))))) (Filter.Germ.hasSup.{u1, u2} α β φ (SemilatticeSup.toHasSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x))
+  forall {α : Type.{u1}} {β : Type.{u2}} {φ : Ultrafilter.{u1} α} [_inst_1 : LinearOrderedAddCommGroup.{u2} β] (x : β), Eq.{max (succ u1) (succ u2)} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) (Abs.abs.{u2} β (Neg.toHasAbs.{u2} β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1))))))) (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1)))))) x)) (Abs.abs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Neg.toHasAbs.{max u1 u2} (Filter.Germ.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β) (Filter.Germ.neg.{u1, u2} α (Ultrafilter.toFilter.{u1} α φ) β (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (OrderedAddCommGroup.toAddCommGroup.{u2} β (LinearOrderedAddCommGroup.toOrderedAddCommGroup.{u2} β _inst_1)))))))) (Filter.Germ.sup.{u1, u2} α β φ (SemilatticeSup.toSup.{u2} β (Lattice.toSemilatticeSup.{u2} β (DistribLattice.toLattice.{u2} β (instDistribLattice.{u2} β (LinearOrderedAddCommGroup.toLinearOrder.{u2} β _inst_1))))))) (Filter.Germ.const.{u1, u2} α β (Ultrafilter.toFilter.{u1} α φ) x))
 Case conversion may be inaccurate. Consider using '#align filter.germ.const_abs Filter.Germ.const_absₓ'. -/
 @[simp]
 theorem const_abs [LinearOrderedAddCommGroup β] (x : β) : (↑(|x|) : β*) = |↑x| := by

mathlib commit https://github.com/leanprover-community/mathlib/commit/3ade05ac9447ae31a22d2ea5423435e054131240

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Abhimanyu Pallavi Sudhir, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module order.filter.filter_product
-! leanprover-community/mathlib commit 3592f45eeaf90143256b1dee3c20aade62924b0c
+! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Order.Filter.Germ
 /-!
 # Ultraproducts
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 If `φ` is an ultrafilter, then the space of germs of functions `f : α → β` at `φ` is called
 the *ultraproduct*. In this file we prove properties of ultraproducts that rely on `φ` being an
 ultrafilter. Definitions and properties that work for any filter should go to `order.filter.germ`.

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

Define the canonical coercion from the nonnegative rationals to any division semiring.

From LeanAPAP

@@ -47,6 +47,7 @@ instance instGroupWithZero [GroupWithZero β] : GroupWithZero β* where
 instance instDivisionSemiring [DivisionSemiring β] : DivisionSemiring β* where
   toSemiring := instSemiring
   __ := instGroupWithZero
+  nnqsmul := _
 
 instance instDivisionRing [DivisionRing β] : DivisionRing β* where
   __ := instRing

Fix a few names and deduplicate the AddCommGroup ℤ instance

@@ -37,27 +37,29 @@ open Ultrafilter
 
 local notation "β*" => Germ (φ : Filter α) β
 
-instance groupWithZero [GroupWithZero β] : GroupWithZero β* :=
-  { Germ.divInvMonoid, Germ.monoidWithZero with
-    mul_inv_cancel := fun f => inductionOn f fun f hf => coe_eq.2 <|
-      (φ.em fun y => f y = 0).elim (fun H => (hf <| coe_eq.2 H).elim) fun H =>
-        H.mono fun x => mul_inv_cancel
-    inv_zero := coe_eq.2 <| by
-       simp only [Function.comp, inv_zero]
-       exact EventuallyEq.refl _ fun _ => 0 }
-
-instance divisionSemiring [DivisionSemiring β] : DivisionSemiring β* where
-  toSemiring := Germ.semiring
-  __ := Germ.groupWithZero
-
-instance divisionRing [DivisionRing β] : DivisionRing β* :=
-  { Germ.ring, Germ.divisionSemiring with qsmul := qsmulRec _ }
-
-instance semifield [Semifield β] : Semifield β* :=
-  { Germ.commSemiring, Germ.divisionSemiring with }
-
-instance field [Field β] : Field β* :=
-  { Germ.commRing, Germ.divisionRing with }
+instance instGroupWithZero [GroupWithZero β] : GroupWithZero β* where
+  __ := instDivInvMonoid
+  __ := instMonoidWithZero
+  mul_inv_cancel f := inductionOn f fun f hf ↦ coe_eq.2 <| (φ.em fun y ↦ f y = 0).elim
+    (fun H ↦ (hf <| coe_eq.2 H).elim) fun H ↦ H.mono fun x ↦ mul_inv_cancel
+  inv_zero := coe_eq.2 <| by simp only [Function.comp, inv_zero, EventuallyEq.rfl]
+
+instance instDivisionSemiring [DivisionSemiring β] : DivisionSemiring β* where
+  toSemiring := instSemiring
+  __ := instGroupWithZero
+
+instance instDivisionRing [DivisionRing β] : DivisionRing β* where
+  __ := instRing
+  __ := instDivisionSemiring
+  qsmul := _
+
+instance instSemifield [Semifield β] : Semifield β* where
+  __ := instCommSemiring
+  __ := instDivisionSemiring
+
+instance instField [Field β] : Field β* where
+  __ := instCommRing
+  __ := instDivisionRing
 
 theorem coe_lt [Preorder β] {f g : α → β} : (f : β*) < g ↔ ∀* x, f x < g x := by
   simp only [lt_iff_le_not_le, eventually_and, coe_le, eventually_not, EventuallyLE]
@@ -86,46 +88,51 @@ instance isTotal [LE β] [IsTotal β (· ≤ ·)] : IsTotal β* (· ≤ ·) :=
     inductionOn₂ f g fun _f _g => eventually_or.1 <| eventually_of_forall fun _x => total_of _ _ _⟩
 
 /-- If `φ` is an ultrafilter then the ultraproduct is a linear order. -/
-noncomputable instance linearOrder [LinearOrder β] : LinearOrder β* :=
+noncomputable instance instLinearOrder [LinearOrder β] : LinearOrder β* :=
   Lattice.toLinearOrder _
 
 @[to_additive]
 noncomputable instance linearOrderedCommGroup [LinearOrderedCommGroup β] :
-    LinearOrderedCommGroup β* :=
-  { Germ.orderedCommGroup, Germ.linearOrder with }
-
-instance strictOrderedSemiring [StrictOrderedSemiring β] : StrictOrderedSemiring β* :=
-  { Germ.orderedSemiring, Germ.orderedAddCancelCommMonoid,
-    Germ.nontrivial with
-    mul_lt_mul_of_pos_left := fun x y z =>
-      inductionOn₃ x y z fun _f _g _h hfg hh =>
-        coe_lt.2 <| (coe_lt.1 hh).mp <| (coe_lt.1 hfg).mono fun _a => mul_lt_mul_of_pos_left
-    mul_lt_mul_of_pos_right := fun x y z =>
-      inductionOn₃ x y z fun _f _g _h hfg hh =>
-        coe_lt.2 <| (coe_lt.1 hh).mp <| (coe_lt.1 hfg).mono fun _a => mul_lt_mul_of_pos_right }
-
-instance strictOrderedCommSemiring [StrictOrderedCommSemiring β] : StrictOrderedCommSemiring β* :=
-  { Germ.strictOrderedSemiring, Germ.orderedCommSemiring with }
-
-instance strictOrderedRing [StrictOrderedRing β] : StrictOrderedRing β* :=
-  { Germ.ring,
-    Germ.strictOrderedSemiring with
-    zero_le_one := const_le zero_le_one
-    mul_pos := fun x y =>
-      inductionOn₂ x y fun _f _g hf hg =>
-        coe_pos.2 <| (coe_pos.1 hg).mp <| (coe_pos.1 hf).mono fun _x => mul_pos }
-
-instance strictOrderedCommRing [StrictOrderedCommRing β] : StrictOrderedCommRing β* :=
-  { Germ.strictOrderedRing, Germ.orderedCommRing with }
-
-noncomputable instance linearOrderedRing [LinearOrderedRing β] : LinearOrderedRing β* :=
-  { Germ.strictOrderedRing, Germ.linearOrder with }
-
-noncomputable instance linearOrderedField [LinearOrderedField β] : LinearOrderedField β* :=
-  { Germ.linearOrderedRing, Germ.field with }
-
-noncomputable instance linearOrderedCommRing [LinearOrderedCommRing β] : LinearOrderedCommRing β* :=
-  { Germ.linearOrderedRing, Germ.commMonoid with }
+    LinearOrderedCommGroup β* where
+  __ := instOrderedCommGroup
+  __ := instLinearOrder
+
+instance instStrictOrderedSemiring [StrictOrderedSemiring β] : StrictOrderedSemiring β* where
+  __ := instOrderedSemiring
+  __ := instOrderedAddCancelCommMonoid
+  mul_lt_mul_of_pos_left x y z := inductionOn₃ x y z fun _f _g _h hfg hh ↦
+    coe_lt.2 <| (coe_lt.1 hh).mp <| (coe_lt.1 hfg).mono fun _a ↦ mul_lt_mul_of_pos_left
+  mul_lt_mul_of_pos_right x y z := inductionOn₃ x y z fun _f _g _h hfg hh ↦
+    coe_lt.2 <| (coe_lt.1 hh).mp <| (coe_lt.1 hfg).mono fun _a ↦ mul_lt_mul_of_pos_right
+
+instance instStrictOrderedCommSemiring [StrictOrderedCommSemiring β] :
+    StrictOrderedCommSemiring β* where
+  __ := instStrictOrderedSemiring
+  __ := instOrderedCommSemiring
+
+instance instStrictOrderedRing [StrictOrderedRing β] : StrictOrderedRing β* where
+  __ := instRing
+  __ := instStrictOrderedSemiring
+  zero_le_one := const_le zero_le_one
+  mul_pos x y := inductionOn₂ x y fun _f _g hf hg ↦
+    coe_pos.2 <| (coe_pos.1 hg).mp <| (coe_pos.1 hf).mono fun _x ↦ mul_pos
+
+instance instStrictOrderedCommRing [StrictOrderedCommRing β] : StrictOrderedCommRing β* where
+  __ := instStrictOrderedRing
+  __ := instOrderedCommRing
+
+noncomputable instance instLinearOrderedRing [LinearOrderedRing β] : LinearOrderedRing β* where
+  __ := instStrictOrderedRing
+  __ := instLinearOrder
+
+noncomputable instance instLinearOrderedField [LinearOrderedField β] : LinearOrderedField β* where
+  __ := instLinearOrderedRing
+  __ := instField
+
+noncomputable instance instLinearOrderedCommRing [LinearOrderedCommRing β] :
+    LinearOrderedCommRing β* where
+  __ := instLinearOrderedRing
+  __ := instCommMonoid
 
 theorem max_def [LinearOrder β] (x y : β*) : max x y = map₂ max x y :=
   inductionOn₂ x y fun a b => by

Follows on from #6262. Again, this does not attempt to fix any diamonds; it only identifies where they may be.

@@ -51,7 +51,7 @@ instance divisionSemiring [DivisionSemiring β] : DivisionSemiring β* where
   __ := Germ.groupWithZero
 
 instance divisionRing [DivisionRing β] : DivisionRing β* :=
-  { Germ.ring, Germ.divisionSemiring with }
+  { Germ.ring, Germ.divisionSemiring with qsmul := qsmulRec _ }
 
 instance semifield [Semifield β] : Semifield β* :=
   { Germ.commSemiring, Germ.divisionSemiring with }

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -25,7 +25,7 @@ universe u v
 
 variable {α : Type u} {β : Type v} {φ : Ultrafilter α}
 
-open Classical
+open scoped Classical
 
 namespace Filter
 

I literally went through and regex'd some uses of cases', replacing them with rcases; this is meant to be a low effort PR as I hope that tools can do this in the future.

rcases is an easier replacement than cases, though with better tools we could in future do a second pass converting simple rcases added here (and existing ones) to cases.

@@ -129,7 +129,7 @@ noncomputable instance linearOrderedCommRing [LinearOrderedCommRing β] : Linear
 
 theorem max_def [LinearOrder β] (x y : β*) : max x y = map₂ max x y :=
   inductionOn₂ x y fun a b => by
-    cases' le_total (a : β*) b with h h
+    rcases le_total (a : β*) b with h | h
     · rw [max_eq_right h, map₂_coe, coe_eq]
       exact h.mono fun i hi => (max_eq_right hi).symm
     · rw [max_eq_left h, map₂_coe, coe_eq]
@@ -138,7 +138,7 @@ theorem max_def [LinearOrder β] (x y : β*) : max x y = map₂ max x y :=
 
 theorem min_def [K : LinearOrder β] (x y : β*) : min x y = map₂ min x y :=
   inductionOn₂ x y fun a b => by
-    cases' le_total (a : β*) b with h h
+    rcases le_total (a : β*) b with h | h
     · rw [min_eq_left h, map₂_coe, coe_eq]
       exact h.mono fun i hi => (min_eq_left hi).symm
     · rw [min_eq_right h, map₂_coe, coe_eq]

Motivated by the Sphere Eversion Project.

@@ -37,17 +37,18 @@ open Ultrafilter
 
 local notation "β*" => Germ (φ : Filter α) β
 
-instance divisionSemiring [DivisionSemiring β] : DivisionSemiring β* :=
-  { Germ.semiring, Germ.divInvMonoid,
-    Germ.nontrivial with
-    mul_inv_cancel := fun f =>
-      inductionOn f fun f hf =>
-        coe_eq.2 <|
-          (φ.em fun y => f y = 0).elim (fun H => (hf <| coe_eq.2 H).elim) fun H =>
-            H.mono fun x => mul_inv_cancel
+instance groupWithZero [GroupWithZero β] : GroupWithZero β* :=
+  { Germ.divInvMonoid, Germ.monoidWithZero with
+    mul_inv_cancel := fun f => inductionOn f fun f hf => coe_eq.2 <|
+      (φ.em fun y => f y = 0).elim (fun H => (hf <| coe_eq.2 H).elim) fun H =>
+        H.mono fun x => mul_inv_cancel
     inv_zero := coe_eq.2 <| by
        simp only [Function.comp, inv_zero]
-       exact EventuallyEq.refl _ fun _ => 0}
+       exact EventuallyEq.refl _ fun _ => 0 }
+
+instance divisionSemiring [DivisionSemiring β] : DivisionSemiring β* where
+  toSemiring := Germ.semiring
+  __ := Germ.groupWithZero
 
 instance divisionRing [DivisionRing β] : DivisionRing β* :=
   { Germ.ring, Germ.divisionSemiring with }
@@ -80,50 +81,6 @@ theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (·
   exact coe_lt
 #align filter.germ.lt_def Filter.Germ.lt_def
 
-instance sup [Sup β] : Sup β* :=
-  ⟨map₂ (· ⊔ ·)⟩
-
-instance inf [Inf β] : Inf β* :=
-  ⟨map₂ (· ⊓ ·)⟩
-
-@[simp, norm_cast]
-theorem const_sup [Sup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : β*) :=
-  rfl
-#align filter.germ.const_sup Filter.Germ.const_sup
-
-@[simp, norm_cast]
-theorem const_inf [Inf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : β*) :=
-  rfl
-#align filter.germ.const_inf Filter.Germ.const_inf
-
-instance semilatticeSup [SemilatticeSup β] : SemilatticeSup β* :=
-  { Germ.partialOrder with
-    sup := (· ⊔ ·)
-    le_sup_left := fun f g =>
-        inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => le_sup_left
-    le_sup_right := fun f g =>
-      inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => le_sup_right
-    sup_le := fun f₁ f₂ g =>
-      inductionOn₃ f₁ f₂ g fun _f₁ _f₂ _g h₁ h₂ => h₂.mp <| h₁.mono fun _x => sup_le }
-
-instance semilatticeInf [SemilatticeInf β] : SemilatticeInf β* :=
-  { Germ.partialOrder with
-    inf := (· ⊓ ·)
-    inf_le_left := fun f g =>
-        inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => inf_le_left
-    inf_le_right := fun f g =>
-      inductionOn₂ f g fun _f _g => eventually_of_forall fun _x => inf_le_right
-    le_inf := fun f₁ f₂ g =>
-      inductionOn₃ f₁ f₂ g fun _f₁ _f₂ _g h₁ h₂ => h₂.mp <| h₁.mono fun _x => le_inf }
-
-instance lattice [Lattice β] : Lattice β* :=
-  { Germ.semilatticeSup, Germ.semilatticeInf with }
-
-instance distribLattice [DistribLattice β] : DistribLattice β* :=
-  { Germ.semilatticeSup, Germ.semilatticeInf with
-    le_sup_inf := fun f g h =>
-      inductionOn₃ f g h fun _f _g _h => eventually_of_forall fun _ => le_sup_inf }
-
 instance isTotal [LE β] [IsTotal β (· ≤ ·)] : IsTotal β* (· ≤ ·) :=
   ⟨fun f g =>
     inductionOn₂ f g fun _f _g => eventually_or.1 <| eventually_of_forall fun _x => total_of _ _ _⟩
@@ -132,53 +89,11 @@ instance isTotal [LE β] [IsTotal β (· ≤ ·)] : IsTotal β* (· ≤ ·) :=
 noncomputable instance linearOrder [LinearOrder β] : LinearOrder β* :=
   Lattice.toLinearOrder _
 
-@[to_additive]
-instance orderedCommMonoid [OrderedCommMonoid β] : OrderedCommMonoid β* :=
-  { Germ.partialOrder, Germ.commMonoid with
-    mul_le_mul_left := fun f g =>
-      inductionOn₂ f g fun _f _g H h =>
-        inductionOn h fun _h => H.mono fun _x H => mul_le_mul_left' H _ }
-
-@[to_additive]
-instance orderedCancelCommMonoid [OrderedCancelCommMonoid β]  :
-    OrderedCancelCommMonoid β* :=
-  { Germ.orderedCommMonoid with
-    le_of_mul_le_mul_left := fun f g h =>
-      inductionOn₃ f g h fun _f _g _h H => H.mono fun _x => le_of_mul_le_mul_left' }
-
-@[to_additive]
-instance orderedCommGroup [OrderedCommGroup β] : OrderedCommGroup β* :=
-  { Germ.orderedCancelCommMonoid, Germ.commGroup with }
-
 @[to_additive]
 noncomputable instance linearOrderedCommGroup [LinearOrderedCommGroup β] :
     LinearOrderedCommGroup β* :=
   { Germ.orderedCommGroup, Germ.linearOrder with }
 
-instance orderedSemiring [OrderedSemiring β] : OrderedSemiring β* :=
-  { Germ.semiring,
-    Germ.orderedAddCommMonoid with
-    zero_le_one := const_le zero_le_one
-    mul_le_mul_of_nonneg_left := fun x y z =>
-      inductionOn₃ x y z fun _f _g _h hfg hh =>
-          hh.mp <| hfg.mono fun _a => mul_le_mul_of_nonneg_left
-    mul_le_mul_of_nonneg_right := fun x y z =>
-      inductionOn₃ x y z fun _f _g _h hfg hh =>
-          hh.mp <| hfg.mono fun _a => mul_le_mul_of_nonneg_right }
-
-instance orderedCommSemiring [OrderedCommSemiring β] : OrderedCommSemiring β* :=
-  { Germ.orderedSemiring, Germ.commSemiring with }
-
-instance orderedRing [OrderedRing β] : OrderedRing β* :=
-  { Germ.ring,
-    Germ.orderedAddCommGroup with
-    zero_le_one := const_le zero_le_one
-    mul_nonneg := fun x y =>
-      inductionOn₂ x y fun _f _g hf hg => hg.mp <| hf.mono fun _a => mul_nonneg }
-
-instance orderedCommRing [OrderedCommRing β] : OrderedCommRing β* :=
-  { Germ.orderedRing, Germ.orderedCommSemiring with }
-
 instance strictOrderedSemiring [StrictOrderedSemiring β] : StrictOrderedSemiring β* :=
   { Germ.orderedSemiring, Germ.orderedAddCancelCommMonoid,
     Germ.nontrivial with

• 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 Abhimanyu Pallavi Sudhir. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Abhimanyu Pallavi Sudhir, Yury Kudryashov
-
-! This file was ported from Lean 3 source module order.filter.filter_product
-! leanprover-community/mathlib commit 2738d2ca56cbc63be80c3bd48e9ed90ad94e947d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.Ultrafilter
 import Mathlib.Order.Filter.Germ
 
+#align_import order.filter.filter_product from "leanprover-community/mathlib"@"2738d2ca56cbc63be80c3bd48e9ed90ad94e947d"
+
 /-!
 # Ultraproducts
 

@@ -248,7 +248,7 @@ theorem const_min [LinearOrder β] (x y : β) : (↑(min x y : β) : β*) = min
 #align filter.germ.const_min Filter.Germ.const_min
 
 @[simp]
-theorem const_abs [LinearOrderedAddCommGroup β] (x : β) : (↑(|x|) : β*) = |↑x| := by
+theorem const_abs [LinearOrderedAddCommGroup β] (x : β) : (↑|x| : β*) = |↑x| := by
   rw [abs_def, map_const]
 #align filter.germ.const_abs Filter.Germ.const_abs
 

Gives the notation3 command the ability to generate a delaborator in most common situations. When it succeeds, notation3-defined syntax is pretty printable.

Examples:

(⋃ (i : ι) (i' : ι'), s i i') = ⋃ (i' : ι') (i : ι), s i i'
(⨆ (g : α → ℝ≥0∞) (_ : Measurable g) (_ : g ≤ f), ∫⁻ (a : α), g a ∂μ) = ∫⁻ (a : α), f a ∂μ

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -32,7 +32,7 @@ open Classical
 
 namespace Filter
 
-local notation3 "∀* "(...)", "r:(scoped p => Filter.Eventually p φ) => r
+local notation3 "∀* "(...)", "r:(scoped p => Filter.Eventually p (Ultrafilter.toFilter φ)) => r
 
 namespace Germ
 

This fixes a bunch of spacing bugs in tactics. Mathlib counterpart of:

• Lean: leanprover/lean4#2240
• Std: leanprover/std4#149
• Aesop: JLimperg/aesop#56

@@ -32,7 +32,7 @@ open Classical
 
 namespace Filter
 
-local notation3"∀* "(...)", "r:(scoped p => Filter.Eventually p φ) => r
+local notation3 "∀* "(...)", "r:(scoped p => Filter.Eventually p φ) => r
 
 namespace Germ
 

@@ -79,7 +79,7 @@ theorem const_lt_iff [Preorder β] {x y : β} : (↑x : β*) < ↑y ↔ x < y :=
 #align filter.germ.const_lt_iff Filter.Germ.const_lt_iff
 
 theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) := by
-  ext (⟨f⟩⟨g⟩)
+  ext ⟨f⟩ ⟨g⟩
   exact coe_lt
 #align filter.germ.lt_def Filter.Germ.lt_def
 

@@ -62,7 +62,7 @@ instance field [Field β] : Field β* :=
   { Germ.commRing, Germ.divisionRing with }
 
 theorem coe_lt [Preorder β] {f g : α → β} : (f : β*) < g ↔ ∀* x, f x < g x := by
-  simp only [lt_iff_le_not_le, eventually_and, coe_le, eventually_not, EventuallyLe]
+  simp only [lt_iff_le_not_le, eventually_and, coe_le, eventually_not, EventuallyLE]
 #align filter.germ.coe_lt Filter.Germ.coe_lt
 
 theorem coe_pos [Preorder β] [Zero β] {f : α → β} : 0 < (f : β*) ↔ ∀* x, 0 < f x :=

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -83,19 +83,19 @@ theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (·
   exact coe_lt
 #align filter.germ.lt_def Filter.Germ.lt_def
 
-instance hasSup [HasSup β] : HasSup β* :=
+instance sup [Sup β] : Sup β* :=
   ⟨map₂ (· ⊔ ·)⟩
 
-instance hasInf [HasInf β] : HasInf β* :=
+instance inf [Inf β] : Inf β* :=
   ⟨map₂ (· ⊓ ·)⟩
 
 @[simp, norm_cast]
-theorem const_sup [HasSup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : β*) :=
+theorem const_sup [Sup β] (a b : β) : ↑(a ⊔ b) = (↑a ⊔ ↑b : β*) :=
   rfl
 #align filter.germ.const_sup Filter.Germ.const_sup
 
 @[simp, norm_cast]
-theorem const_inf [HasInf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : β*) :=
+theorem const_inf [Inf β] (a b : β) : ↑(a ⊓ b) = (↑a ⊓ ↑b : β*) :=
   rfl
 #align filter.germ.const_inf Filter.Germ.const_inf
 

also names instances in Order.Filter.Germ