Changes since the initial port

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

Changes in mathlib3

655994e2

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

448144f7

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Mathbin.Algebra.Order.Ring.Defs
-import Mathbin.Algebra.Ring.InjSurj
+import Algebra.Order.Ring.Defs
+import Algebra.Ring.InjSurj
 
 #align_import algebra.order.positive.ring from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module algebra.order.positive.ring
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Order.Ring.Defs
 import Mathbin.Algebra.Ring.InjSurj
 
+#align_import algebra.order.positive.ring from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Algebraic structures on the set of positive numbers

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -36,10 +36,12 @@ variable [AddMonoid M] [Preorder M] [CovariantClass M M (· + ·) (· < ·)]
 instance : Add { x : M // 0 < x } :=
   ⟨fun x y => ⟨x + y, add_pos x.2 y.2⟩⟩
 
+#print Positive.coe_add /-
 @[simp, norm_cast]
 theorem coe_add (x y : { x : M // 0 < x }) : ↑(x + y) = (x + y : M) :=
   rfl
 #align positive.coe_add Positive.coe_add
+-/
 
 instance : AddSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.AddSemigroup _ coe_add
@@ -56,42 +58,56 @@ instance {M : Type _} [AddRightCancelMonoid M] [Preorder M] [CovariantClass M M
     AddRightCancelSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.AddRightCancelSemigroup _ coe_add
 
+#print Positive.covariantClass_add_lt /-
 instance covariantClass_add_lt :
     CovariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· < ·) :=
   ⟨fun x y z hyz => Subtype.coe_lt_coe.1 <| add_lt_add_left hyz _⟩
 #align positive.covariant_class_add_lt Positive.covariantClass_add_lt
+-/
 
+#print Positive.covariantClass_swap_add_lt /-
 instance covariantClass_swap_add_lt [CovariantClass M M (swap (· + ·)) (· < ·)] :
     CovariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· < ·) :=
   ⟨fun x y z hyz => Subtype.coe_lt_coe.1 <| add_lt_add_right hyz _⟩
 #align positive.covariant_class_swap_add_lt Positive.covariantClass_swap_add_lt
+-/
 
+#print Positive.contravariantClass_add_lt /-
 instance contravariantClass_add_lt [ContravariantClass M M (· + ·) (· < ·)] :
     ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· < ·) :=
   ⟨fun x y z h => Subtype.coe_lt_coe.1 <| lt_of_add_lt_add_left h⟩
 #align positive.contravariant_class_add_lt Positive.contravariantClass_add_lt
+-/
 
+#print Positive.contravariantClass_swap_add_lt /-
 instance contravariantClass_swap_add_lt [ContravariantClass M M (swap (· + ·)) (· < ·)] :
     ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· < ·) :=
   ⟨fun x y z h => Subtype.coe_lt_coe.1 <| lt_of_add_lt_add_right h⟩
 #align positive.contravariant_class_swap_add_lt Positive.contravariantClass_swap_add_lt
+-/
 
+#print Positive.contravariantClass_add_le /-
 instance contravariantClass_add_le [ContravariantClass M M (· + ·) (· ≤ ·)] :
     ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· ≤ ·) :=
   ⟨fun x y z h => Subtype.coe_le_coe.1 <| le_of_add_le_add_left h⟩
 #align positive.contravariant_class_add_le Positive.contravariantClass_add_le
+-/
 
+#print Positive.contravariantClass_swap_add_le /-
 instance contravariantClass_swap_add_le [ContravariantClass M M (swap (· + ·)) (· ≤ ·)] :
     ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· ≤ ·) :=
   ⟨fun x y z h => Subtype.coe_le_coe.1 <| le_of_add_le_add_right h⟩
 #align positive.contravariant_class_swap_add_le Positive.contravariantClass_swap_add_le
+-/
 
 end AddBasic
 
+#print Positive.covariantClass_add_le /-
 instance covariantClass_add_le [AddMonoid M] [PartialOrder M] [CovariantClass M M (· + ·) (· < ·)] :
     CovariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· ≤ ·) :=
   ⟨fun x => StrictMono.monotone fun _ _ h => add_lt_add_left h _⟩
 #align positive.covariant_class_add_le Positive.covariantClass_add_le
+-/
 
 section Mul
 
@@ -100,18 +116,22 @@ variable [StrictOrderedSemiring R]
 instance : Mul { x : R // 0 < x } :=
   ⟨fun x y => ⟨x * y, mul_pos x.2 y.2⟩⟩
 
+#print Positive.val_mul /-
 @[simp]
 theorem val_mul (x y : { x : R // 0 < x }) : ↑(x * y) = (x * y : R) :=
   rfl
 #align positive.coe_mul Positive.val_mul
+-/
 
 instance : Pow { x : R // 0 < x } ℕ :=
   ⟨fun x n => ⟨x ^ n, pow_pos x.2 n⟩⟩
 
+#print Positive.val_pow /-
 @[simp]
 theorem val_pow (x : { x : R // 0 < x }) (n : ℕ) : ↑(x ^ n) = (x ^ n : R) :=
   rfl
 #align positive.coe_pow Positive.val_pow
+-/
 
 instance : Semigroup { x : R // 0 < x } :=
   Subtype.coe_injective.Semigroup coe val_mul

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -36,12 +36,6 @@ variable [AddMonoid M] [Preorder M] [CovariantClass M M (· + ·) (· < ·)]
 instance : Add { x : M // 0 < x } :=
   ⟨fun x y => ⟨x + y, add_pos x.2 y.2⟩⟩
 
-/- warning: positive.coe_add -> Positive.coe_add is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] (x : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (y : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)) x y)) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) y))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.161 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.163 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.161 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.163) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.176 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.178 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.176 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.178)] (x : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (y : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)), Eq.{succ u1} M (Subtype.val.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x y)) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) (Subtype.val.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x) x) (Subtype.val.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x) y))
-Case conversion may be inaccurate. Consider using '#align positive.coe_add Positive.coe_addₓ'. -/
 @[simp, norm_cast]
 theorem coe_add (x y : { x : M // 0 < x }) : ↑(x + y) = (x + y : M) :=
   rfl
@@ -62,67 +56,31 @@ instance {M : Type _} [AddRightCancelMonoid M] [Preorder M] [CovariantClass M M
     AddRightCancelSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.AddRightCancelSemigroup _ coe_add
 
-/- warning: positive.covariant_class_add_lt -> Positive.covariantClass_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.628 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.630 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.628 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.630) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.643 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.645 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.643 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.645)], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.685 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.687 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.685 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.687) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.700 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.702 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.700 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.702)
-Case conversion may be inaccurate. Consider using '#align positive.covariant_class_add_lt Positive.covariantClass_add_ltₓ'. -/
 instance covariantClass_add_lt :
     CovariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· < ·) :=
   ⟨fun x y z hyz => Subtype.coe_lt_coe.1 <| add_lt_add_left hyz _⟩
 #align positive.covariant_class_add_lt Positive.covariantClass_add_lt
 
-/- warning: positive.covariant_class_swap_add_lt -> Positive.covariantClass_swap_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.763 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.765 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.763 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.765) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.778 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.780 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.778 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.780)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.800 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.802 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.800 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.802)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.815 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.817 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.815 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.817)], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.860 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.862 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.860 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.862)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.875 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.877 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.875 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.877)
-Case conversion may be inaccurate. Consider using '#align positive.covariant_class_swap_add_lt Positive.covariantClass_swap_add_ltₓ'. -/
 instance covariantClass_swap_add_lt [CovariantClass M M (swap (· + ·)) (· < ·)] :
     CovariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· < ·) :=
   ⟨fun x y z hyz => Subtype.coe_lt_coe.1 <| add_lt_add_right hyz _⟩
 #align positive.covariant_class_swap_add_lt Positive.covariantClass_swap_add_lt
 
-/- warning: positive.contravariant_class_add_lt -> Positive.contravariantClass_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.938 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.940 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.938 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.940) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.953 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.955 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.953 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.955)] [_inst_4 : ContravariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.972 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.974 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.972 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.974) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.987 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.989 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.987 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.989)], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1029 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1031 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1029 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1031) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1044 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1046 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1044 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1046)
-Case conversion may be inaccurate. Consider using '#align positive.contravariant_class_add_lt Positive.contravariantClass_add_ltₓ'. -/
 instance contravariantClass_add_lt [ContravariantClass M M (· + ·) (· < ·)] :
     ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· < ·) :=
   ⟨fun x y z h => Subtype.coe_lt_coe.1 <| lt_of_add_lt_add_left h⟩
 #align positive.contravariant_class_add_lt Positive.contravariantClass_add_lt
 
-/- warning: positive.contravariant_class_swap_add_lt -> Positive.contravariantClass_swap_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1090 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1092 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1090 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1092) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1105 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1107 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1105 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1107)] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1127 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1129 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1127 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1129)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1142 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1144 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1142 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1144)], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1187 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1189 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1187 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1189)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1202 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1204 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1202 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1204)
-Case conversion may be inaccurate. Consider using '#align positive.contravariant_class_swap_add_lt Positive.contravariantClass_swap_add_ltₓ'. -/
 instance contravariantClass_swap_add_lt [ContravariantClass M M (swap (· + ·)) (· < ·)] :
     ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· < ·) :=
   ⟨fun x y z h => Subtype.coe_lt_coe.1 <| lt_of_add_lt_add_right h⟩
 #align positive.contravariant_class_swap_add_lt Positive.contravariantClass_swap_add_lt
 
-/- warning: positive.contravariant_class_add_le -> Positive.contravariantClass_add_le is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toHasLe.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1248 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1250 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1248 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1250) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1263 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1265 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1263 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1265)] [_inst_4 : ContravariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1282 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1284 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1282 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1284) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1297 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1299 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1297 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1299)], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1339 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1341 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1339 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1341) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1354 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1356 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.le.{u1} M (Preorder.toLE.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1354 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1356)
-Case conversion may be inaccurate. Consider using '#align positive.contravariant_class_add_le Positive.contravariantClass_add_leₓ'. -/
 instance contravariantClass_add_le [ContravariantClass M M (· + ·) (· ≤ ·)] :
     ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· ≤ ·) :=
   ⟨fun x y z h => Subtype.coe_le_coe.1 <| le_of_add_le_add_left h⟩
 #align positive.contravariant_class_add_le Positive.contravariantClass_add_le
 
-/- warning: positive.contravariant_class_swap_add_le -> Positive.contravariantClass_swap_add_le is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toHasLe.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1400 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1402 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1400 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1402) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1415 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1417 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1415 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1417)] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1437 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1439 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1437 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1439)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1452 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1454 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1452 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1454)], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1497 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1499 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1497 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1499)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1512 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1514 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.le.{u1} M (Preorder.toLE.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1512 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1514)
-Case conversion may be inaccurate. Consider using '#align positive.contravariant_class_swap_add_le Positive.contravariantClass_swap_add_leₓ'. -/
 instance contravariantClass_swap_add_le [ContravariantClass M M (swap (· + ·)) (· ≤ ·)] :
     ContravariantClass { x : M // 0 < x } { x : M // 0 < x } (swap (· + ·)) (· ≤ ·) :=
   ⟨fun x y z h => Subtype.coe_le_coe.1 <| le_of_add_le_add_right h⟩
@@ -130,12 +88,6 @@ instance contravariantClass_swap_add_le [ContravariantClass M M (swap (· + ·))
 
 end AddBasic
 
-/- warning: positive.covariant_class_add_le -> Positive.covariantClass_add_le is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : PartialOrder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 (PartialOrder.toPreorder.{u1} M _inst_2) _inst_3))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : PartialOrder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1559 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1561 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1559 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1561) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1574 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1576 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1574 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1576)], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1616 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1618 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 (PartialOrder.toPreorder.{u1} M _inst_2) _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1616 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1618) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1631 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1633 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1631 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1633)
-Case conversion may be inaccurate. Consider using '#align positive.covariant_class_add_le Positive.covariantClass_add_leₓ'. -/
 instance covariantClass_add_le [AddMonoid M] [PartialOrder M] [CovariantClass M M (· + ·) (· < ·)] :
     CovariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· ≤ ·) :=
   ⟨fun x => StrictMono.monotone fun _ _ h => add_lt_add_left h _⟩
@@ -148,9 +100,6 @@ variable [StrictOrderedSemiring R]
 instance : Mul { x : R // 0 < x } :=
   ⟨fun x y => ⟨x * y, mul_pos x.2 y.2⟩⟩
 
-/- warning: positive.coe_mul -> Positive.val_mul is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align positive.coe_mul Positive.val_mulₓ'. -/
 @[simp]
 theorem val_mul (x y : { x : R // 0 < x }) : ↑(x * y) = (x * y : R) :=
   rfl
@@ -159,9 +108,6 @@ theorem val_mul (x y : { x : R // 0 < x }) : ↑(x * y) = (x * y : R) :=
 instance : Pow { x : R // 0 < x } ℕ :=
   ⟨fun x n => ⟨x ^ n, pow_pos x.2 n⟩⟩
 
-/- warning: positive.coe_pow -> Positive.val_pow is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align positive.coe_pow Positive.val_powₓ'. -/
 @[simp]
 theorem val_pow (x : { x : R // 0 < x }) (n : ℕ) : ↑(x ^ n) = (x ^ n : R) :=
   rfl

448144f7

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -149,10 +149,7 @@ instance : Mul { x : R // 0 < x } :=
   ⟨fun x y => ⟨x * y, mul_pos x.2 y.2⟩⟩
 
 /- warning: positive.coe_mul -> Positive.val_mul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (y : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)), Eq.{succ u1} R ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Positive.Subtype.hasMul.{u1} R _inst_1)) x y)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) y))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (y : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)), Eq.{succ u1} R (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (Positive.instMulSubtypeLtToLTToPreorderToPartialOrderOfNatToOfNat0ToZeroToMonoidWithZeroToSemiring.{u1} R _inst_1)) x y)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) x) (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) y))
+<too large>
 Case conversion may be inaccurate. Consider using '#align positive.coe_mul Positive.val_mulₓ'. -/
 @[simp]
 theorem val_mul (x y : { x : R // 0 < x }) : ↑(x * y) = (x * y : R) :=
@@ -163,10 +160,7 @@ instance : Pow { x : R // 0 < x } ℕ :=
   ⟨fun x n => ⟨x ^ n, pow_pos x.2 n⟩⟩
 
 /- warning: positive.coe_pow -> Positive.val_pow is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (n : Nat), Eq.{succ u1} R ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) (HPow.hPow.{u1, 0, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) Nat (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (instHPow.{u1, 0} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) Nat (Positive.Nat.hasPow.{u1} R _inst_1)) x n)) (HPow.hPow.{u1, 0, u1} R Nat R (instHPow.{u1, 0} R Nat (Monoid.Pow.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) x) n)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (n : Nat), Eq.{succ u1} R (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) (HPow.hPow.{u1, 0, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) Nat (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (instHPow.{u1, 0} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) Nat (Positive.instPowSubtypeLtToLTToPreorderToPartialOrderOfNatToOfNat0ToZeroToMonoidWithZeroToSemiringNat.{u1} R _inst_1)) x n)) (HPow.hPow.{u1, 0, u1} R Nat R (instHPow.{u1, 0} R Nat (Monoid.Pow.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) x) n)
+<too large>
 Case conversion may be inaccurate. Consider using '#align positive.coe_pow Positive.val_powₓ'. -/
 @[simp]
 theorem val_pow (x : { x : R // 0 < x }) (n : ℕ) : ↑(x ^ n) = (x ^ n : R) :=

448144f7

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -38,7 +38,7 @@ instance : Add { x : M // 0 < x } :=
 
 /- warning: positive.coe_add -> Positive.coe_add is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))] (x : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (y : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)) x y)) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) y))
+  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] (x : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (y : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)) x y)) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeBase.{succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) M (coeSubtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x))))) y))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.161 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.163 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.161 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.163) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.176 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.178 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.176 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.178)] (x : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (y : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)), Eq.{succ u1} M (Subtype.val.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x y)) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) (Subtype.val.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x) x) (Subtype.val.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x) y))
 Case conversion may be inaccurate. Consider using '#align positive.coe_add Positive.coe_addₓ'. -/
@@ -64,7 +64,7 @@ instance {M : Type _} [AddRightCancelMonoid M] [Preorder M] [CovariantClass M M
 
 /- warning: positive.covariant_class_add_lt -> Positive.covariantClass_add_lt is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
+  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.628 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.630 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.628 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.630) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.643 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.645 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.643 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.645)], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.685 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.687 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.685 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.687) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.700 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.702 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.700 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.702)
 Case conversion may be inaccurate. Consider using '#align positive.covariant_class_add_lt Positive.covariantClass_add_ltₓ'. -/
@@ -75,7 +75,7 @@ instance covariantClass_add_lt :
 
 /- warning: positive.covariant_class_swap_add_lt -> Positive.covariantClass_swap_add_lt is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
+  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.763 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.765 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.763 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.765) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.778 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.780 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.778 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.780)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.800 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.802 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.800 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.802)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.815 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.817 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.815 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.817)], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.860 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.862 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.860 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.862)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.875 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.877 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.875 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.877)
 Case conversion may be inaccurate. Consider using '#align positive.covariant_class_swap_add_lt Positive.covariantClass_swap_add_ltₓ'. -/
@@ -86,7 +86,7 @@ instance covariantClass_swap_add_lt [CovariantClass M M (swap (· + ·)) (· < 
 
 /- warning: positive.contravariant_class_add_lt -> Positive.contravariantClass_add_lt is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
+  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.938 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.940 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.938 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.940) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.953 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.955 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.953 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.955)] [_inst_4 : ContravariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.972 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.974 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.972 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.974) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.987 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.989 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.987 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.989)], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1029 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1031 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1029 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1031) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1044 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1046 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1044 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1046)
 Case conversion may be inaccurate. Consider using '#align positive.contravariant_class_add_lt Positive.contravariantClass_add_ltₓ'. -/
@@ -97,7 +97,7 @@ instance contravariantClass_add_lt [ContravariantClass M M (· + ·) (· < ·)]
 
 /- warning: positive.contravariant_class_swap_add_lt -> Positive.contravariantClass_swap_add_lt is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
+  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1090 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1092 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1090 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1092) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1105 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1107 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1105 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1107)] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1127 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1129 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1127 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1129)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1142 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1144 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1142 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1144)], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1187 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1189 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1187 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1189)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1202 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1204 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LT.lt.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1202 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1204)
 Case conversion may be inaccurate. Consider using '#align positive.contravariant_class_swap_add_lt Positive.contravariantClass_swap_add_ltₓ'. -/
@@ -108,7 +108,7 @@ instance contravariantClass_swap_add_lt [ContravariantClass M M (swap (· + ·))
 
 /- warning: positive.contravariant_class_add_le -> Positive.contravariantClass_add_le is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toLE.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
+  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toHasLe.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1248 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1250 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1248 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1250) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1263 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1265 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1263 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1265)] [_inst_4 : ContravariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1282 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1284 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1282 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1284) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1297 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1299 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1297 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1299)], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1339 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1341 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1339 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1341) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1354 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1356 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.le.{u1} M (Preorder.toLE.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1354 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1356)
 Case conversion may be inaccurate. Consider using '#align positive.contravariant_class_add_le Positive.contravariantClass_add_leₓ'. -/
@@ -119,7 +119,7 @@ instance contravariantClass_add_le [ContravariantClass M M (· + ·) (· ≤ ·)
 
 /- warning: positive.contravariant_class_swap_add_le -> Positive.contravariantClass_swap_add_le is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toLE.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
+  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 _inst_2 _inst_3)))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toHasLe.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1400 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1402 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1400 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1402) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1415 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1417 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1415 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1417)] [_inst_4 : ContravariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1437 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1439 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1437 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1439)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1452 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1454 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1452 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1454)], ContravariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Function.swap.{succ u1, succ u1, succ u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (ᾰ : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1497 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1499 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 _inst_2 _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1497 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1499)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1512 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1514 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.le.{u1} M (Preorder.toLE.{u1} M _inst_2) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_2) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1512 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1514)
 Case conversion may be inaccurate. Consider using '#align positive.contravariant_class_swap_add_le Positive.contravariantClass_swap_add_leₓ'. -/
@@ -132,7 +132,7 @@ end AddBasic
 
 /- warning: positive.covariant_class_add_le -> Positive.covariantClass_add_le is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : PartialOrder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 (PartialOrder.toPreorder.{u1} M _inst_2) _inst_3))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
+  forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : PartialOrder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))) (LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)))], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Positive.Subtype.hasAdd.{u1} M _inst_1 (PartialOrder.toPreorder.{u1} M _inst_2) _inst_3))) (LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)) (Subtype.hasLe.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (fun (x : M) => LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))))) x)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : PartialOrder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1559 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1561 : M) => HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1559 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1561) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1574 : M) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1576 : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1574 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1576)], CovariantClass.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1616 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1618 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => HAdd.hAdd.{u1, u1, u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (instHAdd.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Positive.instAddSubtypeLtToLTOfNatToOfNat0ToZero.{u1} M _inst_1 (PartialOrder.toPreorder.{u1} M _inst_2) _inst_3)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1616 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1618) (fun (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1631 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1633 : Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) => LE.le.{u1} (Subtype.{succ u1} M (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) (Subtype.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (fun (x : M) => LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M _inst_2)) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (AddMonoid.toZero.{u1} M _inst_1))) x)) x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1631 x._@.Mathlib.Algebra.Order.Positive.Ring._hyg.1633)
 Case conversion may be inaccurate. Consider using '#align positive.covariant_class_add_le Positive.covariantClass_add_leₓ'. -/
@@ -150,7 +150,7 @@ instance : Mul { x : R // 0 < x } :=
 
 /- warning: positive.coe_mul -> Positive.val_mul is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (y : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)), Eq.{succ u1} R ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Positive.Subtype.hasMul.{u1} R _inst_1)) x y)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) y))
+  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (y : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)), Eq.{succ u1} R ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (Positive.Subtype.hasMul.{u1} R _inst_1)) x y)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) y))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (y : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)), Eq.{succ u1} R (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) (HMul.hMul.{u1, u1, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (instHMul.{u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (Positive.instMulSubtypeLtToLTToPreorderToPartialOrderOfNatToOfNat0ToZeroToMonoidWithZeroToSemiring.{u1} R _inst_1)) x y)) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) x) (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) y))
 Case conversion may be inaccurate. Consider using '#align positive.coe_mul Positive.val_mulₓ'. -/
@@ -164,7 +164,7 @@ instance : Pow { x : R // 0 < x } ℕ :=
 
 /- warning: positive.coe_pow -> Positive.val_pow is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (n : Nat), Eq.{succ u1} R ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) (HPow.hPow.{u1, 0, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) Nat (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (instHPow.{u1, 0} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) Nat (Positive.Nat.hasPow.{u1} R _inst_1)) x n)) (HPow.hPow.{u1, 0, u1} R Nat R (instHPow.{u1, 0} R Nat (Monoid.Pow.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) x) n)
+  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (n : Nat), Eq.{succ u1} R ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) (HPow.hPow.{u1, 0, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) Nat (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) (instHPow.{u1, 0} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) Nat (Positive.Nat.hasPow.{u1} R _inst_1)) x n)) (HPow.hPow.{u1, 0, u1} R Nat R (instHPow.{u1, 0} R Nat (Monoid.Pow.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeBase.{succ u1, succ u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x)) R (coeSubtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) x))))) x) n)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (x : Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (n : Nat), Eq.{succ u1} R (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) (HPow.hPow.{u1, 0, u1} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) Nat (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) (instHPow.{u1, 0} (Subtype.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x)) Nat (Positive.instPowSubtypeLtToLTToPreorderToPartialOrderOfNatToOfNat0ToZeroToMonoidWithZeroToSemiringNat.{u1} R _inst_1)) x n)) (HPow.hPow.{u1, 0, u1} R Nat R (instHPow.{u1, 0} R Nat (Monoid.Pow.{u1} R (MonoidWithZero.toMonoid.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (Subtype.val.{succ u1} R (fun (x : R) => LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) x) x) n)
 Case conversion may be inaccurate. Consider using '#align positive.coe_pow Positive.val_powₓ'. -/

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

655994e2

chore(Order): add missing inst prefix to instance names (#11238)

This is not exhaustive; it largely does not rename instances that relate to algebra, and only focuses on the "core" order files.

4d23d2cb

Diff

@@ -146,7 +146,7 @@ instance orderedCommMonoid [StrictOrderedCommSemiring R] [Nontrivial R] :
 ordered cancellative commutative monoid. -/
 instance linearOrderedCancelCommMonoid [LinearOrderedCommSemiring R] :
     LinearOrderedCancelCommMonoid { x : R // 0 < x } :=
-  { Subtype.linearOrder _, Positive.orderedCommMonoid with
+  { Subtype.instLinearOrder _, Positive.orderedCommMonoid with
     le_of_mul_le_mul_left := fun a _ _ h => Subtype.coe_le_coe.1 <| (mul_le_mul_left a.2).1 h }
 #align positive.subtype.linear_ordered_cancel_comm_monoid Positive.linearOrderedCancelCommMonoid

655994e2

chore: bump to v4.3.0-rc2 (#8366)

PR contents

This is the supremum of

#8284
#8056
#8023
#8332
#8226 (already approved)
#7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

switching to using explicit lemmas that have the intended level of application
(config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

40b64f79

Diff

@@ -109,7 +109,7 @@ instance : Pow { x : R // 0 < x } ℕ :=
 
 @[simp]
 theorem val_pow (x : { x : R // 0 < x }) (n : ℕ) :
-    (x ^ n : R) = (x : R) ^ n :=
+    ↑(x ^ n) = (x : R) ^ n :=
   rfl
 #align positive.coe_pow Positive.val_pow

655994e2

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -21,7 +21,7 @@ open Function
 
 namespace Positive
 
-variable {M R K : Type _}
+variable {M R K : Type*}
 
 section AddBasic
 
@@ -39,17 +39,17 @@ instance addSemigroup : AddSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.addSemigroup _ coe_add
 #align positive.subtype.add_semigroup Positive.addSemigroup
 
-instance addCommSemigroup {M : Type _} [AddCommMonoid M] [Preorder M]
+instance addCommSemigroup {M : Type*} [AddCommMonoid M] [Preorder M]
     [CovariantClass M M (· + ·) (· < ·)] : AddCommSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.addCommSemigroup _ coe_add
 #align positive.subtype.add_comm_semigroup Positive.addCommSemigroup
 
-instance addLeftCancelSemigroup {M : Type _} [AddLeftCancelMonoid M] [Preorder M]
+instance addLeftCancelSemigroup {M : Type*} [AddLeftCancelMonoid M] [Preorder M]
     [CovariantClass M M (· + ·) (· < ·)] : AddLeftCancelSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.addLeftCancelSemigroup _ coe_add
 #align positive.subtype.add_left_cancel_semigroup Positive.addLeftCancelSemigroup
 
-instance addRightCancelSemigroup {M : Type _} [AddRightCancelMonoid M] [Preorder M]
+instance addRightCancelSemigroup {M : Type*} [AddRightCancelMonoid M] [Preorder M]
     [CovariantClass M M (· + ·) (· < ·)] : AddRightCancelSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.addRightCancelSemigroup _ coe_add
 #align positive.subtype.add_right_cancel_semigroup Positive.addRightCancelSemigroup

655994e2

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module algebra.order.positive.ring
-! leanprover-community/mathlib commit 655994e298904d7e5bbd1e18c95defd7b543eb94
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Ring.Defs
 import Mathlib.Algebra.Ring.InjSurj
 
+#align_import algebra.order.positive.ring from "leanprover-community/mathlib"@"655994e298904d7e5bbd1e18c95defd7b543eb94"
+
 /-!
 # Algebraic structures on the set of positive numbers

655994e2

chore: bump to leanprover/lean4:nightly-2023-02-10 (#2188)

5bbbc25c

Diff

@@ -140,7 +140,7 @@ section mul_comm
 instance orderedCommMonoid [StrictOrderedCommSemiring R] [Nontrivial R] :
     OrderedCommMonoid { x : R // 0 < x } :=
   { Subtype.partialOrder _,
-    Subtype.coe_injective.commMonoid (Subtype.val) val_one val_mul val_pow with
+    Subtype.coe_injective.commMonoid (M₂ := R) (Subtype.val) val_one val_mul val_pow with
     mul_le_mul_left := fun _ _ hxy c =>
       Subtype.coe_le_coe.1 <| mul_le_mul_of_nonneg_left hxy c.2.le }
 #align positive.subtype.ordered_comm_monoid Positive.orderedCommMonoid

655994e2

chore: fix most phantom #aligns (#1794)

3d3fb046

Diff

@@ -40,22 +40,22 @@ theorem coe_add (x y : { x : M // 0 < x }) : ↑(x + y) = (x + y : M) :=
 
 instance addSemigroup : AddSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.addSemigroup _ coe_add
-#align subtype.add_semigroup Positive.addSemigroup
+#align positive.subtype.add_semigroup Positive.addSemigroup
 
 instance addCommSemigroup {M : Type _} [AddCommMonoid M] [Preorder M]
     [CovariantClass M M (· + ·) (· < ·)] : AddCommSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.addCommSemigroup _ coe_add
-#align subtype.add_comm_semigroup Positive.addCommSemigroup
+#align positive.subtype.add_comm_semigroup Positive.addCommSemigroup
 
 instance addLeftCancelSemigroup {M : Type _} [AddLeftCancelMonoid M] [Preorder M]
     [CovariantClass M M (· + ·) (· < ·)] : AddLeftCancelSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.addLeftCancelSemigroup _ coe_add
-#align subtype.add_left_cancel_semigroup Positive.addLeftCancelSemigroup
+#align positive.subtype.add_left_cancel_semigroup Positive.addLeftCancelSemigroup
 
 instance addRightCancelSemigroup {M : Type _} [AddRightCancelMonoid M] [Preorder M]
     [CovariantClass M M (· + ·) (· < ·)] : AddRightCancelSemigroup { x : M // 0 < x } :=
   Subtype.coe_injective.addRightCancelSemigroup _ coe_add
-#align subtype.add_right_cancel_semigroup Positive.addRightCancelSemigroup
+#align positive.subtype.add_right_cancel_semigroup Positive.addRightCancelSemigroup
 
 instance covariantClass_add_lt :
     CovariantClass { x : M // 0 < x } { x : M // 0 < x } (· + ·) (· < ·) :=
@@ -143,7 +143,7 @@ instance orderedCommMonoid [StrictOrderedCommSemiring R] [Nontrivial R] :
     Subtype.coe_injective.commMonoid (Subtype.val) val_one val_mul val_pow with
     mul_le_mul_left := fun _ _ hxy c =>
       Subtype.coe_le_coe.1 <| mul_le_mul_of_nonneg_left hxy c.2.le }
-#align subtype.ordered_comm_monoid Positive.orderedCommMonoid
+#align positive.subtype.ordered_comm_monoid Positive.orderedCommMonoid
 
 /-- If `R` is a nontrivial linear ordered commutative semiring, then `{x : R // 0 < x}` is a linear
 ordered cancellative commutative monoid. -/
@@ -151,7 +151,7 @@ instance linearOrderedCancelCommMonoid [LinearOrderedCommSemiring R] :
     LinearOrderedCancelCommMonoid { x : R // 0 < x } :=
   { Subtype.linearOrder _, Positive.orderedCommMonoid with
     le_of_mul_le_mul_left := fun a _ _ h => Subtype.coe_le_coe.1 <| (mul_le_mul_left a.2).1 h }
-#align subtype.linear_ordered_cancel_comm_monoid Positive.linearOrderedCancelCommMonoid
+#align positive.subtype.linear_ordered_cancel_comm_monoid Positive.linearOrderedCancelCommMonoid
 
 end mul_comm

655994e2

chore: add source headers to ported theory files (#1094)

The script used to do this is included. The yaml file was obtained from https://raw.githubusercontent.com/wiki/leanprover-community/mathlib/mathlib4-port-status.md

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
+
+! This file was ported from Lean 3 source module algebra.order.positive.ring
+! leanprover-community/mathlib commit 655994e298904d7e5bbd1e18c95defd7b543eb94
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Ring.Defs
 import Mathlib.Algebra.Ring.InjSurj

`algebra.order.positive.ring` ⟷ `Mathlib.Algebra.Order.Positive.Ring`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 1 + 63

algebra.order.positive.ring ⟷ Mathlib.Algebra.Order.Positive.Ring

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 1 + 63

`algebra.order.positive.ring` ⟷ `Mathlib.Algebra.Order.Positive.Ring`