algebra.big_operators.pi ⟷ Mathlib.Algebra.BigOperators.Pi

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

@@ -117,7 +117,7 @@ note [partially-applied ext lemmas]. -/
   to_additive
       "\nThis is used as the ext lemma instead of `add_monoid_hom.functions_ext` for reasons explained in\nnote [partially-applied ext lemmas]."]
 theorem MonoidHom.functions_ext' [Finite I] (M : Type _) [CommMonoid M] (g h : (∀ i, Z i) →* M)
-    (H : ∀ i, g.comp (MonoidHom.single Z i) = h.comp (MonoidHom.single Z i)) : g = h :=
+    (H : ∀ i, g.comp (MonoidHom.mulSingle Z i) = h.comp (MonoidHom.mulSingle Z i)) : g = h :=
   g.functions_ext M h fun i => MonoidHom.congr_fun (H i)
 #align monoid_hom.functions_ext' MonoidHom.functions_ext'
 #align add_monoid_hom.functions_ext' AddMonoidHom.functions_ext'

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

@@ -3,10 +3,10 @@ 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.Data.Fintype.Card
-import Mathbin.Algebra.Group.Prod
-import Mathbin.Algebra.BigOperators.Basic
-import Mathbin.Algebra.Ring.Pi
+import Data.Fintype.Card
+import Algebra.Group.Prod
+import Algebra.BigOperators.Basic
+import Algebra.Ring.Pi
 
 #align_import algebra.big_operators.pi from "leanprover-community/mathlib"@"fa2309577c7009ea243cffdf990cd6c84f0ad497"
 

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

@@ -2,17 +2,14 @@
 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.big_operators.pi
-! leanprover-community/mathlib commit fa2309577c7009ea243cffdf990cd6c84f0ad497
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fintype.Card
 import Mathbin.Algebra.Group.Prod
 import Mathbin.Algebra.BigOperators.Basic
 import Mathbin.Algebra.Ring.Pi
 
+#align_import algebra.big_operators.pi from "leanprover-community/mathlib"@"fa2309577c7009ea243cffdf990cd6c84f0ad497"
+
 /-!
 # Big operators for Pi Types
 

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

@@ -28,29 +28,36 @@ open scoped BigOperators
 
 namespace Pi
 
+#print Pi.list_prod_apply /-
 @[to_additive]
 theorem list_prod_apply {α : Type _} {β : α → Type _} [∀ a, Monoid (β a)] (a : α)
     (l : List (∀ a, β a)) : l.Prod a = (l.map fun f : ∀ a, β a => f a).Prod :=
   (evalMonoidHom β a).map_list_prod _
 #align pi.list_prod_apply Pi.list_prod_apply
 #align pi.list_sum_apply Pi.list_sum_apply
+-/
 
+#print Pi.multiset_prod_apply /-
 @[to_additive]
 theorem multiset_prod_apply {α : Type _} {β : α → Type _} [∀ a, CommMonoid (β a)] (a : α)
     (s : Multiset (∀ a, β a)) : s.Prod a = (s.map fun f : ∀ a, β a => f a).Prod :=
   (evalMonoidHom β a).map_multiset_prod _
 #align pi.multiset_prod_apply Pi.multiset_prod_apply
 #align pi.multiset_sum_apply Pi.multiset_sum_apply
+-/
 
 end Pi
 
+#print Finset.prod_apply /-
 @[simp, to_additive]
 theorem Finset.prod_apply {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (a : α)
     (s : Finset γ) (g : γ → ∀ a, β a) : (∏ c in s, g c) a = ∏ c in s, g c a :=
   (Pi.evalMonoidHom β a).map_prod _ _
 #align finset.prod_apply Finset.prod_apply
 #align finset.sum_apply Finset.sum_apply
+-/
 
+#print Finset.prod_fn /-
 /-- An 'unapplied' analogue of `finset.prod_apply`. -/
 @[to_additive "An 'unapplied' analogue of `finset.sum_apply`."]
 theorem Finset.prod_fn {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (s : Finset γ)
@@ -58,14 +65,18 @@ theorem Finset.prod_fn {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoi
   funext fun a => Finset.prod_apply _ _ _
 #align finset.prod_fn Finset.prod_fn
 #align finset.sum_fn Finset.sum_fn
+-/
 
+#print Fintype.prod_apply /-
 @[simp, to_additive]
 theorem Fintype.prod_apply {α : Type _} {β : α → Type _} {γ : Type _} [Fintype γ]
     [∀ a, CommMonoid (β a)] (a : α) (g : γ → ∀ a, β a) : (∏ c, g c) a = ∏ c, g c a :=
   Finset.prod_apply a Finset.univ g
 #align fintype.prod_apply Fintype.prod_apply
 #align fintype.sum_apply Fintype.sum_apply
+-/
 
+#print prod_mk_prod /-
 @[to_additive prod_mk_sum]
 theorem prod_mk_prod {α β γ : Type _} [CommMonoid α] [CommMonoid β] (s : Finset γ) (f : γ → α)
     (g : γ → β) : (∏ x in s, f x, ∏ x in s, g x) = ∏ x in s, (f x, g x) :=
@@ -73,6 +84,7 @@ theorem prod_mk_prod {α β γ : Type _} [CommMonoid α] [CommMonoid β] (s : Fi
   Finset.induction_on s rfl (by simp (config := { contextual := true }) [Prod.ext_iff])
 #align prod_mk_prod prod_mk_prod
 #align prod_mk_sum prod_mk_sum
+-/
 
 section MulSingle
 
@@ -80,12 +92,15 @@ variable {I : Type _} [DecidableEq I] {Z : I → Type _}
 
 variable [∀ i, CommMonoid (Z i)]
 
+#print Finset.univ_prod_mulSingle /-
 @[to_additive]
 theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : ∏ i, Pi.mulSingle i (f i) = f := by
   ext a; simp
 #align finset.univ_prod_mul_single Finset.univ_prod_mulSingle
 #align finset.univ_sum_single Finset.univ_sum_single
+-/
 
+#print MonoidHom.functions_ext /-
 @[to_additive]
 theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (∀ i, Z i) →* G)
     (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h :=
@@ -96,7 +111,9 @@ theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (
   simp only [H]
 #align monoid_hom.functions_ext MonoidHom.functions_ext
 #align add_monoid_hom.functions_ext AddMonoidHom.functions_ext
+-/
 
+#print MonoidHom.functions_ext' /-
 /-- This is used as the ext lemma instead of `monoid_hom.functions_ext` for reasons explained in
 note [partially-applied ext lemmas]. -/
 @[ext,
@@ -107,6 +124,7 @@ theorem MonoidHom.functions_ext' [Finite I] (M : Type _) [CommMonoid M] (g h : (
   g.functions_ext M h fun i => MonoidHom.congr_fun (H i)
 #align monoid_hom.functions_ext' MonoidHom.functions_ext'
 #align add_monoid_hom.functions_ext' AddMonoidHom.functions_ext'
+-/
 
 end MulSingle
 
@@ -118,12 +136,14 @@ variable {I : Type _} [DecidableEq I] {f : I → Type _}
 
 variable [∀ i, NonAssocSemiring (f i)]
 
+#print RingHom.functions_ext /-
 @[ext]
 theorem RingHom.functions_ext [Finite I] (G : Type _) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)
     (H : ∀ (i : I) (x : f i), g (single i x) = h (single i x)) : g = h :=
   RingHom.coe_addMonoidHom_injective <|
     @AddMonoidHom.functions_ext I _ f _ _ G _ (g : (∀ i, f i) →+ G) h H
 #align ring_hom.functions_ext RingHom.functions_ext
+-/
 
 end RingHom
 
@@ -131,17 +151,21 @@ namespace Prod
 
 variable {α β γ : Type _} [CommMonoid α] [CommMonoid β] {s : Finset γ} {f : γ → α × β}
 
+#print Prod.fst_prod /-
 @[to_additive]
 theorem fst_prod : (∏ c in s, f c).1 = ∏ c in s, (f c).1 :=
   (MonoidHom.fst α β).map_prod f s
 #align prod.fst_prod Prod.fst_prod
 #align prod.fst_sum Prod.fst_sum
+-/
 
+#print Prod.snd_prod /-
 @[to_additive]
 theorem snd_prod : (∏ c in s, f c).2 = ∏ c in s, (f c).2 :=
   (MonoidHom.snd α β).map_prod f s
 #align prod.snd_prod Prod.snd_prod
 #align prod.snd_sum Prod.snd_sum
+-/
 
 end Prod
 

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

@@ -54,7 +54,7 @@ theorem Finset.prod_apply {α : Type _} {β : α → Type _} {γ} [∀ a, CommMo
 /-- An 'unapplied' analogue of `finset.prod_apply`. -/
 @[to_additive "An 'unapplied' analogue of `finset.sum_apply`."]
 theorem Finset.prod_fn {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (s : Finset γ)
-    (g : γ → ∀ a, β a) : (∏ c in s, g c) = fun a => ∏ c in s, g c a :=
+    (g : γ → ∀ a, β a) : ∏ c in s, g c = fun a => ∏ c in s, g c a :=
   funext fun a => Finset.prod_apply _ _ _
 #align finset.prod_fn Finset.prod_fn
 #align finset.sum_fn Finset.sum_fn
@@ -81,8 +81,8 @@ variable {I : Type _} [DecidableEq I] {Z : I → Type _}
 variable [∀ i, CommMonoid (Z i)]
 
 @[to_additive]
-theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : (∏ i, Pi.mulSingle i (f i)) = f :=
-  by ext a; simp
+theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : ∏ i, Pi.mulSingle i (f i) = f := by
+  ext a; simp
 #align finset.univ_prod_mul_single Finset.univ_prod_mulSingle
 #align finset.univ_sum_single Finset.univ_sum_single
 

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

@@ -24,7 +24,7 @@ of monoids and groups
 -/
 
 
-open BigOperators
+open scoped BigOperators
 
 namespace Pi
 

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

@@ -28,12 +28,6 @@ open BigOperators
 
 namespace Pi
 
-/- warning: pi.list_prod_apply -> Pi.list_prod_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} [_inst_1 : forall (a : α), Monoid.{u2} (β a)] (a : α) (l : List.{max u1 u2} (forall (a : α), β a)), Eq.{succ u2} (β a) (List.prod.{max u1 u2} (forall (a : α), β a) (Pi.instMul.{u1, u2} α (fun (a : α) => β a) (fun (i : α) => MulOneClass.toHasMul.{u2} (β i) (Monoid.toMulOneClass.{u2} (β i) (_inst_1 i)))) (Pi.instOne.{u1, u2} α (fun (a : α) => β a) (fun (i : α) => MulOneClass.toHasOne.{u2} (β i) (Monoid.toMulOneClass.{u2} (β i) (_inst_1 i)))) l a) (List.prod.{u2} (β a) (MulOneClass.toHasMul.{u2} (β a) (Monoid.toMulOneClass.{u2} (β a) (_inst_1 a))) (MulOneClass.toHasOne.{u2} (β a) (Monoid.toMulOneClass.{u2} (β a) (_inst_1 a))) (List.map.{max u1 u2, u2} (forall (a : α), β a) (β a) (fun (f : forall (a : α), β a) => f a) l))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} [_inst_1 : forall (a : α), Monoid.{u1} (β a)] (a : α) (l : List.{max u2 u1} (forall (a : α), β a)), Eq.{succ u1} (β a) (List.prod.{max u2 u1} (forall (a : α), β a) (Pi.instMul.{u2, u1} α (fun (a : α) => β a) (fun (i : α) => MulOneClass.toMul.{u1} (β i) (Monoid.toMulOneClass.{u1} (β i) (_inst_1 i)))) (Pi.instOne.{u2, u1} α (fun (a : α) => β a) (fun (i : α) => Monoid.toOne.{u1} (β i) (_inst_1 i))) l a) (List.prod.{u1} (β a) (MulOneClass.toMul.{u1} (β a) (Monoid.toMulOneClass.{u1} (β a) (_inst_1 a))) (Monoid.toOne.{u1} (β a) (_inst_1 a)) (List.map.{max u2 u1, u1} (forall (a : α), β a) (β a) (fun (f : forall (a : α), β a) => f a) l))
-Case conversion may be inaccurate. Consider using '#align pi.list_prod_apply Pi.list_prod_applyₓ'. -/
 @[to_additive]
 theorem list_prod_apply {α : Type _} {β : α → Type _} [∀ a, Monoid (β a)] (a : α)
     (l : List (∀ a, β a)) : l.Prod a = (l.map fun f : ∀ a, β a => f a).Prod :=
@@ -41,12 +35,6 @@ theorem list_prod_apply {α : Type _} {β : α → Type _} [∀ a, Monoid (β a)
 #align pi.list_prod_apply Pi.list_prod_apply
 #align pi.list_sum_apply Pi.list_sum_apply
 
-/- warning: pi.multiset_prod_apply -> Pi.multiset_prod_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} [_inst_1 : forall (a : α), CommMonoid.{u2} (β a)] (a : α) (s : Multiset.{max u1 u2} (forall (a : α), β a)), Eq.{succ u2} (β a) (Multiset.prod.{max u1 u2} (forall (a : α), β a) (Pi.commMonoid.{u1, u2} α (fun (a : α) => β a) (fun (i : α) => _inst_1 i)) s a) (Multiset.prod.{u2} (β a) (_inst_1 a) (Multiset.map.{max u1 u2, u2} (forall (a : α), β a) (β a) (fun (f : forall (a : α), β a) => f a) s))
-but is expected to have type
-  forall {α : Type.{u2}} {β : α -> Type.{u1}} [_inst_1 : forall (a : α), CommMonoid.{u1} (β a)] (a : α) (s : Multiset.{max u2 u1} (forall (a : α), β a)), Eq.{succ u1} (β a) (Multiset.prod.{max u2 u1} (forall (a : α), β a) (Pi.commMonoid.{u2, u1} α (fun (a : α) => β a) (fun (i : α) => _inst_1 i)) s a) (Multiset.prod.{u1} (β a) (_inst_1 a) (Multiset.map.{max u2 u1, u1} (forall (a : α), β a) (β a) (fun (f : forall (a : α), β a) => f a) s))
-Case conversion may be inaccurate. Consider using '#align pi.multiset_prod_apply Pi.multiset_prod_applyₓ'. -/
 @[to_additive]
 theorem multiset_prod_apply {α : Type _} {β : α → Type _} [∀ a, CommMonoid (β a)] (a : α)
     (s : Multiset (∀ a, β a)) : s.Prod a = (s.map fun f : ∀ a, β a => f a).Prod :=
@@ -56,12 +44,6 @@ theorem multiset_prod_apply {α : Type _} {β : α → Type _} [∀ a, CommMonoi
 
 end Pi
 
-/- warning: finset.prod_apply -> Finset.prod_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : forall (a : α), CommMonoid.{u2} (β a)] (a : α) (s : Finset.{u3} γ) (g : γ -> (forall (a : α), β a)), Eq.{succ u2} (β a) (Finset.prod.{max u1 u2, u3} (forall (a : α), β a) γ (Pi.commMonoid.{u1, u2} α (fun (a : α) => β a) (fun (i : α) => _inst_1 i)) s (fun (c : γ) => g c) a) (Finset.prod.{u2, u3} (β a) γ (_inst_1 a) s (fun (c : γ) => g c a))
-but is expected to have type
-  forall {α : Type.{u3}} {β : α -> Type.{u2}} {γ : Type.{u1}} [_inst_1 : forall (a : α), CommMonoid.{u2} (β a)] (a : α) (s : Finset.{u1} γ) (g : γ -> (forall (a : α), β a)), Eq.{succ u2} (β a) (Finset.prod.{max u3 u2, u1} (forall (a : α), β a) γ (Pi.commMonoid.{u3, u2} α (fun (a : α) => β a) (fun (i : α) => _inst_1 i)) s (fun (c : γ) => g c) a) (Finset.prod.{u2, u1} (β a) γ (_inst_1 a) s (fun (c : γ) => g c a))
-Case conversion may be inaccurate. Consider using '#align finset.prod_apply Finset.prod_applyₓ'. -/
 @[simp, to_additive]
 theorem Finset.prod_apply {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (a : α)
     (s : Finset γ) (g : γ → ∀ a, β a) : (∏ c in s, g c) a = ∏ c in s, g c a :=
@@ -69,12 +51,6 @@ theorem Finset.prod_apply {α : Type _} {β : α → Type _} {γ} [∀ a, CommMo
 #align finset.prod_apply Finset.prod_apply
 #align finset.sum_apply Finset.sum_apply
 
-/- warning: finset.prod_fn -> Finset.prod_fn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : forall (a : α), CommMonoid.{u2} (β a)] (s : Finset.{u3} γ) (g : γ -> (forall (a : α), β a)), Eq.{succ (max u1 u2)} (forall (a : α), β a) (Finset.prod.{max u1 u2, u3} (forall (a : α), β a) γ (Pi.commMonoid.{u1, u2} α (fun (a : α) => β a) (fun (i : α) => _inst_1 i)) s (fun (c : γ) => g c)) (fun (a : α) => Finset.prod.{u2, u3} (β a) γ (_inst_1 a) s (fun (c : γ) => g c a))
-but is expected to have type
-  forall {α : Type.{u3}} {β : α -> Type.{u2}} {γ : Type.{u1}} [_inst_1 : forall (a : α), CommMonoid.{u2} (β a)] (s : Finset.{u1} γ) (g : γ -> (forall (a : α), β a)), Eq.{max (succ u3) (succ u2)} (forall (a : α), β a) (Finset.prod.{max u3 u2, u1} (forall (a : α), β a) γ (Pi.commMonoid.{u3, u2} α (fun (a : α) => β a) (fun (i : α) => _inst_1 i)) s (fun (c : γ) => g c)) (fun (a : α) => Finset.prod.{u2, u1} (β a) γ (_inst_1 a) s (fun (c : γ) => g c a))
-Case conversion may be inaccurate. Consider using '#align finset.prod_fn Finset.prod_fnₓ'. -/
 /-- An 'unapplied' analogue of `finset.prod_apply`. -/
 @[to_additive "An 'unapplied' analogue of `finset.sum_apply`."]
 theorem Finset.prod_fn {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (s : Finset γ)
@@ -83,12 +59,6 @@ theorem Finset.prod_fn {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoi
 #align finset.prod_fn Finset.prod_fn
 #align finset.sum_fn Finset.sum_fn
 
-/- warning: fintype.prod_apply -> Fintype.prod_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : α -> Type.{u2}} {γ : Type.{u3}} [_inst_1 : Fintype.{u3} γ] [_inst_2 : forall (a : α), CommMonoid.{u2} (β a)] (a : α) (g : γ -> (forall (a : α), β a)), Eq.{succ u2} (β a) (Finset.prod.{max u1 u2, u3} (forall (a : α), β a) γ (Pi.commMonoid.{u1, u2} α (fun (a : α) => β a) (fun (i : α) => _inst_2 i)) (Finset.univ.{u3} γ _inst_1) (fun (c : γ) => g c) a) (Finset.prod.{u2, u3} (β a) γ (_inst_2 a) (Finset.univ.{u3} γ _inst_1) (fun (c : γ) => g c a))
-but is expected to have type
-  forall {α : Type.{u3}} {β : α -> Type.{u2}} {γ : Type.{u1}} [_inst_1 : Fintype.{u1} γ] [_inst_2 : forall (a : α), CommMonoid.{u2} (β a)] (a : α) (g : γ -> (forall (a : α), β a)), Eq.{succ u2} (β a) (Finset.prod.{max u3 u2, u1} (forall (a : α), β a) γ (Pi.commMonoid.{u3, u2} α (fun (a : α) => β a) (fun (i : α) => _inst_2 i)) (Finset.univ.{u1} γ _inst_1) (fun (c : γ) => g c) a) (Finset.prod.{u2, u1} (β a) γ (_inst_2 a) (Finset.univ.{u1} γ _inst_1) (fun (c : γ) => g c a))
-Case conversion may be inaccurate. Consider using '#align fintype.prod_apply Fintype.prod_applyₓ'. -/
 @[simp, to_additive]
 theorem Fintype.prod_apply {α : Type _} {β : α → Type _} {γ : Type _} [Fintype γ]
     [∀ a, CommMonoid (β a)] (a : α) (g : γ → ∀ a, β a) : (∏ c, g c) a = ∏ c, g c a :=
@@ -96,12 +66,6 @@ theorem Fintype.prod_apply {α : Type _} {β : α → Type _} {γ : Type _} [Fin
 #align fintype.prod_apply Fintype.prod_apply
 #align fintype.sum_apply Fintype.sum_apply
 
-/- warning: prod_mk_prod -> prod_mk_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u2} β] (s : Finset.{u3} γ) (f : γ -> α) (g : γ -> β), Eq.{max (succ u1) (succ u2)} (Prod.{u1, u2} α β) (Prod.mk.{u1, u2} α β (Finset.prod.{u1, u3} α γ _inst_1 s (fun (x : γ) => f x)) (Finset.prod.{u2, u3} β γ _inst_2 s (fun (x : γ) => g x))) (Finset.prod.{max u1 u2, u3} (Prod.{u1, u2} α β) γ (Prod.commMonoid.{u1, u2} α β _inst_1 _inst_2) s (fun (x : γ) => Prod.mk.{u1, u2} α β (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : CommMonoid.{u3} α] [_inst_2 : CommMonoid.{u2} β] (s : Finset.{u1} γ) (f : γ -> α) (g : γ -> β), Eq.{max (succ u3) (succ u2)} (Prod.{u3, u2} α β) (Prod.mk.{u3, u2} α β (Finset.prod.{u3, u1} α γ _inst_1 s (fun (x : γ) => f x)) (Finset.prod.{u2, u1} β γ _inst_2 s (fun (x : γ) => g x))) (Finset.prod.{max u2 u3, u1} (Prod.{u3, u2} α β) γ (Prod.instCommMonoidProd.{u3, u2} α β _inst_1 _inst_2) s (fun (x : γ) => Prod.mk.{u3, u2} α β (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align prod_mk_prod prod_mk_prodₓ'. -/
 @[to_additive prod_mk_sum]
 theorem prod_mk_prod {α β γ : Type _} [CommMonoid α] [CommMonoid β] (s : Finset γ) (f : γ → α)
     (g : γ → β) : (∏ x in s, f x, ∏ x in s, g x) = ∏ x in s, (f x, g x) :=
@@ -116,21 +80,12 @@ variable {I : Type _} [DecidableEq I] {Z : I → Type _}
 
 variable [∀ i, CommMonoid (Z i)]
 
-/- warning: finset.univ_prod_mul_single -> Finset.univ_prod_mulSingle is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), CommMonoid.{u2} (Z i)] [_inst_3 : Fintype.{u1} I] (f : forall (i : I), Z i), Eq.{succ (max u1 u2)} (forall (i : I), Z i) (Finset.prod.{max u1 u2, u1} (forall (i : I), Z i) I (Pi.commMonoid.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => _inst_2 i)) (Finset.univ.{u1} I _inst_3) (fun (i : I) => Pi.mulSingle.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (Z i) (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) i (f i))) f
-but is expected to have type
-  forall {I : Type.{u2}} [_inst_1 : DecidableEq.{succ u2} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), CommMonoid.{u1} (Z i)] [_inst_3 : Fintype.{u2} I] (f : forall (i : I), Z i), Eq.{max (succ u2) (succ u1)} (forall (i : I), Z i) (Finset.prod.{max u1 u2, u2} (forall (i : I), Z i) I (Pi.commMonoid.{u2, u1} I (fun (i : I) => Z i) (fun (i : I) => _inst_2 i)) (Finset.univ.{u2} I _inst_3) (fun (i : I) => Pi.mulSingle.{u2, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i (f i))) f
-Case conversion may be inaccurate. Consider using '#align finset.univ_prod_mul_single Finset.univ_prod_mulSingleₓ'. -/
 @[to_additive]
 theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : (∏ i, Pi.mulSingle i (f i)) = f :=
   by ext a; simp
 #align finset.univ_prod_mul_single Finset.univ_prod_mulSingle
 #align finset.univ_sum_single Finset.univ_sum_single
 
-/- warning: monoid_hom.functions_ext -> MonoidHom.functions_ext is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align monoid_hom.functions_ext MonoidHom.functions_extₓ'. -/
 @[to_additive]
 theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (∀ i, Z i) →* G)
     (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h :=
@@ -142,12 +97,6 @@ theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (
 #align monoid_hom.functions_ext MonoidHom.functions_ext
 #align add_monoid_hom.functions_ext AddMonoidHom.functions_ext
 
-/- warning: monoid_hom.functions_ext' -> MonoidHom.functions_ext' is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), CommMonoid.{u2} (Z i)] [_inst_3 : Finite.{succ u1} I] (M : Type.{u3}) [_inst_4 : CommMonoid.{u3} M] (g : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4))) (h : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4))), (forall (i : I), Eq.{max (succ u3) (succ u2)} (MonoidHom.{u2, u3} (Z i) M (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4))) (MonoidHom.comp.{u2, max u1 u2, u3} (Z i) (forall (i : I), Z i) M (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4)) g (MonoidHom.single.{u1, u2} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) i)) (MonoidHom.comp.{u2, max u1 u2, u3} (Z i) (forall (i : I), Z i) M (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4)) h (MonoidHom.single.{u1, u2} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) i))) -> (Eq.{max (succ u3) (succ (max u1 u2))} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4))) g h)
-but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), CommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (M : Type.{u2}) [_inst_4 : CommMonoid.{u2} M] (g : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (h : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))), (forall (i : I), Eq.{max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Z i) M (Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (MonoidHom.comp.{u1, max u3 u1, u2} (Z i) (forall (i : I), Z i) M (Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)) g (MonoidHom.single.{u3, u1} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i)) (MonoidHom.comp.{u1, max u3 u1, u2} (Z i) (forall (i : I), Z i) M (Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)) h (MonoidHom.single.{u3, u1} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) g h)
-Case conversion may be inaccurate. Consider using '#align monoid_hom.functions_ext' MonoidHom.functions_ext'ₓ'. -/
 /-- This is used as the ext lemma instead of `monoid_hom.functions_ext` for reasons explained in
 note [partially-applied ext lemmas]. -/
 @[ext,
@@ -169,9 +118,6 @@ variable {I : Type _} [DecidableEq I] {f : I → Type _}
 
 variable [∀ i, NonAssocSemiring (f i)]
 
-/- warning: ring_hom.functions_ext -> RingHom.functions_ext is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align ring_hom.functions_ext RingHom.functions_extₓ'. -/
 @[ext]
 theorem RingHom.functions_ext [Finite I] (G : Type _) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)
     (H : ∀ (i : I) (x : f i), g (single i x) = h (single i x)) : g = h :=
@@ -185,24 +131,12 @@ namespace Prod
 
 variable {α β γ : Type _} [CommMonoid α] [CommMonoid β] {s : Finset γ} {f : γ → α × β}
 
-/- warning: prod.fst_prod -> Prod.fst_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u2} β] {s : Finset.{u3} γ} {f : γ -> (Prod.{u1, u2} α β)}, Eq.{succ u1} α (Prod.fst.{u1, u2} α β (Finset.prod.{max u1 u2, u3} (Prod.{u1, u2} α β) γ (Prod.commMonoid.{u1, u2} α β _inst_1 _inst_2) s (fun (c : γ) => f c))) (Finset.prod.{u1, u3} α γ _inst_1 s (fun (c : γ) => Prod.fst.{u1, u2} α β (f c)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : CommMonoid.{u3} α] [_inst_2 : CommMonoid.{u2} β] {s : Finset.{u1} γ} {f : γ -> (Prod.{u3, u2} α β)}, Eq.{succ u3} α (Prod.fst.{u3, u2} α β (Finset.prod.{max u3 u2, u1} (Prod.{u3, u2} α β) γ (Prod.instCommMonoidProd.{u3, u2} α β _inst_1 _inst_2) s (fun (c : γ) => f c))) (Finset.prod.{u3, u1} α γ _inst_1 s (fun (c : γ) => Prod.fst.{u3, u2} α β (f c)))
-Case conversion may be inaccurate. Consider using '#align prod.fst_prod Prod.fst_prodₓ'. -/
 @[to_additive]
 theorem fst_prod : (∏ c in s, f c).1 = ∏ c in s, (f c).1 :=
   (MonoidHom.fst α β).map_prod f s
 #align prod.fst_prod Prod.fst_prod
 #align prod.fst_sum Prod.fst_sum
 
-/- warning: prod.snd_prod -> Prod.snd_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : CommMonoid.{u1} α] [_inst_2 : CommMonoid.{u2} β] {s : Finset.{u3} γ} {f : γ -> (Prod.{u1, u2} α β)}, Eq.{succ u2} β (Prod.snd.{u1, u2} α β (Finset.prod.{max u1 u2, u3} (Prod.{u1, u2} α β) γ (Prod.commMonoid.{u1, u2} α β _inst_1 _inst_2) s (fun (c : γ) => f c))) (Finset.prod.{u2, u3} β γ _inst_2 s (fun (c : γ) => Prod.snd.{u1, u2} α β (f c)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u1}} [_inst_1 : CommMonoid.{u2} α] [_inst_2 : CommMonoid.{u3} β] {s : Finset.{u1} γ} {f : γ -> (Prod.{u2, u3} α β)}, Eq.{succ u3} β (Prod.snd.{u2, u3} α β (Finset.prod.{max u2 u3, u1} (Prod.{u2, u3} α β) γ (Prod.instCommMonoidProd.{u2, u3} α β _inst_1 _inst_2) s (fun (c : γ) => f c))) (Finset.prod.{u3, u1} β γ _inst_2 s (fun (c : γ) => Prod.snd.{u2, u3} α β (f c)))
-Case conversion may be inaccurate. Consider using '#align prod.snd_prod Prod.snd_prodₓ'. -/
 @[to_additive]
 theorem snd_prod : (∏ c in s, f c).2 = ∏ c in s, (f c).2 :=
   (MonoidHom.snd α β).map_prod f s

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

@@ -124,9 +124,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align finset.univ_prod_mul_single Finset.univ_prod_mulSingleₓ'. -/
 @[to_additive]
 theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : (∏ i, Pi.mulSingle i (f i)) = f :=
-  by
-  ext a
-  simp
+  by ext a; simp
 #align finset.univ_prod_mul_single Finset.univ_prod_mulSingle
 #align finset.univ_sum_single Finset.univ_sum_single
 

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

@@ -131,10 +131,7 @@ theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : (∏ i, Pi.mul
 #align finset.univ_sum_single Finset.univ_sum_single
 
 /- warning: monoid_hom.functions_ext -> MonoidHom.functions_ext is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), CommMonoid.{u2} (Z i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : CommMonoid.{u3} G] (g : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (h : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u3} G (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (fun (_x : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (MonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) g (Pi.mulSingle.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (Z i) (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) i x)) (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (fun (_x : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (MonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) h (Pi.mulSingle.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (Z i) (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) i x))) -> (Eq.{max (succ u3) (succ (max u1 u2))} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) g h)
-but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), CommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : CommMonoid.{u2} G] (g : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (h : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), Z i) => G) (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), Z i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (MulOneClass.toMul.{max u3 u1} (forall (i : I), Z i) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))))) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (MonoidHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4)) (MonoidHom.monoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))))) g (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), Z i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (MulOneClass.toMul.{max u3 u1} (forall (i : I), Z i) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))))) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (MonoidHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4)) (MonoidHom.monoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))))) h (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) g h)
+<too large>
 Case conversion may be inaccurate. Consider using '#align monoid_hom.functions_ext MonoidHom.functions_extₓ'. -/
 @[to_additive]
 theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (∀ i, Z i) →* G)
@@ -175,10 +172,7 @@ variable {I : Type _} [DecidableEq I] {f : I → Type _}
 variable [∀ i, NonAssocSemiring (f i)]
 
 /- warning: ring_hom.functions_ext -> RingHom.functions_ext is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {f : I -> Type.{u2}} [_inst_2 : forall (i : I), NonAssocSemiring.{u2} (f i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : NonAssocSemiring.{u3} G] (g : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u3} G (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (fun (_x : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) => (forall (i : I), f i) -> G) (RingHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g (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) (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} (f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (f i) (_inst_2 i)))) i x)) (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (fun (_x : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) => (forall (i : I), f i) -> G) (RingHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) h (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) (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} (f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (f i) (_inst_2 i)))) i x))) -> (Eq.{max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
-but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {f : I -> Type.{u1}} [_inst_2 : forall (i : I), NonAssocSemiring.{u1} (f i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : NonAssocSemiring.{u2} G] (g : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), f i) => G) (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) g (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) h (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
+<too large>
 Case conversion may be inaccurate. Consider using '#align ring_hom.functions_ext RingHom.functions_extₓ'. -/
 @[ext]
 theorem RingHom.functions_ext [Finite I] (G : Type _) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)

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

@@ -134,7 +134,7 @@ theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : (∏ i, Pi.mul
 lean 3 declaration is
   forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), CommMonoid.{u2} (Z i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : CommMonoid.{u3} G] (g : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (h : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u3} G (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (fun (_x : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (MonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) g (Pi.mulSingle.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (Z i) (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) i x)) (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (fun (_x : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (MonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) h (Pi.mulSingle.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (Z i) (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) i x))) -> (Eq.{max (succ u3) (succ (max u1 u2))} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) g h)
 but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), CommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : CommMonoid.{u2} G] (g : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (h : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), Z i) => G) (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), Z i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (MulOneClass.toMul.{max u3 u1} (forall (i : I), Z i) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))))) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (MonoidHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4)) (MonoidHom.monoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))))) g (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), Z i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (MulOneClass.toMul.{max u3 u1} (forall (i : I), Z i) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))))) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (MonoidHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4)) (MonoidHom.monoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))))) h (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) g h)
+  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), CommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : CommMonoid.{u2} G] (g : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (h : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), Z i) => G) (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), Z i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (MulOneClass.toMul.{max u3 u1} (forall (i : I), Z i) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))))) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (MonoidHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4)) (MonoidHom.monoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))))) g (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), Z i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (MulOneClass.toMul.{max u3 u1} (forall (i : I), Z i) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))))) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (MonoidHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4)) (MonoidHom.monoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))))) h (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) g h)
 Case conversion may be inaccurate. Consider using '#align monoid_hom.functions_ext MonoidHom.functions_extₓ'. -/
 @[to_additive]
 theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (∀ i, Z i) →* G)
@@ -178,7 +178,7 @@ variable [∀ i, NonAssocSemiring (f i)]
 lean 3 declaration is
   forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {f : I -> Type.{u2}} [_inst_2 : forall (i : I), NonAssocSemiring.{u2} (f i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : NonAssocSemiring.{u3} G] (g : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u3} G (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (fun (_x : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) => (forall (i : I), f i) -> G) (RingHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g (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) (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} (f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (f i) (_inst_2 i)))) i x)) (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (fun (_x : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) => (forall (i : I), f i) -> G) (RingHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) h (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) (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} (f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (f i) (_inst_2 i)))) i x))) -> (Eq.{max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
 but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {f : I -> Type.{u1}} [_inst_2 : forall (i : I), NonAssocSemiring.{u1} (f i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : NonAssocSemiring.{u2} G] (g : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), f i) => G) (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) g (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) h (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
+  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {f : I -> Type.{u1}} [_inst_2 : forall (i : I), NonAssocSemiring.{u1} (f i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : NonAssocSemiring.{u2} G] (g : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), f i) => G) (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) g (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) h (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
 Case conversion may be inaccurate. Consider using '#align ring_hom.functions_ext RingHom.functions_extₓ'. -/
 @[ext]
 theorem RingHom.functions_ext [Finite I] (G : Type _) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

@@ -116,6 +116,12 @@ variable {I : Type _} [DecidableEq I] {Z : I → Type _}
 
 variable [∀ i, CommMonoid (Z i)]
 
+/- warning: finset.univ_prod_mul_single -> Finset.univ_prod_mulSingle is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), CommMonoid.{u2} (Z i)] [_inst_3 : Fintype.{u1} I] (f : forall (i : I), Z i), Eq.{succ (max u1 u2)} (forall (i : I), Z i) (Finset.prod.{max u1 u2, u1} (forall (i : I), Z i) I (Pi.commMonoid.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => _inst_2 i)) (Finset.univ.{u1} I _inst_3) (fun (i : I) => Pi.mulSingle.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (Z i) (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) i (f i))) f
+but is expected to have type
+  forall {I : Type.{u2}} [_inst_1 : DecidableEq.{succ u2} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), CommMonoid.{u1} (Z i)] [_inst_3 : Fintype.{u2} I] (f : forall (i : I), Z i), Eq.{max (succ u2) (succ u1)} (forall (i : I), Z i) (Finset.prod.{max u1 u2, u2} (forall (i : I), Z i) I (Pi.commMonoid.{u2, u1} I (fun (i : I) => Z i) (fun (i : I) => _inst_2 i)) (Finset.univ.{u2} I _inst_3) (fun (i : I) => Pi.mulSingle.{u2, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i (f i))) f
+Case conversion may be inaccurate. Consider using '#align finset.univ_prod_mul_single Finset.univ_prod_mulSingleₓ'. -/
 @[to_additive]
 theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : (∏ i, Pi.mulSingle i (f i)) = f :=
   by
@@ -124,6 +130,12 @@ theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : (∏ i, Pi.mul
 #align finset.univ_prod_mul_single Finset.univ_prod_mulSingle
 #align finset.univ_sum_single Finset.univ_sum_single
 
+/- warning: monoid_hom.functions_ext -> MonoidHom.functions_ext is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), CommMonoid.{u2} (Z i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : CommMonoid.{u3} G] (g : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (h : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u3} G (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (fun (_x : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (MonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) g (Pi.mulSingle.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (Z i) (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) i x)) (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) (fun (_x : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (MonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) h (Pi.mulSingle.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulOneClass.toHasOne.{u2} (Z i) (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) i x))) -> (Eq.{max (succ u3) (succ (max u1 u2))} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} G (CommMonoid.toMonoid.{u3} G _inst_4))) g h)
+but is expected to have type
+  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), CommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : CommMonoid.{u2} G] (g : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (h : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), Z i) => G) (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), Z i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (MulOneClass.toMul.{max u3 u1} (forall (i : I), Z i) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))))) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (MonoidHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4)) (MonoidHom.monoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))))) g (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), Z i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (MulOneClass.toMul.{max u3 u1} (forall (i : I), Z i) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))))) (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (MonoidHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4)) (MonoidHom.monoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))))) h (Pi.mulSingle.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toOne.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} G (CommMonoid.toMonoid.{u2} G _inst_4))) g h)
+Case conversion may be inaccurate. Consider using '#align monoid_hom.functions_ext MonoidHom.functions_extₓ'. -/
 @[to_additive]
 theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (∀ i, Z i) →* G)
     (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h :=
@@ -135,6 +147,12 @@ theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (
 #align monoid_hom.functions_ext MonoidHom.functions_ext
 #align add_monoid_hom.functions_ext AddMonoidHom.functions_ext
 
+/- warning: monoid_hom.functions_ext' -> MonoidHom.functions_ext' is a dubious translation:
+lean 3 declaration is
+  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), CommMonoid.{u2} (Z i)] [_inst_3 : Finite.{succ u1} I] (M : Type.{u3}) [_inst_4 : CommMonoid.{u3} M] (g : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4))) (h : MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4))), (forall (i : I), Eq.{max (succ u3) (succ u2)} (MonoidHom.{u2, u3} (Z i) M (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4))) (MonoidHom.comp.{u2, max u1 u2, u3} (Z i) (forall (i : I), Z i) M (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4)) g (MonoidHom.single.{u1, u2} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) i)) (MonoidHom.comp.{u2, max u1 u2, u3} (Z i) (forall (i : I), Z i) M (Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4)) h (MonoidHom.single.{u1, u2} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i))) i))) -> (Eq.{max (succ u3) (succ (max u1 u2))} (MonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.mulOneClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u2} (Z i) (CommMonoid.toMonoid.{u2} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4))) g h)
+but is expected to have type
+  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), CommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (M : Type.{u2}) [_inst_4 : CommMonoid.{u2} M] (g : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (h : MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))), (forall (i : I), Eq.{max (succ u1) (succ u2)} (MonoidHom.{u1, u2} (Z i) M (Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (MonoidHom.comp.{u1, max u3 u1, u2} (Z i) (forall (i : I), Z i) M (Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)) g (MonoidHom.single.{u3, u1} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i)) (MonoidHom.comp.{u1, max u3 u1, u2} (Z i) (forall (i : I), Z i) M (Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)) h (MonoidHom.single.{u3, u1} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i))) i))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (MonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.mulOneClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => Monoid.toMulOneClass.{u1} (Z i) (CommMonoid.toMonoid.{u1} (Z i) (_inst_2 i)))) (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) g h)
+Case conversion may be inaccurate. Consider using '#align monoid_hom.functions_ext' MonoidHom.functions_ext'ₓ'. -/
 /-- This is used as the ext lemma instead of `monoid_hom.functions_ext` for reasons explained in
 note [partially-applied ext lemmas]. -/
 @[ext,

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

@@ -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.big_operators.pi
-! leanprover-community/mathlib commit 327c3c0d9232d80e250dc8f65e7835b82b266ea5
+! leanprover-community/mathlib commit fa2309577c7009ea243cffdf990cd6c84f0ad497
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -110,59 +110,43 @@ theorem prod_mk_prod {α β γ : Type _} [CommMonoid α] [CommMonoid β] (s : Fi
 #align prod_mk_prod prod_mk_prod
 #align prod_mk_sum prod_mk_sum
 
-section Single
+section MulSingle
 
 variable {I : Type _} [DecidableEq I] {Z : I → Type _}
 
-variable [∀ i, AddCommMonoid (Z i)]
+variable [∀ i, CommMonoid (Z i)]
 
-/- warning: finset.univ_sum_single -> Finset.univ_sum_single is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), AddCommMonoid.{u2} (Z i)] [_inst_3 : Fintype.{u1} I] (f : forall (i : I), Z i), Eq.{succ (max u1 u2)} (forall (i : I), Z i) (Finset.sum.{max u1 u2, u1} (forall (i : I), Z i) I (Pi.addCommMonoid.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => _inst_2 i)) (Finset.univ.{u1} I _inst_3) (fun (i : I) => Pi.single.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddZeroClass.toHasZero.{u2} (Z i) (AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) i (f i))) f
-but is expected to have type
-  forall {I : Type.{u2}} [_inst_1 : DecidableEq.{succ u2} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), AddCommMonoid.{u1} (Z i)] [_inst_3 : Fintype.{u2} I] (f : forall (i : I), Z i), Eq.{max (succ u2) (succ u1)} (forall (i : I), Z i) (Finset.sum.{max u1 u2, u2} (forall (i : I), Z i) I (Pi.addCommMonoid.{u2, u1} I (fun (i : I) => Z i) (fun (i : I) => _inst_2 i)) (Finset.univ.{u2} I _inst_3) (fun (i : I) => Pi.single.{u2, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i (f i))) f
-Case conversion may be inaccurate. Consider using '#align finset.univ_sum_single Finset.univ_sum_singleₓ'. -/
--- As we only defined `single` into `add_monoid`, we only prove the `finset.sum` version here.
-theorem Finset.univ_sum_single [Fintype I] (f : ∀ i, Z i) : (∑ i, Pi.single i (f i)) = f :=
+@[to_additive]
+theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) : (∏ i, Pi.mulSingle i (f i)) = f :=
   by
   ext a
   simp
+#align finset.univ_prod_mul_single Finset.univ_prod_mulSingle
 #align finset.univ_sum_single Finset.univ_sum_single
 
-/- warning: add_monoid_hom.functions_ext -> AddMonoidHom.functions_ext is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), AddCommMonoid.{u2} (Z i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : AddCommMonoid.{u3} G] (g : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) (h : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u3} G (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) (fun (_x : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (AddMonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) g (Pi.single.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddZeroClass.toHasZero.{u2} (Z i) (AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) i x)) (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) (fun (_x : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (AddMonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) h (Pi.single.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddZeroClass.toHasZero.{u2} (Z i) (AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) i x))) -> (Eq.{max (succ u3) (succ (max u1 u2))} (AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) g h)
-but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), AddCommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : AddCommMonoid.{u2} G] (g : AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (h : AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : forall (i : I), Z i) => G) (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : forall (i : I), Z i) => G) _x) (AddHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (AddZeroClass.toAdd.{max u3 u1} (forall (i : I), Z i) (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))))) (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (AddMonoidHomClass.toAddHomClass.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4)) (AddMonoidHom.addMonoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))))) g (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : forall (i : I), Z i) => G) _x) (AddHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (AddZeroClass.toAdd.{max u3 u1} (forall (i : I), Z i) (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))))) (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (AddMonoidHomClass.toAddHomClass.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4)) (AddMonoidHom.addMonoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))))) h (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) g h)
-Case conversion may be inaccurate. Consider using '#align add_monoid_hom.functions_ext AddMonoidHom.functions_extₓ'. -/
-theorem AddMonoidHom.functions_ext [Finite I] (G : Type _) [AddCommMonoid G] (g h : (∀ i, Z i) →+ G)
-    (H : ∀ i x, g (Pi.single i x) = h (Pi.single i x)) : g = h :=
+@[to_additive]
+theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (∀ i, Z i) →* G)
+    (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h :=
   by
   cases nonempty_fintype I
   ext k
-  rw [← Finset.univ_sum_single k, g.map_sum, h.map_sum]
+  rw [← Finset.univ_prod_mulSingle k, g.map_prod, h.map_prod]
   simp only [H]
+#align monoid_hom.functions_ext MonoidHom.functions_ext
 #align add_monoid_hom.functions_ext AddMonoidHom.functions_ext
 
-/- warning: add_monoid_hom.functions_ext' -> AddMonoidHom.functions_ext' is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), AddCommMonoid.{u2} (Z i)] [_inst_3 : Finite.{succ u1} I] (M : Type.{u3}) [_inst_4 : AddCommMonoid.{u3} M] (g : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} M (AddCommMonoid.toAddMonoid.{u3} M _inst_4))) (h : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} M (AddCommMonoid.toAddMonoid.{u3} M _inst_4))), (forall (i : I), Eq.{max (succ u3) (succ u2)} (AddMonoidHom.{u2, u3} (Z i) M (AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i))) (AddMonoid.toAddZeroClass.{u3} M (AddCommMonoid.toAddMonoid.{u3} M _inst_4))) (AddMonoidHom.comp.{u2, max u1 u2, u3} (Z i) (forall (i : I), Z i) M (AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i))) (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} M (AddCommMonoid.toAddMonoid.{u3} M _inst_4)) g (AddMonoidHom.single.{u1, u2} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i))) i)) (AddMonoidHom.comp.{u2, max u1 u2, u3} (Z i) (forall (i : I), Z i) M (AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i))) (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} M (AddCommMonoid.toAddMonoid.{u3} M _inst_4)) h (AddMonoidHom.single.{u1, u2} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i))) i))) -> (Eq.{max (succ u3) (succ (max u1 u2))} (AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) M (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} M (AddCommMonoid.toAddMonoid.{u3} M _inst_4))) g h)
-but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), AddCommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (M : Type.{u2}) [_inst_4 : AddCommMonoid.{u2} M] (g : AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_4))) (h : AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_4))), (forall (i : I), Eq.{max (succ u1) (succ u2)} (AddMonoidHom.{u1, u2} (Z i) M (AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_4))) (AddMonoidHom.comp.{u1, max u3 u1, u2} (Z i) (forall (i : I), Z i) M (AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_4)) g (AddMonoidHom.single.{u3, u1} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i)) (AddMonoidHom.comp.{u1, max u3 u1, u2} (Z i) (forall (i : I), Z i) M (AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_4)) h (AddMonoidHom.single.{u3, u1} I Z (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) M (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_4))) g h)
-Case conversion may be inaccurate. Consider using '#align add_monoid_hom.functions_ext' AddMonoidHom.functions_ext'ₓ'. -/
-/-- This is used as the ext lemma instead of `add_monoid_hom.functions_ext` for reasons explained in
+/-- This is used as the ext lemma instead of `monoid_hom.functions_ext` for reasons explained in
 note [partially-applied ext lemmas]. -/
-@[ext]
-theorem AddMonoidHom.functions_ext' [Finite I] (M : Type _) [AddCommMonoid M]
-    (g h : (∀ i, Z i) →+ M)
-    (H : ∀ i, g.comp (AddMonoidHom.single Z i) = h.comp (AddMonoidHom.single Z i)) : g = h :=
-  have := fun i => AddMonoidHom.congr_fun (H i)
-  -- elab without an expected type
-      g.functions_ext
-    M h this
+@[ext,
+  to_additive
+      "\nThis is used as the ext lemma instead of `add_monoid_hom.functions_ext` for reasons explained in\nnote [partially-applied ext lemmas]."]
+theorem MonoidHom.functions_ext' [Finite I] (M : Type _) [CommMonoid M] (g h : (∀ i, Z i) →* M)
+    (H : ∀ i, g.comp (MonoidHom.single Z i) = h.comp (MonoidHom.single Z i)) : g = h :=
+  g.functions_ext M h fun i => MonoidHom.congr_fun (H i)
+#align monoid_hom.functions_ext' MonoidHom.functions_ext'
 #align add_monoid_hom.functions_ext' AddMonoidHom.functions_ext'
 
-end Single
+end MulSingle
 
 section RingHom
 

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

@@ -133,7 +133,7 @@ theorem Finset.univ_sum_single [Fintype I] (f : ∀ i, Z i) : (∑ i, Pi.single
 lean 3 declaration is
   forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {Z : I -> Type.{u2}} [_inst_2 : forall (i : I), AddCommMonoid.{u2} (Z i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : AddCommMonoid.{u3} G] (g : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) (h : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u3} G (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) (fun (_x : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (AddMonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) g (Pi.single.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddZeroClass.toHasZero.{u2} (Z i) (AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) i x)) (coeFn.{max (succ u3) (succ (max u1 u2)), max (succ (max u1 u2)) (succ u3)} (AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) (fun (_x : AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) => (forall (i : I), Z i) -> G) (AddMonoidHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) h (Pi.single.{u1, u2} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddZeroClass.toHasZero.{u2} (Z i) (AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) i x))) -> (Eq.{max (succ u3) (succ (max u1 u2))} (AddMonoidHom.{max u1 u2, u3} (forall (i : I), Z i) G (Pi.addZeroClass.{u1, u2} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u2} (Z i) (AddCommMonoid.toAddMonoid.{u2} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u3} G (AddCommMonoid.toAddMonoid.{u3} G _inst_4))) g h)
 but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), AddCommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : AddCommMonoid.{u2} G] (g : AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (h : AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : forall (i : I), Z i) => G) (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : forall (i : I), Z i) => G) _x) (AddHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (AddZeroClass.toAdd.{max u3 u1} (forall (i : I), Z i) (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))))) (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (AddMonoidHomClass.toAddHomClass.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4)) (AddMonoidHom.addMonoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))))) g (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : forall (i : I), Z i) => G) _x) (AddHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (AddZeroClass.toAdd.{max u3 u1} (forall (i : I), Z i) (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))))) (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (AddMonoidHomClass.toAddHomClass.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4)) (AddMonoidHom.addMonoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))))) h (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) g h)
+  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {Z : I -> Type.{u1}} [_inst_2 : forall (i : I), AddCommMonoid.{u1} (Z i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : AddCommMonoid.{u2} G] (g : AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (h : AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))), (forall (i : I) (x : Z i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : forall (i : I), Z i) => G) (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : forall (i : I), Z i) => G) _x) (AddHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (AddZeroClass.toAdd.{max u3 u1} (forall (i : I), Z i) (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))))) (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (AddMonoidHomClass.toAddHomClass.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4)) (AddMonoidHom.addMonoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))))) g (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) (fun (_x : forall (i : I), Z i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : forall (i : I), Z i) => G) _x) (AddHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (AddZeroClass.toAdd.{max u3 u1} (forall (i : I), Z i) (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))))) (AddZeroClass.toAdd.{u2} G (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (AddMonoidHomClass.toAddHomClass.{max (max u3 u1) u2, max u3 u1, u2} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4)) (AddMonoidHom.addMonoidHomClass.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))))) h (Pi.single.{u3, u1} I (fun (i : I) => Z i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => AddMonoid.toZero.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (AddMonoidHom.{max u3 u1, u2} (forall (i : I), Z i) G (Pi.addZeroClass.{u3, u1} I (fun (i : I) => Z i) (fun (i : I) => AddMonoid.toAddZeroClass.{u1} (Z i) (AddCommMonoid.toAddMonoid.{u1} (Z i) (_inst_2 i)))) (AddMonoid.toAddZeroClass.{u2} G (AddCommMonoid.toAddMonoid.{u2} G _inst_4))) g h)
 Case conversion may be inaccurate. Consider using '#align add_monoid_hom.functions_ext AddMonoidHom.functions_extₓ'. -/
 theorem AddMonoidHom.functions_ext [Finite I] (G : Type _) [AddCommMonoid G] (g h : (∀ i, Z i) →+ G)
     (H : ∀ i x, g (Pi.single i x) = h (Pi.single i x)) : g = h :=
@@ -176,7 +176,7 @@ variable [∀ i, NonAssocSemiring (f i)]
 lean 3 declaration is
   forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {f : I -> Type.{u2}} [_inst_2 : forall (i : I), NonAssocSemiring.{u2} (f i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : NonAssocSemiring.{u3} G] (g : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u3} G (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (fun (_x : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) => (forall (i : I), f i) -> G) (RingHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g (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) (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} (f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (f i) (_inst_2 i)))) i x)) (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (fun (_x : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) => (forall (i : I), f i) -> G) (RingHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) h (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) (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} (f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (f i) (_inst_2 i)))) i x))) -> (Eq.{max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
 but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {f : I -> Type.{u1}} [_inst_2 : forall (i : I), NonAssocSemiring.{u1} (f i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : NonAssocSemiring.{u2} G] (g : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : forall (i : I), f i) => G) (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) g (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) h (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
+  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {f : I -> Type.{u1}} [_inst_2 : forall (i : I), NonAssocSemiring.{u1} (f i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : NonAssocSemiring.{u2} G] (g : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), f i) => G) (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) g (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) h (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
 Case conversion may be inaccurate. Consider using '#align ring_hom.functions_ext RingHom.functions_extₓ'. -/
 @[ext]
 theorem RingHom.functions_ext [Finite I] (G : Type _) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)

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

@@ -176,7 +176,7 @@ variable [∀ i, NonAssocSemiring (f i)]
 lean 3 declaration is
   forall {I : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} I] {f : I -> Type.{u2}} [_inst_2 : forall (i : I), NonAssocSemiring.{u2} (f i)] [_inst_3 : Finite.{succ u1} I] (G : Type.{u3}) [_inst_4 : NonAssocSemiring.{u3} G] (g : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u3} G (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (fun (_x : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) => (forall (i : I), f i) -> G) (RingHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g (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) (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} (f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (f i) (_inst_2 i)))) i x)) (coeFn.{max (succ (max u1 u2)) (succ u3), max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (fun (_x : RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) => (forall (i : I), f i) -> G) (RingHom.hasCoeToFun.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) h (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) (NonUnitalNonAssocSemiring.toMulZeroClass.{u2} (f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} (f i) (_inst_2 i)))) i x))) -> (Eq.{max (succ (max u1 u2)) (succ u3)} (RingHom.{max u1 u2, u3} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u1, u2} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
 but is expected to have type
-  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {f : I -> Type.{u1}} [_inst_2 : forall (i : I), NonAssocSemiring.{u1} (f i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : NonAssocSemiring.{u2} G] (g : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : forall (i : I), f i) => G) (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) g (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) h (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
+  forall {I : Type.{u3}} [_inst_1 : DecidableEq.{succ u3} I] {f : I -> Type.{u1}} [_inst_2 : forall (i : I), NonAssocSemiring.{u1} (f i)] [_inst_3 : Finite.{succ u3} I] (G : Type.{u2}) [_inst_4 : NonAssocSemiring.{u2} G] (g : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (h : RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4), (forall (i : I) (x : f i), Eq.{succ u2} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : forall (i : I), f i) => G) (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) g (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x)) (FunLike.coe.{max (max (succ u3) (succ u1)) (succ u2), max (succ u3) (succ u1), succ u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) (fun (_x : forall (i : I), f i) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : forall (i : I), f i) => G) _x) (MulHomClass.toFunLike.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonUnitalNonAssocSemiring.toMul.{max u3 u1} (forall (i : I), f i) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)))) (NonUnitalNonAssocSemiring.toMul.{u2} G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4)) (NonUnitalRingHomClass.toMulHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (NonAssocSemiring.toNonUnitalNonAssocSemiring.{max u3 u1} (forall (i : I), f i) (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i))) (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} G _inst_4) (RingHomClass.toNonUnitalRingHomClass.{max (max u3 u1) u2, max u3 u1, u2} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4 (RingHom.instRingHomClassRingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4)))) h (Pi.single.{u3, u1} I (fun (i : I) => f i) (fun (a : I) (b : I) => _inst_1 a b) (fun (i : I) => MulZeroOneClass.toZero.{u1} (f i) (NonAssocSemiring.toMulZeroOneClass.{u1} (f i) (_inst_2 i))) i x))) -> (Eq.{max (max (succ u3) (succ u1)) (succ u2)} (RingHom.{max u3 u1, u2} (forall (i : I), f i) G (Pi.nonAssocSemiring.{u3, u1} I (fun (i : I) => f i) (fun (i : I) => _inst_2 i)) _inst_4) g h)
 Case conversion may be inaccurate. Consider using '#align ring_hom.functions_ext RingHom.functions_extₓ'. -/
 @[ext]
 theorem RingHom.functions_ext [Finite I] (G : Type _) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)

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

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).

@@ -104,7 +104,7 @@ note [partially-applied ext lemmas]. -/
       "\nThis is used as the ext lemma instead of `AddMonoidHom.functions_ext` for reasons
       explained in note [partially-applied ext lemmas]."]
 theorem MonoidHom.functions_ext' [Finite I] (M : Type*) [CommMonoid M] (g h : (∀ i, Z i) →* M)
-    (H : ∀ i, g.comp (MonoidHom.single Z i) = h.comp (MonoidHom.single Z i)) : g = h :=
+    (H : ∀ i, g.comp (MonoidHom.mulSingle Z i) = h.comp (MonoidHom.mulSingle Z i)) : g = h :=
   g.functions_ext M h fun i => DFunLike.congr_fun (H i)
 #align monoid_hom.functions_ext' MonoidHom.functions_ext'
 #align add_monoid_hom.functions_ext' AddMonoidHom.functions_ext'

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)

@@ -78,7 +78,6 @@ theorem pi_eq_sum_univ {ι : Type*} [Fintype ι] [DecidableEq ι] {R : Type*} [S
 section MulSingle
 
 variable {I : Type*} [DecidableEq I] {Z : I → Type*}
-
 variable [∀ i, CommMonoid (Z i)]
 
 @[to_additive]
@@ -117,7 +116,6 @@ section RingHom
 open Pi
 
 variable {I : Type*} [DecidableEq I] {f : I → Type*}
-
 variable [∀ i, NonAssocSemiring (f i)]
 
 @[ext]

This prepares for the introduction of a non-dependent synonym of FunLike, which helps a lot with keeping #8386 readable.

This is entirely search-and-replace in 680197f combined with manual fixes in 4145626, e900597 and b8428f8. The commands that generated this change:

sed -i 's/\bFunLike\b/DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoFunLike\b/toDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/import Mathlib.Data.DFunLike/import Mathlib.Data.FunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bHom_FunLike\b/Hom_DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean     
sed -i 's/\binstFunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bfunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoo many metavariables to apply `fun_like.has_coe_to_fun`/too many metavariables to apply `DFunLike.hasCoeToFun`/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean

Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

@@ -106,7 +106,7 @@ note [partially-applied ext lemmas]. -/
       explained in note [partially-applied ext lemmas]."]
 theorem MonoidHom.functions_ext' [Finite I] (M : Type*) [CommMonoid M] (g h : (∀ i, Z i) →* M)
     (H : ∀ i, g.comp (MonoidHom.single Z i) = h.comp (MonoidHom.single Z i)) : g = h :=
-  g.functions_ext M h fun i => FunLike.congr_fun (H i)
+  g.functions_ext M h fun i => DFunLike.congr_fun (H i)
 #align monoid_hom.functions_ext' MonoidHom.functions_ext'
 #align add_monoid_hom.functions_ext' AddMonoidHom.functions_ext'
 

@@ -41,7 +41,7 @@ end Pi
 @[to_additive (attr := simp)]
 theorem Finset.prod_apply {α : Type*} {β : α → Type*} {γ} [∀ a, CommMonoid (β a)] (a : α)
     (s : Finset γ) (g : γ → ∀ a, β a) : (∏ c in s, g c) a = ∏ c in s, g c a :=
-  (Pi.evalMonoidHom β a).map_prod _ _
+  map_prod (Pi.evalMonoidHom β a) _ _
 #align finset.prod_apply Finset.prod_apply
 #align finset.sum_apply Finset.sum_apply
 
@@ -94,7 +94,7 @@ theorem MonoidHom.functions_ext [Finite I] (G : Type*) [CommMonoid G] (g h : (
     (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h := by
   cases nonempty_fintype I
   ext k
-  rw [← Finset.univ_prod_mulSingle k, g.map_prod, h.map_prod]
+  rw [← Finset.univ_prod_mulSingle k, map_prod, map_prod]
   simp only [H]
 #align monoid_hom.functions_ext MonoidHom.functions_ext
 #align add_monoid_hom.functions_ext AddMonoidHom.functions_ext
@@ -135,13 +135,13 @@ variable {α β γ : Type*} [CommMonoid α] [CommMonoid β] {s : Finset γ} {f :
 
 @[to_additive]
 theorem fst_prod : (∏ c in s, f c).1 = ∏ c in s, (f c).1 :=
-  (MonoidHom.fst α β).map_prod f s
+  map_prod (MonoidHom.fst α β) f s
 #align prod.fst_prod Prod.fst_prod
 #align prod.fst_sum Prod.fst_sum
 
 @[to_additive]
 theorem snd_prod : (∏ c in s, f c).2 = ∏ c in s, (f c).2 :=
-  (MonoidHom.snd α β).map_prod f s
+  map_prod (MonoidHom.snd α β) f s
 #align prod.snd_prod Prod.snd_prod
 #align prod.snd_sum Prod.snd_sum
 

This reduces the file from ~2600 lines to ~1600 lines.

Co-authored-by: Vierkantor <vierkantor@vierkantor.com> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

@@ -68,6 +68,13 @@ theorem prod_mk_prod {α β γ : Type*} [CommMonoid α] [CommMonoid β] (s : Fin
 #align prod_mk_prod prod_mk_prod
 #align prod_mk_sum prod_mk_sum
 
+/-- decomposing `x : ι → R` as a sum along the canonical basis -/
+theorem pi_eq_sum_univ {ι : Type*} [Fintype ι] [DecidableEq ι] {R : Type*} [Semiring R]
+    (x : ι → R) : x = ∑ i, (x i) • fun j => if i = j then (1 : R) else 0 := by
+  ext
+  simp
+#align pi_eq_sum_univ pi_eq_sum_univ
+
 section MulSingle
 
 variable {I : Type*} [DecidableEq I] {Z : I → Type*}

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -23,14 +23,14 @@ open BigOperators
 namespace Pi
 
 @[to_additive]
-theorem list_prod_apply {α : Type _} {β : α → Type _} [∀ a, Monoid (β a)] (a : α)
+theorem list_prod_apply {α : Type*} {β : α → Type*} [∀ a, Monoid (β a)] (a : α)
     (l : List (∀ a, β a)) : l.prod a = (l.map fun f : ∀ a, β a ↦ f a).prod :=
   (evalMonoidHom β a).map_list_prod _
 #align pi.list_prod_apply Pi.list_prod_apply
 #align pi.list_sum_apply Pi.list_sum_apply
 
 @[to_additive]
-theorem multiset_prod_apply {α : Type _} {β : α → Type _} [∀ a, CommMonoid (β a)] (a : α)
+theorem multiset_prod_apply {α : Type*} {β : α → Type*} [∀ a, CommMonoid (β a)] (a : α)
     (s : Multiset (∀ a, β a)) : s.prod a = (s.map fun f : ∀ a, β a ↦ f a).prod :=
   (evalMonoidHom β a).map_multiset_prod _
 #align pi.multiset_prod_apply Pi.multiset_prod_apply
@@ -39,7 +39,7 @@ theorem multiset_prod_apply {α : Type _} {β : α → Type _} [∀ a, CommMonoi
 end Pi
 
 @[to_additive (attr := simp)]
-theorem Finset.prod_apply {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (a : α)
+theorem Finset.prod_apply {α : Type*} {β : α → Type*} {γ} [∀ a, CommMonoid (β a)] (a : α)
     (s : Finset γ) (g : γ → ∀ a, β a) : (∏ c in s, g c) a = ∏ c in s, g c a :=
   (Pi.evalMonoidHom β a).map_prod _ _
 #align finset.prod_apply Finset.prod_apply
@@ -47,21 +47,21 @@ theorem Finset.prod_apply {α : Type _} {β : α → Type _} {γ} [∀ a, CommMo
 
 /-- An 'unapplied' analogue of `Finset.prod_apply`. -/
 @[to_additive "An 'unapplied' analogue of `Finset.sum_apply`."]
-theorem Finset.prod_fn {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (s : Finset γ)
+theorem Finset.prod_fn {α : Type*} {β : α → Type*} {γ} [∀ a, CommMonoid (β a)] (s : Finset γ)
     (g : γ → ∀ a, β a) : ∏ c in s, g c = fun a ↦ ∏ c in s, g c a :=
   funext fun _ ↦ Finset.prod_apply _ _ _
 #align finset.prod_fn Finset.prod_fn
 #align finset.sum_fn Finset.sum_fn
 
 @[to_additive]
-theorem Fintype.prod_apply {α : Type _} {β : α → Type _} {γ : Type _} [Fintype γ]
+theorem Fintype.prod_apply {α : Type*} {β : α → Type*} {γ : Type*} [Fintype γ]
     [∀ a, CommMonoid (β a)] (a : α) (g : γ → ∀ a, β a) : (∏ c, g c) a = ∏ c, g c a :=
   Finset.prod_apply a Finset.univ g
 #align fintype.prod_apply Fintype.prod_apply
 #align fintype.sum_apply Fintype.sum_apply
 
 @[to_additive prod_mk_sum]
-theorem prod_mk_prod {α β γ : Type _} [CommMonoid α] [CommMonoid β] (s : Finset γ) (f : γ → α)
+theorem prod_mk_prod {α β γ : Type*} [CommMonoid α] [CommMonoid β] (s : Finset γ) (f : γ → α)
     (g : γ → β) : (∏ x in s, f x, ∏ x in s, g x) = ∏ x in s, (f x, g x) :=
   haveI := Classical.decEq γ
   Finset.induction_on s rfl (by simp (config := { contextual := true }) [Prod.ext_iff])
@@ -70,7 +70,7 @@ theorem prod_mk_prod {α β γ : Type _} [CommMonoid α] [CommMonoid β] (s : Fi
 
 section MulSingle
 
-variable {I : Type _} [DecidableEq I] {Z : I → Type _}
+variable {I : Type*} [DecidableEq I] {Z : I → Type*}
 
 variable [∀ i, CommMonoid (Z i)]
 
@@ -83,7 +83,7 @@ theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) :
 #align finset.univ_sum_single Finset.univ_sum_single
 
 @[to_additive]
-theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (∀ i, Z i) →* G)
+theorem MonoidHom.functions_ext [Finite I] (G : Type*) [CommMonoid G] (g h : (∀ i, Z i) →* G)
     (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h := by
   cases nonempty_fintype I
   ext k
@@ -97,7 +97,7 @@ note [partially-applied ext lemmas]. -/
 @[to_additive (attr := ext)
       "\nThis is used as the ext lemma instead of `AddMonoidHom.functions_ext` for reasons
       explained in note [partially-applied ext lemmas]."]
-theorem MonoidHom.functions_ext' [Finite I] (M : Type _) [CommMonoid M] (g h : (∀ i, Z i) →* M)
+theorem MonoidHom.functions_ext' [Finite I] (M : Type*) [CommMonoid M] (g h : (∀ i, Z i) →* M)
     (H : ∀ i, g.comp (MonoidHom.single Z i) = h.comp (MonoidHom.single Z i)) : g = h :=
   g.functions_ext M h fun i => FunLike.congr_fun (H i)
 #align monoid_hom.functions_ext' MonoidHom.functions_ext'
@@ -109,12 +109,12 @@ section RingHom
 
 open Pi
 
-variable {I : Type _} [DecidableEq I] {f : I → Type _}
+variable {I : Type*} [DecidableEq I] {f : I → Type*}
 
 variable [∀ i, NonAssocSemiring (f i)]
 
 @[ext]
-theorem RingHom.functions_ext [Finite I] (G : Type _) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)
+theorem RingHom.functions_ext [Finite I] (G : Type*) [NonAssocSemiring G] (g h : (∀ i, f i) →+* G)
     (H : ∀ (i : I) (x : f i), g (single i x) = h (single i x)) : g = h :=
   RingHom.coe_addMonoidHom_injective <|
     @AddMonoidHom.functions_ext I _ f _ _ G _ (g : (∀ i, f i) →+ G) h H
@@ -124,7 +124,7 @@ end RingHom
 
 namespace Prod
 
-variable {α β γ : Type _} [CommMonoid α] [CommMonoid β] {s : Finset γ} {f : γ → α × β}
+variable {α β γ : Type*} [CommMonoid α] [CommMonoid β] {s : Finset γ} {f : γ → α × β}
 
 @[to_additive]
 theorem fst_prod : (∏ c in s, f c).1 = ∏ c in s, (f c).1 :=

• depends on: #5966

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

@@ -2,17 +2,14 @@
 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.big_operators.pi
-! leanprover-community/mathlib commit fa2309577c7009ea243cffdf990cd6c84f0ad497
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fintype.Card
 import Mathlib.Algebra.Group.Prod
 import Mathlib.Algebra.BigOperators.Basic
 import Mathlib.Algebra.Ring.Pi
 
+#align_import algebra.big_operators.pi from "leanprover-community/mathlib"@"fa2309577c7009ea243cffdf990cd6c84f0ad497"
+
 /-!
 # Big operators for Pi Types
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

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

@@ -75,7 +75,7 @@ section MulSingle
 
 variable {I : Type _} [DecidableEq I] {Z : I → Type _}
 
-variable [∀ i, CommMonoid  (Z i)]
+variable [∀ i, CommMonoid (Z i)]
 
 @[to_additive]
 theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) :

• Also remove most superfluous parentheses around big operators (∑, ∏ and variants).
• roughly the used regex: ([^a-zA-Zα-ωΑ-Ω'𝓝ℳ₀𝕂ₛ)]) \(([∑∏][^()∑∏]*,[^()∑∏:]*)\) ([⊂⊆=<≤]) replaced by $1 $2 $3

@@ -51,7 +51,7 @@ theorem Finset.prod_apply {α : Type _} {β : α → Type _} {γ} [∀ a, CommMo
 /-- An 'unapplied' analogue of `Finset.prod_apply`. -/
 @[to_additive "An 'unapplied' analogue of `Finset.sum_apply`."]
 theorem Finset.prod_fn {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (s : Finset γ)
-    (g : γ → ∀ a, β a) : (∏ c in s, g c) = fun a ↦ ∏ c in s, g c a :=
+    (g : γ → ∀ a, β a) : ∏ c in s, g c = fun a ↦ ∏ c in s, g c a :=
   funext fun _ ↦ Finset.prod_apply _ _ _
 #align finset.prod_fn Finset.prod_fn
 #align finset.sum_fn Finset.sum_fn

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -41,7 +41,7 @@ theorem multiset_prod_apply {α : Type _} {β : α → Type _} [∀ a, CommMonoi
 
 end Pi
 
-@[to_additive (attr:=simp)]
+@[to_additive (attr := simp)]
 theorem Finset.prod_apply {α : Type _} {β : α → Type _} {γ} [∀ a, CommMonoid (β a)] (a : α)
     (s : Finset γ) (g : γ → ∀ a, β a) : (∏ c in s, g c) a = ∏ c in s, g c a :=
   (Pi.evalMonoidHom β a).map_prod _ _

@@ -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.big_operators.pi
-! leanprover-community/mathlib commit 509de852e1de55e1efa8eacfa11df0823f26f226
+! leanprover-community/mathlib commit fa2309577c7009ea243cffdf990cd6c84f0ad497
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -71,37 +71,42 @@ theorem prod_mk_prod {α β γ : Type _} [CommMonoid α] [CommMonoid β] (s : Fi
 #align prod_mk_prod prod_mk_prod
 #align prod_mk_sum prod_mk_sum
 
-section Single
+section MulSingle
 
 variable {I : Type _} [DecidableEq I] {Z : I → Type _}
 
-variable [∀ i, AddCommMonoid (Z i)]
+variable [∀ i, CommMonoid  (Z i)]
 
--- As we only defined `single` into `add_monoid`, we only prove the `Finset.sum` version here.
-theorem Finset.univ_sum_single [Fintype I] (f : ∀ i, Z i) : (∑ i, Pi.single i (f i)) = f := by
+@[to_additive]
+theorem Finset.univ_prod_mulSingle [Fintype I] (f : ∀ i, Z i) :
+    (∏ i, Pi.mulSingle i (f i)) = f := by
   ext a
   simp
+#align finset.univ_prod_mul_single Finset.univ_prod_mulSingle
 #align finset.univ_sum_single Finset.univ_sum_single
 
-theorem AddMonoidHom.functions_ext [Finite I] (G : Type _) [AddCommMonoid G] (g h : (∀ i, Z i) →+ G)
-    (H : ∀ i x, g (Pi.single i x) = h (Pi.single i x)) : g = h := by
+@[to_additive]
+theorem MonoidHom.functions_ext [Finite I] (G : Type _) [CommMonoid G] (g h : (∀ i, Z i) →* G)
+    (H : ∀ i x, g (Pi.mulSingle i x) = h (Pi.mulSingle i x)) : g = h := by
   cases nonempty_fintype I
   ext k
-  rw [← Finset.univ_sum_single k, g.map_sum, h.map_sum]
+  rw [← Finset.univ_prod_mulSingle k, g.map_prod, h.map_prod]
   simp only [H]
+#align monoid_hom.functions_ext MonoidHom.functions_ext
 #align add_monoid_hom.functions_ext AddMonoidHom.functions_ext
 
-/-- This is used as the ext lemma instead of `AddMonoidHom.functions_ext` for reasons explained in
+/-- This is used as the ext lemma instead of `MonoidHom.functions_ext` for reasons explained in
 note [partially-applied ext lemmas]. -/
-@[ext]
-theorem AddMonoidHom.functions_ext' [Finite I] (M : Type _) [AddCommMonoid M]
-    (g h : (∀ i, Z i) →+ M)
-    (H : ∀ i, g.comp (AddMonoidHom.single Z i) = h.comp (AddMonoidHom.single Z i)) : g = h :=
-  have := fun i ↦ FunLike.congr_fun (H i)
-  g.functions_ext M h this
+@[to_additive (attr := ext)
+      "\nThis is used as the ext lemma instead of `AddMonoidHom.functions_ext` for reasons
+      explained in note [partially-applied ext lemmas]."]
+theorem MonoidHom.functions_ext' [Finite I] (M : Type _) [CommMonoid M] (g h : (∀ i, Z i) →* M)
+    (H : ∀ i, g.comp (MonoidHom.single Z i) = h.comp (MonoidHom.single Z i)) : g = h :=
+  g.functions_ext M h fun i => FunLike.congr_fun (H i)
+#align monoid_hom.functions_ext' MonoidHom.functions_ext'
 #align add_monoid_hom.functions_ext' AddMonoidHom.functions_ext'
 
-end Single
+end MulSingle
 
 section RingHom
 

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

@@ -77,7 +77,7 @@ variable {I : Type _} [DecidableEq I] {Z : I → Type _}
 
 variable [∀ i, AddCommMonoid (Z i)]
 
--- As we only defined `single` into `add_monoid`, we only prove the `finset.sum` version here.
+-- As we only defined `single` into `add_monoid`, we only prove the `Finset.sum` version here.
 theorem Finset.univ_sum_single [Fintype I] (f : ∀ i, Z i) : (∑ i, Pi.single i (f i)) = f := by
   ext a
   simp

@@ -21,8 +21,7 @@ of monoids and groups
 -/
 
 
--- Port note: commented out the next line
--- open BigOperators
+open BigOperators
 
 namespace Pi
 

This PR is the result of a slight variant on the following "algorithm"

• take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
• take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
• look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
• for pairs that do not have an align statement:
  • use Lean 4 to lookup the file + position of the Lean 4 name
  • add an #align statement just before the next empty line
• manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

@@ -70,7 +70,7 @@ theorem prod_mk_prod {α β γ : Type _} [CommMonoid α] [CommMonoid β] (s : Fi
   haveI := Classical.decEq γ
   Finset.induction_on s rfl (by simp (config := { contextual := true }) [Prod.ext_iff])
 #align prod_mk_prod prod_mk_prod
-#align sum_mk_sum prod_mk_sum
+#align prod_mk_sum prod_mk_sum
 
 section Single
 

Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com>