algebra.group.pi ⟷ Mathlib.Algebra.Group.Pi.Lemmas

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

@@ -470,49 +470,49 @@ open Pi
 
 variable (f)
 
-#print OneHom.single /-
+#print OneHom.mulSingle /-
 /-- The one-preserving homomorphism including a single value
 into a dependent family of values, as functions supported at a point.
 
 This is the `one_hom` version of `pi.mul_single`. -/
 @[to_additive ZeroHom.single
       "The zero-preserving homomorphism including a single value\ninto a dependent family of values, as functions supported at a point.\n\nThis is the `zero_hom` version of `pi.single`."]
-def OneHom.single [∀ i, One <| f i] (i : I) : OneHom (f i) (∀ i, f i)
+def OneHom.mulSingle [∀ i, One <| f i] (i : I) : OneHom (f i) (∀ i, f i)
     where
   toFun := mulSingle i
   map_one' := mulSingle_one i
-#align one_hom.single OneHom.single
+#align one_hom.single OneHom.mulSingle
 #align zero_hom.single ZeroHom.single
 -/
 
-#print OneHom.single_apply /-
+#print OneHom.mulSingle_apply /-
 @[simp, to_additive]
-theorem OneHom.single_apply [∀ i, One <| f i] (i : I) (x : f i) :
-    OneHom.single f i x = mulSingle i x :=
+theorem OneHom.mulSingle_apply [∀ i, One <| f i] (i : I) (x : f i) :
+    OneHom.mulSingle f i x = mulSingle i x :=
   rfl
-#align one_hom.single_apply OneHom.single_apply
+#align one_hom.single_apply OneHom.mulSingle_apply
 #align zero_hom.single_apply ZeroHom.single_apply
 -/
 
-#print MonoidHom.single /-
+#print MonoidHom.mulSingle /-
 /-- The monoid homomorphism including a single monoid into a dependent family of additive monoids,
 as functions supported at a point.
 
 This is the `monoid_hom` version of `pi.mul_single`. -/
 @[to_additive
       "The additive monoid homomorphism including a single additive\nmonoid into a dependent family of additive monoids, as functions supported at a point.\n\nThis is the `add_monoid_hom` version of `pi.single`."]
-def MonoidHom.single [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :=
-  { OneHom.single f i with map_mul' := mulSingle_op₂ (fun _ => (· * ·)) (fun _ => one_mul _) _ }
-#align monoid_hom.single MonoidHom.single
+def MonoidHom.mulSingle [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :=
+  { OneHom.mulSingle f i with map_mul' := mulSingle_op₂ (fun _ => (· * ·)) (fun _ => one_mul _) _ }
+#align monoid_hom.single MonoidHom.mulSingle
 #align add_monoid_hom.single AddMonoidHom.single
 -/
 
-#print MonoidHom.single_apply /-
+#print MonoidHom.mulSingle_apply /-
 @[simp, to_additive]
-theorem MonoidHom.single_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
-    MonoidHom.single f i x = mulSingle i x :=
+theorem MonoidHom.mulSingle_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
+    MonoidHom.mulSingle f i x = mulSingle i x :=
   rfl
-#align monoid_hom.single_apply MonoidHom.single_apply
+#align monoid_hom.single_apply MonoidHom.mulSingle_apply
 #align add_monoid_hom.single_apply AddMonoidHom.single_apply
 -/
 
@@ -553,7 +553,7 @@ theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I
 @[to_additive]
 theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
     mulSingle i (x * y) = mulSingle i x * mulSingle i y :=
-  (MonoidHom.single f i).map_hMul x y
+  (MonoidHom.mulSingle f i).map_hMul x y
 #align pi.mul_single_mul Pi.mulSingle_mul
 #align pi.single_add Pi.single_add
 -/
@@ -562,17 +562,17 @@ theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
 @[to_additive]
 theorem Pi.mulSingle_inv [∀ i, Group <| f i] (i : I) (x : f i) :
     mulSingle i x⁻¹ = (mulSingle i x)⁻¹ :=
-  (MonoidHom.single f i).map_inv x
+  (MonoidHom.mulSingle f i).map_inv x
 #align pi.mul_single_inv Pi.mulSingle_inv
 #align pi.single_neg Pi.single_neg
 -/
 
-#print Pi.single_div /-
+#print Pi.mulSingle_div /-
 @[to_additive]
-theorem Pi.single_div [∀ i, Group <| f i] (i : I) (x y : f i) :
+theorem Pi.mulSingle_div [∀ i, Group <| f i] (i : I) (x y : f i) :
     mulSingle i (x / y) = mulSingle i x / mulSingle i y :=
-  (MonoidHom.single f i).map_div x y
-#align pi.single_div Pi.single_div
+  (MonoidHom.mulSingle f i).map_div x y
+#align pi.single_div Pi.mulSingle_div
 #align pi.single_sub Pi.single_sub
 -/
 

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

@@ -4,8 +4,8 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
 -/
 import Logic.Pairwise
-import Algebra.Hom.GroupInstances
-import Data.Pi.Algebra
+import Algebra.Group.Hom.Instances
+import Algebra.Group.Pi.Basic
 import Data.Set.Function
 import Tactic.PiInstances
 

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

@@ -665,20 +665,20 @@ theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {M : Type _} [Comm
     have hl := congr_fun h l
     have hm := (congr_fun h m).symm
     have hn := (congr_fun h n).symm
-    simp only [mul_apply, mul_single_apply, if_pos rfl] at hk hl hm hn 
+    simp only [mul_apply, mul_single_apply, if_pos rfl] at hk hl hm hn
     rcases eq_or_ne k m with (rfl | hkm)
     · refine' Or.inl ⟨rfl, not_ne_iff.mp fun hln => (hv _).elim⟩
       rcases eq_or_ne k l with (rfl | hkl)
-      · rwa [if_neg hln.symm, if_neg hln.symm, one_mul, one_mul] at hn 
-      · rwa [if_neg hkl.symm, if_neg hln, one_mul, one_mul] at hl 
+      · rwa [if_neg hln.symm, if_neg hln.symm, one_mul, one_mul] at hn
+      · rwa [if_neg hkl.symm, if_neg hln, one_mul, one_mul] at hl
     · rcases eq_or_ne m n with (rfl | hmn)
       · rcases eq_or_ne k l with (rfl | hkl)
-        · rw [if_neg hkm.symm, if_neg hkm.symm, one_mul, if_pos rfl] at hm 
+        · rw [if_neg hkm.symm, if_neg hkm.symm, one_mul, if_pos rfl] at hm
           exact Or.inr (Or.inr ⟨hm, rfl, rfl⟩)
         · simpa only [if_neg hkm, if_neg hkl, mul_one] using hk
-      · rw [if_neg hkm.symm, if_neg hmn, one_mul, mul_one] at hm 
+      · rw [if_neg hkm.symm, if_neg hmn, one_mul, mul_one] at hm
         obtain rfl := (ite_ne_right_iff.mp (ne_of_eq_of_ne hm.symm hu)).1
-        rw [if_neg hkm, if_neg hkm, one_mul, mul_one] at hk 
+        rw [if_neg hkm, if_neg hkm, one_mul, mul_one] at hk
         obtain rfl := (ite_ne_right_iff.mp (ne_of_eq_of_ne hk.symm hu)).1
         exact Or.inr (Or.inl ⟨hk.trans (if_pos rfl), rfl, rfl⟩)
   · rintro (⟨rfl, rfl⟩ | ⟨rfl, rfl, rfl⟩ | ⟨h, rfl, rfl⟩)

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

@@ -625,7 +625,7 @@ theorem Pi.mulSingle_commute [∀ i, MulOneClass <| f i] :
   by_cases h2 : j = k; · subst h2; simp [hij]
   simp [h1, h2]
 #align pi.mul_single_commute Pi.mulSingle_commute
-#align pi.single_commute Pi.single_commute
+#align pi.single_commute Pi.single_addCommute
 -/
 
 #print Pi.mulSingle_apply_commute /-
@@ -638,7 +638,7 @@ theorem Pi.mulSingle_apply_commute [∀ i, MulOneClass <| f i] (x : ∀ i, f i)
   · rfl
   · exact Pi.mulSingle_commute hij _ _
 #align pi.mul_single_apply_commute Pi.mulSingle_apply_commute
-#align pi.single_apply_commute Pi.single_apply_commute
+#align pi.single_apply_commute Pi.single_apply_addCommute
 -/
 
 #print Pi.update_eq_div_mul_mulSingle /-

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

@@ -3,11 +3,11 @@ Copyright (c) 2018 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
 -/
-import Mathbin.Logic.Pairwise
-import Mathbin.Algebra.Hom.GroupInstances
-import Mathbin.Data.Pi.Algebra
-import Mathbin.Data.Set.Function
-import Mathbin.Tactic.PiInstances
+import Logic.Pairwise
+import Algebra.Hom.GroupInstances
+import Data.Pi.Algebra
+import Data.Set.Function
+import Tactic.PiInstances
 
 #align_import algebra.group.pi from "leanprover-community/mathlib"@"e4bc74cbaf429d706cb9140902f7ca6c431e75a4"
 

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

@@ -298,7 +298,7 @@ given by `pi.mul_hom f x b = f b x`. -/
 def Pi.mulHom {γ : Type w} [∀ i, Mul (f i)] [Mul γ] (g : ∀ i, γ →ₙ* f i) : γ →ₙ* ∀ i, f i
     where
   toFun x i := g i x
-  map_mul' x y := funext fun i => (g i).map_mul x y
+  map_mul' x y := funext fun i => (g i).map_hMul x y
 #align pi.mul_hom Pi.mulHom
 #align pi.add_hom Pi.addHom
 -/
@@ -553,7 +553,7 @@ theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I
 @[to_additive]
 theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
     mulSingle i (x * y) = mulSingle i x * mulSingle i y :=
-  (MonoidHom.single f i).map_mul x y
+  (MonoidHom.single f i).map_hMul x y
 #align pi.mul_single_mul Pi.mulSingle_mul
 #align pi.single_add Pi.single_add
 -/
@@ -579,7 +579,7 @@ theorem Pi.single_div [∀ i, Group <| f i] (i : I) (x y : f i) :
 #print Pi.single_mul /-
 theorem Pi.single_mul [∀ i, MulZeroClass <| f i] (i : I) (x y : f i) :
     single i (x * y) = single i x * single i y :=
-  (MulHom.single f i).map_mul x y
+  (MulHom.single f i).map_hMul x y
 #align pi.single_mul Pi.single_mul
 -/
 

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

@@ -2,11 +2,6 @@
 Copyright (c) 2018 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
-
-! This file was ported from Lean 3 source module algebra.group.pi
-! leanprover-community/mathlib commit e4bc74cbaf429d706cb9140902f7ca6c431e75a4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Logic.Pairwise
 import Mathbin.Algebra.Hom.GroupInstances
@@ -14,6 +9,8 @@ import Mathbin.Data.Pi.Algebra
 import Mathbin.Data.Set.Function
 import Mathbin.Tactic.PiInstances
 
+#align_import algebra.group.pi from "leanprover-community/mathlib"@"e4bc74cbaf429d706cb9140902f7ca6c431e75a4"
+
 /-!
 # Pi instances for groups and monoids
 

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

@@ -36,12 +36,14 @@ variable {f : I → Type v}
 -- The family of types already equipped with instances
 variable (x y : ∀ i, f i) (i j : I)
 
+#print Set.preimage_one /-
 @[to_additive]
 theorem Set.preimage_one {α β : Type _} [One β] (s : Set β) [Decidable ((1 : β) ∈ s)] :
     (1 : α → β) ⁻¹' s = if (1 : β) ∈ s then Set.univ else ∅ :=
   Set.preimage_const 1 s
 #align set.preimage_one Set.preimage_one
 #align set.preimage_zero Set.preimage_zero
+-/
 
 namespace Pi
 
@@ -277,12 +279,14 @@ end Pi
 
 namespace MulHom
 
+#print MulHom.coe_mul /-
 @[to_additive]
 theorem coe_mul {M N} {mM : Mul M} {mN : CommSemigroup N} (f g : M →ₙ* N) :
     (f * g : M → N) = fun x => f x * g x :=
   rfl
 #align mul_hom.coe_mul MulHom.coe_mul
 #align add_hom.coe_add AddHom.coe_add
+-/
 
 end MulHom
 
@@ -328,6 +332,7 @@ def Pi.monoidHom {γ : Type w} [∀ i, MulOneClass (f i)] [MulOneClass γ] (g :
 #align pi.add_monoid_hom Pi.addMonoidHom
 -/
 
+#print Pi.monoidHom_injective /-
 @[to_additive]
 theorem Pi.monoidHom_injective {γ : Type w} [Nonempty I] [∀ i, MulOneClass (f i)] [MulOneClass γ]
     (g : ∀ i, γ →* f i) (hg : ∀ i, Function.Injective (g i)) :
@@ -335,6 +340,7 @@ theorem Pi.monoidHom_injective {γ : Type w} [Nonempty I] [∀ i, MulOneClass (f
   Pi.mulHom_injective (fun i => (g i).toMulHom) hg
 #align pi.monoid_hom_injective Pi.monoidHom_injective
 #align pi.add_monoid_hom_injective Pi.addMonoidHom_injective
+-/
 
 variable (f) [∀ i, Mul (f i)]
 
@@ -364,6 +370,7 @@ def Pi.constMulHom (α β : Type _) [Mul β] : β →ₙ* α → β
 #align pi.const_add_hom Pi.constAddHom
 -/
 
+#print MulHom.coeFn /-
 /-- Coercion of a `mul_hom` into a function is itself a `mul_hom`.
 See also `mul_hom.eval`. -/
 @[to_additive
@@ -375,6 +382,7 @@ def MulHom.coeFn (α β : Type _) [Mul α] [CommSemigroup β] : (α →ₙ* β)
   map_mul' x y := rfl
 #align mul_hom.coe_fn MulHom.coeFn
 #align add_hom.coe_fn AddHom.coeFn
+-/
 
 #print MulHom.compLeft /-
 /-- Semigroup homomorphism between the function spaces `I → α` and `I → β`, induced by a semigroup
@@ -502,13 +510,16 @@ def MonoidHom.single [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :
 #align add_monoid_hom.single AddMonoidHom.single
 -/
 
+#print MonoidHom.single_apply /-
 @[simp, to_additive]
 theorem MonoidHom.single_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
     MonoidHom.single f i x = mulSingle i x :=
   rfl
 #align monoid_hom.single_apply MonoidHom.single_apply
 #align add_monoid_hom.single_apply AddMonoidHom.single_apply
+-/
 
+#print MulHom.single /-
 /-- The multiplicative homomorphism including a single `mul_zero_class`
 into a dependent family of `mul_zero_class`es, as functions supported at a point.
 
@@ -519,69 +530,91 @@ def MulHom.single [∀ i, MulZeroClass <| f i] (i : I) : f i →ₙ* ∀ i, f i
   toFun := single i
   map_mul' := Pi.single_op₂ (fun _ => (· * ·)) (fun _ => MulZeroClass.zero_mul _) _
 #align mul_hom.single MulHom.single
+-/
 
 variable {f}
 
+#print Pi.mulSingle_sup /-
 @[to_additive]
 theorem Pi.mulSingle_sup [∀ i, SemilatticeSup (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
     Pi.mulSingle i (x ⊔ y) = Pi.mulSingle i x ⊔ Pi.mulSingle i y :=
   Function.update_sup _ _ _ _
 #align pi.mul_single_sup Pi.mulSingle_sup
 #align pi.single_sup Pi.single_sup
+-/
 
+#print Pi.mulSingle_inf /-
 @[to_additive]
 theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
     Pi.mulSingle i (x ⊓ y) = Pi.mulSingle i x ⊓ Pi.mulSingle i y :=
   Function.update_inf _ _ _ _
 #align pi.mul_single_inf Pi.mulSingle_inf
 #align pi.single_inf Pi.single_inf
+-/
 
+#print Pi.mulSingle_mul /-
 @[to_additive]
 theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
     mulSingle i (x * y) = mulSingle i x * mulSingle i y :=
   (MonoidHom.single f i).map_mul x y
 #align pi.mul_single_mul Pi.mulSingle_mul
 #align pi.single_add Pi.single_add
+-/
 
+#print Pi.mulSingle_inv /-
 @[to_additive]
 theorem Pi.mulSingle_inv [∀ i, Group <| f i] (i : I) (x : f i) :
     mulSingle i x⁻¹ = (mulSingle i x)⁻¹ :=
   (MonoidHom.single f i).map_inv x
 #align pi.mul_single_inv Pi.mulSingle_inv
 #align pi.single_neg Pi.single_neg
+-/
 
+#print Pi.single_div /-
 @[to_additive]
 theorem Pi.single_div [∀ i, Group <| f i] (i : I) (x y : f i) :
     mulSingle i (x / y) = mulSingle i x / mulSingle i y :=
   (MonoidHom.single f i).map_div x y
 #align pi.single_div Pi.single_div
 #align pi.single_sub Pi.single_sub
+-/
 
+#print Pi.single_mul /-
 theorem Pi.single_mul [∀ i, MulZeroClass <| f i] (i : I) (x y : f i) :
     single i (x * y) = single i x * single i y :=
   (MulHom.single f i).map_mul x y
 #align pi.single_mul Pi.single_mul
+-/
 
+#print Pi.single_mul_left_apply /-
 theorem Pi.single_mul_left_apply [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (a * x i) j = Pi.single i a j * x j :=
   (Pi.apply_single (fun i => (· * x i)) (fun i => MulZeroClass.zero_mul _) _ _ _).symm
 #align pi.single_mul_left_apply Pi.single_mul_left_apply
+-/
 
+#print Pi.single_mul_right_apply /-
 theorem Pi.single_mul_right_apply [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (x i * a) j = x j * Pi.single i a j :=
   (Pi.apply_single (fun i => (· * ·) (x i)) (fun i => MulZeroClass.mul_zero _) _ _ _).symm
 #align pi.single_mul_right_apply Pi.single_mul_right_apply
+-/
 
+#print Pi.single_mul_left /-
 theorem Pi.single_mul_left [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (a * x i) = Pi.single i a * x :=
   funext fun j => Pi.single_mul_left_apply _ _ _ _
 #align pi.single_mul_left Pi.single_mul_left
+-/
 
+#print Pi.single_mul_right /-
 theorem Pi.single_mul_right [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (x i * a) = x * Pi.single i a :=
   funext fun j => Pi.single_mul_right_apply _ _ _ _
 #align pi.single_mul_right Pi.single_mul_right
+-/
 
+#print Pi.mulSingle_commute /-
 /-- The injection into a pi group at different indices commutes.
 
 For injections of commuting elements at the same index, see `commute.map` -/
@@ -596,7 +629,9 @@ theorem Pi.mulSingle_commute [∀ i, MulOneClass <| f i] :
   simp [h1, h2]
 #align pi.mul_single_commute Pi.mulSingle_commute
 #align pi.single_commute Pi.single_commute
+-/
 
+#print Pi.mulSingle_apply_commute /-
 /-- The injection into a pi group with the same values commutes. -/
 @[to_additive "The injection into an additive pi group with the same values commutes."]
 theorem Pi.mulSingle_apply_commute [∀ i, MulOneClass <| f i] (x : ∀ i, f i) (i j : I) :
@@ -607,7 +642,9 @@ theorem Pi.mulSingle_apply_commute [∀ i, MulOneClass <| f i] (x : ∀ i, f i)
   · exact Pi.mulSingle_commute hij _ _
 #align pi.mul_single_apply_commute Pi.mulSingle_apply_commute
 #align pi.single_apply_commute Pi.single_apply_commute
+-/
 
+#print Pi.update_eq_div_mul_mulSingle /-
 @[to_additive update_eq_sub_add_single]
 theorem Pi.update_eq_div_mul_mulSingle [∀ i, Group <| f i] (g : ∀ i : I, f i) (x : f i) :
     Function.update g i x = g / mulSingle i (g i) * mulSingle i x :=
@@ -617,7 +654,9 @@ theorem Pi.update_eq_div_mul_mulSingle [∀ i, Group <| f i] (g : ∀ i : I, f i
   · simp
   · simp [Function.update_noteq h.symm, h]
 #align pi.update_eq_div_mul_single Pi.update_eq_div_mul_mulSingle
+-/
 
+#print Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle /-
 @[to_additive Pi.single_add_single_eq_single_add_single]
 theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {M : Type _} [CommMonoid M]
     {k l m n : I} {u v : M} (hu : u ≠ 1) (hv : v ≠ 1) :
@@ -651,6 +690,7 @@ theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {M : Type _} [Comm
     · simp_rw [← Pi.mulSingle_mul, h, mul_single_one]
 #align pi.mul_single_mul_mul_single_eq_mul_single_mul_mul_single Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle
 #align pi.single_add_single_eq_single_add_single Pi.single_add_single_eq_single_add_single
+-/
 
 end Single
 
@@ -693,17 +733,21 @@ theorem update_div [∀ i, Div (f i)] [DecidableEq I] (f₁ f₂ : ∀ i, f i) (
 
 variable [One α] [Nonempty ι] {a : α}
 
+#print Function.const_eq_one /-
 @[simp, to_additive]
 theorem const_eq_one : const ι a = 1 ↔ a = 1 :=
   @const_inj _ _ _ _ 1
 #align function.const_eq_one Function.const_eq_one
 #align function.const_eq_zero Function.const_eq_zero
+-/
 
+#print Function.const_ne_one /-
 @[to_additive]
 theorem const_ne_one : const ι a ≠ 1 ↔ a ≠ 1 :=
   const_eq_one.Not
 #align function.const_ne_one Function.const_ne_one
 #align function.const_ne_zero Function.const_ne_zero
+-/
 
 end Function
 

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

@@ -48,7 +48,7 @@ namespace Pi
 #print Pi.semigroup /-
 @[to_additive]
 instance semigroup [∀ i, Semigroup <| f i] : Semigroup (∀ i : I, f i) := by
-  refine_struct { mul := (· * ·).. } <;> pi_instance_derive_field
+  refine_struct { mul := (· * ·) .. } <;> pi_instance_derive_field
 #align pi.semigroup Pi.semigroup
 #align pi.add_semigroup Pi.addSemigroup
 -/
@@ -57,7 +57,7 @@ instance semigroup [∀ i, Semigroup <| f i] : Semigroup (∀ i : I, f i) := by
 instance semigroupWithZero [∀ i, SemigroupWithZero <| f i] : SemigroupWithZero (∀ i : I, f i) := by
   refine_struct
       { zero := (0 : ∀ i, f i)
-        mul := (· * ·).. } <;>
+        mul := (· * ·) .. } <;>
     pi_instance_derive_field
 #align pi.semigroup_with_zero Pi.semigroupWithZero
 -/
@@ -65,7 +65,7 @@ instance semigroupWithZero [∀ i, SemigroupWithZero <| f i] : SemigroupWithZero
 #print Pi.commSemigroup /-
 @[to_additive]
 instance commSemigroup [∀ i, CommSemigroup <| f i] : CommSemigroup (∀ i : I, f i) := by
-  refine_struct { mul := (· * ·).. } <;> pi_instance_derive_field
+  refine_struct { mul := (· * ·) .. } <;> pi_instance_derive_field
 #align pi.comm_semigroup Pi.commSemigroup
 #align pi.add_comm_semigroup Pi.addCommSemigroup
 -/
@@ -75,7 +75,7 @@ instance commSemigroup [∀ i, CommSemigroup <| f i] : CommSemigroup (∀ i : I,
 instance mulOneClass [∀ i, MulOneClass <| f i] : MulOneClass (∀ i : I, f i) := by
   refine_struct
       { one := (1 : ∀ i, f i)
-        mul := (· * ·).. } <;>
+        mul := (· * ·) .. } <;>
     pi_instance_derive_field
 #align pi.mul_one_class Pi.mulOneClass
 #align pi.add_zero_class Pi.addZeroClass
@@ -201,7 +201,7 @@ instance rightCancelMonoid [∀ i, RightCancelMonoid <| f i] : RightCancelMonoid
   refine_struct
       { one := (1 : ∀ i, f i)
         mul := (· * ·)
-        npow := Monoid.npow.. } <;>
+        npow := Monoid.npow .. } <;>
     pi_instance_derive_field
 #align pi.right_cancel_monoid Pi.rightCancelMonoid
 #align pi.add_right_cancel_monoid Pi.addRightCancelMonoid
@@ -235,7 +235,7 @@ instance cancelCommMonoid [∀ i, CancelCommMonoid <| f i] : CancelCommMonoid (
 instance mulZeroClass [∀ i, MulZeroClass <| f i] : MulZeroClass (∀ i : I, f i) := by
   refine_struct
       { zero := (0 : ∀ i, f i)
-        mul := (· * ·).. } <;>
+        mul := (· * ·) .. } <;>
     pi_instance_derive_field
 #align pi.mul_zero_class Pi.mulZeroClass
 -/
@@ -245,7 +245,7 @@ instance mulZeroOneClass [∀ i, MulZeroOneClass <| f i] : MulZeroOneClass (∀
   refine_struct
       { zero := (0 : ∀ i, f i)
         one := (1 : ∀ i, f i)
-        mul := (· * ·).. } <;>
+        mul := (· * ·) .. } <;>
     pi_instance_derive_field
 #align pi.mul_zero_one_class Pi.mulZeroOneClass
 -/
@@ -629,20 +629,20 @@ theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {M : Type _} [Comm
     have hl := congr_fun h l
     have hm := (congr_fun h m).symm
     have hn := (congr_fun h n).symm
-    simp only [mul_apply, mul_single_apply, if_pos rfl] at hk hl hm hn
+    simp only [mul_apply, mul_single_apply, if_pos rfl] at hk hl hm hn 
     rcases eq_or_ne k m with (rfl | hkm)
     · refine' Or.inl ⟨rfl, not_ne_iff.mp fun hln => (hv _).elim⟩
       rcases eq_or_ne k l with (rfl | hkl)
-      · rwa [if_neg hln.symm, if_neg hln.symm, one_mul, one_mul] at hn
-      · rwa [if_neg hkl.symm, if_neg hln, one_mul, one_mul] at hl
+      · rwa [if_neg hln.symm, if_neg hln.symm, one_mul, one_mul] at hn 
+      · rwa [if_neg hkl.symm, if_neg hln, one_mul, one_mul] at hl 
     · rcases eq_or_ne m n with (rfl | hmn)
       · rcases eq_or_ne k l with (rfl | hkl)
-        · rw [if_neg hkm.symm, if_neg hkm.symm, one_mul, if_pos rfl] at hm
+        · rw [if_neg hkm.symm, if_neg hkm.symm, one_mul, if_pos rfl] at hm 
           exact Or.inr (Or.inr ⟨hm, rfl, rfl⟩)
         · simpa only [if_neg hkm, if_neg hkl, mul_one] using hk
-      · rw [if_neg hkm.symm, if_neg hmn, one_mul, mul_one] at hm
+      · rw [if_neg hkm.symm, if_neg hmn, one_mul, mul_one] at hm 
         obtain rfl := (ite_ne_right_iff.mp (ne_of_eq_of_ne hm.symm hu)).1
-        rw [if_neg hkm, if_neg hkm, one_mul, mul_one] at hk
+        rw [if_neg hkm, if_neg hkm, one_mul, mul_one] at hk 
         obtain rfl := (ite_ne_right_iff.mp (ne_of_eq_of_ne hk.symm hu)).1
         exact Or.inr (Or.inl ⟨hk.trans (if_pos rfl), rfl, rfl⟩)
   · rintro (⟨rfl, rfl⟩ | ⟨rfl, rfl, rfl⟩ | ⟨h, rfl, rfl⟩)

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

@@ -36,12 +36,6 @@ variable {f : I → Type v}
 -- The family of types already equipped with instances
 variable (x y : ∀ i, f i) (i j : I)
 
-/- warning: set.preimage_one -> Set.preimage_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : One.{u2} β] (s : Set.{u2} β) [_inst_2 : Decidable (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β _inst_1))) s)], Eq.{succ u1} (Set.{u1} α) (Set.preimage.{u1, u2} α β (OfNat.ofNat.{max u1 u2} (α -> β) 1 (OfNat.mk.{max u1 u2} (α -> β) 1 (One.one.{max u1 u2} (α -> β) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))))) s) (ite.{succ u1} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β _inst_1))) s) _inst_2 (Set.univ.{u1} α) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u1} β] (s : Set.{u1} β) [_inst_2 : Decidable (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_1)) s)], Eq.{succ u2} (Set.{u2} α) (Set.preimage.{u2, u1} α β (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Algebra.Group.Pi._hyg.93 : α) => β) (fun (i : α) => _inst_1)))) s) (ite.{succ u2} (Set.{u2} α) (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_1)) s) _inst_2 (Set.univ.{u2} α) (EmptyCollection.emptyCollection.{u2} (Set.{u2} α) (Set.instEmptyCollectionSet.{u2} α)))
-Case conversion may be inaccurate. Consider using '#align set.preimage_one Set.preimage_oneₓ'. -/
 @[to_additive]
 theorem Set.preimage_one {α β : Type _} [One β] (s : Set β) [Decidable ((1 : β) ∈ s)] :
     (1 : α → β) ⁻¹' s = if (1 : β) ∈ s then Set.univ else ∅ :=
@@ -283,12 +277,6 @@ end Pi
 
 namespace MulHom
 
-/- warning: mul_hom.coe_mul -> MulHom.coe_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {mM : Mul.{u1} M} {mN : CommSemigroup.{u2} N} (f : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (g : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))), Eq.{max (succ u1) (succ u2)} (M -> N) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (M -> N) (M -> N) (M -> N) (instHMul.{max u1 u2} (M -> N) (Pi.instMul.{u1, u2} M (fun (ᾰ : M) => N) (fun (i : M) => Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) f) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) g)) (fun (x : M) => HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) f x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) g x))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} {mM : Mul.{u2} M} {mN : CommSemigroup.{u1} N} (f : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) (g : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (instHMul.{max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (Pi.instMul.{u2, u1} M (fun (ᾰ : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (fun (i : M) => Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) i) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) i) mN)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g)) (fun (x : M) => HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) mN))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g x))
-Case conversion may be inaccurate. Consider using '#align mul_hom.coe_mul MulHom.coe_mulₓ'. -/
 @[to_additive]
 theorem coe_mul {M N} {mM : Mul M} {mN : CommSemigroup N} (f g : M →ₙ* N) :
     (f * g : M → N) = fun x => f x * g x :=
@@ -340,12 +328,6 @@ def Pi.monoidHom {γ : Type w} [∀ i, MulOneClass (f i)] [MulOneClass γ] (g :
 #align pi.add_monoid_hom Pi.addMonoidHom
 -/
 
-/- warning: pi.monoid_hom_injective -> Pi.monoidHom_injective is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (coeFn.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) (fun (_x : MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) => γ -> (f i)) (MonoidHom.hasCoeToFun.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), (fun (i : I) => f i) i) (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ u3) (succ (max u1 u2))} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (fun (_x : MonoidHom.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) => γ -> (forall (i : I), (fun (i : I) => f i) i)) (MonoidHom.hasCoeToFun.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : γ) => f i) _x) (MulHomClass.toFunLike.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MonoidHomClass.toMulHomClass.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) _inst_3 (_inst_2 i) (MonoidHom.monoidHomClass.{u3, u2} γ (f i) _inst_3 (_inst_2 i)))) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), f i) (FunLike.coe.{max (max (succ u1) (succ u2)) (succ u3), succ u3, max (succ u1) (succ u2)} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : γ) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
-Case conversion may be inaccurate. Consider using '#align pi.monoid_hom_injective Pi.monoidHom_injectiveₓ'. -/
 @[to_additive]
 theorem Pi.monoidHom_injective {γ : Type w} [Nonempty I] [∀ i, MulOneClass (f i)] [MulOneClass γ]
     (g : ∀ i, γ →* f i) (hg : ∀ i, Function.Injective (g i)) :
@@ -382,12 +364,6 @@ def Pi.constMulHom (α β : Type _) [Mul β] : β →ₙ* α → β
 #align pi.const_add_hom Pi.constAddHom
 -/
 
-/- warning: mul_hom.coe_fn -> MulHom.coeFn is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) (β : Type.{u2}) [_inst_2 : Mul.{u1} α] [_inst_3 : CommSemigroup.{u2} β], MulHom.{max u2 u1, max u1 u2} (MulHom.{u1, u2} α β _inst_2 (Semigroup.toHasMul.{u2} β (CommSemigroup.toSemigroup.{u2} β _inst_3))) (α -> β) (MulHom.hasMul.{u1, u2} α β _inst_2 _inst_3) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Semigroup.toHasMul.{u2} β (CommSemigroup.toSemigroup.{u2} β _inst_3)))
-but is expected to have type
-  forall (α : Type.{u1}) (β : Type.{u2}) [_inst_2 : Mul.{u1} α] [_inst_3 : CommSemigroup.{u2} β], MulHom.{max u2 u1, max u1 u2} (MulHom.{u1, u2} α β _inst_2 (Semigroup.toMul.{u2} β (CommSemigroup.toSemigroup.{u2} β _inst_3))) (α -> β) (MulHom.instMulMulHomToMulToSemigroup.{u1, u2} α β _inst_2 _inst_3) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Semigroup.toMul.{u2} β (CommSemigroup.toSemigroup.{u2} β _inst_3)))
-Case conversion may be inaccurate. Consider using '#align mul_hom.coe_fn MulHom.coeFnₓ'. -/
 /-- Coercion of a `mul_hom` into a function is itself a `mul_hom`.
 See also `mul_hom.eval`. -/
 @[to_additive
@@ -526,12 +502,6 @@ def MonoidHom.single [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :
 #align add_monoid_hom.single AddMonoidHom.single
 -/
 
-/- warning: monoid_hom.single_apply -> MonoidHom.single_apply is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (coeFn.{max (succ (max u1 u2)) (succ u2), max (succ u2) (succ (max u1 u2))} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (fun (_x : MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) => (f i) -> (forall (i : I), f i)) (MonoidHom.hasCoeToFun.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i x)
-but is expected to have type
-  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : f i) => forall (i : I), f i) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, max (succ u1) (succ u2)} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (fun (_x : f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : f i) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x)
-Case conversion may be inaccurate. Consider using '#align monoid_hom.single_apply MonoidHom.single_applyₓ'. -/
 @[simp, to_additive]
 theorem MonoidHom.single_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
     MonoidHom.single f i x = mulSingle i x :=
@@ -539,12 +509,6 @@ theorem MonoidHom.single_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
 #align monoid_hom.single_apply MonoidHom.single_apply
 #align add_monoid_hom.single_apply AddMonoidHom.single_apply
 
-/- warning: mul_hom.single -> MulHom.single is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (i : I), MulHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i)) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i)))
-but is expected to have type
-  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (i : I), MulHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i)) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toMul.{u2} (f i) (_inst_2 i)))
-Case conversion may be inaccurate. Consider using '#align mul_hom.single MulHom.singleₓ'. -/
 /-- The multiplicative homomorphism including a single `mul_zero_class`
 into a dependent family of `mul_zero_class`es, as functions supported at a point.
 
@@ -558,12 +522,6 @@ def MulHom.single [∀ i, MulZeroClass <| f i] (i : I) : f i →ₙ* ∀ i, f i
 
 variable {f}
 
-/- warning: pi.mul_single_sup -> Pi.mulSingle_sup is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), SemilatticeSup.{u2} (f i)] [_inst_3 : forall (i : I), One.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i (Sup.sup.{u2} (f i) (SemilatticeSup.toHasSup.{u2} (f i) (_inst_2 i)) x y)) (Sup.sup.{max u1 u2} (forall (i : I), f i) (Pi.hasSup.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => SemilatticeSup.toHasSup.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i y))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), SemilatticeSup.{u2} (f i)] [_inst_3 : forall (i : I), One.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i (Sup.sup.{u2} (f i) (SemilatticeSup.toSup.{u2} (f i) (_inst_2 i)) x y)) (Sup.sup.{max u2 u1} (forall (i : I), f i) (Pi.instSupForAll.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => SemilatticeSup.toSup.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i y))
-Case conversion may be inaccurate. Consider using '#align pi.mul_single_sup Pi.mulSingle_supₓ'. -/
 @[to_additive]
 theorem Pi.mulSingle_sup [∀ i, SemilatticeSup (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
     Pi.mulSingle i (x ⊔ y) = Pi.mulSingle i x ⊔ Pi.mulSingle i y :=
@@ -571,12 +529,6 @@ theorem Pi.mulSingle_sup [∀ i, SemilatticeSup (f i)] [∀ i, One (f i)] (i : I
 #align pi.mul_single_sup Pi.mulSingle_sup
 #align pi.single_sup Pi.single_sup
 
-/- warning: pi.mul_single_inf -> Pi.mulSingle_inf is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), SemilatticeInf.{u2} (f i)] [_inst_3 : forall (i : I), One.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i (Inf.inf.{u2} (f i) (SemilatticeInf.toHasInf.{u2} (f i) (_inst_2 i)) x y)) (Inf.inf.{max u1 u2} (forall (i : I), f i) (Pi.hasInf.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => SemilatticeInf.toHasInf.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i y))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), SemilatticeInf.{u2} (f i)] [_inst_3 : forall (i : I), One.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i (Inf.inf.{u2} (f i) (SemilatticeInf.toInf.{u2} (f i) (_inst_2 i)) x y)) (Inf.inf.{max u2 u1} (forall (i : I), f i) (Pi.instInfForAll.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => SemilatticeInf.toInf.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i y))
-Case conversion may be inaccurate. Consider using '#align pi.mul_single_inf Pi.mulSingle_infₓ'. -/
 @[to_additive]
 theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
     Pi.mulSingle i (x ⊓ y) = Pi.mulSingle i x ⊓ Pi.mulSingle i y :=
@@ -584,12 +536,6 @@ theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I
 #align pi.mul_single_inf Pi.mulSingle_inf
 #align pi.single_inf Pi.single_inf
 
-/- warning: pi.mul_single_mul -> Pi.mulSingle_mul is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulOneClass.toHasMul.{u2} (f i) (_inst_2 i))) x y)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulOneClass.toHasMul.{u2} (f i) (_inst_2 i)))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i y))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulOneClass.toMul.{u2} (f i) (_inst_2 i))) x y)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulOneClass.toMul.{u2} (f i) (_inst_2 i)))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i y))
-Case conversion may be inaccurate. Consider using '#align pi.mul_single_mul Pi.mulSingle_mulₓ'. -/
 @[to_additive]
 theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
     mulSingle i (x * y) = mulSingle i x * mulSingle i y :=
@@ -597,12 +543,6 @@ theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
 #align pi.mul_single_mul Pi.mulSingle_mul
 #align pi.single_add Pi.single_add
 
-/- warning: pi.mul_single_inv -> Pi.mulSingle_inv is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), Group.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) i (Inv.inv.{u2} (f i) (DivInvMonoid.toHasInv.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))) x)) (Inv.inv.{max u1 u2} (forall (i : I), f i) (Pi.instInv.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => DivInvMonoid.toHasInv.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i)))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) i x))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), Group.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => InvOneClass.toOne.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i))))) i (Inv.inv.{u2} (f i) (InvOneClass.toInv.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i))))) x)) (Inv.inv.{max u2 u1} (forall (i : I), f i) (Pi.instInv.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => InvOneClass.toInv.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i)))))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => InvOneClass.toOne.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i))))) i x))
-Case conversion may be inaccurate. Consider using '#align pi.mul_single_inv Pi.mulSingle_invₓ'. -/
 @[to_additive]
 theorem Pi.mulSingle_inv [∀ i, Group <| f i] (i : I) (x : f i) :
     mulSingle i x⁻¹ = (mulSingle i x)⁻¹ :=
@@ -610,12 +550,6 @@ theorem Pi.mulSingle_inv [∀ i, Group <| f i] (i : I) (x : f i) :
 #align pi.mul_single_inv Pi.mulSingle_inv
 #align pi.single_neg Pi.single_neg
 
-/- warning: pi.single_div -> Pi.single_div is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), Group.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) i (HDiv.hDiv.{u2, u2, u2} (f i) (f i) (f i) (instHDiv.{u2} (f i) (DivInvMonoid.toHasDiv.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i)))) x y)) (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHDiv.{max u1 u2} (forall (i : I), f i) (Pi.instDiv.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => DivInvMonoid.toHasDiv.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) i y))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), Group.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => InvOneClass.toOne.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i))))) i (HDiv.hDiv.{u2, u2, u2} (f i) (f i) (f i) (instHDiv.{u2} (f i) (DivInvMonoid.toDiv.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i)))) x y)) (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHDiv.{max u1 u2} (forall (i : I), f i) (Pi.instDiv.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => DivInvMonoid.toDiv.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => InvOneClass.toOne.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i))))) i x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => InvOneClass.toOne.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i))))) i y))
-Case conversion may be inaccurate. Consider using '#align pi.single_div Pi.single_divₓ'. -/
 @[to_additive]
 theorem Pi.single_div [∀ i, Group <| f i] (i : I) (x y : f i) :
     mulSingle i (x / y) = mulSingle i x / mulSingle i y :=
@@ -623,67 +557,31 @@ theorem Pi.single_div [∀ i, Group <| f i] (i : I) (x y : f i) :
 #align pi.single_div Pi.single_div
 #align pi.single_sub Pi.single_sub
 
-/- warning: pi.single_mul -> Pi.single_mul is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) x y)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i)))) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i x) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i y))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) x y)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toMul.{u2} (f i) (_inst_2 i)))) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i x) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i y))
-Case conversion may be inaccurate. Consider using '#align pi.single_mul Pi.single_mulₓ'. -/
 theorem Pi.single_mul [∀ i, MulZeroClass <| f i] (i : I) (x y : f i) :
     single i (x * y) = single i x * single i y :=
   (MulHom.single f i).map_mul x y
 #align pi.single_mul Pi.single_mul
 
-/- warning: pi.single_mul_left_apply -> Pi.single_mul_left_apply is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) (j : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{succ u2} (f j) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) a (x i)) j) (HMul.hMul.{u2, u2, u2} (f j) (f j) (f j) (instHMul.{u2} (f j) (MulZeroClass.toHasMul.{u2} (f j) (_inst_2 j))) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i a j) (x j))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) (j : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{succ u2} (f j) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) a (x i)) j) (HMul.hMul.{u2, u2, u2} (f j) (f j) (f j) (instHMul.{u2} (f j) (MulZeroClass.toMul.{u2} (f j) (_inst_2 j))) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i a j) (x j))
-Case conversion may be inaccurate. Consider using '#align pi.single_mul_left_apply Pi.single_mul_left_applyₓ'. -/
 theorem Pi.single_mul_left_apply [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (a * x i) j = Pi.single i a j * x j :=
   (Pi.apply_single (fun i => (· * x i)) (fun i => MulZeroClass.zero_mul _) _ _ _).symm
 #align pi.single_mul_left_apply Pi.single_mul_left_apply
 
-/- warning: pi.single_mul_right_apply -> Pi.single_mul_right_apply is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) (j : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{succ u2} (f j) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) (x i) a) j) (HMul.hMul.{u2, u2, u2} (f j) (f j) (f j) (instHMul.{u2} (f j) (MulZeroClass.toHasMul.{u2} (f j) (_inst_2 j))) (x j) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i a j))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) (j : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{succ u2} (f j) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) (x i) a) j) (HMul.hMul.{u2, u2, u2} (f j) (f j) (f j) (instHMul.{u2} (f j) (MulZeroClass.toMul.{u2} (f j) (_inst_2 j))) (x j) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i a j))
-Case conversion may be inaccurate. Consider using '#align pi.single_mul_right_apply Pi.single_mul_right_applyₓ'. -/
 theorem Pi.single_mul_right_apply [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (x i * a) j = x j * Pi.single i a j :=
   (Pi.apply_single (fun i => (· * ·) (x i)) (fun i => MulZeroClass.mul_zero _) _ _ _).symm
 #align pi.single_mul_right_apply Pi.single_mul_right_apply
 
-/- warning: pi.single_mul_left -> Pi.single_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) a (x i))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i)))) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i a) x)
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) a (x i))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toMul.{u2} (f i) (_inst_2 i)))) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i a) x)
-Case conversion may be inaccurate. Consider using '#align pi.single_mul_left Pi.single_mul_leftₓ'. -/
 theorem Pi.single_mul_left [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (a * x i) = Pi.single i a * x :=
   funext fun j => Pi.single_mul_left_apply _ _ _ _
 #align pi.single_mul_left Pi.single_mul_left
 
-/- warning: pi.single_mul_right -> Pi.single_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) (x i) a)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i)))) x (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i a))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) (x i) a)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toMul.{u2} (f i) (_inst_2 i)))) x (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i a))
-Case conversion may be inaccurate. Consider using '#align pi.single_mul_right Pi.single_mul_rightₓ'. -/
 theorem Pi.single_mul_right [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (x i * a) = x * Pi.single i a :=
   funext fun j => Pi.single_mul_right_apply _ _ _ _
 #align pi.single_mul_right Pi.single_mul_right
 
-/- warning: pi.mul_single_commute -> Pi.mulSingle_commute is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)], Pairwise.{u1} I (fun (i : I) (j : I) => forall (x : f i) (y : f j), Commute.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulOneClass.toHasMul.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) j y))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)], Pairwise.{u1} I (fun (i : I) (j : I) => forall (x : f i) (y : f j), Commute.{max u2 u1} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulOneClass.toMul.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) j y))
-Case conversion may be inaccurate. Consider using '#align pi.mul_single_commute Pi.mulSingle_commuteₓ'. -/
 /-- The injection into a pi group at different indices commutes.
 
 For injections of commuting elements at the same index, see `commute.map` -/
@@ -699,12 +597,6 @@ theorem Pi.mulSingle_commute [∀ i, MulOneClass <| f i] :
 #align pi.mul_single_commute Pi.mulSingle_commute
 #align pi.single_commute Pi.single_commute
 
-/- warning: pi.mul_single_apply_commute -> Pi.mulSingle_apply_commute is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (x : forall (i : I), f i) (i : I) (j : I), Commute.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulOneClass.toHasMul.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i (x i)) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) j (x j))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (x : forall (i : I), f i) (i : I) (j : I), Commute.{max u2 u1} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulOneClass.toMul.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i (x i)) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) j (x j))
-Case conversion may be inaccurate. Consider using '#align pi.mul_single_apply_commute Pi.mulSingle_apply_commuteₓ'. -/
 /-- The injection into a pi group with the same values commutes. -/
 @[to_additive "The injection into an additive pi group with the same values commutes."]
 theorem Pi.mulSingle_apply_commute [∀ i, MulOneClass <| f i] (x : ∀ i, f i) (i j : I) :
@@ -716,12 +608,6 @@ theorem Pi.mulSingle_apply_commute [∀ i, MulOneClass <| f i] (x : ∀ i, f i)
 #align pi.mul_single_apply_commute Pi.mulSingle_apply_commute
 #align pi.single_apply_commute Pi.single_apply_commute
 
-/- warning: pi.update_eq_div_mul_single -> Pi.update_eq_div_mul_mulSingle is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), Group.{u2} (f i)] (g : forall (i : I), f i) (x : f i), Eq.{max (succ u1) (succ u2)} (forall (a : I), f a) (Function.update.{succ u1, succ u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) g i x) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (a : I), f a) (forall (a : I), f a) (forall (a : I), f a) (instHMul.{max u1 u2} (forall (a : I), f a) (Pi.instMul.{u1, u2} I (fun (a : I) => f a) (fun (i : I) => MulOneClass.toHasMul.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))))) (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (forall (a : I), f a) (forall (a : I), f a) (forall (a : I), f a) (instHDiv.{max u1 u2} (forall (a : I), f a) (Pi.instDiv.{u1, u2} I (fun (a : I) => f a) (fun (i : I) => DivInvMonoid.toHasDiv.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) g (Pi.mulSingle.{u1, u2} I (fun (a : I) => f a) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) i (g i))) (Pi.mulSingle.{u1, u2} I (fun (a : I) => f a) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) i x))
-but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), Group.{u2} (f i)] (g : forall (i : I), f i) (x : f i), Eq.{max (succ u1) (succ u2)} (forall (a : I), f a) (Function.update.{succ u1, succ u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) g i x) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (a : I), f a) (forall (a : I), f a) (forall (a : I), f a) (instHMul.{max u1 u2} (forall (a : I), f a) (Pi.instMul.{u1, u2} I (fun (a : I) => f a) (fun (i : I) => MulOneClass.toMul.{u2} (f i) (Monoid.toMulOneClass.{u2} (f i) (DivInvMonoid.toMonoid.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))))) (HDiv.hDiv.{max u1 u2, max u1 u2, max u1 u2} (forall (a : I), f a) (forall (a : I), f a) (forall (a : I), f a) (instHDiv.{max u1 u2} (forall (a : I), f a) (Pi.instDiv.{u1, u2} I (fun (a : I) => f a) (fun (i : I) => DivInvMonoid.toDiv.{u2} (f i) (Group.toDivInvMonoid.{u2} (f i) (_inst_2 i))))) g (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => InvOneClass.toOne.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i))))) i (g i))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => InvOneClass.toOne.{u2} (f i) (DivInvOneMonoid.toInvOneClass.{u2} (f i) (DivisionMonoid.toDivInvOneMonoid.{u2} (f i) (Group.toDivisionMonoid.{u2} (f i) (_inst_2 i))))) i x))
-Case conversion may be inaccurate. Consider using '#align pi.update_eq_div_mul_single Pi.update_eq_div_mul_mulSingleₓ'. -/
 @[to_additive update_eq_sub_add_single]
 theorem Pi.update_eq_div_mul_mulSingle [∀ i, Group <| f i] (g : ∀ i : I, f i) (x : f i) :
     Function.update g i x = g / mulSingle i (g i) * mulSingle i x :=
@@ -732,12 +618,6 @@ theorem Pi.update_eq_div_mul_mulSingle [∀ i, Group <| f i] (g : ∀ i : I, f i
   · simp [Function.update_noteq h.symm, h]
 #align pi.update_eq_div_mul_single Pi.update_eq_div_mul_mulSingle
 
-/- warning: pi.mul_single_mul_mul_single_eq_mul_single_mul_mul_single -> Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {M : Type.{u2}} [_inst_2 : CommMonoid.{u2} M] {k : I} {l : I} {m : I} {n : I} {u : M} {v : M}, (Ne.{succ u2} M u (OfNat.ofNat.{u2} M 1 (OfNat.mk.{u2} M 1 (One.one.{u2} M (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))))))) -> (Ne.{succ u2} M v (OfNat.ofNat.{u2} M 1 (OfNat.mk.{u2} M 1 (One.one.{u2} M (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))))))) -> (Iff (Eq.{succ (max u1 u2)} (I -> M) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (I -> M) (I -> M) (I -> M) (instHMul.{max u1 u2} (I -> M) (Pi.instMul.{u1, u2} I (fun (i : I) => M) (fun (i : I) => MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))))) (Pi.mulSingle.{u1, u2} I (fun {k : I} => M) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))) k u) (Pi.mulSingle.{u1, u2} I (fun (i : I) => M) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))) l v)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (I -> M) (I -> M) (I -> M) (instHMul.{max u1 u2} (I -> M) (Pi.instMul.{u1, u2} I (fun (i : I) => M) (fun (i : I) => MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => M) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))) m u) (Pi.mulSingle.{u1, u2} I (fun (i : I) => M) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))) n v))) (Or (And (Eq.{succ u1} I k m) (Eq.{succ u1} I l n)) (Or (And (Eq.{succ u2} M u v) (And (Eq.{succ u1} I k n) (Eq.{succ u1} I l m))) (And (Eq.{succ u2} M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2)))) u v) (OfNat.ofNat.{u2} M 1 (OfNat.mk.{u2} M 1 (One.one.{u2} M (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))))))) (And (Eq.{succ u1} I k l) (Eq.{succ u1} I m n))))))
-but is expected to have type
-  forall {I : Type.{u2}} [_inst_1 : DecidableEq.{succ u2} I] {M : Type.{u1}} [_inst_2 : CommMonoid.{u1} M] {k : I} {l : I} {m : I} {n : I} {u : M} {v : M}, (Ne.{succ u1} M u (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))))) -> (Ne.{succ u1} M v (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))))) -> (Iff (Eq.{succ (max u2 u1)} (I -> M) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (I -> M) (I -> M) (I -> M) (instHMul.{max u2 u1} (I -> M) (Pi.instMul.{u2, u1} I (fun (i : I) => M) (fun (i : I) => MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))))) (Pi.mulSingle.{u2, u1} I (fun (k : I) => M) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) k u) (Pi.mulSingle.{u2, u1} I (fun (i : I) => M) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) l v)) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (I -> M) (I -> M) (I -> M) (instHMul.{max u2 u1} (I -> M) (Pi.instMul.{u2, u1} I (fun (i : I) => M) (fun (i : I) => MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))))) (Pi.mulSingle.{u2, u1} I (fun (i : I) => M) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) m u) (Pi.mulSingle.{u2, u1} I (fun (i : I) => M) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) n v))) (Or (And (Eq.{succ u2} I k m) (Eq.{succ u2} I l n)) (Or (And (Eq.{succ u1} M u v) (And (Eq.{succ u2} I k n) (Eq.{succ u2} I l m))) (And (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)))) u v) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))))) (And (Eq.{succ u2} I k l) (Eq.{succ u2} I m n))))))
-Case conversion may be inaccurate. Consider using '#align pi.mul_single_mul_mul_single_eq_mul_single_mul_mul_single Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingleₓ'. -/
 @[to_additive Pi.single_add_single_eq_single_add_single]
 theorem Pi.mulSingle_mul_mulSingle_eq_mulSingle_mul_mulSingle {M : Type _} [CommMonoid M]
     {k l m n : I} {u v : M} (hu : u ≠ 1) (hv : v ≠ 1) :
@@ -813,24 +693,12 @@ theorem update_div [∀ i, Div (f i)] [DecidableEq I] (f₁ f₂ : ∀ i, f i) (
 
 variable [One α] [Nonempty ι] {a : α}
 
-/- warning: function.const_eq_one -> Function.const_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : One.{u2} α] [_inst_2 : Nonempty.{succ u1} ι] {a : α}, Iff (Eq.{max (succ u1) (succ u2)} (ι -> α) (Function.const.{succ u2, succ u1} α ι a) (OfNat.ofNat.{max u1 u2} (ι -> α) 1 (OfNat.mk.{max u1 u2} (ι -> α) 1 (One.one.{max u1 u2} (ι -> α) (Pi.instOne.{u1, u2} ι (fun (ᾰ : ι) => α) (fun (i : ι) => _inst_1)))))) (Eq.{succ u2} α a (OfNat.ofNat.{u2} α 1 (OfNat.mk.{u2} α 1 (One.one.{u2} α _inst_1))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : Nonempty.{succ u2} ι] {a : α}, Iff (Eq.{max (succ u2) (succ u1)} (ι -> α) (Function.const.{succ u1, succ u2} α ι a) (OfNat.ofNat.{max u2 u1} (ι -> α) 1 (One.toOfNat1.{max u2 u1} (ι -> α) (Pi.instOne.{u2, u1} ι (fun (a._@.Init.Prelude._hyg.54 : ι) => α) (fun (i : ι) => _inst_1))))) (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align function.const_eq_one Function.const_eq_oneₓ'. -/
 @[simp, to_additive]
 theorem const_eq_one : const ι a = 1 ↔ a = 1 :=
   @const_inj _ _ _ _ 1
 #align function.const_eq_one Function.const_eq_one
 #align function.const_eq_zero Function.const_eq_zero
 
-/- warning: function.const_ne_one -> Function.const_ne_one is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : One.{u2} α] [_inst_2 : Nonempty.{succ u1} ι] {a : α}, Iff (Ne.{max (succ u1) (succ u2)} (ι -> α) (Function.const.{succ u2, succ u1} α ι a) (OfNat.ofNat.{max u1 u2} (ι -> α) 1 (OfNat.mk.{max u1 u2} (ι -> α) 1 (One.one.{max u1 u2} (ι -> α) (Pi.instOne.{u1, u2} ι (fun (ᾰ : ι) => α) (fun (i : ι) => _inst_1)))))) (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 1 (OfNat.mk.{u2} α 1 (One.one.{u2} α _inst_1))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : Nonempty.{succ u2} ι] {a : α}, Iff (Ne.{max (succ u2) (succ u1)} (ι -> α) (Function.const.{succ u1, succ u2} α ι a) (OfNat.ofNat.{max u2 u1} (ι -> α) 1 (One.toOfNat1.{max u2 u1} (ι -> α) (Pi.instOne.{u2, u1} ι (fun (a._@.Init.Prelude._hyg.54 : ι) => α) (fun (i : ι) => _inst_1))))) (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align function.const_ne_one Function.const_ne_oneₓ'. -/
 @[to_additive]
 theorem const_ne_one : const ι a ≠ 1 ↔ a ≠ 1 :=
   const_eq_one.Not

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

@@ -693,12 +693,8 @@ theorem Pi.mulSingle_commute [∀ i, MulOneClass <| f i] :
     Pairwise fun i j => ∀ (x : f i) (y : f j), Commute (mulSingle i x) (mulSingle j y) :=
   by
   intro i j hij x y; ext k
-  by_cases h1 : i = k;
-  · subst h1
-    simp [hij]
-  by_cases h2 : j = k;
-  · subst h2
-    simp [hij]
+  by_cases h1 : i = k; · subst h1; simp [hij]
+  by_cases h2 : j = k; · subst h2; simp [hij]
   simp [h1, h2]
 #align pi.mul_single_commute Pi.mulSingle_commute
 #align pi.single_commute Pi.single_commute

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

@@ -287,7 +287,7 @@ namespace MulHom
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} {mM : Mul.{u1} M} {mN : CommSemigroup.{u2} N} (f : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (g : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))), Eq.{max (succ u1) (succ u2)} (M -> N) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (M -> N) (M -> N) (M -> N) (instHMul.{max u1 u2} (M -> N) (Pi.instMul.{u1, u2} M (fun (ᾰ : M) => N) (fun (i : M) => Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) f) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) g)) (fun (x : M) => HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) f x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) g x))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} {mM : Mul.{u2} M} {mN : CommSemigroup.{u1} N} (f : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) (g : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (instHMul.{max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (Pi.instMul.{u2, u1} M (fun (ᾰ : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (fun (i : M) => Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) i) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) i) mN)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g)) (fun (x : M) => HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) mN))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g x))
+  forall {M : Type.{u2}} {N : Type.{u1}} {mM : Mul.{u2} M} {mN : CommSemigroup.{u1} N} (f : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) (g : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (instHMul.{max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (Pi.instMul.{u2, u1} M (fun (ᾰ : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) ᾰ) (fun (i : M) => Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) i) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) i) mN)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g)) (fun (x : M) => HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) x) mN))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g x))
 Case conversion may be inaccurate. Consider using '#align mul_hom.coe_mul MulHom.coe_mulₓ'. -/
 @[to_additive]
 theorem coe_mul {M N} {mM : Mul M} {mN : CommSemigroup N} (f g : M →ₙ* N) :
@@ -344,7 +344,7 @@ def Pi.monoidHom {γ : Type w} [∀ i, MulOneClass (f i)] [MulOneClass γ] (g :
 lean 3 declaration is
   forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (coeFn.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) (fun (_x : MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) => γ -> (f i)) (MonoidHom.hasCoeToFun.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), (fun (i : I) => f i) i) (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ u3) (succ (max u1 u2))} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (fun (_x : MonoidHom.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) => γ -> (forall (i : I), (fun (i : I) => f i) i)) (MonoidHom.hasCoeToFun.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
 but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : γ) => f i) _x) (MulHomClass.toFunLike.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MonoidHomClass.toMulHomClass.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) _inst_3 (_inst_2 i) (MonoidHom.monoidHomClass.{u3, u2} γ (f i) _inst_3 (_inst_2 i)))) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), f i) (FunLike.coe.{max (max (succ u1) (succ u2)) (succ u3), succ u3, max (succ u1) (succ u2)} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : γ) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : γ) => f i) _x) (MulHomClass.toFunLike.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MonoidHomClass.toMulHomClass.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) _inst_3 (_inst_2 i) (MonoidHom.monoidHomClass.{u3, u2} γ (f i) _inst_3 (_inst_2 i)))) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), f i) (FunLike.coe.{max (max (succ u1) (succ u2)) (succ u3), succ u3, max (succ u1) (succ u2)} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : γ) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
 Case conversion may be inaccurate. Consider using '#align pi.monoid_hom_injective Pi.monoidHom_injectiveₓ'. -/
 @[to_additive]
 theorem Pi.monoidHom_injective {γ : Type w} [Nonempty I] [∀ i, MulOneClass (f i)] [MulOneClass γ]
@@ -530,7 +530,7 @@ def MonoidHom.single [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :
 lean 3 declaration is
   forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (coeFn.{max (succ (max u1 u2)) (succ u2), max (succ u2) (succ (max u1 u2))} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (fun (_x : MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) => (f i) -> (forall (i : I), f i)) (MonoidHom.hasCoeToFun.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i x)
 but is expected to have type
-  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : f i) => forall (i : I), f i) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, max (succ u1) (succ u2)} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (fun (_x : f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : f i) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x)
+  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : f i) => forall (i : I), f i) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, max (succ u1) (succ u2)} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (fun (_x : f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : f i) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x)
 Case conversion may be inaccurate. Consider using '#align monoid_hom.single_apply MonoidHom.single_applyₓ'. -/
 @[simp, to_additive]
 theorem MonoidHom.single_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :

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

@@ -558,6 +558,12 @@ def MulHom.single [∀ i, MulZeroClass <| f i] (i : I) : f i →ₙ* ∀ i, f i
 
 variable {f}
 
+/- warning: pi.mul_single_sup -> Pi.mulSingle_sup is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), SemilatticeSup.{u2} (f i)] [_inst_3 : forall (i : I), One.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i (Sup.sup.{u2} (f i) (SemilatticeSup.toHasSup.{u2} (f i) (_inst_2 i)) x y)) (Sup.sup.{max u1 u2} (forall (i : I), f i) (Pi.hasSup.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => SemilatticeSup.toHasSup.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i y))
+but is expected to have type
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), SemilatticeSup.{u2} (f i)] [_inst_3 : forall (i : I), One.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i (Sup.sup.{u2} (f i) (SemilatticeSup.toSup.{u2} (f i) (_inst_2 i)) x y)) (Sup.sup.{max u2 u1} (forall (i : I), f i) (Pi.instSupForAll.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => SemilatticeSup.toSup.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i y))
+Case conversion may be inaccurate. Consider using '#align pi.mul_single_sup Pi.mulSingle_supₓ'. -/
 @[to_additive]
 theorem Pi.mulSingle_sup [∀ i, SemilatticeSup (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
     Pi.mulSingle i (x ⊔ y) = Pi.mulSingle i x ⊔ Pi.mulSingle i y :=
@@ -565,6 +571,12 @@ theorem Pi.mulSingle_sup [∀ i, SemilatticeSup (f i)] [∀ i, One (f i)] (i : I
 #align pi.mul_single_sup Pi.mulSingle_sup
 #align pi.single_sup Pi.single_sup
 
+/- warning: pi.mul_single_inf -> Pi.mulSingle_inf is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), SemilatticeInf.{u2} (f i)] [_inst_3 : forall (i : I), One.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i (Inf.inf.{u2} (f i) (SemilatticeInf.toHasInf.{u2} (f i) (_inst_2 i)) x y)) (Inf.inf.{max u1 u2} (forall (i : I), f i) (Pi.hasInf.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => SemilatticeInf.toHasInf.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i y))
+but is expected to have type
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), SemilatticeInf.{u2} (f i)] [_inst_3 : forall (i : I), One.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i (Inf.inf.{u2} (f i) (SemilatticeInf.toInf.{u2} (f i) (_inst_2 i)) x y)) (Inf.inf.{max u2 u1} (forall (i : I), f i) (Pi.instInfForAll.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => SemilatticeInf.toInf.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_3 i) i y))
+Case conversion may be inaccurate. Consider using '#align pi.mul_single_inf Pi.mulSingle_infₓ'. -/
 @[to_additive]
 theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
     Pi.mulSingle i (x ⊓ y) = Pi.mulSingle i x ⊓ Pi.mulSingle i y :=

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
 
 ! This file was ported from Lean 3 source module algebra.group.pi
-! leanprover-community/mathlib commit 90df25ded755a2cf9651ea850d1abe429b1e4eb1
+! leanprover-community/mathlib commit e4bc74cbaf429d706cb9140902f7ca6c431e75a4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -558,6 +558,20 @@ def MulHom.single [∀ i, MulZeroClass <| f i] (i : I) : f i →ₙ* ∀ i, f i
 
 variable {f}
 
+@[to_additive]
+theorem Pi.mulSingle_sup [∀ i, SemilatticeSup (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
+    Pi.mulSingle i (x ⊔ y) = Pi.mulSingle i x ⊔ Pi.mulSingle i y :=
+  Function.update_sup _ _ _ _
+#align pi.mul_single_sup Pi.mulSingle_sup
+#align pi.single_sup Pi.single_sup
+
+@[to_additive]
+theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I) (x y : f i) :
+    Pi.mulSingle i (x ⊓ y) = Pi.mulSingle i x ⊓ Pi.mulSingle i y :=
+  Function.update_inf _ _ _ _
+#align pi.mul_single_inf Pi.mulSingle_inf
+#align pi.single_inf Pi.single_inf
+
 /- warning: pi.mul_single_mul -> Pi.mulSingle_mul is a dubious translation:
 lean 3 declaration is
   forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i) (y : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulOneClass.toHasMul.{u2} (f i) (_inst_2 i))) x y)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulOneClass.toHasMul.{u2} (f i) (_inst_2 i)))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i y))

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

@@ -40,7 +40,7 @@ variable (x y : ∀ i, f i) (i j : I)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : One.{u2} β] (s : Set.{u2} β) [_inst_2 : Decidable (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β _inst_1))) s)], Eq.{succ u1} (Set.{u1} α) (Set.preimage.{u1, u2} α β (OfNat.ofNat.{max u1 u2} (α -> β) 1 (OfNat.mk.{max u1 u2} (α -> β) 1 (One.one.{max u1 u2} (α -> β) (Pi.instOne.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_1))))) s) (ite.{succ u1} (Set.{u1} α) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (OfNat.ofNat.{u2} β 1 (OfNat.mk.{u2} β 1 (One.one.{u2} β _inst_1))) s) _inst_2 (Set.univ.{u1} α) (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u1} β] (s : Set.{u1} β) [_inst_2 : Decidable (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_1)) s)], Eq.{succ u2} (Set.{u2} α) (Set.preimage.{u2, u1} α β (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Algebra.Group.Pi._hyg.90 : α) => β) (fun (i : α) => _inst_1)))) s) (ite.{succ u2} (Set.{u2} α) (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_1)) s) _inst_2 (Set.univ.{u2} α) (EmptyCollection.emptyCollection.{u2} (Set.{u2} α) (Set.instEmptyCollectionSet.{u2} α)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u1} β] (s : Set.{u1} β) [_inst_2 : Decidable (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_1)) s)], Eq.{succ u2} (Set.{u2} α) (Set.preimage.{u2, u1} α β (OfNat.ofNat.{max u2 u1} (α -> β) 1 (One.toOfNat1.{max u2 u1} (α -> β) (Pi.instOne.{u2, u1} α (fun (a._@.Mathlib.Algebra.Group.Pi._hyg.93 : α) => β) (fun (i : α) => _inst_1)))) s) (ite.{succ u2} (Set.{u2} α) (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (OfNat.ofNat.{u1} β 1 (One.toOfNat1.{u1} β _inst_1)) s) _inst_2 (Set.univ.{u2} α) (EmptyCollection.emptyCollection.{u2} (Set.{u2} α) (Set.instEmptyCollectionSet.{u2} α)))
 Case conversion may be inaccurate. Consider using '#align set.preimage_one Set.preimage_oneₓ'. -/
 @[to_additive]
 theorem Set.preimage_one {α β : Type _} [One β] (s : Set β) [Decidable ((1 : β) ∈ s)] :
@@ -608,21 +608,45 @@ theorem Pi.single_mul [∀ i, MulZeroClass <| f i] (i : I) (x y : f i) :
   (MulHom.single f i).map_mul x y
 #align pi.single_mul Pi.single_mul
 
+/- warning: pi.single_mul_left_apply -> Pi.single_mul_left_apply is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) (j : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{succ u2} (f j) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) a (x i)) j) (HMul.hMul.{u2, u2, u2} (f j) (f j) (f j) (instHMul.{u2} (f j) (MulZeroClass.toHasMul.{u2} (f j) (_inst_2 j))) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i a j) (x j))
+but is expected to have type
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) (j : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{succ u2} (f j) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) a (x i)) j) (HMul.hMul.{u2, u2, u2} (f j) (f j) (f j) (instHMul.{u2} (f j) (MulZeroClass.toMul.{u2} (f j) (_inst_2 j))) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i a j) (x j))
+Case conversion may be inaccurate. Consider using '#align pi.single_mul_left_apply Pi.single_mul_left_applyₓ'. -/
 theorem Pi.single_mul_left_apply [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (a * x i) j = Pi.single i a j * x j :=
   (Pi.apply_single (fun i => (· * x i)) (fun i => MulZeroClass.zero_mul _) _ _ _).symm
 #align pi.single_mul_left_apply Pi.single_mul_left_apply
 
+/- warning: pi.single_mul_right_apply -> Pi.single_mul_right_apply is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) (j : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{succ u2} (f j) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) (x i) a) j) (HMul.hMul.{u2, u2, u2} (f j) (f j) (f j) (instHMul.{u2} (f j) (MulZeroClass.toHasMul.{u2} (f j) (_inst_2 j))) (x j) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i a j))
+but is expected to have type
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) (j : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{succ u2} (f j) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) (x i) a) j) (HMul.hMul.{u2, u2, u2} (f j) (f j) (f j) (instHMul.{u2} (f j) (MulZeroClass.toMul.{u2} (f j) (_inst_2 j))) (x j) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i a j))
+Case conversion may be inaccurate. Consider using '#align pi.single_mul_right_apply Pi.single_mul_right_applyₓ'. -/
 theorem Pi.single_mul_right_apply [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (x i * a) j = x j * Pi.single i a j :=
   (Pi.apply_single (fun i => (· * ·) (x i)) (fun i => MulZeroClass.mul_zero _) _ _ _).symm
 #align pi.single_mul_right_apply Pi.single_mul_right_apply
 
+/- warning: pi.single_mul_left -> Pi.single_mul_left is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) a (x i))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i)))) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i a) x)
+but is expected to have type
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) a (x i))) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toMul.{u2} (f i) (_inst_2 i)))) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i a) x)
+Case conversion may be inaccurate. Consider using '#align pi.single_mul_left Pi.single_mul_leftₓ'. -/
 theorem Pi.single_mul_left [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (a * x i) = Pi.single i a * x :=
   funext fun j => Pi.single_mul_left_apply _ _ _ _
 #align pi.single_mul_left Pi.single_mul_left
 
+/- warning: pi.single_mul_right -> Pi.single_mul_right is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i))) (x i) a)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toHasMul.{u2} (f i) (_inst_2 i)))) x (Pi.single.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toHasZero.{u2} (f i) (_inst_2 i)) i a))
+but is expected to have type
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} (x : forall (i : I), f i) (i : I) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulZeroClass.{u2} (f i)] (a : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i (HMul.hMul.{u2, u2, u2} (f i) (f i) (f i) (instHMul.{u2} (f i) (MulZeroClass.toMul.{u2} (f i) (_inst_2 i))) (x i) a)) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (forall (i : I), f i) (forall (i : I), f i) (forall (i : I), f i) (instHMul.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulZeroClass.toMul.{u2} (f i) (_inst_2 i)))) x (Pi.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroClass.toZero.{u2} (f i) (_inst_2 i)) i a))
+Case conversion may be inaccurate. Consider using '#align pi.single_mul_right Pi.single_mul_rightₓ'. -/
 theorem Pi.single_mul_right [∀ i, MulZeroClass <| f i] (a : f i) :
     Pi.single i (x i * a) = x * Pi.single i a :=
   funext fun j => Pi.single_mul_right_apply _ _ _ _
@@ -848,17 +872,21 @@ namespace Pi
 
 variable [DecidableEq I] [∀ i, Preorder (f i)] [∀ i, One (f i)]
 
+#print Pi.mulSingle_mono /-
 @[to_additive]
 theorem mulSingle_mono : Monotone (Pi.mulSingle i : f i → ∀ i, f i) :=
   Function.update_mono
 #align pi.mul_single_mono Pi.mulSingle_mono
 #align pi.single_mono Pi.single_mono
+-/
 
+#print Pi.mulSingle_strictMono /-
 @[to_additive]
 theorem mulSingle_strictMono : StrictMono (Pi.mulSingle i : f i → ∀ i, f i) :=
   Function.update_strictMono
 #align pi.mul_single_strict_mono Pi.mulSingle_strictMono
 #align pi.single_strict_mono Pi.single_strictMono
+-/
 
 end Pi
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/52932b3a083d4142e78a15dc928084a22fea9ba0

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
 
 ! This file was ported from Lean 3 source module algebra.group.pi
-! leanprover-community/mathlib commit 246f6f7989ff86bd07e1b014846f11304f33cf9e
+! leanprover-community/mathlib commit 90df25ded755a2cf9651ea850d1abe429b1e4eb1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -844,3 +844,21 @@ noncomputable def Function.ExtendByOne.hom [MulOneClass R] : (ι → R) →* η
 
 end Extend
 
+namespace Pi
+
+variable [DecidableEq I] [∀ i, Preorder (f i)] [∀ i, One (f i)]
+
+@[to_additive]
+theorem mulSingle_mono : Monotone (Pi.mulSingle i : f i → ∀ i, f i) :=
+  Function.update_mono
+#align pi.mul_single_mono Pi.mulSingle_mono
+#align pi.single_mono Pi.single_mono
+
+@[to_additive]
+theorem mulSingle_strictMono : StrictMono (Pi.mulSingle i : f i → ∀ i, f i) :=
+  Function.update_strictMono
+#align pi.mul_single_strict_mono Pi.mulSingle_strictMono
+#align pi.single_strict_mono Pi.single_strictMono
+
+end Pi
+

mathlib commit https://github.com/leanprover-community/mathlib/commit/246f6f7989ff86bd07e1b014846f11304f33cf9e

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
 
 ! This file was ported from Lean 3 source module algebra.group.pi
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
+! leanprover-community/mathlib commit 246f6f7989ff86bd07e1b014846f11304f33cf9e
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -34,7 +34,7 @@ variable {I : Type u}
 variable {f : I → Type v}
 
 -- The family of types already equipped with instances
-variable (x y : ∀ i, f i) (i : I)
+variable (x y : ∀ i, f i) (i j : I)
 
 /- warning: set.preimage_one -> Set.preimage_one is a dubious translation:
 lean 3 declaration is
@@ -608,6 +608,26 @@ theorem Pi.single_mul [∀ i, MulZeroClass <| f i] (i : I) (x y : f i) :
   (MulHom.single f i).map_mul x y
 #align pi.single_mul Pi.single_mul
 
+theorem Pi.single_mul_left_apply [∀ i, MulZeroClass <| f i] (a : f i) :
+    Pi.single i (a * x i) j = Pi.single i a j * x j :=
+  (Pi.apply_single (fun i => (· * x i)) (fun i => MulZeroClass.zero_mul _) _ _ _).symm
+#align pi.single_mul_left_apply Pi.single_mul_left_apply
+
+theorem Pi.single_mul_right_apply [∀ i, MulZeroClass <| f i] (a : f i) :
+    Pi.single i (x i * a) j = x j * Pi.single i a j :=
+  (Pi.apply_single (fun i => (· * ·) (x i)) (fun i => MulZeroClass.mul_zero _) _ _ _).symm
+#align pi.single_mul_right_apply Pi.single_mul_right_apply
+
+theorem Pi.single_mul_left [∀ i, MulZeroClass <| f i] (a : f i) :
+    Pi.single i (a * x i) = Pi.single i a * x :=
+  funext fun j => Pi.single_mul_left_apply _ _ _ _
+#align pi.single_mul_left Pi.single_mul_left
+
+theorem Pi.single_mul_right [∀ i, MulZeroClass <| f i] (a : f i) :
+    Pi.single i (x i * a) = x * Pi.single i a :=
+  funext fun j => Pi.single_mul_right_apply _ _ _ _
+#align pi.single_mul_right Pi.single_mul_right
+
 /- warning: pi.mul_single_commute -> Pi.mulSingle_commute is a dubious translation:
 lean 3 declaration is
   forall {I : Type.{u1}} {f : I -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)], Pairwise.{u1} I (fun (i : I) (j : I) => forall (x : f i) (y : f j), Commute.{max u1 u2} (forall (i : I), f i) (Pi.instMul.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => MulOneClass.toHasMul.{u2} (f i) (_inst_2 i))) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) j y))

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

@@ -287,7 +287,7 @@ namespace MulHom
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} {mM : Mul.{u1} M} {mN : CommSemigroup.{u2} N} (f : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (g : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))), Eq.{max (succ u1) (succ u2)} (M -> N) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (M -> N) (M -> N) (M -> N) (instHMul.{max u1 u2} (M -> N) (Pi.instMul.{u1, u2} M (fun (ᾰ : M) => N) (fun (i : M) => Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) f) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) g)) (fun (x : M) => HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) f x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) g x))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} {mM : Mul.{u2} M} {mN : CommSemigroup.{u1} N} (f : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) (g : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (instHMul.{max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (Pi.instMul.{u2, u1} M (fun (ᾰ : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (fun (i : M) => Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) i) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) i) mN)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g)) (fun (x : M) => HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) mN))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g x))
+  forall {M : Type.{u2}} {N : Type.{u1}} {mM : Mul.{u2} M} {mN : CommSemigroup.{u1} N} (f : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) (g : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (instHMul.{max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (Pi.instMul.{u2, u1} M (fun (ᾰ : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) ᾰ) (fun (i : M) => Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) i) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) i) mN)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g)) (fun (x : M) => HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) x) mN))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g x))
 Case conversion may be inaccurate. Consider using '#align mul_hom.coe_mul MulHom.coe_mulₓ'. -/
 @[to_additive]
 theorem coe_mul {M N} {mM : Mul M} {mN : CommSemigroup N} (f g : M →ₙ* N) :
@@ -344,7 +344,7 @@ def Pi.monoidHom {γ : Type w} [∀ i, MulOneClass (f i)] [MulOneClass γ] (g :
 lean 3 declaration is
   forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (coeFn.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) (fun (_x : MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) => γ -> (f i)) (MonoidHom.hasCoeToFun.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), (fun (i : I) => f i) i) (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ u3) (succ (max u1 u2))} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (fun (_x : MonoidHom.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) => γ -> (forall (i : I), (fun (i : I) => f i) i)) (MonoidHom.hasCoeToFun.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
 but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : γ) => f i) _x) (MulHomClass.toFunLike.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MonoidHomClass.toMulHomClass.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) _inst_3 (_inst_2 i) (MonoidHom.monoidHomClass.{u3, u2} γ (f i) _inst_3 (_inst_2 i)))) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), f i) (FunLike.coe.{max (max (succ u1) (succ u2)) (succ u3), succ u3, max (succ u1) (succ u2)} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : γ) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : γ) => f i) _x) (MulHomClass.toFunLike.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MonoidHomClass.toMulHomClass.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) _inst_3 (_inst_2 i) (MonoidHom.monoidHomClass.{u3, u2} γ (f i) _inst_3 (_inst_2 i)))) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), f i) (FunLike.coe.{max (max (succ u1) (succ u2)) (succ u3), succ u3, max (succ u1) (succ u2)} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : γ) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
 Case conversion may be inaccurate. Consider using '#align pi.monoid_hom_injective Pi.monoidHom_injectiveₓ'. -/
 @[to_additive]
 theorem Pi.monoidHom_injective {γ : Type w} [Nonempty I] [∀ i, MulOneClass (f i)] [MulOneClass γ]
@@ -530,7 +530,7 @@ def MonoidHom.single [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :
 lean 3 declaration is
   forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (coeFn.{max (succ (max u1 u2)) (succ u2), max (succ u2) (succ (max u1 u2))} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (fun (_x : MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) => (f i) -> (forall (i : I), f i)) (MonoidHom.hasCoeToFun.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i x)
 but is expected to have type
-  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : f i) => forall (i : I), f i) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, max (succ u1) (succ u2)} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (fun (_x : f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : f i) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x)
+  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : f i) => forall (i : I), f i) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, max (succ u1) (succ u2)} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (fun (_x : f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : f i) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x)
 Case conversion may be inaccurate. Consider using '#align monoid_hom.single_apply MonoidHom.single_applyₓ'. -/
 @[simp, to_additive]
 theorem MonoidHom.single_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :

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

@@ -553,7 +553,7 @@ This is the `mul_hom` version of `pi.single`. -/
 def MulHom.single [∀ i, MulZeroClass <| f i] (i : I) : f i →ₙ* ∀ i, f i
     where
   toFun := single i
-  map_mul' := Pi.single_op₂ (fun _ => (· * ·)) (fun _ => zero_mul _) _
+  map_mul' := Pi.single_op₂ (fun _ => (· * ·)) (fun _ => MulZeroClass.zero_mul _) _
 #align mul_hom.single MulHom.single
 
 variable {f}

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

@@ -287,7 +287,7 @@ namespace MulHom
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} {mM : Mul.{u1} M} {mN : CommSemigroup.{u2} N} (f : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (g : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))), Eq.{max (succ u1) (succ u2)} (M -> N) (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (M -> N) (M -> N) (M -> N) (instHMul.{max u1 u2} (M -> N) (Pi.instMul.{u1, u2} M (fun (ᾰ : M) => N) (fun (i : M) => Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN)))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) f) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) g)) (fun (x : M) => HMul.hMul.{u2, u2, u2} N N N (instHMul.{u2} N (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) f x) (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) (fun (_x : MulHom.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) => M -> N) (MulHom.hasCoeToFun.{u1, u2} M N mM (Semigroup.toHasMul.{u2} N (CommSemigroup.toSemigroup.{u2} N mN))) g x))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} {mM : Mul.{u2} M} {mN : CommSemigroup.{u1} N} (f : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) (g : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) ᾰ) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) ᾰ) (instHMul.{max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) ᾰ) (Pi.instMul.{u2, u1} M (fun (ᾰ : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) ᾰ) (fun (i : M) => Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) i) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) i) mN)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g)) (fun (x : M) => HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) x) mN))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g x))
+  forall {M : Type.{u2}} {N : Type.{u1}} {mM : Mul.{u2} M} {mN : CommSemigroup.{u1} N} (f : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) (g : MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))), Eq.{max (succ u2) (succ u1)} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (HMul.hMul.{max u2 u1, max u2 u1, max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (instHMul.{max u2 u1} (forall (ᾰ : M), (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (Pi.instMul.{u2, u1} M (fun (ᾰ : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) ᾰ) (fun (i : M) => Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) i) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) i) mN)))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g)) (fun (x : M) => HMul.hMul.{u1, u1, u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (instHMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (Semigroup.toMul.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) (CommSemigroup.toSemigroup.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) x) mN))) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) f x) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MulHom.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN))) M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)) (MulHom.mulHomClass.{u2, u1} M N mM (Semigroup.toMul.{u1} N (CommSemigroup.toSemigroup.{u1} N mN)))) g x))
 Case conversion may be inaccurate. Consider using '#align mul_hom.coe_mul MulHom.coe_mulₓ'. -/
 @[to_additive]
 theorem coe_mul {M N} {mM : Mul M} {mN : CommSemigroup N} (f g : M →ₙ* N) :
@@ -344,7 +344,7 @@ def Pi.monoidHom {γ : Type w} [∀ i, MulOneClass (f i)] [MulOneClass γ] (g :
 lean 3 declaration is
   forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (coeFn.{max (succ u2) (succ u3), max (succ u3) (succ u2)} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) (fun (_x : MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) => γ -> (f i)) (MonoidHom.hasCoeToFun.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), (fun (i : I) => f i) i) (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ u3) (succ (max u1 u2))} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (fun (_x : MonoidHom.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) => γ -> (forall (i : I), (fun (i : I) => f i) i)) (MonoidHom.hasCoeToFun.{u3, max u1 u2} γ (forall (i : I), (fun (i : I) => f i) i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => (fun (i : I) => f i) i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
 but is expected to have type
-  forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : γ) => f i) _x) (MulHomClass.toFunLike.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MonoidHomClass.toMulHomClass.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) _inst_3 (_inst_2 i) (MonoidHom.monoidHomClass.{u3, u2} γ (f i) _inst_3 (_inst_2 i)))) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), f i) (FunLike.coe.{max (max (succ u1) (succ u2)) (succ u3), succ u3, max (succ u1) (succ u2)} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : γ) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
+  forall {I : Type.{u1}} {f : I -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Nonempty.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] [_inst_3 : MulOneClass.{u3} γ] (g : forall (i : I), MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)), (forall (i : I), Function.Injective.{succ u3, succ u2} γ (f i) (FunLike.coe.{max (succ u2) (succ u3), succ u3, succ u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : γ) => f i) _x) (MulHomClass.toFunLike.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MonoidHomClass.toMulHomClass.{max u2 u3, u3, u2} (MonoidHom.{u3, u2} γ (f i) _inst_3 (_inst_2 i)) γ (f i) _inst_3 (_inst_2 i) (MonoidHom.monoidHomClass.{u3, u2} γ (f i) _inst_3 (_inst_2 i)))) (g i))) -> (Function.Injective.{succ u3, max (succ u1) (succ u2)} γ (forall (i : I), f i) (FunLike.coe.{max (max (succ u1) (succ u2)) (succ u3), succ u3, max (succ u1) (succ u2)} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (fun (_x : γ) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : γ) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) (MulOneClass.toMul.{u3} γ _inst_3) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max (max u1 u2) u3, u3, max u1 u2} (MonoidHom.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u3, max u1 u2} γ (forall (i : I), f i) _inst_3 (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (Pi.monoidHom.{u1, u2, u3} I (fun (i : I) => f i) γ (fun (i : I) => _inst_2 i) _inst_3 g)))
 Case conversion may be inaccurate. Consider using '#align pi.monoid_hom_injective Pi.monoidHom_injectiveₓ'. -/
 @[to_additive]
 theorem Pi.monoidHom_injective {γ : Type w} [Nonempty I] [∀ i, MulOneClass (f i)] [MulOneClass γ]
@@ -530,7 +530,7 @@ def MonoidHom.single [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :
 lean 3 declaration is
   forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} (forall (i : I), f i) (coeFn.{max (succ (max u1 u2)) (succ u2), max (succ u2) (succ (max u1 u2))} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (fun (_x : MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) => (f i) -> (forall (i : I), f i)) (MonoidHom.hasCoeToFun.{u2, max u1 u2} (f i) (forall (i : I), f i) ((fun (i : I) => _inst_2 i) i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => (fun (i : I) => _inst_2 i) i))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (f i) (_inst_2 i)) i x)
 but is expected to have type
-  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : f i) => forall (i : I), f i) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, max (succ u1) (succ u2)} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (fun (_x : f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : f i) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x)
+  forall {I : Type.{u1}} (f : I -> Type.{u2}) [_inst_1 : DecidableEq.{succ u1} I] [_inst_2 : forall (i : I), MulOneClass.{u2} (f i)] (i : I) (x : f i), Eq.{max (succ u1) (succ u2)} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : f i) => forall (i : I), f i) x) (FunLike.coe.{max (succ u1) (succ u2), succ u2, max (succ u1) (succ u2)} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (fun (_x : f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : f i) => forall (i : I), f i) _x) (MulHomClass.toFunLike.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (MulOneClass.toMul.{u2} (f i) (_inst_2 i)) (MulOneClass.toMul.{max u1 u2} (forall (i : I), f i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (MonoidHomClass.toMulHomClass.{max u1 u2, u2, max u1 u2} (MonoidHom.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) (MonoidHom.monoidHomClass.{u2, max u1 u2} (f i) (forall (i : I), f i) (_inst_2 i) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))))) (MonoidHom.single.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => _inst_2 i) i) x) (Pi.mulSingle.{u1, u2} I f (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toOne.{u2} (f i) (_inst_2 i)) i x)
 Case conversion may be inaccurate. Consider using '#align monoid_hom.single_apply MonoidHom.single_applyₓ'. -/
 @[simp, to_additive]
 theorem MonoidHom.single_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :

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

Move everything that can't be additivised out of Algebra.Group.Pi.Lemmas:

• MulZeroClass, MulZeroOneClass, etc... instances go to a new Algebra.GroupWithZero.Pi file. I credit Eric W. for https://github.com/leanprover-community/mathlib/pull/4766.
• AddMonoidWithOne, AddGroupWithOne instances go to Algebra.Ring.Pi.

@@ -4,7 +4,6 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
 -/
 import Mathlib.Algebra.Group.Hom.Instances
-import Mathlib.Data.Int.Cast.Defs
 import Mathlib.Data.Set.Function
 import Mathlib.Logic.Pairwise
 
@@ -17,6 +16,10 @@ This file proves lemmas about the instances defined in `Algebra.Group.Pi.Basic`
 imports.
 -/
 
+assert_not_exists AddMonoidWithOne
+-- TODO (after #11855)
+-- assert_not_exists MulZeroClass
+
 universe u v w
 
 variable {ι α : Type*}
@@ -35,49 +38,6 @@ theorem Set.preimage_one {α β : Type*} [One β] (s : Set β) [Decidable ((1 :
 #align set.preimage_one Set.preimage_one
 #align set.preimage_zero Set.preimage_zero
 
-namespace Pi
-
-instance addMonoidWithOne [∀ i, AddMonoidWithOne <| f i] : AddMonoidWithOne (∀ i : I, f i) :=
-  { addMonoid with
-    natCast := fun n _ => n
-    natCast_zero := funext fun _ => AddMonoidWithOne.natCast_zero
-    natCast_succ := fun n => funext fun _ => AddMonoidWithOne.natCast_succ n
-  }
-
-instance addGroupWithOne [∀ i, AddGroupWithOne <| f i] : AddGroupWithOne (∀ i : I, f i) :=
-  { addGroup, addMonoidWithOne with
-    intCast := fun z _ => z
-    intCast_ofNat := fun n => funext fun _ => AddGroupWithOne.intCast_ofNat n
-    intCast_negSucc := fun n => funext fun _ => AddGroupWithOne.intCast_negSucc n
-  }
-
-instance mulZeroClass [∀ i, MulZeroClass <| f i] : MulZeroClass (∀ i : I, f i) :=
-  { zero := (0 : ∀ i, f i)
-    mul := (· * ·)
-    --pi_instance
-    zero_mul := by intros; ext; exact zero_mul _
-    mul_zero := by intros; ext; exact mul_zero _
-}
-#align pi.mul_zero_class Pi.mulZeroClass
-
-instance mulZeroOneClass [∀ i, MulZeroOneClass <| f i] : MulZeroOneClass (∀ i : I, f i) :=
-  { mulZeroClass, mulOneClass with }
-#align pi.mul_zero_one_class Pi.mulZeroOneClass
-
-instance monoidWithZero [∀ i, MonoidWithZero <| f i] : MonoidWithZero (∀ i : I, f i) :=
-  { monoid, mulZeroClass with }
-#align pi.monoid_with_zero Pi.monoidWithZero
-
-instance commMonoidWithZero [∀ i, CommMonoidWithZero <| f i] : CommMonoidWithZero (∀ i : I, f i) :=
-  { monoidWithZero, commMonoid with }
-#align pi.comm_monoid_with_zero Pi.commMonoidWithZero
-
-instance semigroupWithZero [∀ i, SemigroupWithZero <| f i] : SemigroupWithZero (∀ i : I, f i) :=
-  { semigroup, mulZeroClass with }
-#align pi.semigroup_with_zero Pi.semigroupWithZero
-
-end Pi
-
 namespace MulHom
 
 @[to_additive]
@@ -304,17 +264,6 @@ theorem MonoidHom.mulSingle_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i)
 #align monoid_hom.single_apply MonoidHom.mulSingle_apply
 #align add_monoid_hom.single_apply AddMonoidHom.single_apply
 
-/-- The multiplicative homomorphism including a single `MulZeroClass`
-into a dependent family of `MulZeroClass`es, as functions supported at a point.
-
-This is the `MulHom` version of `Pi.single`. -/
-@[simps]
-def MulHom.single [∀ i, MulZeroClass <| f i] (i : I) : f i →ₙ* ∀ i, f i where
-  toFun := Pi.single i
-  map_mul' := Pi.single_op₂ (fun _ => (· * ·)) (fun _ => zero_mul _) _
-#align mul_hom.single MulHom.single
-#align mul_hom.single_apply MulHom.single_apply
-
 variable {f}
 
 @[to_additive]
@@ -352,31 +301,6 @@ theorem Pi.mulSingle_div [∀ i, Group <| f i] (i : I) (x y : f i) :
 #align pi.single_div Pi.mulSingle_div
 #align pi.single_sub Pi.single_sub
 
-theorem Pi.single_mul [∀ i, MulZeroClass <| f i] (i : I) (x y : f i) :
-    single i (x * y) = single i x * single i y :=
-  (MulHom.single f i).map_mul x y
-#align pi.single_mul Pi.single_mul
-
-theorem Pi.single_mul_left_apply [∀ i, MulZeroClass <| f i] (a : f i) :
-    Pi.single i (a * x i) j = Pi.single i a j * x j :=
-  (Pi.apply_single (fun i => (· * x i)) (fun _ => zero_mul _) _ _ _).symm
-#align pi.single_mul_left_apply Pi.single_mul_left_apply
-
-theorem Pi.single_mul_right_apply [∀ i, MulZeroClass <| f i] (a : f i) :
-    Pi.single i (x i * a) j = x j * Pi.single i a j :=
-  (Pi.apply_single (fun i => (· * ·) (x i)) (fun _ => mul_zero _) _ _ _).symm
-#align pi.single_mul_right_apply Pi.single_mul_right_apply
-
-theorem Pi.single_mul_left [∀ i, MulZeroClass <| f i] (a : f i) :
-    Pi.single i (a * x i) = Pi.single i a * x :=
-  funext fun _ => Pi.single_mul_left_apply _ _ _ _
-#align pi.single_mul_left Pi.single_mul_left
-
-theorem Pi.single_mul_right [∀ i, MulZeroClass <| f i] (a : f i) :
-    Pi.single i (x i * a) = x * Pi.single i a :=
-  funext fun _ => Pi.single_mul_right_apply _ _ _ _
-#align pi.single_mul_right Pi.single_mul_right
-
 section
 variable [∀ i, Mul <| f i]
 

Before this PR, the MonoidHom version of Pi.mulSingle was called MonoidHom.single for brevity; but this is confusing when contrasted with MulHom.single which is about Pi.single.

After this PR, the name is MonoidHom.mulSingle.

Also fix the name of Pi.single_div since it is about Pi.mulSingle (and we don't have the lemma that would be called Pi.single_div).

@@ -271,17 +271,16 @@ This is the `OneHom` version of `Pi.mulSingle`. -/
       as functions supported at a point.
 
       This is the `ZeroHom` version of `Pi.single`."]
-def OneHom.single [∀ i, One <| f i] (i : I) : OneHom (f i) (∀ i, f i) where
+nonrec def OneHom.mulSingle [∀ i, One <| f i] (i : I) : OneHom (f i) (∀ i, f i) where
   toFun := mulSingle i
   map_one' := mulSingle_one i
-#align one_hom.single OneHom.single
+#align one_hom.single OneHom.mulSingle
 #align zero_hom.single ZeroHom.single
 
 @[to_additive (attr := simp)]
-theorem OneHom.single_apply [∀ i, One <| f i] (i : I) (x : f i) :
-    OneHom.single f i x = mulSingle i x :=
-  rfl
-#align one_hom.single_apply OneHom.single_apply
+theorem OneHom.mulSingle_apply [∀ i, One <| f i] (i : I) (x : f i) :
+    mulSingle f i x = Pi.mulSingle i x := rfl
+#align one_hom.single_apply OneHom.mulSingle_apply
 #align zero_hom.single_apply ZeroHom.single_apply
 
 /-- The monoid homomorphism including a single monoid into a dependent family of additive monoids,
@@ -293,16 +292,16 @@ This is the `MonoidHom` version of `Pi.mulSingle`. -/
       of additive monoids, as functions supported at a point.
 
       This is the `AddMonoidHom` version of `Pi.single`."]
-def MonoidHom.single [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :=
-  { OneHom.single f i with map_mul' := mulSingle_op₂ (fun _ => (· * ·)) (fun _ => one_mul _) _ }
-#align monoid_hom.single MonoidHom.single
+def MonoidHom.mulSingle [∀ i, MulOneClass <| f i] (i : I) : f i →* ∀ i, f i :=
+  { OneHom.mulSingle f i with map_mul' := mulSingle_op₂ (fun _ => (· * ·)) (fun _ => one_mul _) _ }
+#align monoid_hom.single MonoidHom.mulSingle
 #align add_monoid_hom.single AddMonoidHom.single
 
 @[to_additive (attr := simp)]
-theorem MonoidHom.single_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
-    MonoidHom.single f i x = mulSingle i x :=
+theorem MonoidHom.mulSingle_apply [∀ i, MulOneClass <| f i] (i : I) (x : f i) :
+    mulSingle f i x = Pi.mulSingle i x :=
   rfl
-#align monoid_hom.single_apply MonoidHom.single_apply
+#align monoid_hom.single_apply MonoidHom.mulSingle_apply
 #align add_monoid_hom.single_apply AddMonoidHom.single_apply
 
 /-- The multiplicative homomorphism including a single `MulZeroClass`
@@ -335,22 +334,22 @@ theorem Pi.mulSingle_inf [∀ i, SemilatticeInf (f i)] [∀ i, One (f i)] (i : I
 @[to_additive]
 theorem Pi.mulSingle_mul [∀ i, MulOneClass <| f i] (i : I) (x y : f i) :
     mulSingle i (x * y) = mulSingle i x * mulSingle i y :=
-  (MonoidHom.single f i).map_mul x y
+  (MonoidHom.mulSingle f i).map_mul x y
 #align pi.mul_single_mul Pi.mulSingle_mul
 #align pi.single_add Pi.single_add
 
 @[to_additive]
 theorem Pi.mulSingle_inv [∀ i, Group <| f i] (i : I) (x : f i) :
     mulSingle i x⁻¹ = (mulSingle i x)⁻¹ :=
-  (MonoidHom.single f i).map_inv x
+  (MonoidHom.mulSingle f i).map_inv x
 #align pi.mul_single_inv Pi.mulSingle_inv
 #align pi.single_neg Pi.single_neg
 
 @[to_additive]
-theorem Pi.single_div [∀ i, Group <| f i] (i : I) (x y : f i) :
+theorem Pi.mulSingle_div [∀ i, Group <| f i] (i : I) (x y : f i) :
     mulSingle i (x / y) = mulSingle i x / mulSingle i y :=
-  (MonoidHom.single f i).map_div x y
-#align pi.single_div Pi.single_div
+  (MonoidHom.mulSingle f i).map_div x y
+#align pi.single_div Pi.mulSingle_div
 #align pi.single_sub Pi.single_sub
 
 theorem Pi.single_mul [∀ i, MulZeroClass <| f i] (i : I) (x y : f i) :

This is a far from a complete success at the PR title, but it makes a fair bit of progress, and then guards this with appropriate assert_not_exists Ring statements.

It also breaks apart the Mathlib.GroupTheory.Subsemigroup.[Center|Centralizer] files, to pull the Set.center and Set.centralizer declarations into their own files not depending on Subsemigroup.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
 -/
 import Mathlib.Algebra.Group.Hom.Instances
+import Mathlib.Data.Int.Cast.Defs
 import Mathlib.Data.Set.Function
 import Mathlib.Logic.Pairwise
 

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -19,7 +19,6 @@ imports.
 universe u v w
 
 variable {ι α : Type*}
-
 variable {I : Type u}
 
 -- The indexing type

Those lemmas were weird and unused, except the last few about transitivity of = and ≠, which I moved to Logic.Basic

@@ -3,7 +3,6 @@ Copyright (c) 2018 Simon Hudon. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Simon Hudon, Patrick Massot
 -/
-import Mathlib.Init.CCLemmas
 import Mathlib.Algebra.Group.Hom.Instances
 import Mathlib.Data.Set.Function
 import Mathlib.Logic.Pairwise

Rename

• Data.Pi.Algebra to Algebra.Group.Pi.Basic
• Algebra.Group.Pi to Algebra.Group.Pi.Lemmas

Move a few instances from the latter to the former, the goal being that Algebra.Group.Pi.Basic is about all the pi instances of the classes defined in Algebra.Group.Defs. Algebra.Group.Pi.Lemmas will need further rearranging.

@@ -5,29 +5,16 @@ Authors: Simon Hudon, Patrick Massot
 -/
 import Mathlib.Init.CCLemmas
 import Mathlib.Algebra.Group.Hom.Instances
-import Mathlib.Data.Pi.Algebra
 import Mathlib.Data.Set.Function
 import Mathlib.Logic.Pairwise
 
 #align_import algebra.group.pi from "leanprover-community/mathlib"@"e4bc74cbaf429d706cb9140902f7ca6c431e75a4"
 
 /-!
-# Pi instances for groups and monoids
+# Extra lemmas about products of monoids and groups
 
-This file defines instances for group, monoid, semigroup and related structures on Pi types.
--/
-
-/-
-  Porting notes:
-
-  See this Zulip discussion: [https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/not.20porting.20pi_instance]
-
-  * This file now includes the pi instances for `AddMonoidWithOne` and `AddGroupWithOne`
-  * This file relied on the `pi_instance` tactic, which was not available at the time of porting.
-    The comment `--pi_instance` is inserted before all fields which were previously derived by
-    `pi_instance`.
-  * This file previously gave data fields explicitly. Now previously-defined instances are sourced
-    via `with` as much as possible.
+This file proves lemmas about the instances defined in `Algebra.Group.Pi.Basic` that require more
+imports.
 -/
 
 universe u v w
@@ -51,51 +38,6 @@ theorem Set.preimage_one {α β : Type*} [One β] (s : Set β) [Decidable ((1 :
 
 namespace Pi
 
-@[to_additive]
-instance semigroup [∀ i, Semigroup <| f i] : Semigroup (∀ i : I, f i) :=
-  { mul := (· * ·)
-    --pi_instance
-    mul_assoc := by intros; ext; exact mul_assoc _ _ _ }
-#align pi.semigroup Pi.semigroup
-#align pi.add_semigroup Pi.addSemigroup
-
-@[to_additive]
-instance commSemigroup [∀ i, CommSemigroup <| f i] : CommSemigroup (∀ i : I, f i) :=
-  { semigroup with
-    --pi_instance
-    mul_comm := by intros; ext; exact mul_comm _ _
-  }
-#align pi.comm_semigroup Pi.commSemigroup
-#align pi.add_comm_semigroup Pi.addCommSemigroup
-
-@[to_additive]
-instance mulOneClass [∀ i, MulOneClass <| f i] : MulOneClass (∀ i : I, f i) :=
-  { one := (1 : ∀ i, f i)
-    mul := (· * ·)
-    --pi_instance
-    one_mul := by intros; ext; exact one_mul _
-    mul_one := by intros; ext; exact mul_one _
-  }
-#align pi.mul_one_class Pi.mulOneClass
-#align pi.add_zero_class Pi.addZeroClass
-
-@[to_additive]
-instance invOneClass [∀ i, InvOneClass <| f i] : InvOneClass (∀ i : I, f i) :=
-  { one := (1 : ∀ i, f i)
-    inv := (· ⁻¹)
-    inv_one := by intros; ext; exact inv_one }
-
-@[to_additive]
-instance monoid [∀ i, Monoid <| f i] : Monoid (∀ i : I, f i) :=
-  { semigroup, mulOneClass with
-    npow := fun n x i => x i ^ n
-    --pi_instance
-    npow_zero := by intros; ext; exact Monoid.npow_zero _
-    npow_succ := by intros; ext; exact Monoid.npow_succ _ _
-  }
-#align pi.monoid Pi.monoid
-#align pi.add_monoid Pi.addMonoid
-
 instance addMonoidWithOne [∀ i, AddMonoidWithOne <| f i] : AddMonoidWithOne (∀ i : I, f i) :=
   { addMonoid with
     natCast := fun n _ => n
@@ -103,59 +45,6 @@ instance addMonoidWithOne [∀ i, AddMonoidWithOne <| f i] : AddMonoidWithOne (
     natCast_succ := fun n => funext fun _ => AddMonoidWithOne.natCast_succ n
   }
 
-@[to_additive]
-instance commMonoid [∀ i, CommMonoid <| f i] : CommMonoid (∀ i : I, f i) :=
-  { monoid, commSemigroup with }
-#align pi.comm_monoid Pi.commMonoid
-#align pi.add_comm_monoid Pi.addCommMonoid
-
-@[to_additive Pi.subNegMonoid]
-instance divInvMonoid [∀ i, DivInvMonoid <| f i] : DivInvMonoid (∀ i : I, f i) :=
-  { monoid with
-    inv := Inv.inv
-    div := Div.div
-    zpow := fun z x i => x i ^ z
-    --pi_instance
-    div_eq_mul_inv := by intros; ext; exact div_eq_mul_inv _ _
-    zpow_zero' := by intros; ext; exact DivInvMonoid.zpow_zero' _
-    zpow_succ' := by intros; ext; exact DivInvMonoid.zpow_succ' _ _
-    zpow_neg' := by intros; ext; exact DivInvMonoid.zpow_neg' _ _
-  }
-
-@[to_additive Pi.subNegZeroMonoid]
-instance divInvOneMonoid [∀ i, DivInvOneMonoid <| f i] : DivInvOneMonoid (∀ i : I, f i) :=
-  { divInvMonoid with
-    inv_one := by ext; exact inv_one }
-
-@[to_additive]
-instance involutiveInv [∀ i, InvolutiveInv <| f i] : InvolutiveInv (∀ i, f i) :=
-  { inv := Inv.inv
-    --pi_instance
-    inv_inv := by intros; ext; exact inv_inv _
-  }
-
-@[to_additive Pi.subtractionMonoid]
-instance divisionMonoid [∀ i, DivisionMonoid <| f i] : DivisionMonoid (∀ i, f i) :=
-  { divInvMonoid, involutiveInv with
-    --pi_instance
-    mul_inv_rev := by intros; ext; exact mul_inv_rev _ _
-    inv_eq_of_mul := by
-      intros _ _ h; ext; exact DivisionMonoid.inv_eq_of_mul _ _ (congrFun h _)
-  }
-
-@[to_additive Pi.subtractionCommMonoid]
-instance [∀ i, DivisionCommMonoid <| f i] : DivisionCommMonoid (∀ i, f i) :=
-  { divisionMonoid, commSemigroup with }
-
-@[to_additive]
-instance group [∀ i, Group <| f i] : Group (∀ i : I, f i) :=
-  { divInvMonoid with
-    --pi_instance
-    mul_left_inv := by intros; ext; exact mul_left_inv _
-    }
-#align pi.group Pi.group
-#align pi.add_group Pi.addGroup
-
 instance addGroupWithOne [∀ i, AddGroupWithOne <| f i] : AddGroupWithOne (∀ i : I, f i) :=
   { addGroup, addMonoidWithOne with
     intCast := fun z _ => z
@@ -163,61 +52,6 @@ instance addGroupWithOne [∀ i, AddGroupWithOne <| f i] : AddGroupWithOne (∀
     intCast_negSucc := fun n => funext fun _ => AddGroupWithOne.intCast_negSucc n
   }
 
-@[to_additive]
-instance commGroup [∀ i, CommGroup <| f i] : CommGroup (∀ i : I, f i) :=
-  { group, commMonoid with }
-#align pi.comm_group Pi.commGroup
-#align pi.add_comm_group Pi.addCommGroup
-
-@[to_additive]
-instance [∀ i, Mul <| f i] [∀ i, IsLeftCancelMul <| f i] : IsLeftCancelMul (∀ i : I, f i) where
-  mul_left_cancel  _ _ _ h := funext fun _ => mul_left_cancel (congr_fun h _)
-
-@[to_additive]
-instance [∀ i, Mul <| f i] [∀ i, IsRightCancelMul <| f i] : IsRightCancelMul (∀ i : I, f i) where
-  mul_right_cancel  _ _ _ h := funext fun _ => mul_right_cancel (congr_fun h _)
-
-@[to_additive]
-instance [∀ i, Mul <| f i] [∀ i, IsCancelMul <| f i] : IsCancelMul (∀ i : I, f i) where
-
-@[to_additive]
-instance leftCancelSemigroup [∀ i, LeftCancelSemigroup <| f i] :
-    LeftCancelSemigroup (∀ i : I, f i) :=
-  { semigroup with mul_left_cancel := fun _ _ _ => mul_left_cancel }
-#align pi.left_cancel_semigroup Pi.leftCancelSemigroup
-#align pi.add_left_cancel_semigroup Pi.addLeftCancelSemigroup
-
-@[to_additive]
-instance rightCancelSemigroup [∀ i, RightCancelSemigroup <| f i] :
-    RightCancelSemigroup (∀ i : I, f i) :=
-  { semigroup with mul_right_cancel := fun _ _ _ => mul_right_cancel }
-#align pi.right_cancel_semigroup Pi.rightCancelSemigroup
-#align pi.add_right_cancel_semigroup Pi.addRightCancelSemigroup
-
-@[to_additive]
-instance leftCancelMonoid [∀ i, LeftCancelMonoid <| f i] : LeftCancelMonoid (∀ i : I, f i) :=
-  { leftCancelSemigroup, monoid with }
-#align pi.left_cancel_monoid Pi.leftCancelMonoid
-#align pi.add_left_cancel_monoid Pi.addLeftCancelMonoid
-
-@[to_additive]
-instance rightCancelMonoid [∀ i, RightCancelMonoid <| f i] : RightCancelMonoid (∀ i : I, f i) :=
-  { rightCancelSemigroup, monoid with }
-#align pi.right_cancel_monoid Pi.rightCancelMonoid
-#align pi.add_right_cancel_monoid Pi.addRightCancelMonoid
-
-@[to_additive]
-instance cancelMonoid [∀ i, CancelMonoid <| f i] : CancelMonoid (∀ i : I, f i) :=
-  { leftCancelMonoid, rightCancelMonoid with }
-#align pi.cancel_monoid Pi.cancelMonoid
-#align pi.add_cancel_monoid Pi.addCancelMonoid
-
-@[to_additive]
-instance cancelCommMonoid [∀ i, CancelCommMonoid <| f i] : CancelCommMonoid (∀ i : I, f i) :=
-  { leftCancelMonoid, commMonoid with }
-#align pi.cancel_comm_monoid Pi.cancelCommMonoid
-#align pi.add_cancel_comm_monoid Pi.addCancelCommMonoid
-
 instance mulZeroClass [∀ i, MulZeroClass <| f i] : MulZeroClass (∀ i : I, f i) :=
   { zero := (0 : ∀ i, f i)
     mul := (· * ·)

Subset of #9319