algebra.star.prod | 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

9abfa6f0

(last sync)

refactor(linear_algebra/matrix/hermitian): golf and generalize (#18565)

A handful of these results can be proven trivially using results about is_self_adjoint. This also generalizes the typeclass arguments throughout the file, though largely in a mathematically meaningless way.

Diff

@@ -29,6 +29,10 @@ instance [has_star R] [has_star S] : has_star (R × S) :=
 
 lemma star_def [has_star R] [has_star S] (x : R × S) : star x = (star x.1, star x.2) := rfl
 
+instance [has_star R] [has_star S] [has_trivial_star R] [has_trivial_star S] :
+  has_trivial_star (R × S) :=
+{ star_trivial := λ _, prod.ext (star_trivial _) (star_trivial _) }
+
 instance [has_involutive_star R] [has_involutive_star S] : has_involutive_star (R × S) :=
 { star_involutive := λ _, prod.ext (star_star _) (star_star _) }

247a102b

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

9abfa6f0

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2022 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Mathbin.Algebra.Star.Basic
-import Mathbin.Algebra.Ring.Prod
-import Mathbin.Algebra.Module.Prod
+import Algebra.Star.Basic
+import Algebra.Ring.Prod
+import Algebra.Module.Prod
 
 #align_import algebra.star.prod from "leanprover-community/mathlib"@"9abfa6f0727d5adc99067e325e15d1a9de17fd8e"

9abfa6f0

bump to nightly-2023-09-02-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/442a83d738cb208d3600056c489be16900ba701d

a4ca67cb

Diff

@@ -53,14 +53,14 @@ instance [Star R] [Star S] [TrivialStar R] [TrivialStar S] : TrivialStar (R × S
 instance [InvolutiveStar R] [InvolutiveStar S] : InvolutiveStar (R × S)
     where star_involutive _ := Prod.ext (star_star _) (star_star _)
 
-instance [Semigroup R] [Semigroup S] [StarSemigroup R] [StarSemigroup S] : StarSemigroup (R × S)
+instance [Semigroup R] [Semigroup S] [StarMul R] [StarMul S] : StarMul (R × S)
     where star_hMul _ _ := Prod.ext (star_hMul _ _) (star_hMul _ _)
 
 instance [AddMonoid R] [AddMonoid S] [StarAddMonoid R] [StarAddMonoid S] : StarAddMonoid (R × S)
     where star_add _ _ := Prod.ext (star_add _ _) (star_add _ _)
 
 instance [NonUnitalSemiring R] [NonUnitalSemiring S] [StarRing R] [StarRing S] : StarRing (R × S) :=
-  { Prod.starAddMonoid, (Prod.starSemigroup : StarSemigroup (R × S)) with }
+  { Prod.starAddMonoid, (Prod.starSemigroup : StarMul (R × S)) with }
 
 instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S] [StarModule α R]
     [StarModule α S] : StarModule α (R × S)
@@ -70,7 +70,7 @@ end Prod
 
 #print Units.embed_product_star /-
 @[simp]
-theorem Units.embed_product_star [Monoid R] [StarSemigroup R] (u : Rˣ) :
+theorem Units.embed_product_star [Monoid R] [StarMul R] (u : Rˣ) :
     Units.embedProduct R (star u) = star (Units.embedProduct R u) :=
   rfl
 #align units.embed_product_star Units.embed_product_star

9abfa6f0

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -54,7 +54,7 @@ instance [InvolutiveStar R] [InvolutiveStar S] : InvolutiveStar (R × S)
     where star_involutive _ := Prod.ext (star_star _) (star_star _)
 
 instance [Semigroup R] [Semigroup S] [StarSemigroup R] [StarSemigroup S] : StarSemigroup (R × S)
-    where star_mul _ _ := Prod.ext (star_mul _ _) (star_mul _ _)
+    where star_hMul _ _ := Prod.ext (star_hMul _ _) (star_hMul _ _)
 
 instance [AddMonoid R] [AddMonoid S] [StarAddMonoid R] [StarAddMonoid S] : StarAddMonoid (R × S)
     where star_add _ _ := Prod.ext (star_add _ _) (star_add _ _)

9abfa6f0

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2022 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module algebra.star.prod
-! leanprover-community/mathlib commit 9abfa6f0727d5adc99067e325e15d1a9de17fd8e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Star.Basic
 import Mathbin.Algebra.Ring.Prod
 import Mathbin.Algebra.Module.Prod
 
+#align_import algebra.star.prod from "leanprover-community/mathlib"@"9abfa6f0727d5adc99067e325e15d1a9de17fd8e"
+
 /-!
 # `star` on product types

9abfa6f0

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -71,9 +71,11 @@ instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S] [Star
 
 end Prod
 
+#print Units.embed_product_star /-
 @[simp]
 theorem Units.embed_product_star [Monoid R] [StarSemigroup R] (u : Rˣ) :
     Units.embedProduct R (star u) = star (Units.embedProduct R u) :=
   rfl
 #align units.embed_product_star Units.embed_product_star
+-/

9abfa6f0

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -71,12 +71,6 @@ instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S] [Star
 
 end Prod
 
-/- warning: units.embed_product_star -> Units.embed_product_star is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toHasStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toHasInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.group.{u1} R _inst_1)))) (Units.starSemigroup.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.hasStar.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.hasStar.{u1} R (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) u))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
-Case conversion may be inaccurate. Consider using '#align units.embed_product_star Units.embed_product_starₓ'. -/
 @[simp]
 theorem Units.embed_product_star [Monoid R] [StarSemigroup R] (u : Rˣ) :
     Units.embedProduct R (star u) = star (Units.embedProduct R u) :=

9abfa6f0

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -75,7 +75,7 @@ end Prod
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toHasStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toHasInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.group.{u1} R _inst_1)))) (Units.starSemigroup.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.hasStar.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.hasStar.{u1} R (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) u))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
+  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
 Case conversion may be inaccurate. Consider using '#align units.embed_product_star Units.embed_product_starₓ'. -/
 @[simp]
 theorem Units.embed_product_star [Monoid R] [StarSemigroup R] (u : Rˣ) :

9abfa6f0

bump to nightly-2023-03-24-16

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

5b87f9bb

Diff

@@ -75,7 +75,7 @@ end Prod
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toHasStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toHasInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.group.{u1} R _inst_1)))) (Units.starSemigroup.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.hasStar.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.hasStar.{u1} R (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) u))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
+  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
 Case conversion may be inaccurate. Consider using '#align units.embed_product_star Units.embed_product_starₓ'. -/
 @[simp]
 theorem Units.embed_product_star [Monoid R] [StarSemigroup R] (u : Rˣ) :

9abfa6f0

bump to nightly-2023-03-21-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/290a7ba01fbcab1b64757bdaa270d28f4dcede35

c67df486

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 
 ! This file was ported from Lean 3 source module algebra.star.prod
-! leanprover-community/mathlib commit be24ec5de6701447e5df5ca75400ffee19d65659
+! leanprover-community/mathlib commit 9abfa6f0727d5adc99067e325e15d1a9de17fd8e
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -50,6 +50,9 @@ theorem star_def [Star R] [Star S] (x : R × S) : star x = (star x.1, star x.2)
 #align prod.star_def Prod.star_def
 -/
 
+instance [Star R] [Star S] [TrivialStar R] [TrivialStar S] : TrivialStar (R × S)
+    where star_trivial _ := Prod.ext (star_trivial _) (star_trivial _)
+
 instance [InvolutiveStar R] [InvolutiveStar S] : InvolutiveStar (R × S)
     where star_involutive _ := Prod.ext (star_star _) (star_star _)

be24ec5d

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -72,7 +72,7 @@ end Prod
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toHasStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toHasInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.group.{u1} R _inst_1)))) (Units.starSemigroup.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.hasStar.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.hasStar.{u1} R (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) u))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
+  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
 Case conversion may be inaccurate. Consider using '#align units.embed_product_star Units.embed_product_starₓ'. -/
 @[simp]
 theorem Units.embed_product_star [Monoid R] [StarSemigroup R] (u : Rˣ) :

be24ec5d

bump to nightly-2023-03-08-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

10f15343

Diff

@@ -72,7 +72,7 @@ end Prod
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toHasStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toHasInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.group.{u1} R _inst_1)))) (Units.starSemigroup.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.hasStar.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.hasStar.{u1} R (InvolutiveStar.toHasStar.{u1} R (StarSemigroup.toHasInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (fun (_x : MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) => (Units.{u1} R _inst_1) -> (Prod.{u1, u1} R (MulOpposite.{u1} R))) (MonoidHom.hasCoeToFun.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.mulOneClass.{u1} R _inst_1) (Prod.mulOneClass.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.mulOneClass.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.embedProduct.{u1} R _inst_1) u))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
+  forall {R : Type.{u1}} [_inst_1 : Monoid.{u1} R] [_inst_2 : StarSemigroup.{u1} R (Monoid.toSemigroup.{u1} R _inst_1)] (u : Units.{u1} R _inst_1), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) (Star.star.{u1} (Units.{u1} R _inst_1) (InvolutiveStar.toStar.{u1} (Units.{u1} R _inst_1) (StarSemigroup.toInvolutiveStar.{u1} (Units.{u1} R _inst_1) (Monoid.toSemigroup.{u1} (Units.{u1} R _inst_1) (DivInvMonoid.toMonoid.{u1} (Units.{u1} R _inst_1) (Group.toDivInvMonoid.{u1} (Units.{u1} R _inst_1) (Units.instGroupUnits.{u1} R _inst_1)))) (Units.instStarSemigroupUnitsToSemigroupToMonoidToDivInvMonoidInstGroupUnits.{u1} R _inst_1 _inst_2))) u)) (Star.star.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) u) (Prod.instStarProd.{u1, u1} R (MulOpposite.{u1} R) (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)) (MulOpposite.instStarMulOpposite.{u1} R (InvolutiveStar.toStar.{u1} R (StarSemigroup.toInvolutiveStar.{u1} R (Monoid.toSemigroup.{u1} R _inst_1) _inst_2)))) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (fun (_x : Units.{u1} R _inst_1) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Units.{u1} R _inst_1) => Prod.{u1, u1} R (MulOpposite.{u1} R)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (MulOneClass.toMul.{u1} (Units.{u1} R _inst_1) (Units.instMulOneClassUnits.{u1} R _inst_1)) (MulOneClass.toMul.{u1} (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))) (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Units.{u1} R _inst_1) (Prod.{u1, u1} R (MulOpposite.{u1} R)) (Units.instMulOneClassUnits.{u1} R _inst_1) (Prod.instMulOneClassProd.{u1, u1} R (MulOpposite.{u1} R) (Monoid.toMulOneClass.{u1} R _inst_1) (MulOpposite.instMulOneClassMulOpposite.{u1} R (Monoid.toMulOneClass.{u1} R _inst_1)))))) (Units.embedProduct.{u1} R _inst_1) u))
 Case conversion may be inaccurate. Consider using '#align units.embed_product_star Units.embed_product_starₓ'. -/
 @[simp]
 theorem Units.embed_product_star [Monoid R] [StarSemigroup R] (u : Rˣ) :

be24ec5d

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

9abfa6f0

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

@@ -62,7 +62,7 @@ instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S]
 
 end Prod
 
---Porting note: removing @[simp], `simp` simplifies LHS
+-- Porting note: removing @[simp], `simp` simplifies LHS
 theorem Units.embed_product_star [Monoid R] [StarMul R] (u : Rˣ) :
     Units.embedProduct R (star u) = star (Units.embedProduct R u) :=
   rfl

9abfa6f0

chore: reduce imports (#9830)

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

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

f4c4ca61

Diff

@@ -5,7 +5,7 @@ Authors: Eric Wieser
 -/
 import Mathlib.Algebra.Star.Basic
 import Mathlib.Algebra.Ring.Prod
-import Mathlib.Algebra.Module.Prod
+import Mathlib.GroupTheory.GroupAction.Prod
 
 #align_import algebra.star.prod from "leanprover-community/mathlib"@"9abfa6f0727d5adc99067e325e15d1a9de17fd8e"

9abfa6f0

style: fix wrapping of where (#7149)

084cfb35

Diff

@@ -38,17 +38,18 @@ theorem star_def [Star R] [Star S] (x : R × S) : star x = (star x.1, star x.2)
   rfl
 #align prod.star_def Prod.star_def
 
-instance [Star R] [Star S] [TrivialStar R] [TrivialStar S] : TrivialStar (R × S)
-    where star_trivial _ := Prod.ext (star_trivial _) (star_trivial _)
+instance [Star R] [Star S] [TrivialStar R] [TrivialStar S] : TrivialStar (R × S) where
+  star_trivial _ := Prod.ext (star_trivial _) (star_trivial _)
 
-instance [InvolutiveStar R] [InvolutiveStar S] : InvolutiveStar (R × S)
-    where star_involutive _ := Prod.ext (star_star _) (star_star _)
+instance [InvolutiveStar R] [InvolutiveStar S] : InvolutiveStar (R × S) where
+  star_involutive _ := Prod.ext (star_star _) (star_star _)
 
-instance [Mul R] [Mul S] [StarMul R] [StarMul S] : StarMul (R × S)
-    where star_mul _ _ := Prod.ext (star_mul _ _) (star_mul _ _)
+instance [Mul R] [Mul S] [StarMul R] [StarMul S] : StarMul (R × S) where
+  star_mul _ _ := Prod.ext (star_mul _ _) (star_mul _ _)
 
-instance [AddMonoid R] [AddMonoid S] [StarAddMonoid R] [StarAddMonoid S] : StarAddMonoid (R × S)
-    where star_add _ _ := Prod.ext (star_add _ _) (star_add _ _)
+instance [AddMonoid R] [AddMonoid S] [StarAddMonoid R] [StarAddMonoid S] :
+    StarAddMonoid (R × S) where
+  star_add _ _ := Prod.ext (star_add _ _) (star_add _ _)
 
 instance [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S] [StarRing R] [StarRing S] :
     StarRing (R × S) :=
@@ -56,8 +57,8 @@ instance [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S] [StarRing R
     inferInstanceAs (StarMul (R × S)) with }
 
 instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S]
-    [StarModule α R] [StarModule α S] : StarModule α (R × S)
-    where star_smul _ _ := Prod.ext (star_smul _ _) (star_smul _ _)
+    [StarModule α R] [StarModule α S] : StarModule α (R × S) where
+  star_smul _ _ := Prod.ext (star_smul _ _) (star_smul _ _)
 
 end Prod

9abfa6f0

refactor(Algebra/Star/*): Allow for star operation on non-associative algebras (#6562)

Typically a * operation on a mathematical structure R equipped with a multiplication is an involutive anti-automorphism i.e.

∀ r s : R, star (r * s) = star s * star r

Currently mathlib defines a class StarSemigroup to be a semigroup satisfying this property. However, the requirement for the multiplication to be associative is unnecessarily restrictive. There are important classes of star-algebra which are not associative (e.g. JB*-algebras).

This PR removes the requirement for a StarSemigroup to be a semigroup, merely requiring it to have a multiplication.

I've changed the name from StarSemigroup to StarMul since it's no longer a semigroup.

Zulip discussion

Previously opened as a mathlib PR https://github.com/leanprover-community/mathlib/pull/17949

Co-authored-by: Christopher Hoskin <mans0954@users.noreply.github.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

85c04e73

Diff

@@ -44,15 +44,16 @@ instance [Star R] [Star S] [TrivialStar R] [TrivialStar S] : TrivialStar (R × S
 instance [InvolutiveStar R] [InvolutiveStar S] : InvolutiveStar (R × S)
     where star_involutive _ := Prod.ext (star_star _) (star_star _)
 
-instance [Semigroup R] [Semigroup S] [StarSemigroup R] [StarSemigroup S] : StarSemigroup (R × S)
+instance [Mul R] [Mul S] [StarMul R] [StarMul S] : StarMul (R × S)
     where star_mul _ _ := Prod.ext (star_mul _ _) (star_mul _ _)
 
 instance [AddMonoid R] [AddMonoid S] [StarAddMonoid R] [StarAddMonoid S] : StarAddMonoid (R × S)
     where star_add _ _ := Prod.ext (star_add _ _) (star_add _ _)
 
-instance [NonUnitalSemiring R] [NonUnitalSemiring S] [StarRing R] [StarRing S] : StarRing (R × S) :=
+instance [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S] [StarRing R] [StarRing S] :
+    StarRing (R × S) :=
   { inferInstanceAs (StarAddMonoid (R × S)),
-    inferInstanceAs (StarSemigroup (R × S)) with }
+    inferInstanceAs (StarMul (R × S)) with }
 
 instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S]
     [StarModule α R] [StarModule α S] : StarModule α (R × S)
@@ -61,7 +62,7 @@ instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S]
 end Prod
 
 --Porting note: removing @[simp], `simp` simplifies LHS
-theorem Units.embed_product_star [Monoid R] [StarSemigroup R] (u : Rˣ) :
+theorem Units.embed_product_star [Monoid R] [StarMul R] (u : Rˣ) :
     Units.embedProduct R (star u) = star (Units.embedProduct R u) :=
   rfl
 #align units.embed_product_star Units.embed_product_star

9abfa6f0

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) 2022 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module algebra.star.prod
-! leanprover-community/mathlib commit 9abfa6f0727d5adc99067e325e15d1a9de17fd8e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Star.Basic
 import Mathlib.Algebra.Ring.Prod
 import Mathlib.Algebra.Module.Prod
 
+#align_import algebra.star.prod from "leanprover-community/mathlib"@"9abfa6f0727d5adc99067e325e15d1a9de17fd8e"
+
 /-!
 # `Star` on product types

9abfa6f0

chore: sync Mathlib.Algebra.Star.Pi (#3081)

076068bc

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 
 ! This file was ported from Lean 3 source module algebra.star.prod
-! leanprover-community/mathlib commit 247a102b14f3cebfee126293341af5f6bed00237
+! leanprover-community/mathlib commit 9abfa6f0727d5adc99067e325e15d1a9de17fd8e
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -41,6 +41,9 @@ theorem star_def [Star R] [Star S] (x : R × S) : star x = (star x.1, star x.2)
   rfl
 #align prod.star_def Prod.star_def
 
+instance [Star R] [Star S] [TrivialStar R] [TrivialStar S] : TrivialStar (R × S)
+    where star_trivial _ := Prod.ext (star_trivial _) (star_trivial _)
+
 instance [InvolutiveStar R] [InvolutiveStar S] : InvolutiveStar (R × S)
     where star_involutive _ := Prod.ext (star_star _) (star_star _)

247a102b

chore: use inferInstanceAs (#2074)

Drop

by delta mydef; infer_instance. This generates id _ in the proof.
show _, by infer_instance. This generates let in let; not sure if it's bad for defeq but a reducible inferInstanceAs should not be worse.

f9f9320a

Diff

@@ -51,8 +51,8 @@ instance [AddMonoid R] [AddMonoid S] [StarAddMonoid R] [StarAddMonoid S] : StarA
     where star_add _ _ := Prod.ext (star_add _ _) (star_add _ _)
 
 instance [NonUnitalSemiring R] [NonUnitalSemiring S] [StarRing R] [StarRing S] : StarRing (R × S) :=
-  { (show StarAddMonoid (R × S) by infer_instance),
-    (show StarSemigroup (R × S) by infer_instance) with }
+  { inferInstanceAs (StarAddMonoid (R × S)),
+    inferInstanceAs (StarSemigroup (R × S)) with }
 
 instance {α : Type w} [SMul α R] [SMul α S] [Star α] [Star R] [Star S]
     [StarModule α R] [StarModule α S] : StarModule α (R × S)

247a102b

feat: port Algebra.Star.Prod (#1434)

ef529d52

`algebra.star.prod` ⟷ `Mathlib.Algebra.Star.Prod`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 3 + 182

algebra.star.prod ⟷ Mathlib.Algebra.Star.Prod

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 3 + 182

`algebra.star.prod` ⟷ `Mathlib.Algebra.Star.Prod`