algebra.order.group.order_iso | 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

6632ca20

(last sync)

feat(algebra/order/group/order_iso): add order_iso.div_{left,right} (#18968)

Diff

@@ -51,6 +51,12 @@ attribute [to_additive neg_le_of_neg_le] inv_le_of_inv_le'
 lemma le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ :=
 (order_iso.inv α).le_symm_apply
 
+/-- `x ↦ a / x` as an order-reversing equivalence. -/
+@[to_additive "`x ↦ a - x` as an order-reversing equivalence.", simps]
+def order_iso.div_left (a : α) : α ≃o αᵒᵈ :=
+{ to_equiv := (equiv.div_left a).trans order_dual.to_dual,
+  map_rel_iff' := λ x y, @div_le_div_iff_left α _ _ _ _ _ _ _ }
+
 end typeclasses_left_right_le
 
 end group
@@ -74,6 +80,12 @@ def order_iso.mul_right (a : α) : α ≃o α :=
   (order_iso.mul_right a).symm = order_iso.mul_right a⁻¹ :=
 by { ext x, refl }
 
+/-- `x ↦ x / a` as an order isomorphism. -/
+@[to_additive "`x ↦ x - a` as an order isomorphism.", simps]
+def order_iso.div_right (a : α) : α ≃o α :=
+{ to_equiv := equiv.div_right a,
+  map_rel_iff' := λ x y, div_le_div_iff_right a }
+
 end right
 
 section left

a95b16cb

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

6632ca20

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
 -/
 import Algebra.Order.Group.Defs
-import Algebra.Hom.Equiv.Units.Basic
+import Algebra.Group.Units.Equiv
 
 #align_import algebra.order.group.order_iso from "leanprover-community/mathlib"@"6632ca2081e55ff5cf228ca63011979a0efb495b"

6632ca20

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 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
 -/
-import Mathbin.Algebra.Order.Group.Defs
-import Mathbin.Algebra.Hom.Equiv.Units.Basic
+import Algebra.Order.Group.Defs
+import Algebra.Hom.Equiv.Units.Basic
 
 #align_import algebra.order.group.order_iso from "leanprover-community/mathlib"@"6632ca2081e55ff5cf228ca63011979a0efb495b"

6632ca20

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -57,7 +57,7 @@ theorem inv_le' : a⁻¹ ≤ b ↔ b⁻¹ ≤ a :=
 #align neg_le neg_le
 -/
 
-alias inv_le' ↔ inv_le_of_inv_le' _
+alias ⟨inv_le_of_inv_le', _⟩ := inv_le'
 #align inv_le_of_inv_le' inv_le_of_inv_le'
 
 attribute [to_additive neg_le_of_neg_le] inv_le_of_inv_le'
@@ -85,7 +85,7 @@ end TypeclassesLeftRightLe
 
 end Group
 
-alias le_inv' ↔ le_inv_of_le_inv _
+alias ⟨le_inv_of_le_inv, _⟩ := le_inv'
 #align le_inv_of_le_inv le_inv_of_le_inv
 
 attribute [to_additive] le_inv_of_le_inv

6632ca20

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 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
-
-! This file was ported from Lean 3 source module algebra.order.group.order_iso
-! leanprover-community/mathlib commit 6632ca2081e55ff5cf228ca63011979a0efb495b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Order.Group.Defs
 import Mathbin.Algebra.Hom.Equiv.Units.Basic
 
+#align_import algebra.order.group.order_iso from "leanprover-community/mathlib"@"6632ca2081e55ff5cf228ca63011979a0efb495b"
+
 /-!
 # Inverse and multiplication as order isomorphisms in ordered groups

6632ca20

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -39,6 +39,7 @@ section
 
 variable (α)
 
+#print OrderIso.inv /-
 /-- `x ↦ x⁻¹` as an order-reversing equivalence. -/
 @[to_additive "`x ↦ -x` as an order-reversing equivalence.", simps]
 def OrderIso.inv : α ≃o αᵒᵈ
@@ -47,26 +48,32 @@ def OrderIso.inv : α ≃o αᵒᵈ
   map_rel_iff' a b := @inv_le_inv_iff α _ _ _ _ _ _
 #align order_iso.inv OrderIso.inv
 #align order_iso.neg OrderIso.neg
+-/
 
 end
 
+#print inv_le' /-
 @[to_additive neg_le]
 theorem inv_le' : a⁻¹ ≤ b ↔ b⁻¹ ≤ a :=
   (OrderIso.inv α).symm_apply_le
 #align inv_le' inv_le'
 #align neg_le neg_le
+-/
 
 alias inv_le' ↔ inv_le_of_inv_le' _
 #align inv_le_of_inv_le' inv_le_of_inv_le'
 
 attribute [to_additive neg_le_of_neg_le] inv_le_of_inv_le'
 
+#print le_inv' /-
 @[to_additive le_neg]
 theorem le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ :=
   (OrderIso.inv α).le_symm_apply
 #align le_inv' le_inv'
 #align le_neg le_neg
+-/
 
+#print OrderIso.divLeft /-
 /-- `x ↦ a / x` as an order-reversing equivalence. -/
 @[to_additive "`x ↦ a - x` as an order-reversing equivalence.", simps]
 def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ
@@ -75,6 +82,7 @@ def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ
   map_rel_iff' x y := @div_le_div_iff_left α _ _ _ _ _ _ _
 #align order_iso.div_left OrderIso.divLeft
 #align order_iso.sub_left OrderIso.subLeft
+-/
 
 end TypeclassesLeftRightLe
 
@@ -93,6 +101,7 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 
+#print OrderIso.mulRight /-
 /-- `equiv.mul_right` as an `order_iso`. See also `order_embedding.mul_right`. -/
 @[to_additive "`equiv.add_right` as an `order_iso`. See also `order_embedding.add_right`.",
   simps (config := { simpRhs := true }) toEquiv apply]
@@ -102,13 +111,17 @@ def OrderIso.mulRight (a : α) : α ≃o α
   toEquiv := Equiv.mulRight a
 #align order_iso.mul_right OrderIso.mulRight
 #align order_iso.add_right OrderIso.addRight
+-/
 
+#print OrderIso.mulRight_symm /-
 @[simp, to_additive]
 theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ := by
   ext x; rfl
 #align order_iso.mul_right_symm OrderIso.mulRight_symm
 #align order_iso.add_right_symm OrderIso.addRight_symm
+-/
 
+#print OrderIso.divRight /-
 /-- `x ↦ x / a` as an order isomorphism. -/
 @[to_additive "`x ↦ x - a` as an order isomorphism.", simps]
 def OrderIso.divRight (a : α) : α ≃o α
@@ -117,6 +130,7 @@ def OrderIso.divRight (a : α) : α ≃o α
   map_rel_iff' x y := div_le_div_iff_right a
 #align order_iso.div_right OrderIso.divRight
 #align order_iso.sub_right OrderIso.subRight
+-/
 
 end Right
 
@@ -124,6 +138,7 @@ section Left
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
+#print OrderIso.mulLeft /-
 /-- `equiv.mul_left` as an `order_iso`. See also `order_embedding.mul_left`. -/
 @[to_additive "`equiv.add_left` as an `order_iso`. See also `order_embedding.add_left`.",
   simps (config := { simpRhs := true }) toEquiv apply]
@@ -133,12 +148,15 @@ def OrderIso.mulLeft (a : α) : α ≃o α
   toEquiv := Equiv.mulLeft a
 #align order_iso.mul_left OrderIso.mulLeft
 #align order_iso.add_left OrderIso.addLeft
+-/
 
+#print OrderIso.mulLeft_symm /-
 @[simp, to_additive]
 theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ := by
   ext x; rfl
 #align order_iso.mul_left_symm OrderIso.mulLeft_symm
 #align order_iso.add_left_symm OrderIso.addLeft_symm
+-/
 
 end Left

6632ca20

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -39,12 +39,6 @@ section
 
 variable (α)
 
-/- warning: order_iso.inv -> OrderIso.inv is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)], OrderIso.{u1, u1} α (OrderDual.{u1} α) _inst_2 (OrderDual.hasLe.{u1} α _inst_2)
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.210 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.212 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.210 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.212) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.225 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.227 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.225 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.227)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.247 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.249 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.247 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.249)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.262 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.264 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.262 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.264)], OrderIso.{u1, u1} α (OrderDual.{u1} α) _inst_2 (OrderDual.instLEOrderDual.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align order_iso.inv OrderIso.invₓ'. -/
 /-- `x ↦ x⁻¹` as an order-reversing equivalence. -/
 @[to_additive "`x ↦ -x` as an order-reversing equivalence.", simps]
 def OrderIso.inv : α ≃o αᵒᵈ
@@ -56,47 +50,23 @@ def OrderIso.inv : α ≃o αᵒᵈ
 
 end
 
-/- warning: inv_le' -> inv_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.327 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.329 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.327 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.329) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.342 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.344 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.342 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.344)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.364 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.366 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.364 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.366)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.379 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.381 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.379 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.381)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a)
-Case conversion may be inaccurate. Consider using '#align inv_le' inv_le'ₓ'. -/
 @[to_additive neg_le]
 theorem inv_le' : a⁻¹ ≤ b ↔ b⁻¹ ≤ a :=
   (OrderIso.inv α).symm_apply_le
 #align inv_le' inv_le'
 #align neg_le neg_le
 
-/- warning: inv_le_of_inv_le' -> inv_le_of_inv_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) -> (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.327 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.329 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.327 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.329) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.342 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.344 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.342 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.344)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.364 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.366 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.364 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.366)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.379 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.381 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.379 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.381)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) -> (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a)
-Case conversion may be inaccurate. Consider using '#align inv_le_of_inv_le' inv_le_of_inv_le'ₓ'. -/
 alias inv_le' ↔ inv_le_of_inv_le' _
 #align inv_le_of_inv_le' inv_le_of_inv_le'
 
 attribute [to_additive neg_le_of_neg_le] inv_le_of_inv_le'
 
-/- warning: le_inv' -> le_inv' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (LE.le.{u1} α _inst_2 b (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.438 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.440 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.438 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.440) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.453 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.455 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.453 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.455)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.475 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.477 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.475 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.477)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.490 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.492 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.490 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.492)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LE.le.{u1} α _inst_2 b (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align le_inv' le_inv'ₓ'. -/
 @[to_additive le_neg]
 theorem le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ :=
   (OrderIso.inv α).le_symm_apply
 #align le_inv' le_inv'
 #align le_neg le_neg
 
-/- warning: order_iso.div_left -> OrderIso.divLeft is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)], α -> (OrderIso.{u1, u1} α (OrderDual.{u1} α) _inst_2 (OrderDual.hasLe.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.549 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.551 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.549 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.551) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.564 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.566 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.564 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.566)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.586 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.588 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.586 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.588)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.601 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.603 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.601 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.603)], α -> (OrderIso.{u1, u1} α (OrderDual.{u1} α) _inst_2 (OrderDual.instLEOrderDual.{u1} α _inst_2))
-Case conversion may be inaccurate. Consider using '#align order_iso.div_left OrderIso.divLeftₓ'. -/
 /-- `x ↦ a / x` as an order-reversing equivalence. -/
 @[to_additive "`x ↦ a - x` as an order-reversing equivalence.", simps]
 def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ
@@ -110,12 +80,6 @@ end TypeclassesLeftRightLe
 
 end Group
 
-/- warning: le_inv_of_le_inv -> le_inv_of_le_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) -> (LE.le.{u1} α _inst_2 b (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.438 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.440 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.438 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.440) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.453 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.455 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.453 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.455)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.475 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.477 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.475 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.477)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.490 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.492 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.490 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.492)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) -> (LE.le.{u1} α _inst_2 b (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align le_inv_of_le_inv le_inv_of_le_invₓ'. -/
 alias le_inv' ↔ le_inv_of_le_inv _
 #align le_inv_of_le_inv le_inv_of_le_inv
 
@@ -129,12 +93,6 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 
-/- warning: order_iso.mul_right -> OrderIso.mulRight is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.747 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.749 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.747 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.749)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.762 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.764 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.762 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.764)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
-Case conversion may be inaccurate. Consider using '#align order_iso.mul_right OrderIso.mulRightₓ'. -/
 /-- `equiv.mul_right` as an `order_iso`. See also `order_embedding.mul_right`. -/
 @[to_additive "`equiv.add_right` as an `order_iso`. See also `order_embedding.add_right`.",
   simps (config := { simpRhs := true }) toEquiv apply]
@@ -145,24 +103,12 @@ def OrderIso.mulRight (a : α) : α ≃o α
 #align order_iso.mul_right OrderIso.mulRight
 #align order_iso.add_right OrderIso.addRight
 
-/- warning: order_iso.mul_right_symm -> OrderIso.mulRight_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.863 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.865 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.863 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.865)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.878 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.880 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.878 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.880)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align order_iso.mul_right_symm OrderIso.mulRight_symmₓ'. -/
 @[simp, to_additive]
 theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ := by
   ext x; rfl
 #align order_iso.mul_right_symm OrderIso.mulRight_symm
 #align order_iso.add_right_symm OrderIso.addRight_symm
 
-/- warning: order_iso.div_right -> OrderIso.divRight is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.943 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.945 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.943 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.945)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.958 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.960 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.958 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.960)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
-Case conversion may be inaccurate. Consider using '#align order_iso.div_right OrderIso.divRightₓ'. -/
 /-- `x ↦ x / a` as an order isomorphism. -/
 @[to_additive "`x ↦ x - a` as an order isomorphism.", simps]
 def OrderIso.divRight (a : α) : α ≃o α
@@ -178,12 +124,6 @@ section Left
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
-/- warning: order_iso.mul_left -> OrderIso.mulLeft is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1064 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1066 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1064 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1066) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1079 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1081 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1079 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1081)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
-Case conversion may be inaccurate. Consider using '#align order_iso.mul_left OrderIso.mulLeftₓ'. -/
 /-- `equiv.mul_left` as an `order_iso`. See also `order_embedding.mul_left`. -/
 @[to_additive "`equiv.add_left` as an `order_iso`. See also `order_embedding.add_left`.",
   simps (config := { simpRhs := true }) toEquiv apply]
@@ -194,12 +134,6 @@ def OrderIso.mulLeft (a : α) : α ≃o α
 #align order_iso.mul_left OrderIso.mulLeft
 #align order_iso.add_left OrderIso.addLeft
 
-/- warning: order_iso.mul_left_symm -> OrderIso.mulLeft_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1174 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1176 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1174 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1176) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1189 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1191 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1189 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1191)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align order_iso.mul_left_symm OrderIso.mulLeft_symmₓ'. -/
 @[simp, to_additive]
 theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ := by
   ext x; rfl

6632ca20

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -152,10 +152,8 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.863 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.865 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.863 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.865)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.878 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.880 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.878 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.880)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align order_iso.mul_right_symm OrderIso.mulRight_symmₓ'. -/
 @[simp, to_additive]
-theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ :=
-  by
-  ext x
-  rfl
+theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ := by
+  ext x; rfl
 #align order_iso.mul_right_symm OrderIso.mulRight_symm
 #align order_iso.add_right_symm OrderIso.addRight_symm
 
@@ -203,10 +201,8 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1174 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1176 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1174 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1176) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1189 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1191 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1189 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1191)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align order_iso.mul_left_symm OrderIso.mulLeft_symmₓ'. -/
 @[simp, to_additive]
-theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ :=
-  by
-  ext x
-  rfl
+theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ := by
+  ext x; rfl
 #align order_iso.mul_left_symm OrderIso.mulLeft_symm
 #align order_iso.add_left_symm OrderIso.addLeft_symm

6632ca20

bump to nightly-2023-05-13-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/403190b5419b3f03f1a2893ad9352ca7f7d8bff6

e7ae2e9d

Diff

@@ -91,6 +91,12 @@ theorem le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ :=
 #align le_inv' le_inv'
 #align le_neg le_neg
 
+/- warning: order_iso.div_left -> OrderIso.divLeft is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)], α -> (OrderIso.{u1, u1} α (OrderDual.{u1} α) _inst_2 (OrderDual.hasLe.{u1} α _inst_2))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.549 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.551 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.549 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.551) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.564 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.566 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.564 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.566)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.586 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.588 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.586 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.588)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.601 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.603 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.601 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.603)], α -> (OrderIso.{u1, u1} α (OrderDual.{u1} α) _inst_2 (OrderDual.instLEOrderDual.{u1} α _inst_2))
+Case conversion may be inaccurate. Consider using '#align order_iso.div_left OrderIso.divLeftₓ'. -/
 /-- `x ↦ a / x` as an order-reversing equivalence. -/
 @[to_additive "`x ↦ a - x` as an order-reversing equivalence.", simps]
 def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ
@@ -127,7 +133,7 @@ variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.627 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.629 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.627 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.629)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.642 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.644 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.642 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.644)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.747 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.749 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.747 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.749)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.762 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.764 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.762 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.764)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
 Case conversion may be inaccurate. Consider using '#align order_iso.mul_right OrderIso.mulRightₓ'. -/
 /-- `equiv.mul_right` as an `order_iso`. See also `order_embedding.mul_right`. -/
 @[to_additive "`equiv.add_right` as an `order_iso`. See also `order_embedding.add_right`.",
@@ -143,7 +149,7 @@ def OrderIso.mulRight (a : α) : α ≃o α
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.743 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.745 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.743 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.745)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.758 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.760 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.758 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.760)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.863 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.865 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.863 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.865)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.878 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.880 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.878 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.880)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulRight.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align order_iso.mul_right_symm OrderIso.mulRight_symmₓ'. -/
 @[simp, to_additive]
 theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ :=
@@ -153,6 +159,12 @@ theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.
 #align order_iso.mul_right_symm OrderIso.mulRight_symm
 #align order_iso.add_right_symm OrderIso.addRight_symm
 
+/- warning: order_iso.div_right -> OrderIso.divRight is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.943 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.945 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.943 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.945)) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.958 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.960 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.958 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.960)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
+Case conversion may be inaccurate. Consider using '#align order_iso.div_right OrderIso.divRightₓ'. -/
 /-- `x ↦ x / a` as an order isomorphism. -/
 @[to_additive "`x ↦ x - a` as an order isomorphism.", simps]
 def OrderIso.divRight (a : α) : α ≃o α
@@ -172,7 +184,7 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.868 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.870 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.868 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.870) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.883 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.885 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.883 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.885)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1064 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1066 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1064 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1066) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1079 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1081 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1079 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1081)], α -> (OrderIso.{u1, u1} α α _inst_2 _inst_2)
 Case conversion may be inaccurate. Consider using '#align order_iso.mul_left OrderIso.mulLeftₓ'. -/
 /-- `equiv.mul_left` as an `order_iso`. See also `order_embedding.mul_left`. -/
 @[to_additive "`equiv.add_left` as an `order_iso`. See also `order_embedding.add_left`.",
@@ -188,7 +200,7 @@ def OrderIso.mulLeft (a : α) : α ≃o α
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.978 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.980 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.978 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.980) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.993 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.995 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.993 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.995)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1174 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1176 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1174 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1176) (fun (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1189 : α) (x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1191 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1189 x._@.Mathlib.Algebra.Order.Group.OrderIso._hyg.1191)] (a : α), Eq.{succ u1} (OrderIso.{u1, u1} α α _inst_2 _inst_2) (OrderIso.symm.{u1, u1} α α _inst_2 _inst_2 (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 a)) (OrderIso.mulLeft.{u1} α _inst_1 _inst_2 _inst_3 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align order_iso.mul_left_symm OrderIso.mulLeft_symmₓ'. -/
 @[simp, to_additive]
 theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ :=

6632ca20

bump to nightly-2023-05-09-02

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

6a26eca8

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
 
 ! This file was ported from Lean 3 source module algebra.order.group.order_iso
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit 6632ca2081e55ff5cf228ca63011979a0efb495b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -91,6 +91,15 @@ theorem le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ :=
 #align le_inv' le_inv'
 #align le_neg le_neg
 
+/-- `x ↦ a / x` as an order-reversing equivalence. -/
+@[to_additive "`x ↦ a - x` as an order-reversing equivalence.", simps]
+def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ
+    where
+  toEquiv := (Equiv.divLeft a).trans OrderDual.toDual
+  map_rel_iff' x y := @div_le_div_iff_left α _ _ _ _ _ _ _
+#align order_iso.div_left OrderIso.divLeft
+#align order_iso.sub_left OrderIso.subLeft
+
 end TypeclassesLeftRightLe
 
 end Group
@@ -144,6 +153,15 @@ theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.
 #align order_iso.mul_right_symm OrderIso.mulRight_symm
 #align order_iso.add_right_symm OrderIso.addRight_symm
 
+/-- `x ↦ x / a` as an order isomorphism. -/
+@[to_additive "`x ↦ x - a` as an order isomorphism.", simps]
+def OrderIso.divRight (a : α) : α ≃o α
+    where
+  toEquiv := Equiv.divRight a
+  map_rel_iff' x y := div_le_div_iff_right a
+#align order_iso.div_right OrderIso.divRight
+#align order_iso.sub_right OrderIso.subRight
+
 end Right
 
 section Left

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

6632ca20

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

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

f4c4ca61

Diff

@@ -5,6 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
 import Mathlib.Algebra.Group.Units.Equiv
 import Mathlib.Algebra.Order.Group.Defs
+import Mathlib.Order.Hom.Basic
 
 #align_import algebra.order.group.order_iso from "leanprover-community/mathlib"@"6632ca2081e55ff5cf228ca63011979a0efb495b"

6632ca20

refactor(Algebra/Hom): transpose Hom and file name (#8095)

I believe the file defining a type of morphisms belongs alongside the file defining the structure this morphism works on. So I would like to reorganize the files in the Mathlib.Algebra.Hom folder so that e.g. Mathlib.Algebra.Hom.Ring becomes Mathlib.Algebra.Ring.Hom and Mathlib.Algebra.Hom.NonUnitalAlg becomes Mathlib.Algebra.Algebra.NonUnitalHom.

While fixing the imports I went ahead and sorted them for good luck.

The full list of changes is: renamed: Mathlib/Algebra/Hom/NonUnitalAlg.lean -> Mathlib/Algebra/Algebra/NonUnitalHom.lean renamed: Mathlib/Algebra/Hom/Aut.lean -> Mathlib/Algebra/Group/Aut.lean renamed: Mathlib/Algebra/Hom/Commute.lean -> Mathlib/Algebra/Group/Commute/Hom.lean renamed: Mathlib/Algebra/Hom/Embedding.lean -> Mathlib/Algebra/Group/Embedding.lean renamed: Mathlib/Algebra/Hom/Equiv/Basic.lean -> Mathlib/Algebra/Group/Equiv/Basic.lean renamed: Mathlib/Algebra/Hom/Equiv/TypeTags.lean -> Mathlib/Algebra/Group/Equiv/TypeTags.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/Basic.lean -> Mathlib/Algebra/Group/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/GroupWithZero.lean -> Mathlib/Algebra/GroupWithZero/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Freiman.lean -> Mathlib/Algebra/Group/Freiman.lean renamed: Mathlib/Algebra/Hom/Group/Basic.lean -> Mathlib/Algebra/Group/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Group/Defs.lean -> Mathlib/Algebra/Group/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/GroupAction.lean -> Mathlib/GroupTheory/GroupAction/Hom.lean renamed: Mathlib/Algebra/Hom/GroupInstances.lean -> Mathlib/Algebra/Group/Hom/Instances.lean renamed: Mathlib/Algebra/Hom/Iterate.lean -> Mathlib/Algebra/GroupPower/IterateHom.lean renamed: Mathlib/Algebra/Hom/Centroid.lean -> Mathlib/Algebra/Ring/CentroidHom.lean renamed: Mathlib/Algebra/Hom/Ring/Basic.lean -> Mathlib/Algebra/Ring/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Ring/Defs.lean -> Mathlib/Algebra/Ring/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/Units.lean -> Mathlib/Algebra/Group/Units/Hom.lean

Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Reorganizing.20.60Mathlib.2EAlgebra.2EHom.60

92fe122e

Diff

@@ -3,8 +3,8 @@ 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
 -/
+import Mathlib.Algebra.Group.Units.Equiv
 import Mathlib.Algebra.Order.Group.Defs
-import Mathlib.Algebra.Hom.Equiv.Units.Basic
 
 #align_import algebra.order.group.order_iso from "leanprover-community/mathlib"@"6632ca2081e55ff5cf228ca63011979a0efb495b"

6632ca20

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -50,7 +50,7 @@ theorem inv_le' : a⁻¹ ≤ b ↔ b⁻¹ ≤ a :=
 #align inv_le' inv_le'
 #align neg_le neg_le
 
-alias inv_le' ↔ inv_le_of_inv_le' _
+alias ⟨inv_le_of_inv_le', _⟩ := inv_le'
 #align inv_le_of_inv_le' inv_le_of_inv_le'
 
 attribute [to_additive neg_le_of_neg_le] inv_le_of_inv_le'
@@ -74,7 +74,7 @@ end TypeclassesLeftRightLE
 
 end Group
 
-alias le_inv' ↔ le_inv_of_le_inv _
+alias ⟨le_inv_of_le_inv, _⟩ := le_inv'
 #align le_inv_of_le_inv le_inv_of_le_inv
 
 attribute [to_additive] le_inv_of_le_inv

6632ca20

chore: remove 'Ported by' headers (#6018)

Briefly during the port we were adding "Ported by" headers, but only ~60 / 3000 files ended up with such a header.

I propose deleting them.

We could consider adding these uniformly via a script, as part of the great history rewrite...?

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

e8318a88

Diff

@@ -2,7 +2,6 @@
 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
-Ported by: Scott Morrison
 -/
 import Mathlib.Algebra.Order.Group.Defs
 import Mathlib.Algebra.Hom.Equiv.Units.Basic

6632ca20

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

@@ -3,15 +3,12 @@ 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
 Ported by: Scott Morrison
-
-! This file was ported from Lean 3 source module algebra.order.group.order_iso
-! leanprover-community/mathlib commit 6632ca2081e55ff5cf228ca63011979a0efb495b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Group.Defs
 import Mathlib.Algebra.Hom.Equiv.Units.Basic
 
+#align_import algebra.order.group.order_iso from "leanprover-community/mathlib"@"6632ca2081e55ff5cf228ca63011979a0efb495b"
+
 /-!
 # Inverse and multiplication as order isomorphisms in ordered groups

6632ca20

chore: forward-port leanprover-community/mathlib#18968 (#3890)

4e590eb9

Diff

@@ -5,7 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 Ported by: Scott Morrison
 
 ! This file was ported from Lean 3 source module algebra.order.group.order_iso
-! leanprover-community/mathlib commit a95b16cbade0f938fc24abd05412bde1e84bab9b
+! leanprover-community/mathlib commit 6632ca2081e55ff5cf228ca63011979a0efb495b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -66,6 +66,14 @@ theorem le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ :=
 #align le_inv' le_inv'
 #align le_neg le_neg
 
+/-- `x ↦ a / x` as an order-reversing equivalence. -/
+@[to_additive (attr := simps!) "`x ↦ a - x` as an order-reversing equivalence."]
+def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ where
+  toEquiv := (Equiv.divLeft a).trans OrderDual.toDual
+  map_rel_iff' {_ _} := @div_le_div_iff_left α _ _ _ _ _ _ _
+#align order_iso.div_left OrderIso.divLeft
+#align order_iso.sub_left OrderIso.subLeft
+
 end TypeclassesLeftRightLE
 
 end Group
@@ -102,6 +110,14 @@ theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.
 #align order_iso.mul_right_symm OrderIso.mulRight_symm
 #align order_iso.add_right_symm OrderIso.addRight_symm
 
+/-- `x ↦ x / a` as an order isomorphism. -/
+@[to_additive (attr := simps!) "`x ↦ x - a` as an order isomorphism."]
+def OrderIso.divRight (a : α) : α ≃o α where
+  toEquiv := Equiv.divRight a
+  map_rel_iff' {_ _} := div_le_div_iff_right a
+#align order_iso.div_right OrderIso.divRight
+#align order_iso.sub_right OrderIso.subRight
+
 end Right
 
 section Left

a95b16cb

fix: replace symmApply by symm_apply (#2560)

9aade17b

Diff

@@ -44,7 +44,7 @@ def OrderIso.inv : α ≃o αᵒᵈ where
 #align order_iso.inv OrderIso.inv
 #align order_iso.neg OrderIso.neg
 #align order_iso.inv_apply OrderIso.inv_apply
-#align order_iso.inv_symm_apply OrderIso.inv_symmApply
+#align order_iso.inv_symm_apply OrderIso.inv_symm_apply
 
 end

a95b16cb

feat: require @[simps!] if simps runs in expensive mode (#1885)

This does not change the behavior of simps, just raises a linter error if you run simps in a more expensive mode without writing !.
Fixed some incorrect occurrences of to_additive, simps. Will do that systematically in future PR.
Fix port of OmegaCompletePartialOrder.ContinuousHom.ofMono a bit

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

52c04a34

Diff

@@ -37,7 +37,7 @@ section
 variable (α)
 
 /-- `x ↦ x⁻¹` as an order-reversing equivalence. -/
-@[to_additive (attr := simps) "`x ↦ -x` as an order-reversing equivalence."]
+@[to_additive (attr := simps!) "`x ↦ -x` as an order-reversing equivalence."]
 def OrderIso.inv : α ≃o αᵒᵈ where
   toEquiv := (Equiv.inv α).trans OrderDual.toDual
   map_rel_iff' {_ _} := @inv_le_inv_iff α _ _ _ _ _ _
@@ -85,7 +85,7 @@ section Right
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 
 /-- `Equiv.mulRight` as an `OrderIso`. See also `OrderEmbedding.mulRight`. -/
-@[to_additive (attr := simps (config := { simpRhs := true }) toEquiv apply)
+@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
   "`Equiv.addRight` as an `OrderIso`. See also `OrderEmbedding.addRight`."]
 def OrderIso.mulRight (a : α) : α ≃o α where
   map_rel_iff' {_ _} := mul_le_mul_iff_right a
@@ -109,7 +109,7 @@ section Left
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
 /-- `Equiv.mulLeft` as an `OrderIso`. See also `OrderEmbedding.mulLeft`. -/
-@[to_additive (attr := simps (config := { simpRhs := true }) toEquiv apply)
+@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
   "`Equiv.addLeft` as an `OrderIso`. See also `OrderEmbedding.addLeft`."]
 def OrderIso.mulLeft (a : α) : α ≃o α where
   map_rel_iff' {_ _} := mul_le_mul_iff_left a

a95b16cb

fix: use to_additive (attr := _) here and there (#2073)

adaaf293

Diff

@@ -37,7 +37,7 @@ section
 variable (α)
 
 /-- `x ↦ x⁻¹` as an order-reversing equivalence. -/
-@[to_additive "`x ↦ -x` as an order-reversing equivalence.", simps]
+@[to_additive (attr := simps) "`x ↦ -x` as an order-reversing equivalence."]
 def OrderIso.inv : α ≃o αᵒᵈ where
   toEquiv := (Equiv.inv α).trans OrderDual.toDual
   map_rel_iff' {_ _} := @inv_le_inv_iff α _ _ _ _ _ _
@@ -85,8 +85,8 @@ section Right
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 
 /-- `Equiv.mulRight` as an `OrderIso`. See also `OrderEmbedding.mulRight`. -/
-@[to_additive "`Equiv.addRight` as an `OrderIso`. See also `OrderEmbedding.addRight`.",
-  simps (config := { simpRhs := true }) toEquiv apply]
+@[to_additive (attr := simps (config := { simpRhs := true }) toEquiv apply)
+  "`Equiv.addRight` as an `OrderIso`. See also `OrderEmbedding.addRight`."]
 def OrderIso.mulRight (a : α) : α ≃o α where
   map_rel_iff' {_ _} := mul_le_mul_iff_right a
   toEquiv := Equiv.mulRight a
@@ -109,15 +109,16 @@ section Left
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
 /-- `Equiv.mulLeft` as an `OrderIso`. See also `OrderEmbedding.mulLeft`. -/
-@[to_additive "`Equiv.addLeft` as an `OrderIso`. See also `OrderEmbedding.addLeft`.",
-  simps (config := { simpRhs := true }) toEquiv apply]
+@[to_additive (attr := simps (config := { simpRhs := true }) toEquiv apply)
+  "`Equiv.addLeft` as an `OrderIso`. See also `OrderEmbedding.addLeft`."]
 def OrderIso.mulLeft (a : α) : α ≃o α where
   map_rel_iff' {_ _} := mul_le_mul_iff_left a
   toEquiv := Equiv.mulLeft a
 #align order_iso.mul_left OrderIso.mulLeft
 #align order_iso.add_left OrderIso.addLeft
 #align order_iso.mul_left_apply OrderIso.mulLeft_apply
-#align order_iso.mul_left_to_equiv OrderIso.mulLeft_toEquiv
+#align order_iso.add_left_apply OrderIso.addLeft_apply
+#align order_iso.add_left_to_equiv OrderIso.addLeft_toEquiv
 
 @[to_additive (attr := simp)]
 theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ := by

a95b16cb

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

@@ -43,6 +43,8 @@ def OrderIso.inv : α ≃o αᵒᵈ where
   map_rel_iff' {_ _} := @inv_le_inv_iff α _ _ _ _ _ _
 #align order_iso.inv OrderIso.inv
 #align order_iso.neg OrderIso.neg
+#align order_iso.inv_apply OrderIso.inv_apply
+#align order_iso.inv_symm_apply OrderIso.inv_symmApply
 
 end
 
@@ -53,8 +55,10 @@ theorem inv_le' : a⁻¹ ≤ b ↔ b⁻¹ ≤ a :=
 #align neg_le neg_le
 
 alias inv_le' ↔ inv_le_of_inv_le' _
+#align inv_le_of_inv_le' inv_le_of_inv_le'
 
 attribute [to_additive neg_le_of_neg_le] inv_le_of_inv_le'
+#align neg_le_of_neg_le neg_le_of_neg_le
 
 @[to_additive le_neg]
 theorem le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ :=
@@ -67,8 +71,10 @@ end TypeclassesLeftRightLE
 end Group
 
 alias le_inv' ↔ le_inv_of_le_inv _
+#align le_inv_of_le_inv le_inv_of_le_inv
 
 attribute [to_additive] le_inv_of_le_inv
+#align le_neg_of_le_neg le_neg_of_le_neg
 
 section Group
 
@@ -86,6 +92,8 @@ def OrderIso.mulRight (a : α) : α ≃o α where
   toEquiv := Equiv.mulRight a
 #align order_iso.mul_right OrderIso.mulRight
 #align order_iso.add_right OrderIso.addRight
+#align order_iso.mul_right_apply OrderIso.mulRight_apply
+#align order_iso.mul_right_to_equiv OrderIso.mulRight_toEquiv
 
 @[to_additive (attr := simp)]
 theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ := by
@@ -108,6 +116,8 @@ def OrderIso.mulLeft (a : α) : α ≃o α where
   toEquiv := Equiv.mulLeft a
 #align order_iso.mul_left OrderIso.mulLeft
 #align order_iso.add_left OrderIso.addLeft
+#align order_iso.mul_left_apply OrderIso.mulLeft_apply
+#align order_iso.mul_left_to_equiv OrderIso.mulLeft_toEquiv
 
 @[to_additive (attr := simp)]
 theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ := by

a95b16cb

feat: improve the way to_additive deals with attributes (#1314)

The new syntax for any attributes that need to be copied by to_additive is @[to_additive (attrs := simp, ext, simps)]
Adds the auxiliary declarations generated by the simp and simps attributes to the to_additive-dictionary.
Future issue: Does not yet translate auxiliary declarations for other attributes (including custom simp-attributes). In particular it's possible that norm_cast might generate some auxiliary declarations.
Fixes #950
Fixes #953
Fixes #1149
This moves the interaction between to_additive and simps from the Simps file to the toAdditive file for uniformity.
Make the same changes to @[reassoc]

Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

56bf4cd6

Diff

@@ -87,7 +87,7 @@ def OrderIso.mulRight (a : α) : α ≃o α where
 #align order_iso.mul_right OrderIso.mulRight
 #align order_iso.add_right OrderIso.addRight
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ := by
   ext x
   rfl
@@ -109,7 +109,7 @@ def OrderIso.mulLeft (a : α) : α ≃o α where
 #align order_iso.mul_left OrderIso.mulLeft
 #align order_iso.add_left OrderIso.addLeft
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ := by
   ext x
   rfl

a95b16cb

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

@@ -3,6 +3,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
 Ported by: Scott Morrison
+
+! This file was ported from Lean 3 source module algebra.order.group.order_iso
+! leanprover-community/mathlib commit a95b16cbade0f938fc24abd05412bde1e84bab9b
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Group.Defs
 import Mathlib.Algebra.Hom.Equiv.Units.Basic

`algebra.order.group.order_iso` ⟷ `Mathlib.Algebra.Order.Group.OrderIso`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 1 + 50

algebra.order.group.order_iso ⟷ Mathlib.Algebra.Order.Group.OrderIso

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 1 + 50

`algebra.order.group.order_iso` ⟷ `Mathlib.Algebra.Order.Group.OrderIso`