algebra.order.monoid.nat_cast | Mathlib porting status

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

07fee0ca

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

448144f7

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl, Yuyang Zhao
 -/
 import Algebra.Order.Monoid.Lemmas
-import Algebra.Order.ZeroLeOne
+import Algebra.Order.ZeroLEOne
 import Data.Nat.Cast.Defs
 
 #align_import algebra.order.monoid.nat_cast from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl, Yuyang Zhao
 -/
-import Mathbin.Algebra.Order.Monoid.Lemmas
-import Mathbin.Algebra.Order.ZeroLeOne
-import Mathbin.Data.Nat.Cast.Defs
+import Algebra.Order.Monoid.Lemmas
+import Algebra.Order.ZeroLeOne
+import Data.Nat.Cast.Defs
 
 #align_import algebra.order.monoid.nat_cast from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -152,12 +152,12 @@ theorem one_lt_two [CovariantClass α α (· + ·) (· < ·)] : (1 : α) < 2 :=
 
 end
 
-alias zero_lt_two ← two_pos
+alias two_pos := zero_lt_two
 #align two_pos two_pos
 
-alias zero_lt_three ← three_pos
+alias three_pos := zero_lt_three
 #align three_pos three_pos
 
-alias zero_lt_four ← four_pos
+alias four_pos := zero_lt_four
 #align four_pos four_pos

448144f7

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl, Yuyang Zhao
-
-! This file was ported from Lean 3 source module algebra.order.monoid.nat_cast
-! 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.Monoid.Lemmas
 import Mathbin.Algebra.Order.ZeroLeOne
 import Mathbin.Data.Nat.Cast.Defs
 
+#align_import algebra.order.monoid.nat_cast from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Order of numerials in an `add_monoid_with_one`.

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -24,45 +24,59 @@ variable {α : Type _}
 
 open Function
 
+#print lt_add_one /-
 theorem lt_add_one [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α] [NeZero (1 : α)]
     [CovariantClass α α (· + ·) (· < ·)] (a : α) : a < a + 1 :=
   lt_add_of_pos_right _ zero_lt_one
 #align lt_add_one lt_add_one
+-/
 
+#print lt_one_add /-
 theorem lt_one_add [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α] [NeZero (1 : α)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (a : α) : a < 1 + a :=
   lt_add_of_pos_left _ zero_lt_one
 #align lt_one_add lt_one_add
+-/
 
 variable [AddMonoidWithOne α]
 
+#print zero_le_two /-
 theorem zero_le_two [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     (0 : α) ≤ 2 :=
   add_nonneg zero_le_one zero_le_one
 #align zero_le_two zero_le_two
+-/
 
+#print zero_le_three /-
 theorem zero_le_three [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     (0 : α) ≤ 3 :=
   add_nonneg zero_le_two zero_le_one
 #align zero_le_three zero_le_three
+-/
 
+#print zero_le_four /-
 theorem zero_le_four [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     (0 : α) ≤ 4 :=
   add_nonneg zero_le_two zero_le_two
 #align zero_le_four zero_le_four
+-/
 
+#print one_le_two /-
 theorem one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (· ≤ ·)] : (1 : α) ≤ 2 :=
   calc
     1 = 1 + 0 := (add_zero 1).symm
     _ ≤ 1 + 1 := add_le_add_left zero_le_one _
 #align one_le_two one_le_two
+-/
 
+#print one_le_two' /-
 theorem one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     (1 : α) ≤ 2 :=
   calc
     1 = 0 + 1 := (zero_add 1).symm
     _ ≤ 1 + 1 := add_le_add_right zero_le_one _
 #align one_le_two' one_le_two'
+-/
 
 section
 
@@ -72,40 +86,52 @@ section
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
+#print zero_lt_two /-
 /-- See `zero_lt_two'` for a version with the type explicit. -/
 @[simp]
 theorem zero_lt_two : (0 : α) < 2 :=
   zero_lt_one.trans_le one_le_two
 #align zero_lt_two zero_lt_two
+-/
 
+#print zero_lt_three /-
 /-- See `zero_lt_three'` for a version with the type explicit. -/
 @[simp]
 theorem zero_lt_three : (0 : α) < 3 :=
   lt_add_of_lt_of_nonneg zero_lt_two zero_le_one
 #align zero_lt_three zero_lt_three
+-/
 
+#print zero_lt_four /-
 /-- See `zero_lt_four'` for a version with the type explicit. -/
 @[simp]
 theorem zero_lt_four : (0 : α) < 4 :=
   lt_add_of_lt_of_nonneg zero_lt_two zero_le_two
 #align zero_lt_four zero_lt_four
+-/
 
 variable (α)
 
+#print zero_lt_two' /-
 /-- See `zero_lt_two` for a version with the type implicit. -/
 theorem zero_lt_two' : (0 : α) < 2 :=
   zero_lt_two
 #align zero_lt_two' zero_lt_two'
+-/
 
+#print zero_lt_three' /-
 /-- See `zero_lt_three` for a version with the type implicit. -/
 theorem zero_lt_three' : (0 : α) < 3 :=
   zero_lt_three
 #align zero_lt_three' zero_lt_three'
+-/
 
+#print zero_lt_four' /-
 /-- See `zero_lt_four` for a version with the type implicit. -/
 theorem zero_lt_four' : (0 : α) < 4 :=
   zero_lt_four
 #align zero_lt_four' zero_lt_four'
+-/
 
 instance ZeroLEOneClass.NeZero.two : NeZero (2 : α) :=
   ⟨zero_lt_two.ne'⟩
@@ -121,9 +147,11 @@ instance ZeroLEOneClass.NeZero.four : NeZero (4 : α) :=
 
 end
 
+#print one_lt_two /-
 theorem one_lt_two [CovariantClass α α (· + ·) (· < ·)] : (1 : α) < 2 :=
   lt_add_one _
 #align one_lt_two one_lt_two
+-/
 
 end

448144f7

bump to nightly-2023-06-09-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

16afdc39

Diff

@@ -55,7 +55,6 @@ theorem one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (
   calc
     1 = 1 + 0 := (add_zero 1).symm
     _ ≤ 1 + 1 := add_le_add_left zero_le_one _
-    
 #align one_le_two one_le_two
 
 theorem one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
@@ -63,7 +62,6 @@ theorem one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (·
   calc
     1 = 0 + 1 := (zero_add 1).symm
     _ ≤ 1 + 1 := add_le_add_right zero_le_one _
-    
 #align one_le_two' one_le_two'
 
 section

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -24,23 +24,11 @@ variable {α : Type _}
 
 open Function
 
-/- warning: lt_add_one -> lt_add_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) _inst_1 (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1)))] [_inst_6 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)))] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toZero.{u1} α _inst_2) _inst_1 (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1))] [_inst_6 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.36 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.38 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.36 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.38) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.51 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.53 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.51 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.53)] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α _inst_2)) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align lt_add_one lt_add_oneₓ'. -/
 theorem lt_add_one [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α] [NeZero (1 : α)]
     [CovariantClass α α (· + ·) (· < ·)] (a : α) : a < a + 1 :=
   lt_add_of_pos_right _ zero_lt_one
 #align lt_add_one lt_add_one
 
-/- warning: lt_one_add -> lt_one_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) _inst_1 (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1)))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)))] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toZero.{u1} α _inst_2) _inst_1 (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.107 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.109 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.107 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.109)) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.122 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.124 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.122 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.124)] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align lt_one_add lt_one_addₓ'. -/
 theorem lt_one_add [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α] [NeZero (1 : α)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (a : α) : a < 1 + a :=
   lt_add_of_pos_left _ zero_lt_one
@@ -48,45 +36,21 @@ theorem lt_one_add [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass
 
 variable [AddMonoidWithOne α]
 
-/- warning: zero_le_two -> zero_le_two is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.172 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.174 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.172 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.174) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.187 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.189 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.187 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.189)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align zero_le_two zero_le_twoₓ'. -/
 theorem zero_le_two [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     (0 : α) ≤ 2 :=
   add_nonneg zero_le_one zero_le_one
 #align zero_le_two zero_le_two
 
-/- warning: zero_le_three -> zero_le_three is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.265 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.267 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.265 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.267) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.280 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.282 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.280 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.282)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 3 (instOfNat.{u1} α 3 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))
-Case conversion may be inaccurate. Consider using '#align zero_le_three zero_le_threeₓ'. -/
 theorem zero_le_three [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     (0 : α) ≤ 3 :=
   add_nonneg zero_le_two zero_le_one
 #align zero_le_three zero_le_three
 
-/- warning: zero_le_four -> zero_le_four is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.358 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.360 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.358 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.360) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.373 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.375 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.373 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.375)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 4 (instOfNat.{u1} α 4 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))))
-Case conversion may be inaccurate. Consider using '#align zero_le_four zero_le_fourₓ'. -/
 theorem zero_le_four [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     (0 : α) ≤ 4 :=
   add_nonneg zero_le_two zero_le_two
 #align zero_le_four zero_le_four
 
-/- warning: one_le_two -> one_le_two is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) _inst_2] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α _inst_2)], LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) _inst_2] [_inst_4 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.451 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.453 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.451 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.453) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.466 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.468 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.466 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.468)], LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align one_le_two one_le_twoₓ'. -/
 theorem one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (· ≤ ·)] : (1 : α) ≤ 2 :=
   calc
     1 = 1 + 0 := (add_zero 1).symm
@@ -94,12 +58,6 @@ theorem one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (· + ·) (
     
 #align one_le_two one_le_two
 
-/- warning: one_le_two' -> one_le_two' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) _inst_2] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)], LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) _inst_2] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.563 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.565 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.563 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.565)) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.578 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.580 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.578 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.580)], LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align one_le_two' one_le_two'ₓ'. -/
 theorem one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     (1 : α) ≤ 2 :=
   calc
@@ -116,36 +74,18 @@ section
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
-/- warning: zero_lt_two -> zero_lt_two is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.752 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.754 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.752 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.754) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.767 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.769 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.767 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.769)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align zero_lt_two zero_lt_twoₓ'. -/
 /-- See `zero_lt_two'` for a version with the type explicit. -/
 @[simp]
 theorem zero_lt_two : (0 : α) < 2 :=
   zero_lt_one.trans_le one_le_two
 #align zero_lt_two zero_lt_two
 
-/- warning: zero_lt_three -> zero_lt_three is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.816 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.818 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.816 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.818) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.831 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.833 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.831 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.833)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 3 (instOfNat.{u1} α 3 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))
-Case conversion may be inaccurate. Consider using '#align zero_lt_three zero_lt_threeₓ'. -/
 /-- See `zero_lt_three'` for a version with the type explicit. -/
 @[simp]
 theorem zero_lt_three : (0 : α) < 3 :=
   lt_add_of_lt_of_nonneg zero_lt_two zero_le_one
 #align zero_lt_three zero_lt_three
 
-/- warning: zero_lt_four -> zero_lt_four is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.914 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.916 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.914 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.916) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.929 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.931 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.929 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.931)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 4 (instOfNat.{u1} α 4 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))))
-Case conversion may be inaccurate. Consider using '#align zero_lt_four zero_lt_fourₓ'. -/
 /-- See `zero_lt_four'` for a version with the type explicit. -/
 @[simp]
 theorem zero_lt_four : (0 : α) < 4 :=
@@ -154,34 +94,16 @@ theorem zero_lt_four : (0 : α) < 4 :=
 
 variable (α)
 
-/- warning: zero_lt_two' -> zero_lt_two' is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1067 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1069 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1067 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1069) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1082 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1084 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1082 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1084)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align zero_lt_two' zero_lt_two'ₓ'. -/
 /-- See `zero_lt_two` for a version with the type implicit. -/
 theorem zero_lt_two' : (0 : α) < 2 :=
   zero_lt_two
 #align zero_lt_two' zero_lt_two'
 
-/- warning: zero_lt_three' -> zero_lt_three' is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1130 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1132 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1130 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1132) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1145 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1147 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1145 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1147)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 3 (instOfNat.{u1} α 3 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))
-Case conversion may be inaccurate. Consider using '#align zero_lt_three' zero_lt_three'ₓ'. -/
 /-- See `zero_lt_three` for a version with the type implicit. -/
 theorem zero_lt_three' : (0 : α) < 3 :=
   zero_lt_three
 #align zero_lt_three' zero_lt_three'
 
-/- warning: zero_lt_four' -> zero_lt_four' is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1193 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1195 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1193 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1195) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1208 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1210 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1208 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1210)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 4 (instOfNat.{u1} α 4 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))))
-Case conversion may be inaccurate. Consider using '#align zero_lt_four' zero_lt_four'ₓ'. -/
 /-- See `zero_lt_four` for a version with the type implicit. -/
 theorem zero_lt_four' : (0 : α) < 4 :=
   zero_lt_four
@@ -201,42 +123,18 @@ instance ZeroLEOneClass.NeZero.four : NeZero (4 : α) :=
 
 end
 
-/- warning: one_lt_two -> one_lt_two is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1449 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1451 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1449 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1451) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1464 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1466 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1464 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1466)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align one_lt_two one_lt_twoₓ'. -/
 theorem one_lt_two [CovariantClass α α (· + ·) (· < ·)] : (1 : α) < 2 :=
   lt_add_one _
 #align one_lt_two one_lt_two
 
 end
 
-/- warning: two_pos -> two_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.752 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.754 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.752 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.754) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.767 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.769 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.767 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.769)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
-Case conversion may be inaccurate. Consider using '#align two_pos two_posₓ'. -/
 alias zero_lt_two ← two_pos
 #align two_pos two_pos
 
-/- warning: three_pos -> three_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.816 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.818 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.816 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.818) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.831 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.833 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.831 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.833)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 3 (instOfNat.{u1} α 3 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))
-Case conversion may be inaccurate. Consider using '#align three_pos three_posₓ'. -/
 alias zero_lt_three ← three_pos
 #align three_pos three_pos
 
-/- warning: four_pos -> four_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.914 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.916 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.914 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.916) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.929 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.931 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.929 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.931)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 4 (instOfNat.{u1} α 4 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))))
-Case conversion may be inaccurate. Consider using '#align four_pos four_posₓ'. -/
 alias zero_lt_four ← four_pos
 #align four_pos four_pos

448144f7

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -26,7 +26,7 @@ open Function
 
 /- warning: lt_add_one -> lt_add_one is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) _inst_1 (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1)))] [_inst_6 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)))] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))))
+  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) _inst_1 (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1)))] [_inst_6 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)))] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toZero.{u1} α _inst_2) _inst_1 (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1))] [_inst_6 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.36 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.38 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.36 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.38) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.51 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.53 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.51 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.53)] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α _inst_2)) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
 Case conversion may be inaccurate. Consider using '#align lt_add_one lt_add_oneₓ'. -/
@@ -37,7 +37,7 @@ theorem lt_add_one [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass
 
 /- warning: lt_one_add -> lt_one_add is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) _inst_1 (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1)))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)))] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)
+  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) _inst_1 (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1)))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)))] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : AddZeroClass.{u1} α] [_inst_3 : PartialOrder.{u1} α] [_inst_4 : ZeroLEOneClass.{u1} α (AddZeroClass.toZero.{u1} α _inst_2) _inst_1 (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3))] [_inst_5 : NeZero.{u1} α (AddZeroClass.toZero.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.107 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.109 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.107 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.109)) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.122 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.124 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.122 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.124)] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_3)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)) a)
 Case conversion may be inaccurate. Consider using '#align lt_one_add lt_one_addₓ'. -/
@@ -50,7 +50,7 @@ variable [AddMonoidWithOne α]
 
 /- warning: zero_le_two -> zero_le_two is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.172 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.174 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.172 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.174) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.187 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.189 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.187 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.189)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
 Case conversion may be inaccurate. Consider using '#align zero_le_two zero_le_twoₓ'. -/
@@ -61,7 +61,7 @@ theorem zero_le_two [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·
 
 /- warning: zero_le_three -> zero_le_three is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.265 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.267 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.265 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.267) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.280 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.282 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.280 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.282)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 3 (instOfNat.{u1} α 3 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))
 Case conversion may be inaccurate. Consider using '#align zero_le_three zero_le_threeₓ'. -/
@@ -72,7 +72,7 @@ theorem zero_le_three [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (
 
 /- warning: zero_le_four -> zero_le_four is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.358 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.360 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.358 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.360) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.373 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.375 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.373 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.375)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 4 (instOfNat.{u1} α 4 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))))
 Case conversion may be inaccurate. Consider using '#align zero_le_four zero_le_fourₓ'. -/
@@ -118,7 +118,7 @@ variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
 /- warning: zero_lt_two -> zero_lt_two is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.752 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.754 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.752 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.754) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.767 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.769 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.767 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.769)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
 Case conversion may be inaccurate. Consider using '#align zero_lt_two zero_lt_twoₓ'. -/
@@ -130,7 +130,7 @@ theorem zero_lt_two : (0 : α) < 2 :=
 
 /- warning: zero_lt_three -> zero_lt_three is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.816 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.818 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.816 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.818) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.831 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.833 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.831 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.833)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 3 (instOfNat.{u1} α 3 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))
 Case conversion may be inaccurate. Consider using '#align zero_lt_three zero_lt_threeₓ'. -/
@@ -142,7 +142,7 @@ theorem zero_lt_three : (0 : α) < 3 :=
 
 /- warning: zero_lt_four -> zero_lt_four is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.914 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.916 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.914 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.916) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.929 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.931 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.929 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.931)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 4 (instOfNat.{u1} α 4 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))))
 Case conversion may be inaccurate. Consider using '#align zero_lt_four zero_lt_fourₓ'. -/
@@ -156,7 +156,7 @@ variable (α)
 
 /- warning: zero_lt_two' -> zero_lt_two' is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1067 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1069 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1067 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1069) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1082 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1084 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1082 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1084)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
 Case conversion may be inaccurate. Consider using '#align zero_lt_two' zero_lt_two'ₓ'. -/
@@ -167,7 +167,7 @@ theorem zero_lt_two' : (0 : α) < 2 :=
 
 /- warning: zero_lt_three' -> zero_lt_three' is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1130 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1132 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1130 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1132) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1145 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1147 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1145 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1147)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 3 (instOfNat.{u1} α 3 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))
 Case conversion may be inaccurate. Consider using '#align zero_lt_three' zero_lt_three'ₓ'. -/
@@ -178,7 +178,7 @@ theorem zero_lt_three' : (0 : α) < 3 :=
 
 /- warning: zero_lt_four' -> zero_lt_four' is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
+  forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1193 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1195 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1193 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1195) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1208 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1210 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1208 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1210)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 4 (instOfNat.{u1} α 4 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))))
 Case conversion may be inaccurate. Consider using '#align zero_lt_four' zero_lt_four'ₓ'. -/
@@ -203,7 +203,7 @@ end
 
 /- warning: one_lt_two -> one_lt_two is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1449 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1451 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1449 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1451) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1464 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1466 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1464 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.1466)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
 Case conversion may be inaccurate. Consider using '#align one_lt_two one_lt_twoₓ'. -/
@@ -215,7 +215,7 @@ end
 
 /- warning: two_pos -> two_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 2 (OfNat.mk.{u1} α 2 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.752 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.754 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.752 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.754) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.767 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.769 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.767 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.769)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 2 (instOfNat.{u1} α 2 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)))))
 Case conversion may be inaccurate. Consider using '#align two_pos two_posₓ'. -/
@@ -224,7 +224,7 @@ alias zero_lt_two ← two_pos
 
 /- warning: three_pos -> three_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 3 (OfNat.mk.{u1} α 3 (bit1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.816 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.818 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.816 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.818) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.831 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.833 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.831 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.833)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 3 (instOfNat.{u1} α 3 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))))
 Case conversion may be inaccurate. Consider using '#align three_pos three_posₓ'. -/
@@ -233,7 +233,7 @@ alias zero_lt_three ← three_pos
 
 /- warning: four_pos -> four_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)))], LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 4 (OfNat.mk.{u1} α 4 (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (bit0.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1))) (One.one.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddMonoidWithOne.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : ZeroLEOneClass.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (AddMonoidWithOne.toOne.{u1} α _inst_1) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : NeZero.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (AddMonoidWithOne.toOne.{u1} α _inst_1)))] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.914 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.916 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.914 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.916) (fun (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.929 : α) (x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.931 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.929 x._@.Mathlib.Algebra.Order.Monoid.NatCast._hyg.931)], LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddMonoidWithOne.toAddMonoid.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 4 (instOfNat.{u1} α 4 (AddMonoidWithOne.toNatCast.{u1} α _inst_1) (instAtLeastTwoHAddNatInstHAddInstAddNatOfNat (OfNat.ofNat.{0} Nat 2 (instOfNatNat 2)))))
 Case conversion may be inaccurate. Consider using '#align four_pos four_posₓ'. -/

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

07fee0ca

chore: tidy various files (#7343)

ee7626c6

Diff

@@ -18,13 +18,13 @@ variable {α : Type*}
 open Function
 
 lemma lt_add_one [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α]
-  [NeZero (1 : α)] [CovariantClass α α (·+·) (·<·)] (a : α) : a < a + 1 :=
-lt_add_of_pos_right _ zero_lt_one
+    [NeZero (1 : α)] [CovariantClass α α (·+·) (·<·)] (a : α) : a < a + 1 :=
+  lt_add_of_pos_right _ zero_lt_one
 #align lt_add_one lt_add_one
 
 lemma lt_one_add [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α]
-  [NeZero (1 : α)] [CovariantClass α α (swap (·+·)) (·<·)] (a : α) : a < 1 + a :=
-lt_add_of_pos_left _ zero_lt_one
+    [NeZero (1 : α)] [CovariantClass α α (swap (·+·)) (·<·)] (a : α) : a < 1 + a :=
+  lt_add_of_pos_left _ zero_lt_one
 #align lt_one_add lt_one_add
 
 variable [AddMonoidWithOne α]
@@ -49,14 +49,14 @@ lemma zero_le_four [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+
 
 lemma one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
     (1 : α) ≤ 2 :=
-calc (1 : α) = 1 + 0 := (add_zero 1).symm
+  calc (1 : α) = 1 + 0 := (add_zero 1).symm
      _ ≤ 1 + 1 := add_le_add_left zero_le_one _
      _ = 2 := one_add_one_eq_two
 #align one_le_two one_le_two
 
 lemma one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (·+·)) (·≤·)] :
     (1 : α) ≤ 2 :=
-calc (1 : α) = 0 + 1 := (zero_add 1).symm
+  calc (1 : α) = 0 + 1 := (zero_add 1).symm
      _ ≤ 1 + 1 := add_le_add_right zero_le_one _
      _ = 2 := one_add_one_eq_two
 #align one_le_two' one_le_two'

07fee0ca

chore: only four spaces for subsequent lines (#7286)

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

0c7d6fa5

Diff

@@ -36,7 +36,7 @@ lemma zero_le_two [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·
 #align zero_le_two zero_le_two
 
 lemma zero_le_three [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
-  (0 : α) ≤ 3 := by
+    (0 : α) ≤ 3 := by
   rw [← two_add_one_eq_three]
   exact add_nonneg zero_le_two zero_le_one
 #align zero_le_three zero_le_three
@@ -48,14 +48,14 @@ lemma zero_le_four [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+
 #align zero_le_four zero_le_four
 
 lemma one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
-  (1 : α) ≤ 2 :=
+    (1 : α) ≤ 2 :=
 calc (1 : α) = 1 + 0 := (add_zero 1).symm
      _ ≤ 1 + 1 := add_le_add_left zero_le_one _
      _ = 2 := one_add_one_eq_two
 #align one_le_two one_le_two
 
 lemma one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (·+·)) (·≤·)] :
-  (1 : α) ≤ 2 :=
+    (1 : α) ≤ 2 :=
 calc (1 : α) = 0 + 1 := (zero_add 1).symm
      _ ≤ 1 + 1 := add_le_add_right zero_le_one _
      _ = 2 := one_add_one_eq_two

07fee0ca

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -110,11 +110,11 @@ lemma one_lt_two [CovariantClass α α (·+·) (·<·)] : (1 : α) < 2 := by
 
 end
 
-alias zero_lt_two ← two_pos
+alias two_pos := zero_lt_two
 #align two_pos two_pos
 
-alias zero_lt_three ← three_pos
+alias three_pos := zero_lt_three
 #align three_pos three_pos
 
-alias zero_lt_four ← four_pos
+alias four_pos := zero_lt_four
 #align four_pos four_pos

07fee0ca

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

@@ -13,7 +13,7 @@ import Mathlib.Data.Nat.Cast.Defs
 # Order of numerals in an `AddMonoidWithOne`.
 -/
 
-variable {α : Type _}
+variable {α : Type*}
 
 open Function

07fee0ca

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,16 +2,13 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl, Yuyang Zhao
-
-! This file was ported from Lean 3 source module algebra.order.monoid.nat_cast
-! leanprover-community/mathlib commit 07fee0ca54c320250c98bacf31ca5f288b2bcbe2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Monoid.Lemmas
 import Mathlib.Algebra.Order.ZeroLEOne
 import Mathlib.Data.Nat.Cast.Defs
 
+#align_import algebra.order.monoid.nat_cast from "leanprover-community/mathlib"@"07fee0ca54c320250c98bacf31ca5f288b2bcbe2"
+
 /-!
 # Order of numerals in an `AddMonoidWithOne`.
 -/

07fee0ca

chore: tidy various files (#5233)

697ac1d3

Diff

@@ -72,29 +72,33 @@ variable [CovariantClass α α (·+·) (·≤·)]
 
 /-- See `zero_lt_two'` for a version with the type explicit. -/
 @[simp] lemma zero_lt_two : (0 : α) < 2 := zero_lt_one.trans_le one_le_two
+#align zero_lt_two zero_lt_two
+
 /-- See `zero_lt_three'` for a version with the type explicit. -/
 @[simp] lemma zero_lt_three : (0 : α) < 3 := by
   rw [← two_add_one_eq_three]
   exact lt_add_of_lt_of_nonneg zero_lt_two zero_le_one
+#align zero_lt_three zero_lt_three
+
 /-- See `zero_lt_four'` for a version with the type explicit. -/
 @[simp] lemma zero_lt_four : (0 : α) < 4 := by
   rw [← three_add_one_eq_four]
   exact lt_add_of_lt_of_nonneg zero_lt_three zero_le_one
 #align zero_lt_four zero_lt_four
-#align zero_lt_three zero_lt_three
-#align zero_lt_two zero_lt_two
 
 variable (α)
 
 /-- See `zero_lt_two` for a version with the type implicit. -/
 lemma zero_lt_two' : (0 : α) < 2 := zero_lt_two
+#align zero_lt_two' zero_lt_two'
+
 /-- See `zero_lt_three` for a version with the type implicit. -/
 lemma zero_lt_three' : (0 : α) < 3 := zero_lt_three
+#align zero_lt_three' zero_lt_three'
+
 /-- See `zero_lt_four` for a version with the type implicit. -/
 lemma zero_lt_four' : (0 : α) < 4 := zero_lt_four
 #align zero_lt_four' zero_lt_four'
-#align zero_lt_three' zero_lt_three'
-#align zero_lt_two' zero_lt_two'
 
 instance ZeroLEOneClass.neZero.two : NeZero (2 : α) := ⟨zero_lt_two.ne'⟩
 instance ZeroLEOneClass.neZero.three : NeZero (3 : α) := ⟨zero_lt_three.ne'⟩
@@ -110,8 +114,10 @@ lemma one_lt_two [CovariantClass α α (·+·) (·<·)] : (1 : α) < 2 := by
 end
 
 alias zero_lt_two ← two_pos
+#align two_pos two_pos
+
 alias zero_lt_three ← three_pos
+#align three_pos three_pos
+
 alias zero_lt_four ← four_pos
 #align four_pos four_pos
-#align three_pos three_pos
-#align two_pos two_pos

07fee0ca

chore: bump to nightly-2023-02-03 (#1999)

78fc778d

Diff

@@ -52,14 +52,14 @@ lemma zero_le_four [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+
 
 lemma one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
   (1 : α) ≤ 2 :=
-calc 1 = 1 + 0 := (add_zero 1).symm
+calc (1 : α) = 1 + 0 := (add_zero 1).symm
      _ ≤ 1 + 1 := add_le_add_left zero_le_one _
      _ = 2 := one_add_one_eq_two
 #align one_le_two one_le_two
 
 lemma one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (·+·)) (·≤·)] :
   (1 : α) ≤ 2 :=
-calc 1 = 0 + 1 := (zero_add 1).symm
+calc (1 : α) = 0 + 1 := (zero_add 1).symm
      _ ≤ 1 + 1 := add_le_add_right zero_le_one _
      _ = 2 := one_add_one_eq_two
 #align one_le_two' one_le_two'

07fee0ca

chore: add missing #align statements (#1902)

This PR is the result of a slight variant on the following "algorithm"

take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
for pairs that do not have an align statement:
- use Lean 4 to lookup the file + position of the Lean 4 name
- add an #align statement just before the next empty line
manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

b72bb858

Diff

@@ -23,10 +23,12 @@ open Function
 lemma lt_add_one [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α]
   [NeZero (1 : α)] [CovariantClass α α (·+·) (·<·)] (a : α) : a < a + 1 :=
 lt_add_of_pos_right _ zero_lt_one
+#align lt_add_one lt_add_one
 
 lemma lt_one_add [One α] [AddZeroClass α] [PartialOrder α] [ZeroLEOneClass α]
   [NeZero (1 : α)] [CovariantClass α α (swap (·+·)) (·<·)] (a : α) : a < 1 + a :=
 lt_add_of_pos_left _ zero_lt_one
+#align lt_one_add lt_one_add
 
 variable [AddMonoidWithOne α]
 
@@ -34,28 +36,33 @@ lemma zero_le_two [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·
     (0 : α) ≤ 2 := by
   rw [← one_add_one_eq_two]
   exact add_nonneg zero_le_one zero_le_one
+#align zero_le_two zero_le_two
 
 lemma zero_le_three [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
   (0 : α) ≤ 3 := by
   rw [← two_add_one_eq_three]
   exact add_nonneg zero_le_two zero_le_one
+#align zero_le_three zero_le_three
 
 lemma zero_le_four [Preorder α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
     (0 : α) ≤ 4 := by
   rw [← three_add_one_eq_four]
   exact add_nonneg zero_le_three zero_le_one
+#align zero_le_four zero_le_four
 
 lemma one_le_two [LE α] [ZeroLEOneClass α] [CovariantClass α α (·+·) (·≤·)] :
   (1 : α) ≤ 2 :=
 calc 1 = 1 + 0 := (add_zero 1).symm
      _ ≤ 1 + 1 := add_le_add_left zero_le_one _
      _ = 2 := one_add_one_eq_two
+#align one_le_two one_le_two
 
 lemma one_le_two' [LE α] [ZeroLEOneClass α] [CovariantClass α α (swap (·+·)) (·≤·)] :
   (1 : α) ≤ 2 :=
 calc 1 = 0 + 1 := (zero_add 1).symm
      _ ≤ 1 + 1 := add_le_add_right zero_le_one _
      _ = 2 := one_add_one_eq_two
+#align one_le_two' one_le_two'
 
 section
 variable [PartialOrder α] [ZeroLEOneClass α] [NeZero (1 : α)]
@@ -73,6 +80,9 @@ variable [CovariantClass α α (·+·) (·≤·)]
 @[simp] lemma zero_lt_four : (0 : α) < 4 := by
   rw [← three_add_one_eq_four]
   exact lt_add_of_lt_of_nonneg zero_lt_three zero_le_one
+#align zero_lt_four zero_lt_four
+#align zero_lt_three zero_lt_three
+#align zero_lt_two zero_lt_two
 
 variable (α)
 
@@ -82,6 +92,9 @@ lemma zero_lt_two' : (0 : α) < 2 := zero_lt_two
 lemma zero_lt_three' : (0 : α) < 3 := zero_lt_three
 /-- See `zero_lt_four` for a version with the type implicit. -/
 lemma zero_lt_four' : (0 : α) < 4 := zero_lt_four
+#align zero_lt_four' zero_lt_four'
+#align zero_lt_three' zero_lt_three'
+#align zero_lt_two' zero_lt_two'
 
 instance ZeroLEOneClass.neZero.two : NeZero (2 : α) := ⟨zero_lt_two.ne'⟩
 instance ZeroLEOneClass.neZero.three : NeZero (3 : α) := ⟨zero_lt_three.ne'⟩
@@ -92,9 +105,13 @@ end
 lemma one_lt_two [CovariantClass α α (·+·) (·<·)] : (1 : α) < 2 := by
   rw [← one_add_one_eq_two]
   exact lt_add_one _
+#align one_lt_two one_lt_two
 
 end
 
 alias zero_lt_two ← two_pos
 alias zero_lt_three ← three_pos
 alias zero_lt_four ← four_pos
+#align four_pos four_pos
+#align three_pos three_pos
+#align two_pos two_pos

07fee0ca

chore: fix casing per naming scheme (#1183)

Fix a lot of wrong casing mostly in the docstrings but also sometimes in def/theorem names. E.g. fin 2 --> Fin 2, add_monoid_hom --> AddMonoidHom

Remove \n from to_additive docstrings that were inserted by mathport.

Move files and directories with Gcd and Smul to GCD and SMul

71723d8b

Diff

@@ -83,9 +83,9 @@ lemma zero_lt_three' : (0 : α) < 3 := zero_lt_three
 /-- See `zero_lt_four` for a version with the type implicit. -/
 lemma zero_lt_four' : (0 : α) < 4 := zero_lt_four
 
-instance zero_le_one_class.ne_zero.two : NeZero (2 : α) := ⟨zero_lt_two.ne'⟩
-instance zero_le_one_class.ne_zero.three : NeZero (3 : α) := ⟨zero_lt_three.ne'⟩
-instance zero_le_one_class.ne_zero.four : NeZero (4 : α) := ⟨zero_lt_four.ne'⟩
+instance ZeroLEOneClass.neZero.two : NeZero (2 : α) := ⟨zero_lt_two.ne'⟩
+instance ZeroLEOneClass.neZero.three : NeZero (3 : α) := ⟨zero_lt_three.ne'⟩
+instance ZeroLEOneClass.neZero.four : NeZero (4 : α) := ⟨zero_lt_four.ne'⟩
 
 end

07fee0ca

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) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl, Yuyang Zhao
+
+! This file was ported from Lean 3 source module algebra.order.monoid.nat_cast
+! leanprover-community/mathlib commit 07fee0ca54c320250c98bacf31ca5f288b2bcbe2
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Monoid.Lemmas
 import Mathlib.Algebra.Order.ZeroLEOne

`algebra.order.monoid.nat_cast` ⟷ `Mathlib.Algebra.Order.Monoid.NatCast`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 28

algebra.order.monoid.nat_cast ⟷ Mathlib.Algebra.Order.Monoid.NatCast

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 28

`algebra.order.monoid.nat_cast` ⟷ `Mathlib.Algebra.Order.Monoid.NatCast`