algebra.hom.equiv.units.basic | 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

a95b16cb

(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

@@ -3,8 +3,8 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 -/
-import Algebra.Hom.Equiv.Basic
-import Algebra.Hom.Units
+import Algebra.Group.Equiv.Basic
+import Algebra.Group.Units.Hom
 
 #align_import algebra.hom.equiv.units.basic from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2024-02-17-08

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

42bef5c2

Diff

@@ -32,12 +32,12 @@ def toUnits [Group G] : G ≃* Gˣ
 #align to_add_units toAddUnits
 -/
 
-#print coe_toUnits /-
+#print val_toUnits_apply /-
 @[simp, to_additive]
-theorem coe_toUnits [Group G] (g : G) : (toUnits g : G) = g :=
+theorem val_toUnits_apply [Group G] (g : G) : (toUnits g : G) = g :=
   rfl
-#align coe_to_units coe_toUnits
-#align coe_to_add_units coe_toAddUnits
+#align coe_to_units val_toUnits_apply
+#align coe_to_add_units val_toAddUnits_apply
 -/
 
 namespace Units

448144f7

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 -/
-import Mathbin.Algebra.Hom.Equiv.Basic
-import Mathbin.Algebra.Hom.Units
+import Algebra.Hom.Equiv.Basic
+import Algebra.Hom.Units
 
 #align_import algebra.hom.equiv.units.basic from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
-
-! This file was ported from Lean 3 source module algebra.hom.equiv.units.basic
-! 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.Hom.Equiv.Basic
 import Mathbin.Algebra.Hom.Units
 
+#align_import algebra.hom.equiv.units.basic from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Multiplicative and additive equivalence acting on units.

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -21,6 +21,7 @@ import Mathbin.Algebra.Hom.Units
 
 variable {F α β A B M N P Q G H : Type _}
 
+#print toUnits /-
 /-- A group is isomorphic to its group of units. -/
 @[to_additive "An additive group is isomorphic to its group of additive units"]
 def toUnits [Group G] : G ≃* Gˣ
@@ -32,17 +33,21 @@ def toUnits [Group G] : G ≃* Gˣ
   map_mul' x y := Units.ext rfl
 #align to_units toUnits
 #align to_add_units toAddUnits
+-/
 
+#print coe_toUnits /-
 @[simp, to_additive]
 theorem coe_toUnits [Group G] (g : G) : (toUnits g : G) = g :=
   rfl
 #align coe_to_units coe_toUnits
 #align coe_to_add_units coe_toAddUnits
+-/
 
 namespace Units
 
 variable [Monoid M] [Monoid N] [Monoid P]
 
+#print Units.mapEquiv /-
 /-- A multiplicative equivalence of monoids defines a multiplicative equivalence
 of their groups of units. -/
 def mapEquiv (h : M ≃* N) : Mˣ ≃* Nˣ :=
@@ -51,16 +56,21 @@ def mapEquiv (h : M ≃* N) : Mˣ ≃* Nˣ :=
     left_inv := fun u => ext <| h.left_inv u
     right_inv := fun u => ext <| h.right_inv u }
 #align units.map_equiv Units.mapEquiv
+-/
 
+#print Units.mapEquiv_symm /-
 @[simp]
 theorem mapEquiv_symm (h : M ≃* N) : (mapEquiv h).symm = mapEquiv h.symm :=
   rfl
 #align units.map_equiv_symm Units.mapEquiv_symm
+-/
 
+#print Units.coe_mapEquiv /-
 @[simp]
 theorem coe_mapEquiv (h : M ≃* N) (x : Mˣ) : (mapEquiv h x : N) = h x :=
   rfl
 #align units.coe_map_equiv Units.coe_mapEquiv
+-/
 
 #print Units.mulLeft /-
 /-- Left multiplication by a unit of a monoid is a permutation of the underlying type. -/
@@ -83,11 +93,13 @@ theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft :=
 #align add_units.add_left_symm AddUnits.addLeft_symm
 -/
 
+#print Units.mulLeft_bijective /-
 @[to_additive]
 theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((· * ·) a : M → M) :=
   (mulLeft a).Bijective
 #align units.mul_left_bijective Units.mulLeft_bijective
 #align add_units.add_left_bijective AddUnits.addLeft_bijective
+-/
 
 #print Units.mulRight /-
 /-- Right multiplication by a unit of a monoid is a permutation of the underlying type. -/
@@ -110,11 +122,13 @@ theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight :=
 #align add_units.add_right_symm AddUnits.addRight_symm
 -/
 
+#print Units.mulRight_bijective /-
 @[to_additive]
 theorem mulRight_bijective (a : Mˣ) : Function.Bijective ((· * a) : M → M) :=
   (mulRight a).Bijective
 #align units.mul_right_bijective Units.mulRight_bijective
 #align add_units.add_right_bijective AddUnits.addRight_bijective
+-/
 
 end Units
 
@@ -151,17 +165,21 @@ theorem mulLeft_symm_apply (a : G) : ((Equiv.mulLeft a).symm : G → G) = (· *
 #align equiv.add_left_symm_apply Equiv.addLeft_symm_apply
 -/
 
+#print Equiv.mulLeft_symm /-
 @[simp, to_additive]
 theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ :=
   ext fun x => rfl
 #align equiv.mul_left_symm Equiv.mulLeft_symm
 #align equiv.add_left_symm Equiv.addLeft_symm
+-/
 
+#print Group.mulLeft_bijective /-
 @[to_additive]
 theorem Group.mulLeft_bijective (a : G) : Function.Bijective ((· * ·) a) :=
   (Equiv.mulLeft a).Bijective
 #align group.mul_left_bijective Group.mulLeft_bijective
 #align add_group.add_left_bijective AddGroup.addLeft_bijective
+-/
 
 #print Equiv.mulRight /-
 /-- Right multiplication in a `group` is a permutation of the underlying type. -/
@@ -180,11 +198,13 @@ theorem coe_mulRight (a : G) : ⇑(Equiv.mulRight a) = fun x => x * a :=
 #align equiv.coe_add_right Equiv.coe_addRight
 -/
 
+#print Equiv.mulRight_symm /-
 @[simp, to_additive]
 theorem mulRight_symm (a : G) : (Equiv.mulRight a).symm = Equiv.mulRight a⁻¹ :=
   ext fun x => rfl
 #align equiv.mul_right_symm Equiv.mulRight_symm
 #align equiv.add_right_symm Equiv.addRight_symm
+-/
 
 #print Equiv.mulRight_symm_apply /-
 /-- Extra simp lemma that `dsimp` can use. `simp` will never use this. -/
@@ -196,11 +216,13 @@ theorem mulRight_symm_apply (a : G) : ((Equiv.mulRight a).symm : G → G) = fun
 #align equiv.add_right_symm_apply Equiv.addRight_symm_apply
 -/
 
+#print Group.mulRight_bijective /-
 @[to_additive]
 theorem Group.mulRight_bijective (a : G) : Function.Bijective (· * a) :=
   (Equiv.mulRight a).Bijective
 #align group.mul_right_bijective Group.mulRight_bijective
 #align add_group.add_right_bijective AddGroup.addRight_bijective
+-/
 
 #print Equiv.divLeft /-
 /-- A version of `equiv.mul_left a b⁻¹` that is defeq to `a / b`. -/
@@ -214,12 +236,14 @@ protected def divLeft (a : G) : G ≃ G where
 #align equiv.sub_left Equiv.subLeft
 -/
 
+#print Equiv.divLeft_eq_inv_trans_mulLeft /-
 @[to_additive]
 theorem divLeft_eq_inv_trans_mulLeft (a : G) :
     Equiv.divLeft a = (Equiv.inv G).trans (Equiv.mulLeft a) :=
   ext fun _ => div_eq_mul_inv _ _
 #align equiv.div_left_eq_inv_trans_mul_left Equiv.divLeft_eq_inv_trans_mulLeft
 #align equiv.sub_left_eq_neg_trans_add_left Equiv.subLeft_eq_neg_trans_addLeft
+-/
 
 #print Equiv.divRight /-
 /-- A version of `equiv.mul_right a⁻¹ b` that is defeq to `b / a`. -/
@@ -234,16 +258,19 @@ protected def divRight (a : G) : G ≃ G
 #align equiv.sub_right Equiv.subRight
 -/
 
+#print Equiv.divRight_eq_mulRight_inv /-
 @[to_additive]
 theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹ :=
   ext fun _ => div_eq_mul_inv _ _
 #align equiv.div_right_eq_mul_right_inv Equiv.divRight_eq_mulRight_inv
 #align equiv.sub_right_eq_add_right_neg Equiv.subRight_eq_addRight_neg
+-/
 
 end Group
 
 end Equiv
 
+#print MulEquiv.inv /-
 /-- In a `division_comm_monoid`, `equiv.inv` is a `mul_equiv`. There is a variant of this
 `mul_equiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
 @[to_additive "When the `add_group` is commutative, `equiv.neg` is an `add_equiv`.", simps apply]
@@ -254,10 +281,13 @@ def MulEquiv.inv (G : Type _) [DivisionCommMonoid G] : G ≃* G :=
     map_mul' := mul_inv }
 #align mul_equiv.inv MulEquiv.inv
 #align add_equiv.neg AddEquiv.neg
+-/
 
+#print MulEquiv.inv_symm /-
 @[simp]
 theorem MulEquiv.inv_symm (G : Type _) [DivisionCommMonoid G] :
     (MulEquiv.inv G).symm = MulEquiv.inv G :=
   rfl
 #align mul_equiv.inv_symm MulEquiv.inv_symm
+-/

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -21,12 +21,6 @@ import Mathbin.Algebra.Hom.Units
 
 variable {F α β A B M N P Q G H : Type _}
 
-/- warning: to_units -> toUnits is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G], MulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G], MulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.instMulOneClassUnits.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))
-Case conversion may be inaccurate. Consider using '#align to_units toUnitsₓ'. -/
 /-- A group is isomorphic to its group of units. -/
 @[to_additive "An additive group is isomorphic to its group of additive units"]
 def toUnits [Group G] : G ≃* Gˣ
@@ -39,12 +33,6 @@ def toUnits [Group G] : G ≃* Gˣ
 #align to_units toUnits
 #align to_add_units toAddUnits
 
-/- warning: coe_to_units -> coe_toUnits is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Eq.{succ u1} G ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) G (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) G (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) G (coeBase.{succ u1, succ u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) G (Units.hasCoe.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (coeFn.{succ u1, succ u1} (MulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (fun (_x : MulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) => G -> (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulEquiv.hasCoeToFun.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.mulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (toUnits.{u1} G _inst_1) g)) g
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Eq.{succ u1} G (Units.val.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.instMulOneClassUnits.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) G (fun (_x : G) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : G) => Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.instMulOneClassUnits.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (MulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.instMulOneClassUnits.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulEquivClass.toEquivLike.{u1, u1, u1} (MulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.instMulOneClassUnits.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.instMulOneClassUnits.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulEquiv.instMulEquivClassMulEquiv.{u1, u1} G (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toMul.{u1} (Units.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Units.instMulOneClassUnits.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (toUnits.{u1} G _inst_1) g)) g
-Case conversion may be inaccurate. Consider using '#align coe_to_units coe_toUnitsₓ'. -/
 @[simp, to_additive]
 theorem coe_toUnits [Group G] (g : G) : (toUnits g : G) = g :=
   rfl
@@ -55,12 +43,6 @@ namespace Units
 
 variable [Monoid M] [Monoid N] [Monoid P]
 
-/- warning: units.map_equiv -> Units.mapEquiv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N], (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) -> (MulEquiv.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} (Units.{u2} N _inst_2) (Units.mulOneClass.{u2} N _inst_2)))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N], (MulEquiv.{u1, u2} M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) -> (MulEquiv.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toMul.{u1} (Units.{u1} M _inst_1) (Units.instMulOneClassUnits.{u1} M _inst_1)) (MulOneClass.toMul.{u2} (Units.{u2} N _inst_2) (Units.instMulOneClassUnits.{u2} N _inst_2)))
-Case conversion may be inaccurate. Consider using '#align units.map_equiv Units.mapEquivₓ'. -/
 /-- A multiplicative equivalence of monoids defines a multiplicative equivalence
 of their groups of units. -/
 def mapEquiv (h : M ≃* N) : Mˣ ≃* Nˣ :=
@@ -70,23 +52,11 @@ def mapEquiv (h : M ≃* N) : Mˣ ≃* Nˣ :=
     right_inv := fun u => ext <| h.right_inv u }
 #align units.map_equiv Units.mapEquiv
 
-/- warning: units.map_equiv_symm -> Units.mapEquiv_symm is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (h : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))), Eq.{max (succ u2) (succ u1)} (MulEquiv.{u2, u1} (Units.{u2} N _inst_2) (Units.{u1} M _inst_1) (MulOneClass.toHasMul.{u2} (Units.{u2} N _inst_2) (Units.mulOneClass.{u2} N _inst_2)) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1))) (MulEquiv.symm.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} (Units.{u2} N _inst_2) (Units.mulOneClass.{u2} N _inst_2)) (Units.mapEquiv.{u1, u2} M N _inst_1 _inst_2 h)) (Units.mapEquiv.{u2, u1} N M _inst_2 _inst_1 (MulEquiv.symm.{u1, u2} M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) h))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (h : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2))), Eq.{max (succ u2) (succ u1)} (MulEquiv.{u1, u2} (Units.{u1} N _inst_2) (Units.{u2} M _inst_1) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MulOneClass.toMul.{u2} (Units.{u2} M _inst_1) (Units.instMulOneClassUnits.{u2} M _inst_1))) (MulEquiv.symm.{u2, u1} (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} (Units.{u2} M _inst_1) (Units.instMulOneClassUnits.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (Units.mapEquiv.{u2, u1} M N _inst_1 _inst_2 h)) (Units.mapEquiv.{u1, u2} N M _inst_2 _inst_1 (MulEquiv.symm.{u2, u1} M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) h))
-Case conversion may be inaccurate. Consider using '#align units.map_equiv_symm Units.mapEquiv_symmₓ'. -/
 @[simp]
 theorem mapEquiv_symm (h : M ≃* N) : (mapEquiv h).symm = mapEquiv h.symm :=
   rfl
 #align units.map_equiv_symm Units.mapEquiv_symm
 
-/- warning: units.coe_map_equiv -> Units.coe_mapEquiv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (h : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (x : Units.{u1} M _inst_1), Eq.{succ u2} N ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Units.{u2} N _inst_2) N (HasLiftT.mk.{succ u2, succ u2} (Units.{u2} N _inst_2) N (CoeTCₓ.coe.{succ u2, succ u2} (Units.{u2} N _inst_2) N (coeBase.{succ u2, succ u2} (Units.{u2} N _inst_2) N (Units.hasCoe.{u2} N _inst_2)))) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} (Units.{u2} N _inst_2) (Units.mulOneClass.{u2} N _inst_2))) (fun (_x : MulEquiv.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} (Units.{u2} N _inst_2) (Units.mulOneClass.{u2} N _inst_2))) => (Units.{u1} M _inst_1) -> (Units.{u2} N _inst_2)) (MulEquiv.hasCoeToFun.{u1, u2} (Units.{u1} M _inst_1) (Units.{u2} N _inst_2) (MulOneClass.toHasMul.{u1} (Units.{u1} M _inst_1) (Units.mulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} (Units.{u2} N _inst_2) (Units.mulOneClass.{u2} N _inst_2))) (Units.mapEquiv.{u1, u2} M N _inst_1 _inst_2 h) x)) (coeFn.{max (succ u1) (succ u2), max (succ u1) (succ u2)} (MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) (fun (_x : MulEquiv.{u1, u2} M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) => M -> N) (MulEquiv.hasCoeToFun.{u1, u2} M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2))) h ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) x))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (h : MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2))) (x : Units.{u2} M _inst_1), Eq.{succ u1} N (Units.val.{u1} N _inst_2 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} (Units.{u2} M _inst_1) (Units.instMulOneClassUnits.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2))) (Units.{u2} M _inst_1) (fun (_x : Units.{u2} M _inst_1) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Units.{u2} M _inst_1) => Units.{u1} N _inst_2) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} (Units.{u2} M _inst_1) (Units.instMulOneClassUnits.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2))) (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} (Units.{u2} M _inst_1) (Units.instMulOneClassUnits.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2))) (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} (Units.{u2} M _inst_1) (Units.instMulOneClassUnits.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2))) (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} (Units.{u2} M _inst_1) (Units.instMulOneClassUnits.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} (Units.{u2} M _inst_1) (Units.{u1} N _inst_2) (MulOneClass.toMul.{u2} (Units.{u2} M _inst_1) (Units.instMulOneClassUnits.{u2} M _inst_1)) (MulOneClass.toMul.{u1} (Units.{u1} N _inst_2) (Units.instMulOneClassUnits.{u1} N _inst_2)))))) (Units.mapEquiv.{u2, u1} M N _inst_1 _inst_2 h) x)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2))) M (fun (_x : M) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : M) => N) _x) (EmbeddingLike.toFunLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2))) M N (EquivLike.toEmbeddingLike.{max (succ u2) (succ u1), succ u2, succ u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2))) M N (MulEquivClass.toEquivLike.{max u2 u1, u2, u1} (MulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2))) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MulEquiv.instMulEquivClassMulEquiv.{u2, u1} M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)))))) h (Units.val.{u2} M _inst_1 x))
-Case conversion may be inaccurate. Consider using '#align units.coe_map_equiv Units.coe_mapEquivₓ'. -/
 @[simp]
 theorem coe_mapEquiv (h : M ≃* N) (x : Mˣ) : (mapEquiv h x : N) = h x :=
   rfl
@@ -113,12 +83,6 @@ theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft :=
 #align add_units.add_left_symm AddUnits.addLeft_symm
 -/
 
-/- warning: units.mul_left_bijective -> Units.mulLeft_bijective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) a))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.476 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 a) x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.476)
-Case conversion may be inaccurate. Consider using '#align units.mul_left_bijective Units.mulLeft_bijectiveₓ'. -/
 @[to_additive]
 theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((· * ·) a : M → M) :=
   (mulLeft a).Bijective
@@ -146,12 +110,6 @@ theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight :=
 #align add_units.add_right_symm AddUnits.addRight_symm
 -/
 
-/- warning: units.mul_right_bijective -> Units.mulRight_bijective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (fun (_x : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) _x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) a))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (fun (_x : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) _x (Units.val.{u1} M _inst_1 a))
-Case conversion may be inaccurate. Consider using '#align units.mul_right_bijective Units.mulRight_bijectiveₓ'. -/
 @[to_additive]
 theorem mulRight_bijective (a : Mˣ) : Function.Bijective ((· * a) : M → M) :=
   (mulRight a).Bijective
@@ -193,24 +151,12 @@ theorem mulLeft_symm_apply (a : G) : ((Equiv.mulLeft a).symm : G → G) = (· *
 #align equiv.add_left_symm_apply Equiv.addLeft_symm_apply
 -/
 
-/- warning: equiv.mul_left_symm -> Equiv.mulLeft_symm is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Eq.{succ u1} (Equiv.{succ u1, succ u1} G G) (Equiv.symm.{succ u1, succ u1} G G (Equiv.mulLeft.{u1} G _inst_1 a)) (Equiv.mulLeft.{u1} G _inst_1 (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Eq.{succ u1} (Equiv.{succ u1, succ u1} G G) (Equiv.symm.{succ u1, succ u1} G G (Equiv.mulLeft.{u1} G _inst_1 a)) (Equiv.mulLeft.{u1} G _inst_1 (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align equiv.mul_left_symm Equiv.mulLeft_symmₓ'. -/
 @[simp, to_additive]
 theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ :=
   ext fun x => rfl
 #align equiv.mul_left_symm Equiv.mulLeft_symm
 #align equiv.add_left_symm Equiv.addLeft_symm
 
-/- warning: group.mul_left_bijective -> Group.mulLeft_bijective is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.890 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.890)
-Case conversion may be inaccurate. Consider using '#align group.mul_left_bijective Group.mulLeft_bijectiveₓ'. -/
 @[to_additive]
 theorem Group.mulLeft_bijective (a : G) : Function.Bijective ((· * ·) a) :=
   (Equiv.mulLeft a).Bijective
@@ -234,12 +180,6 @@ theorem coe_mulRight (a : G) : ⇑(Equiv.mulRight a) = fun x => x * a :=
 #align equiv.coe_add_right Equiv.coe_addRight
 -/
 
-/- warning: equiv.mul_right_symm -> Equiv.mulRight_symm is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Eq.{succ u1} (Equiv.{succ u1, succ u1} G G) (Equiv.symm.{succ u1, succ u1} G G (Equiv.mulRight.{u1} G _inst_1 a)) (Equiv.mulRight.{u1} G _inst_1 (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Eq.{succ u1} (Equiv.{succ u1, succ u1} G G) (Equiv.symm.{succ u1, succ u1} G G (Equiv.mulRight.{u1} G _inst_1 a)) (Equiv.mulRight.{u1} G _inst_1 (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align equiv.mul_right_symm Equiv.mulRight_symmₓ'. -/
 @[simp, to_additive]
 theorem mulRight_symm (a : G) : (Equiv.mulRight a).symm = Equiv.mulRight a⁻¹ :=
   ext fun x => rfl
@@ -256,12 +196,6 @@ theorem mulRight_symm_apply (a : G) : ((Equiv.mulRight a).symm : G → G) = fun
 #align equiv.add_right_symm_apply Equiv.addRight_symm_apply
 -/
 
-/- warning: group.mul_right_bijective -> Group.mulRight_bijective is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (fun (_x : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) _x a)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (fun (_x : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) _x a)
-Case conversion may be inaccurate. Consider using '#align group.mul_right_bijective Group.mulRight_bijectiveₓ'. -/
 @[to_additive]
 theorem Group.mulRight_bijective (a : G) : Function.Bijective (· * a) :=
   (Equiv.mulRight a).Bijective
@@ -280,12 +214,6 @@ protected def divLeft (a : G) : G ≃ G where
 #align equiv.sub_left Equiv.subLeft
 -/
 
-/- warning: equiv.div_left_eq_inv_trans_mul_left -> Equiv.divLeft_eq_inv_trans_mulLeft is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Eq.{succ u1} (Equiv.{succ u1, succ u1} G G) (Equiv.divLeft.{u1} G _inst_1 a) (Equiv.trans.{succ u1, succ u1, succ u1} G G G (Equiv.inv.{u1} G (DivisionMonoid.toHasInvolutiveInv.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))) (Equiv.mulLeft.{u1} G _inst_1 a))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Eq.{succ u1} (Equiv.{succ u1, succ u1} G G) (Equiv.divLeft.{u1} G _inst_1 a) (Equiv.trans.{succ u1, succ u1, succ u1} G G G (Equiv.inv.{u1} G (DivisionMonoid.toInvolutiveInv.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))) (Equiv.mulLeft.{u1} G _inst_1 a))
-Case conversion may be inaccurate. Consider using '#align equiv.div_left_eq_inv_trans_mul_left Equiv.divLeft_eq_inv_trans_mulLeftₓ'. -/
 @[to_additive]
 theorem divLeft_eq_inv_trans_mulLeft (a : G) :
     Equiv.divLeft a = (Equiv.inv G).trans (Equiv.mulLeft a) :=
@@ -306,12 +234,6 @@ protected def divRight (a : G) : G ≃ G
 #align equiv.sub_right Equiv.subRight
 -/
 
-/- warning: equiv.div_right_eq_mul_right_inv -> Equiv.divRight_eq_mulRight_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Eq.{succ u1} (Equiv.{succ u1, succ u1} G G) (Equiv.divRight.{u1} G _inst_1 a) (Equiv.mulRight.{u1} G _inst_1 (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Eq.{succ u1} (Equiv.{succ u1, succ u1} G G) (Equiv.divRight.{u1} G _inst_1 a) (Equiv.mulRight.{u1} G _inst_1 (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align equiv.div_right_eq_mul_right_inv Equiv.divRight_eq_mulRight_invₓ'. -/
 @[to_additive]
 theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹ :=
   ext fun _ => div_eq_mul_inv _ _
@@ -322,12 +244,6 @@ end Group
 
 end Equiv
 
-/- warning: mul_equiv.inv -> MulEquiv.inv is a dubious translation:
-lean 3 declaration is
-  forall (G : Type.{u1}) [_inst_1 : DivisionCommMonoid.{u1} G], MulEquiv.{u1, u1} G G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1))))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1)))))
-but is expected to have type
-  forall (G : Type.{u1}) [_inst_1 : DivisionCommMonoid.{u1} G], MulEquiv.{u1, u1} G G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align mul_equiv.inv MulEquiv.invₓ'. -/
 /-- In a `division_comm_monoid`, `equiv.inv` is a `mul_equiv`. There is a variant of this
 `mul_equiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
 @[to_additive "When the `add_group` is commutative, `equiv.neg` is an `add_equiv`.", simps apply]
@@ -339,12 +255,6 @@ def MulEquiv.inv (G : Type _) [DivisionCommMonoid G] : G ≃* G :=
 #align mul_equiv.inv MulEquiv.inv
 #align add_equiv.neg AddEquiv.neg
 
-/- warning: mul_equiv.inv_symm -> MulEquiv.inv_symm is a dubious translation:
-lean 3 declaration is
-  forall (G : Type.{u1}) [_inst_1 : DivisionCommMonoid.{u1} G], Eq.{succ u1} (MulEquiv.{u1, u1} G G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1))))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1)))))) (MulEquiv.symm.{u1, u1} G G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1))))) (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1))))) (MulEquiv.inv.{u1} G _inst_1)) (MulEquiv.inv.{u1} G _inst_1)
-but is expected to have type
-  forall (G : Type.{u1}) [_inst_1 : DivisionCommMonoid.{u1} G], Eq.{succ u1} (MulEquiv.{u1, u1} G G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1)))))) (MulEquiv.symm.{u1, u1} G G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1))))) (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (DivisionMonoid.toDivInvMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G _inst_1))))) (MulEquiv.inv.{u1} G _inst_1)) (MulEquiv.inv.{u1} G _inst_1)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.inv_symm MulEquiv.inv_symmₓ'. -/
 @[simp]
 theorem MulEquiv.inv_symm (G : Type _) [DivisionCommMonoid G] :
     (MulEquiv.inv G).symm = MulEquiv.inv G :=

448144f7

bump to nightly-2023-05-19-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

a31df521

Diff

@@ -117,7 +117,7 @@ theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) a))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.468 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 a) x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.468)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.476 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 a) x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.476)
 Case conversion may be inaccurate. Consider using '#align units.mul_left_bijective Units.mulLeft_bijectiveₓ'. -/
 @[to_additive]
 theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((· * ·) a : M → M) :=
@@ -209,7 +209,7 @@ theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ :=
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a)
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.877 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.877)
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.890 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.890)
 Case conversion may be inaccurate. Consider using '#align group.mul_left_bijective Group.mulLeft_bijectiveₓ'. -/
 @[to_additive]
 theorem Group.mulLeft_bijective (a : G) : Function.Bijective ((· * ·) a) :=

448144f7

bump to nightly-2023-03-11-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

a8ee822f

Diff

@@ -117,7 +117,7 @@ theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Units.{u1} M _inst_1) M (HasLiftT.mk.{succ u1, succ u1} (Units.{u1} M _inst_1) M (CoeTCₓ.coe.{succ u1, succ u1} (Units.{u1} M _inst_1) M (coeBase.{succ u1, succ u1} (Units.{u1} M _inst_1) M (Units.hasCoe.{u1} M _inst_1)))) a))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.464 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 a) x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.464)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (a : Units.{u1} M _inst_1), Function.Bijective.{succ u1, succ u1} M M (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.468 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Units.val.{u1} M _inst_1 a) x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.468)
 Case conversion may be inaccurate. Consider using '#align units.mul_left_bijective Units.mulLeft_bijectiveₓ'. -/
 @[to_additive]
 theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((· * ·) a : M → M) :=
@@ -209,7 +209,7 @@ theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ :=
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a)
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.870 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.870)
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (a : G), Function.Bijective.{succ u1, succ u1} G G (fun (x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.877 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a x._@.Mathlib.Algebra.Hom.Equiv.Units.Basic._hyg.877)
 Case conversion may be inaccurate. Consider using '#align group.mul_left_bijective Group.mulLeft_bijectiveₓ'. -/
 @[to_additive]
 theorem Group.mulLeft_bijective (a : G) : Function.Bijective ((· * ·) a) :=

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

a95b16cb

feat(Algebra/Ring/Equiv): add lemma isUnit_iff (#11237)

Add one lemma stating that an element is a unit if and only if its image through a ring equivalence is a unit.

9fb3e1ad

Diff

@@ -248,3 +248,10 @@ theorem MulEquiv.inv_symm (G : Type*) [DivisionCommMonoid G] :
   rfl
 #align mul_equiv.inv_symm MulEquiv.inv_symm
 -- Porting note: no `add_equiv.neg_symm` in `mathlib3`
+
+@[to_additive]
+protected
+theorem MulEquiv.map_isUnit_iff {M N} [Monoid M] [Monoid N] [EquivLike F M N] [MonoidHomClass F M N]
+    (f : F) {m : M} : IsUnit (f m) ↔ IsUnit m :=
+  isUnit_map_of_leftInverse (MonoidHom.inverse (f : M →* N) (EquivLike.inv f)
+    (EquivLike.left_inv f) <| EquivLike.right_inv f) (EquivLike.left_inv f)

a95b16cb

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -229,7 +229,7 @@ end Equiv
 
 -- Porting note: we don't put `@[simp]` on the additive version;
 -- mysteriously simp can already prove that one (although not the multiplicative one)!
--- porting note: `@[simps apply]` removed because right now it's generating lemmas which
+-- Porting note: `@[simps apply]` removed because right now it's generating lemmas which
 -- aren't in simp normal form (they contain a `toFun`)
 /-- In a `DivisionCommMonoid`, `Equiv.inv` is a `MulEquiv`. There is a variant of this
 `MulEquiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
@@ -247,4 +247,4 @@ theorem MulEquiv.inv_symm (G : Type*) [DivisionCommMonoid G] :
     (MulEquiv.inv G).symm = MulEquiv.inv G :=
   rfl
 #align mul_equiv.inv_symm MulEquiv.inv_symm
--- porting note: no `add_equiv.neg_symm` in `mathlib3`
+-- Porting note: no `add_equiv.neg_symm` in `mathlib3`

a95b16cb

feat(GroupTheory/Submonoid/Units): Add Submonoid.units and related definitions and lemmas. (#9006)

The subgroup of the type of units added in this PR is something we have in other guises, which are somewhat less useful for some forms of working. The intention is to provide different options depending on how you want to think about the group of units in a submonoid.

Co-authored-by: lines <34025592+linesthatinterlace@users.noreply.github.com> Co-authored-by: Johan Commelin <johan@commelin.net>

b94dc689

Diff

@@ -15,7 +15,8 @@ import Mathlib.Algebra.Group.Units.Hom
 variable {F α β A B M N P Q G H : Type*}
 
 /-- A group is isomorphic to its group of units. -/
-@[to_additive "An additive group is isomorphic to its group of additive units"]
+@[to_additive (attr := simps apply_val symm_apply)
+"An additive group is isomorphic to its group of additive units"]
 def toUnits [Group G] : G ≃* Gˣ where
   toFun x := ⟨x, x⁻¹, mul_inv_self _, inv_mul_self _⟩
   invFun x := x
@@ -25,11 +26,12 @@ def toUnits [Group G] : G ≃* Gˣ where
 #align to_units toUnits
 #align to_add_units toAddUnits
 
+#align coe_to_units val_toUnits_apply
+#align coe_to_add_units val_toAddUnits_apply
+
 @[to_additive (attr := simp)]
-theorem coe_toUnits [Group G] (g : G) : (toUnits g : G) = g :=
-  rfl
-#align coe_to_units coe_toUnits
-#align coe_to_add_units coe_toAddUnits
+lemma toUnits_val_apply {G : Type*} [Group G] (x : Gˣ) : toUnits (x : G) = x := by
+  simp_rw [MulEquiv.apply_eq_iff_symm_apply, toUnits_symm_apply]
 
 namespace Units

a95b16cb

chore: Replace (· op ·) a by (a op ·) (#8843)

I used the regex $\(· (.) ·$ (.)\), replacing with ($2 $1 ·).

d14658b4

Diff

@@ -120,7 +120,7 @@ protected def mulLeft (a : G) : Perm G :=
 #align equiv.add_left Equiv.addLeft
 
 @[to_additive (attr := simp)]
-theorem coe_mulLeft (a : G) : ⇑(Equiv.mulLeft a) = (· * ·) a :=
+theorem coe_mulLeft (a : G) : ⇑(Equiv.mulLeft a) = (a * ·) :=
   rfl
 #align equiv.coe_mul_left Equiv.coe_mulLeft
 #align equiv.coe_add_left Equiv.coe_addLeft

a95b16cb

style: shorten simps configurations (#8296)

Use .asFn and .lemmasOnly as simps configuration options.

For reference, these are defined here:

https://github.com/leanprover-community/mathlib4/blob/4055c8b471380825f07416b12cb0cf266da44d84/Mathlib/Tactic/Simps/Basic.lean#L843-L851

e0637173

Diff

@@ -55,7 +55,7 @@ theorem coe_mapEquiv (h : M ≃* N) (x : Mˣ) : (mapEquiv h x : N) = h x :=
 #align units.coe_map_equiv Units.coe_mapEquiv
 
 /-- Left multiplication by a unit of a monoid is a permutation of the underlying type. -/
-@[to_additive (attr := simps (config := { fullyApplied := false }) apply)
+@[to_additive (attr := simps (config := .asFn) apply)
   "Left addition of an additive unit is a permutation of the underlying type."]
 def mulLeft (u : Mˣ) : Equiv.Perm M where
   toFun x := u * x
@@ -80,7 +80,7 @@ theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((a * ·) : M → M) :=
 #align add_units.add_left_bijective AddUnits.addLeft_bijective
 
 /-- Right multiplication by a unit of a monoid is a permutation of the underlying type. -/
-@[to_additive (attr := simps (config := { fullyApplied := false }) apply)
+@[to_additive (attr := simps (config := .asFn) apply)
 "Right addition of an additive unit is a permutation of the underlying type."]
 def mulRight (u : Mˣ) : Equiv.Perm M where
   toFun x := x * u

a95b16cb

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) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 -/
-import Mathlib.Algebra.Hom.Equiv.Basic
-import Mathlib.Algebra.Hom.Units
+import Mathlib.Algebra.Group.Equiv.Basic
+import Mathlib.Algebra.Group.Units.Hom
 
 #align_import algebra.hom.equiv.units.basic from "leanprover-community/mathlib"@"a95b16cbade0f938fc24abd05412bde1e84bab9b"

a95b16cb

chore: exactly 4 spaces in theorems (#7328)

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

d3263b23

Diff

@@ -203,8 +203,7 @@ theorem divLeft_eq_inv_trans_mulLeft (a : G) :
 
 /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
 @[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
-protected def divRight (a : G) : G ≃
-      G where
+protected def divRight (a : G) : G ≃ G where
   toFun b := b / a
   invFun b := b * a
   left_inv b := by simp [div_eq_mul_inv]

a95b16cb

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

@@ -12,7 +12,7 @@ import Mathlib.Algebra.Hom.Units
 # Multiplicative and additive equivalence acting on units.
 -/
 
-variable {F α β A B M N P Q G H : Type _}
+variable {F α β A B M N P Q G H : Type*}
 
 /-- A group is isomorphic to its group of units. -/
 @[to_additive "An additive group is isomorphic to its group of additive units"]
@@ -234,7 +234,7 @@ end Equiv
 `MulEquiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
 @[to_additive (attr := simps apply)
   "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
-def MulEquiv.inv (G : Type _) [DivisionCommMonoid G] : G ≃* G :=
+def MulEquiv.inv (G : Type*) [DivisionCommMonoid G] : G ≃* G :=
   { Equiv.inv G with toFun := Inv.inv, invFun := Inv.inv, map_mul' := mul_inv }
 #align mul_equiv.inv MulEquiv.inv
 #align add_equiv.neg AddEquiv.neg
@@ -242,7 +242,7 @@ def MulEquiv.inv (G : Type _) [DivisionCommMonoid G] : G ≃* G :=
 #align add_equiv.neg_apply AddEquiv.neg_apply
 
 @[to_additive (attr := simp)]
-theorem MulEquiv.inv_symm (G : Type _) [DivisionCommMonoid G] :
+theorem MulEquiv.inv_symm (G : Type*) [DivisionCommMonoid G] :
     (MulEquiv.inv G).symm = MulEquiv.inv G :=
   rfl
 #align mul_equiv.inv_symm MulEquiv.inv_symm

a95b16cb

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) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
-Ported by: Scott Morrison
 -/
 import Mathlib.Algebra.Hom.Equiv.Basic
 import Mathlib.Algebra.Hom.Units

a95b16cb

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) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 Ported by: Scott Morrison
-
-! This file was ported from Lean 3 source module algebra.hom.equiv.units.basic
-! 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.Hom.Equiv.Basic
 import Mathlib.Algebra.Hom.Units
 
+#align_import algebra.hom.equiv.units.basic from "leanprover-community/mathlib"@"a95b16cbade0f938fc24abd05412bde1e84bab9b"
+
 /-!
 # Multiplicative and additive equivalence acting on units.
 -/

a95b16cb

fix: add back lemmas deleted during porting (#3035)

These lemmas are not tautologies, despite the assumption that they were. We know this because otherwise CI would fail.

After adding these back, a few statements downstream need to change from statements about toEquiv to statements about EquivLike.toEquiv.

fa1b54f8

Diff

@@ -236,18 +236,12 @@ end Equiv
 -- aren't in simp normal form (they contain a `toFun`)
 /-- In a `DivisionCommMonoid`, `Equiv.inv` is a `MulEquiv`. There is a variant of this
 `MulEquiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
-@[to_additive "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
+@[to_additive (attr := simps apply)
+  "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
 def MulEquiv.inv (G : Type _) [DivisionCommMonoid G] : G ≃* G :=
   { Equiv.inv G with toFun := Inv.inv, invFun := Inv.inv, map_mul' := mul_inv }
 #align mul_equiv.inv MulEquiv.inv
 #align add_equiv.neg AddEquiv.neg
-
--- porting note: this lemma and the next are added manually because `simps` was
--- not quite generating the right thing
-@[to_additive (attr := simp)]
-theorem MulEquiv.inv_apply (G : Type _) [DivisionCommMonoid G] (a : G) :
-    (MulEquiv.inv G).toEquiv a = a⁻¹ :=
-  rfl
 #align mul_equiv.inv_apply MulEquiv.inv_apply
 #align add_equiv.neg_apply AddEquiv.neg_apply

a95b16cb

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

adaaf293

Diff

@@ -59,8 +59,8 @@ theorem coe_mapEquiv (h : M ≃* N) (x : Mˣ) : (mapEquiv h x : N) = h x :=
 #align units.coe_map_equiv Units.coe_mapEquiv
 
 /-- Left multiplication by a unit of a monoid is a permutation of the underlying type. -/
-@[to_additive "Left addition of an additive unit is a permutation of the underlying type.",
-  simps (config := { fullyApplied := false }) apply]
+@[to_additive (attr := simps (config := { fullyApplied := false }) apply)
+  "Left addition of an additive unit is a permutation of the underlying type."]
 def mulLeft (u : Mˣ) : Equiv.Perm M where
   toFun x := u * x
   invFun x := u⁻¹ * x
@@ -69,6 +69,7 @@ def mulLeft (u : Mˣ) : Equiv.Perm M where
 #align units.mul_left Units.mulLeft
 #align add_units.add_left AddUnits.addLeft
 #align units.mul_left_apply Units.mulLeft_apply
+#align add_units.add_left_apply AddUnits.addLeft_apply
 
 @[to_additive (attr := simp)]
 theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft :=
@@ -83,8 +84,8 @@ theorem mulLeft_bijective (a : Mˣ) : Function.Bijective ((a * ·) : M → M) :=
 #align add_units.add_left_bijective AddUnits.addLeft_bijective
 
 /-- Right multiplication by a unit of a monoid is a permutation of the underlying type. -/
-@[to_additive "Right addition of an additive unit is a permutation of the underlying type.",
-  simps (config := { fullyApplied := false }) apply]
+@[to_additive (attr := simps (config := { fullyApplied := false }) apply)
+"Right addition of an additive unit is a permutation of the underlying type."]
 def mulRight (u : Mˣ) : Equiv.Perm M where
   toFun x := x * u
   invFun x := x * ↑u⁻¹
@@ -93,6 +94,7 @@ def mulRight (u : Mˣ) : Equiv.Perm M where
 #align units.mul_right Units.mulRight
 #align add_units.add_right AddUnits.addRight
 #align units.mul_right_apply Units.mulRight_apply
+#align add_units.add_right_apply AddUnits.addRight_apply
 
 @[to_additive (attr := simp)]
 theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight :=
@@ -183,7 +185,7 @@ theorem _root_.Group.mulRight_bijective (a : G) : Function.Bijective (· * a) :=
 #align add_group.add_right_bijective AddGroup.addRight_bijective
 
 /-- A version of `Equiv.mulLeft a b⁻¹` that is defeq to `a / b`. -/
-@[to_additive " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. ", simps]
+@[to_additive (attr := simps) " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. "]
 protected def divLeft (a : G) : G ≃ G where
   toFun b := a / b
   invFun b := b⁻¹ * a
@@ -193,6 +195,8 @@ protected def divLeft (a : G) : G ≃ G where
 #align equiv.sub_left Equiv.subLeft
 #align equiv.div_left_apply Equiv.divLeft_apply
 #align equiv.div_left_symm_apply Equiv.divLeft_symm_apply
+#align equiv.sub_left_apply Equiv.subLeft_apply
+#align equiv.sub_left_symm_apply Equiv.subLeft_symm_apply
 
 @[to_additive]
 theorem divLeft_eq_inv_trans_mulLeft (a : G) :
@@ -202,7 +206,7 @@ theorem divLeft_eq_inv_trans_mulLeft (a : G) :
 #align equiv.sub_left_eq_neg_trans_add_left Equiv.subLeft_eq_neg_trans_addLeft
 
 /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
-@[to_additive " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. ", simps]
+@[to_additive (attr := simps) " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. "]
 protected def divRight (a : G) : G ≃
       G where
   toFun b := b / a
@@ -213,6 +217,8 @@ protected def divRight (a : G) : G ≃
 #align equiv.sub_right Equiv.subRight
 #align equiv.div_right_symm_apply Equiv.divRight_symm_apply
 #align equiv.div_right_apply Equiv.divRight_apply
+#align equiv.sub_right_symm_apply Equiv.subRight_symm_apply
+#align equiv.sub_right_apply Equiv.subRight_apply
 
 @[to_additive]
 theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹ :=
@@ -238,18 +244,16 @@ def MulEquiv.inv (G : Type _) [DivisionCommMonoid G] : G ≃* G :=
 
 -- porting note: this lemma and the next are added manually because `simps` was
 -- not quite generating the right thing
-@[simp] theorem MulEquiv.inv_apply (G : Type _) [DivisionCommMonoid G] (a : G) :
+@[to_additive (attr := simp)]
+theorem MulEquiv.inv_apply (G : Type _) [DivisionCommMonoid G] (a : G) :
     (MulEquiv.inv G).toEquiv a = a⁻¹ :=
   rfl
 #align mul_equiv.inv_apply MulEquiv.inv_apply
-
-@[simp] theorem AddEquiv.neg_apply (G : Type _) [SubtractionCommMonoid G] (a : G) :
-    (AddEquiv.neg G).toEquiv a = -a :=
-  rfl
 #align add_equiv.neg_apply AddEquiv.neg_apply
 
-@[simp]
+@[to_additive (attr := simp)]
 theorem MulEquiv.inv_symm (G : Type _) [DivisionCommMonoid G] :
     (MulEquiv.inv G).symm = MulEquiv.inv G :=
   rfl
 #align mul_equiv.inv_symm MulEquiv.inv_symm
+-- porting note: no `add_equiv.neg_symm` in `mathlib3`

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

@@ -68,6 +68,7 @@ def mulLeft (u : Mˣ) : Equiv.Perm M where
   right_inv := u.mul_inv_cancel_left
 #align units.mul_left Units.mulLeft
 #align add_units.add_left AddUnits.addLeft
+#align units.mul_left_apply Units.mulLeft_apply
 
 @[to_additive (attr := simp)]
 theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft :=
@@ -91,6 +92,7 @@ def mulRight (u : Mˣ) : Equiv.Perm M where
   right_inv x := inv_mul_cancel_right x u
 #align units.mul_right Units.mulRight
 #align add_units.add_right AddUnits.addRight
+#align units.mul_right_apply Units.mulRight_apply
 
 @[to_additive (attr := simp)]
 theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight :=
@@ -189,6 +191,8 @@ protected def divLeft (a : G) : G ≃ G where
   right_inv b := by simp [div_eq_mul_inv]
 #align equiv.div_left Equiv.divLeft
 #align equiv.sub_left Equiv.subLeft
+#align equiv.div_left_apply Equiv.divLeft_apply
+#align equiv.div_left_symm_apply Equiv.divLeft_symm_apply
 
 @[to_additive]
 theorem divLeft_eq_inv_trans_mulLeft (a : G) :
@@ -207,6 +211,8 @@ protected def divRight (a : G) : G ≃
   right_inv b := by simp [div_eq_mul_inv]
 #align equiv.div_right Equiv.divRight
 #align equiv.sub_right Equiv.subRight
+#align equiv.div_right_symm_apply Equiv.divRight_symm_apply
+#align equiv.div_right_apply Equiv.divRight_apply
 
 @[to_additive]
 theorem divRight_eq_mulRight_inv (a : G) : Equiv.divRight a = Equiv.mulRight a⁻¹ :=

a95b16cb

chore: fix casing errors per naming scheme (#1670)

526ab32a

Diff

@@ -181,7 +181,7 @@ theorem _root_.Group.mulRight_bijective (a : G) : Function.Bijective (· * a) :=
 #align add_group.add_right_bijective AddGroup.addRight_bijective
 
 /-- A version of `Equiv.mulLeft a b⁻¹` that is defeq to `a / b`. -/
-@[to_additive " A version of `equiv.add_left a (-b)` that is defeq to `a - b`. ", simps]
+@[to_additive " A version of `Equiv.addLeft a (-b)` that is defeq to `a - b`. ", simps]
 protected def divLeft (a : G) : G ≃ G where
   toFun b := a / b
   invFun b := b⁻¹ * a
@@ -198,7 +198,7 @@ theorem divLeft_eq_inv_trans_mulLeft (a : G) :
 #align equiv.sub_left_eq_neg_trans_add_left Equiv.subLeft_eq_neg_trans_addLeft
 
 /-- A version of `Equiv.mulRight a⁻¹ b` that is defeq to `b / a`. -/
-@[to_additive " A version of `equiv.add_right (-a) b` that is defeq to `b - a`. ", simps]
+@[to_additive " A version of `Equiv.addRight (-a) b` that is defeq to `b - a`. ", simps]
 protected def divRight (a : G) : G ≃
       G where
   toFun b := b / a

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

@@ -29,7 +29,7 @@ def toUnits [Group G] : G ≃* Gˣ where
 #align to_units toUnits
 #align to_add_units toAddUnits
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_toUnits [Group G] (g : G) : (toUnits g : G) = g :=
   rfl
 #align coe_to_units coe_toUnits
@@ -69,7 +69,7 @@ def mulLeft (u : Mˣ) : Equiv.Perm M where
 #align units.mul_left Units.mulLeft
 #align add_units.add_left AddUnits.addLeft
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mulLeft_symm (u : Mˣ) : u.mulLeft.symm = u⁻¹.mulLeft :=
   Equiv.ext fun _ => rfl
 #align units.mul_left_symm Units.mulLeft_symm
@@ -92,7 +92,7 @@ def mulRight (u : Mˣ) : Equiv.Perm M where
 #align units.mul_right Units.mulRight
 #align add_units.add_right AddUnits.addRight
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mulRight_symm (u : Mˣ) : u.mulRight.symm = u⁻¹.mulRight :=
   Equiv.ext fun _ => rfl
 #align units.mul_right_symm Units.mulRight_symm
@@ -119,7 +119,7 @@ protected def mulLeft (a : G) : Perm G :=
 #align equiv.mul_left Equiv.mulLeft
 #align equiv.add_left Equiv.addLeft
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_mulLeft (a : G) : ⇑(Equiv.mulLeft a) = (· * ·) a :=
   rfl
 #align equiv.coe_mul_left Equiv.coe_mulLeft
@@ -135,7 +135,7 @@ theorem mulLeft_symm_apply (a : G) : ((Equiv.mulLeft a).symm : G → G) = (a⁻
 #align equiv.mul_left_symm_apply Equiv.mulLeft_symm_apply
 #align equiv.add_left_symm_apply Equiv.addLeft_symm_apply
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mulLeft_symm (a : G) : (Equiv.mulLeft a).symm = Equiv.mulLeft a⁻¹ :=
   ext fun _ => rfl
 #align equiv.mul_left_symm Equiv.mulLeft_symm
@@ -154,13 +154,13 @@ protected def mulRight (a : G) : Perm G :=
 #align equiv.mul_right Equiv.mulRight
 #align equiv.add_right Equiv.addRight
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem coe_mulRight (a : G) : ⇑(Equiv.mulRight a) = fun x => x * a :=
   rfl
 #align equiv.coe_mul_right Equiv.coe_mulRight
 #align equiv.coe_add_right Equiv.coe_addRight
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mulRight_symm (a : G) : (Equiv.mulRight a).symm = Equiv.mulRight a⁻¹ :=
   ext fun _ => rfl
 #align equiv.mul_right_symm Equiv.mulRight_symm

a95b16cb

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

@@ -222,9 +222,9 @@ end Equiv
 -- mysteriously simp can already prove that one (although not the multiplicative one)!
 -- porting note: `@[simps apply]` removed because right now it's generating lemmas which
 -- aren't in simp normal form (they contain a `toFun`)
-/-- In a `division_comm_monoid`, `equiv.inv` is a `mul_equiv`. There is a variant of this
-`mul_equiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
-@[to_additive "When the `add_group` is commutative, `equiv.neg` is an `add_equiv`."]
+/-- In a `DivisionCommMonoid`, `Equiv.inv` is a `MulEquiv`. There is a variant of this
+`MulEquiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
+@[to_additive "When the `AddGroup` is commutative, `Equiv.neg` is an `AddEquiv`."]
 def MulEquiv.inv (G : Type _) [DivisionCommMonoid G] : G ≃* G :=
   { Equiv.inv G with toFun := Inv.inv, invFun := Inv.inv, map_mul' := mul_inv }
 #align mul_equiv.inv MulEquiv.inv

a95b16cb

fix: reintroduce to_fun_as_coe as simp lemma (#931)

This is a proposed fix for the broken simp calls in #922. See https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/.60simp.60.20calls.20broken.20in.20mathlib4.23922/near/314783451 for more details. Note that to_fun_as_coe was a syntactic tautology when it was ported, but this is no longer the case because we now have FunLike.

a2d69bdf

Diff

@@ -220,14 +220,28 @@ end Equiv
 
 -- Porting note: we don't put `@[simp]` on the additive version;
 -- mysteriously simp can already prove that one (although not the multiplicative one)!
+-- porting note: `@[simps apply]` removed because right now it's generating lemmas which
+-- aren't in simp normal form (they contain a `toFun`)
 /-- In a `division_comm_monoid`, `equiv.inv` is a `mul_equiv`. There is a variant of this
 `mul_equiv.inv' G : G ≃* Gᵐᵒᵖ` for the non-commutative case. -/
-@[to_additive "When the `add_group` is commutative, `equiv.neg` is an `add_equiv`.", simps apply]
+@[to_additive "When the `add_group` is commutative, `equiv.neg` is an `add_equiv`."]
 def MulEquiv.inv (G : Type _) [DivisionCommMonoid G] : G ≃* G :=
   { Equiv.inv G with toFun := Inv.inv, invFun := Inv.inv, map_mul' := mul_inv }
 #align mul_equiv.inv MulEquiv.inv
 #align add_equiv.neg AddEquiv.neg
 
+-- porting note: this lemma and the next are added manually because `simps` was
+-- not quite generating the right thing
+@[simp] theorem MulEquiv.inv_apply (G : Type _) [DivisionCommMonoid G] (a : G) :
+    (MulEquiv.inv G).toEquiv a = a⁻¹ :=
+  rfl
+#align mul_equiv.inv_apply MulEquiv.inv_apply
+
+@[simp] theorem AddEquiv.neg_apply (G : Type _) [SubtractionCommMonoid G] (a : G) :
+    (AddEquiv.neg G).toEquiv a = -a :=
+  rfl
+#align add_equiv.neg_apply AddEquiv.neg_apply
+
 @[simp]
 theorem MulEquiv.inv_symm (G : Type _) [DivisionCommMonoid G] :
     (MulEquiv.inv G).symm = MulEquiv.inv G :=

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) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Callum Sutton, Yury Kudryashov
 Ported by: Scott Morrison
+
+! This file was ported from Lean 3 source module algebra.hom.equiv.units.basic
+! 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.Hom.Equiv.Basic
 import Mathlib.Algebra.Hom.Units

`algebra.hom.equiv.units.basic` ⟷ `Mathlib.Algebra.Group.Units.Equiv`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 27

algebra.hom.equiv.units.basic ⟷ Mathlib.Algebra.Group.Units.Equiv

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 27

`algebra.hom.equiv.units.basic` ⟷ `Mathlib.Algebra.Group.Units.Equiv`