algebra.group_with_zero.semiconj | 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

70d50ecf

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

448144f7

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
 import Algebra.GroupWithZero.Units.Basic
-import Algebra.Group.Semiconj
+import Algebra.Group.Semiconj.Defs
 
 #align_import algebra.group_with_zero.semiconj from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -58,10 +58,10 @@ theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ :=
   · simp only [ha, zero_left]
   by_cases hx : x = 0
   · subst x
-    simp only [SemiconjBy, MulZeroClass.mul_zero, @eq_comm _ _ (y * a), mul_eq_zero] at h 
+    simp only [SemiconjBy, MulZeroClass.mul_zero, @eq_comm _ _ (y * a), mul_eq_zero] at h
     simp [h.resolve_right ha]
   · have := mul_ne_zero ha hx
-    rw [h.eq, mul_ne_zero_iff] at this 
+    rw [h.eq, mul_ne_zero_iff] at this
     exact @units_inv_right _ _ _ (Units.mk0 x hx) (Units.mk0 y this.1) h
 #align semiconj_by.inv_right₀ SemiconjBy.inv_right₀
 -/

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) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathbin.Algebra.GroupWithZero.Units.Basic
-import Mathbin.Algebra.Group.Semiconj
+import Algebra.GroupWithZero.Units.Basic
+import Algebra.Group.Semiconj
 
 #align_import algebra.group_with_zero.semiconj 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) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module algebra.group_with_zero.semiconj
-! 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.GroupWithZero.Units.Basic
 import Mathbin.Algebra.Group.Semiconj
 
+#align_import algebra.group_with_zero.semiconj from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Lemmas about semiconjugate elements in a `group_with_zero`.

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -24,28 +24,37 @@ variable {α M₀ G₀ M₀' G₀' F F' : Type _}
 
 namespace SemiconjBy
 
+#print SemiconjBy.zero_right /-
 @[simp]
 theorem zero_right [MulZeroClass G₀] (a : G₀) : SemiconjBy a 0 0 := by
   simp only [SemiconjBy, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
 #align semiconj_by.zero_right SemiconjBy.zero_right
+-/
 
+#print SemiconjBy.zero_left /-
 @[simp]
 theorem zero_left [MulZeroClass G₀] (x y : G₀) : SemiconjBy 0 x y := by
   simp only [SemiconjBy, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
 #align semiconj_by.zero_left SemiconjBy.zero_left
+-/
 
 variable [GroupWithZero G₀] {a x y x' y' : G₀}
 
+#print SemiconjBy.inv_symm_left_iff₀ /-
 @[simp]
 theorem inv_symm_left_iff₀ : SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x :=
   by_cases (fun ha : a = 0 => by simp only [ha, inv_zero, SemiconjBy.zero_left]) fun ha =>
     @units_inv_symm_left_iff _ _ (Units.mk0 a ha) _ _
 #align semiconj_by.inv_symm_left_iff₀ SemiconjBy.inv_symm_left_iff₀
+-/
 
+#print SemiconjBy.inv_symm_left₀ /-
 theorem inv_symm_left₀ (h : SemiconjBy a x y) : SemiconjBy a⁻¹ y x :=
   SemiconjBy.inv_symm_left_iff₀.2 h
 #align semiconj_by.inv_symm_left₀ SemiconjBy.inv_symm_left₀
+-/
 
+#print SemiconjBy.inv_right₀ /-
 theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ :=
   by
   by_cases ha : a = 0
@@ -58,16 +67,21 @@ theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ :=
     rw [h.eq, mul_ne_zero_iff] at this 
     exact @units_inv_right _ _ _ (Units.mk0 x hx) (Units.mk0 y this.1) h
 #align semiconj_by.inv_right₀ SemiconjBy.inv_right₀
+-/
 
+#print SemiconjBy.inv_right_iff₀ /-
 @[simp]
 theorem inv_right_iff₀ : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y :=
   ⟨fun h => inv_inv x ▸ inv_inv y ▸ h.inv_right₀, inv_right₀⟩
 #align semiconj_by.inv_right_iff₀ SemiconjBy.inv_right_iff₀
+-/
 
+#print SemiconjBy.div_right /-
 theorem div_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
     SemiconjBy a (x / x') (y / y') := by rw [div_eq_mul_inv, div_eq_mul_inv];
   exact h.mul_right h'.inv_right₀
 #align semiconj_by.div_right SemiconjBy.div_right
+-/
 
 end SemiconjBy

448144f7

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -52,10 +52,10 @@ theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ :=
   · simp only [ha, zero_left]
   by_cases hx : x = 0
   · subst x
-    simp only [SemiconjBy, MulZeroClass.mul_zero, @eq_comm _ _ (y * a), mul_eq_zero] at h
+    simp only [SemiconjBy, MulZeroClass.mul_zero, @eq_comm _ _ (y * a), mul_eq_zero] at h 
     simp [h.resolve_right ha]
   · have := mul_ne_zero ha hx
-    rw [h.eq, mul_ne_zero_iff] at this
+    rw [h.eq, mul_ne_zero_iff] at this 
     exact @units_inv_right _ _ _ (Units.mk0 x hx) (Units.mk0 y this.1) h
 #align semiconj_by.inv_right₀ SemiconjBy.inv_right₀

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -24,23 +24,11 @@ variable {α M₀ G₀ M₀' G₀' F F' : Type _}
 
 namespace SemiconjBy
 
-/- warning: semiconj_by.zero_right -> SemiconjBy.zero_right is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_1 : MulZeroClass.{u1} G₀] (a : G₀), SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ _inst_1) a (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ _inst_1)))) (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ _inst_1))))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_1 : MulZeroClass.{u1} G₀] (a : G₀), SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ _inst_1) a (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MulZeroClass.toZero.{u1} G₀ _inst_1))) (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MulZeroClass.toZero.{u1} G₀ _inst_1)))
-Case conversion may be inaccurate. Consider using '#align semiconj_by.zero_right SemiconjBy.zero_rightₓ'. -/
 @[simp]
 theorem zero_right [MulZeroClass G₀] (a : G₀) : SemiconjBy a 0 0 := by
   simp only [SemiconjBy, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
 #align semiconj_by.zero_right SemiconjBy.zero_right
 
-/- warning: semiconj_by.zero_left -> SemiconjBy.zero_left is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_1 : MulZeroClass.{u1} G₀] (x : G₀) (y : G₀), SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ _inst_1) (OfNat.ofNat.{u1} G₀ 0 (OfNat.mk.{u1} G₀ 0 (Zero.zero.{u1} G₀ (MulZeroClass.toHasZero.{u1} G₀ _inst_1)))) x y
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_1 : MulZeroClass.{u1} G₀] (x : G₀) (y : G₀), SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ _inst_1) (OfNat.ofNat.{u1} G₀ 0 (Zero.toOfNat0.{u1} G₀ (MulZeroClass.toZero.{u1} G₀ _inst_1))) x y
-Case conversion may be inaccurate. Consider using '#align semiconj_by.zero_left SemiconjBy.zero_leftₓ'. -/
 @[simp]
 theorem zero_left [MulZeroClass G₀] (x y : G₀) : SemiconjBy 0 x y := by
   simp only [SemiconjBy, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
@@ -48,34 +36,16 @@ theorem zero_left [MulZeroClass G₀] (x y : G₀) : SemiconjBy 0 x y := by
 
 variable [GroupWithZero G₀] {a x y x' y' : G₀}
 
-/- warning: semiconj_by.inv_symm_left_iff₀ -> SemiconjBy.inv_symm_left_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀}, Iff (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) a) x y) (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a y x)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀}, Iff (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_1) a) x y) (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a y x)
-Case conversion may be inaccurate. Consider using '#align semiconj_by.inv_symm_left_iff₀ SemiconjBy.inv_symm_left_iff₀ₓ'. -/
 @[simp]
 theorem inv_symm_left_iff₀ : SemiconjBy a⁻¹ x y ↔ SemiconjBy a y x :=
   by_cases (fun ha : a = 0 => by simp only [ha, inv_zero, SemiconjBy.zero_left]) fun ha =>
     @units_inv_symm_left_iff _ _ (Units.mk0 a ha) _ _
 #align semiconj_by.inv_symm_left_iff₀ SemiconjBy.inv_symm_left_iff₀
 
-/- warning: semiconj_by.inv_symm_left₀ -> SemiconjBy.inv_symm_left₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀}, (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y) -> (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) a) y x)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀}, (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y) -> (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_1) a) y x)
-Case conversion may be inaccurate. Consider using '#align semiconj_by.inv_symm_left₀ SemiconjBy.inv_symm_left₀ₓ'. -/
 theorem inv_symm_left₀ (h : SemiconjBy a x y) : SemiconjBy a⁻¹ y x :=
   SemiconjBy.inv_symm_left_iff₀.2 h
 #align semiconj_by.inv_symm_left₀ SemiconjBy.inv_symm_left₀
 
-/- warning: semiconj_by.inv_right₀ -> SemiconjBy.inv_right₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀}, (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y) -> (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) x) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) y))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀}, (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y) -> (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_1) x) (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_1) y))
-Case conversion may be inaccurate. Consider using '#align semiconj_by.inv_right₀ SemiconjBy.inv_right₀ₓ'. -/
 theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ :=
   by
   by_cases ha : a = 0
@@ -89,23 +59,11 @@ theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ :=
     exact @units_inv_right _ _ _ (Units.mk0 x hx) (Units.mk0 y this.1) h
 #align semiconj_by.inv_right₀ SemiconjBy.inv_right₀
 
-/- warning: semiconj_by.inv_right_iff₀ -> SemiconjBy.inv_right_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀}, Iff (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) x) (Inv.inv.{u1} G₀ (DivInvMonoid.toHasInv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1)) y)) (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y)
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀}, Iff (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_1) x) (Inv.inv.{u1} G₀ (GroupWithZero.toInv.{u1} G₀ _inst_1) y)) (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y)
-Case conversion may be inaccurate. Consider using '#align semiconj_by.inv_right_iff₀ SemiconjBy.inv_right_iff₀ₓ'. -/
 @[simp]
 theorem inv_right_iff₀ : SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y :=
   ⟨fun h => inv_inv x ▸ inv_inv y ▸ h.inv_right₀, inv_right₀⟩
 #align semiconj_by.inv_right_iff₀ SemiconjBy.inv_right_iff₀
 
-/- warning: semiconj_by.div_right -> SemiconjBy.div_right is a dubious translation:
-lean 3 declaration is
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀} {x' : G₀} {y' : G₀}, (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y) -> (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x' y') -> (SemiconjBy.{u1} G₀ (MulZeroClass.toHasMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))) x x') (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (DivInvMonoid.toHasDiv.{u1} G₀ (GroupWithZero.toDivInvMonoid.{u1} G₀ _inst_1))) y y'))
-but is expected to have type
-  forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀} {x' : G₀} {y' : G₀}, (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y) -> (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x' y') -> (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_1)) x x') (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_1)) y y'))
-Case conversion may be inaccurate. Consider using '#align semiconj_by.div_right SemiconjBy.div_rightₓ'. -/
 theorem div_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
     SemiconjBy a (x / x') (y / y') := by rw [div_eq_mul_inv, div_eq_mul_inv];
   exact h.mul_right h'.inv_right₀

448144f7

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -107,9 +107,7 @@ but is expected to have type
   forall {G₀ : Type.{u1}} [_inst_1 : GroupWithZero.{u1} G₀] {a : G₀} {x : G₀} {y : G₀} {x' : G₀} {y' : G₀}, (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x y) -> (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a x' y') -> (SemiconjBy.{u1} G₀ (MulZeroClass.toMul.{u1} G₀ (MulZeroOneClass.toMulZeroClass.{u1} G₀ (MonoidWithZero.toMulZeroOneClass.{u1} G₀ (GroupWithZero.toMonoidWithZero.{u1} G₀ _inst_1)))) a (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_1)) x x') (HDiv.hDiv.{u1, u1, u1} G₀ G₀ G₀ (instHDiv.{u1} G₀ (GroupWithZero.toDiv.{u1} G₀ _inst_1)) y y'))
 Case conversion may be inaccurate. Consider using '#align semiconj_by.div_right SemiconjBy.div_rightₓ'. -/
 theorem div_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
-    SemiconjBy a (x / x') (y / y') :=
-  by
-  rw [div_eq_mul_inv, div_eq_mul_inv]
+    SemiconjBy a (x / x') (y / y') := by rw [div_eq_mul_inv, div_eq_mul_inv];
   exact h.mul_right h'.inv_right₀
 #align semiconj_by.div_right SemiconjBy.div_right

448144f7

bump to nightly-2023-03-11-16

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

cd44fb92

Diff

@@ -32,7 +32,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align semiconj_by.zero_right SemiconjBy.zero_rightₓ'. -/
 @[simp]
 theorem zero_right [MulZeroClass G₀] (a : G₀) : SemiconjBy a 0 0 := by
-  simp only [SemiconjBy, mul_zero, zero_mul]
+  simp only [SemiconjBy, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
 #align semiconj_by.zero_right SemiconjBy.zero_right
 
 /- warning: semiconj_by.zero_left -> SemiconjBy.zero_left is a dubious translation:
@@ -43,7 +43,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align semiconj_by.zero_left SemiconjBy.zero_leftₓ'. -/
 @[simp]
 theorem zero_left [MulZeroClass G₀] (x y : G₀) : SemiconjBy 0 x y := by
-  simp only [SemiconjBy, mul_zero, zero_mul]
+  simp only [SemiconjBy, MulZeroClass.mul_zero, MulZeroClass.zero_mul]
 #align semiconj_by.zero_left SemiconjBy.zero_left
 
 variable [GroupWithZero G₀] {a x y x' y' : G₀}
@@ -82,7 +82,7 @@ theorem inv_right₀ (h : SemiconjBy a x y) : SemiconjBy a x⁻¹ y⁻¹ :=
   · simp only [ha, zero_left]
   by_cases hx : x = 0
   · subst x
-    simp only [SemiconjBy, mul_zero, @eq_comm _ _ (y * a), mul_eq_zero] at h
+    simp only [SemiconjBy, MulZeroClass.mul_zero, @eq_comm _ _ (y * a), mul_eq_zero] at h
     simp [h.resolve_right ha]
   · have := mul_ne_zero ha hx
     rw [h.eq, mul_ne_zero_iff] at this

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

70d50ecf

chore: split Algebra.Semiconj and Algebra.Commute (#7098)

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

5cffe216

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
 import Mathlib.Algebra.GroupWithZero.Units.Basic
-import Mathlib.Algebra.Group.Semiconj
+import Mathlib.Algebra.Group.Semiconj.Units
 import Mathlib.Init.Classical
 
 #align_import algebra.group_with_zero.semiconj from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"

70d50ecf

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

@@ -15,7 +15,7 @@ import Mathlib.Init.Classical
 -/
 
 
-variable {α M₀ G₀ M₀' G₀' F F' : Type _}
+variable {α M₀ G₀ M₀' G₀' F F' : Type*}
 
 namespace SemiconjBy

70d50ecf

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module algebra.group_with_zero.semiconj
-! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.GroupWithZero.Units.Basic
 import Mathlib.Algebra.Group.Semiconj
 import Mathlib.Init.Classical
 
+#align_import algebra.group_with_zero.semiconj from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"
+
 /-!
 # Lemmas about semiconjugate elements in a `GroupWithZero`.

70d50ecf

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

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

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2020 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
+
+! This file was ported from Lean 3 source module algebra.group_with_zero.semiconj
+! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.GroupWithZero.Units.Basic
 import Mathlib.Algebra.Group.Semiconj

`algebra.group_with_zero.semiconj` ⟷ `Mathlib.Algebra.GroupWithZero.Semiconj`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 24

algebra.group_with_zero.semiconj ⟷ Mathlib.Algebra.GroupWithZero.Semiconj

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 24

`algebra.group_with_zero.semiconj` ⟷ `Mathlib.Algebra.GroupWithZero.Semiconj`