Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

6c5f73fd

(last sync)

feat(algebra/big_operators/basic): finset.sum under mod (#18364)

and ∏ a in s, f a = b ^ s.card if f a = b for all a

Diff

@@ -3,6 +3,7 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
+import data.int.order.basic
 import data.list.forall2
 
 /-!
@@ -543,6 +544,18 @@ by rw [div_eq_mul_inv, alternating_prod_cons']
 
 end alternating
 
+lemma sum_nat_mod (l : list ℕ) (n : ℕ) : l.sum % n = (l.map (% n)).sum % n :=
+by induction l; simp [nat.add_mod, *]
+
+lemma prod_nat_mod (l : list ℕ) (n : ℕ) : l.prod % n = (l.map (% n)).prod % n :=
+by induction l; simp [nat.mul_mod, *]
+
+lemma sum_int_mod (l : list ℤ) (n : ℤ) : l.sum % n = (l.map (% n)).sum % n :=
+by induction l; simp [int.add_mod, *]
+
+lemma prod_int_mod (l : list ℤ) (n : ℤ) : l.prod % n = (l.map (% n)).prod % n :=
+by induction l; simp [int.mul_mod, *]
+
 end list
 
 section monoid_hom

bb37dbda

feat(algebra/big_operators/order): prod_pos lemma for ennreal (#18391)

This adds:

canonically_ordered_comm_semiring.list_prod_pos
canonically_ordered_comm_semiring.multiset_prod_pos
canonically_ordered_comm_semiring.prod_pos

which extend the existing canonically_ordered_comm_semiring.mul_pos. Primarily, these are intended for use on enat and ennreal, which don't satisfy the typeclasses required by list.prod_pos and finset.prod_pos. At any rate, those statements are weaker.

Forward port in https://github.com/leanprover-community/mathlib4/pull/2120

Diff

@@ -486,6 +486,16 @@ begin
     exact mul_pos (h _ $ mem_cons_self _ _) (ih $ λ a ha, h a $ mem_cons_of_mem _ ha) }
 end
 
+/-- A variant of `list.prod_pos` for `canonically_ordered_comm_semiring`. -/
+@[simp]
+lemma _root_.canonically_ordered_comm_semiring.list_prod_pos
+  {α : Type*} [canonically_ordered_comm_semiring α] [nontrivial α] :
+    Π {l : list α}, 0 < l.prod ↔ (∀ x ∈ l, (0 : α) < x)
+| [] := ⟨λ h x hx, hx.elim, λ _, zero_lt_one⟩
+| (x :: xs) := by simp_rw [prod_cons, mem_cons_iff, forall_eq_or_imp,
+    canonically_ordered_comm_semiring.mul_pos,
+    _root_.canonically_ordered_comm_semiring.list_prod_pos]
+
 /-!
 Several lemmas about sum/head/tail for `list ℕ`.
 These are hard to generalize well, as they rely on the fact that `default ℕ = 0`.

47adfab3

chore(*): sync list.replicate with Mathlib 4 (#18181)

Sync arguments order and golfs with leanprover-community/mathlib4#1579

Diff

@@ -51,7 +51,7 @@ lemma prod_eq_foldr : l.prod = foldr (*) 1 l :=
 list.rec_on l rfl $ λ a l ihl, by rw [prod_cons, foldr_cons, ihl]
 
 @[simp, priority 500, to_additive]
-theorem prod_replicate (a : M) (n : ℕ) : (replicate n a).prod = a ^ n :=
+theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).prod = a ^ n :=
 begin
   induction n with n ih,
   { rw pow_zero, refl },
@@ -94,13 +94,8 @@ l.prod_hom₂ (*) mul_mul_mul_comm (mul_one _) _ _
 @[simp]
 lemma prod_map_neg {α} [comm_monoid α] [has_distrib_neg α] (l : list α) :
   (l.map has_neg.neg).prod = (-1) ^ l.length * l.prod :=
-begin
-  convert @prod_map_mul α α _ l (λ _, -1) id,
-  { ext, rw neg_one_mul, refl },
-  { rw [← prod_replicate, map_eq_replicate_iff.2],
-    exact λ _ _, rfl },
-  { rw l.map_id },
-end
+by simpa only [id, neg_mul, one_mul, map_const', prod_replicate, map_id]
+    using @prod_map_mul α α _ l (λ _, -1) id
 
 @[to_additive]
 lemma prod_map_hom (L : list ι) (f : ι → M) {G : Type*} [monoid_hom_class G M N] (g : G) :
@@ -478,7 +473,7 @@ lemma prod_map_erase [decidable_eq ι] [comm_monoid M] (f : ι → M) {a} :
         mul_left_comm (f a) (f b)], }
   end
 
-@[simp] lemma sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
+lemma sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
 by rw [sum_replicate, smul_eq_mul]
 
 /-- The product of a list of positive natural numbers is positive,

f694c7de

refactor(*): define list.replicate and migrate to it (#18127)

This definition differs from list.repeat by the order of arguments. The new order is in sync with the Lean 4 version.

Diff

@@ -51,17 +51,17 @@ lemma prod_eq_foldr : l.prod = foldr (*) 1 l :=
 list.rec_on l rfl $ λ a l ihl, by rw [prod_cons, foldr_cons, ihl]
 
 @[simp, priority 500, to_additive]
-theorem prod_repeat (a : M) (n : ℕ) : (repeat a n).prod = a ^ n :=
+theorem prod_replicate (a : M) (n : ℕ) : (replicate n a).prod = a ^ n :=
 begin
   induction n with n ih,
   { rw pow_zero, refl },
-  { rw [list.repeat_succ, list.prod_cons, ih, pow_succ] }
+  { rw [list.replicate_succ, list.prod_cons, ih, pow_succ] }
 end
 
 @[to_additive sum_eq_card_nsmul]
 lemma prod_eq_pow_card (l : list M) (m : M) (h : ∀ (x ∈ l), x = m) :
   l.prod = m ^ l.length :=
-by rw [← prod_repeat, ← list.eq_repeat.mpr ⟨rfl, h⟩]
+by rw [← prod_replicate, ← eq_replicate_length.2 h]
 
 @[to_additive]
 lemma prod_hom_rel (l : list ι) {r : M → N → Prop} {f : ι → M} {g : ι → N} (h₁ : r 1 1)
@@ -97,8 +97,8 @@ lemma prod_map_neg {α} [comm_monoid α] [has_distrib_neg α] (l : list α) :
 begin
   convert @prod_map_mul α α _ l (λ _, -1) id,
   { ext, rw neg_one_mul, refl },
-  { convert (prod_repeat _ _).symm, rw eq_repeat,
-    use l.length_map _, intro, rw mem_map, rintro ⟨_, _, rfl⟩, refl },
+  { rw [← prod_replicate, map_eq_replicate_iff.2],
+    exact λ _ _, rfl },
   { rw l.map_id },
 end
 
@@ -268,7 +268,7 @@ lemma prod_le_pow_card [preorder M]
   [covariant_class M M (function.swap (*)) (≤)] [covariant_class M M (*) (≤)]
   (l : list M) (n : M) (h : ∀ (x ∈ l), x ≤ n) :
   l.prod ≤ n ^ l.length :=
-by simpa only [map_id'', map_const, prod_repeat] using prod_le_prod' h
+by simpa only [map_id'', map_const, prod_replicate] using prod_le_prod' h
 
 @[to_additive exists_lt_of_sum_lt] lemma exists_lt_of_prod_lt' [linear_order M]
   [covariant_class M M (function.swap (*)) (≤)] [covariant_class M M (*) (≤)] {l : list ι}
@@ -478,8 +478,8 @@ lemma prod_map_erase [decidable_eq ι] [comm_monoid M] (f : ι → M) {a} :
         mul_left_comm (f a) (f b)], }
   end
 
-@[simp] lemma sum_const_nat (m n : ℕ) : sum (list.repeat m n) = m * n :=
-by induction n; [refl, simp only [*, repeat_succ, sum_cons, nat.mul_succ, add_comm]]
+@[simp] lemma sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
+by rw [sum_replicate, smul_eq_mul]
 
 /-- The product of a list of positive natural numbers is positive,
 and likewise for any nontrivial ordered semiring. -/

26f081a2

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

6c5f73fd

bump to nightly-2024-04-09-08

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

659ec6f7

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
-import Data.Int.Order.Basic
+import Algebra.Order.Group.Int
 import Data.List.Forall2
 
 #align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"

6c5f73fd

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -95,7 +95,7 @@ theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).Prod = a ^ n :=
   by
   induction' n with n ih
   · rw [pow_zero]; rfl
-  · rw [List.replicate_succ, List.prod_cons, ih, pow_succ]
+  · rw [List.replicate_succ, List.prod_cons, ih, pow_succ']
 #align list.prod_replicate List.prod_replicate
 #align list.sum_replicate List.sum_replicate
 -/

6c5f73fd

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -187,7 +187,7 @@ theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
   refine' ⟨fun h => _, prod_is_unit⟩
   induction' L with m L ih
   · exact fun m' h' => False.elim (not_mem_nil m' h')
-  rw [prod_cons, IsUnit.mul_iff] at h 
+  rw [prod_cons, IsUnit.mul_iff] at h
   exact fun m' h' => Or.elim (eq_or_mem_of_mem_cons h') (fun H => H.substr h.1) fun H => ih h.2 _ H
 #align list.prod_is_unit_iff List.prod_isUnit_iff
 #align list.sum_is_add_unit_iff List.sum_isAddUnit_iff
@@ -285,7 +285,7 @@ theorem Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y
     Commute y l.Prod := by
   induction' l with z l IH
   · simp
-  · rw [List.forall_mem_cons] at h 
+  · rw [List.forall_mem_cons] at h
     rw [List.prod_cons]
     exact Commute.mul_right h.1 (IH h.2)
 #align commute.list_prod_right Commute.list_prod_right
@@ -549,7 +549,7 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
   by
   apply ext_le h fun i h₁ h₂ => _
   have : (L.take (i + 1)).Prod = (L'.take (i + 1)).Prod := h' _ (Nat.succ_le_of_lt h₁)
-  rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this 
+  rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this
   convert mul_left_cancel this
 #align list.eq_of_prod_take_eq List.eq_of_prod_take_eq
 #align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
@@ -577,7 +577,7 @@ theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
   | [b], h, _ => by simpa using h
   | a :: b :: l, hl₁, hl₂ =>
     by
-    simp only [forall_eq_or_imp, List.mem_cons _ a] at hl₁ 
+    simp only [forall_eq_or_imp, List.mem_cons _ a] at hl₁
     rw [List.prod_cons]
     apply one_lt_mul_of_lt_of_le' hl₁.1
     apply le_of_lt ((b :: l).one_lt_prod_of_one_lt hl₁.2 (l.cons_ne_nil b))

6c5f73fd

bump to nightly-2023-11-29-11

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

049e2cad

Diff

@@ -557,7 +557,7 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
 
 #print List.monotone_prod_take /-
 @[to_additive]
-theorem monotone_prod_take [CanonicallyOrderedCommMonoid M] (L : List M) :
+theorem monotone_prod_take [CanonicallyOrderedAddCommMonoid M] (L : List M) :
     Monotone fun i => (L.take i).Prod :=
   by
   apply monotone_nat_of_le_succ fun n => _

6c5f73fd

bump to nightly-2023-10-21-06

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

a2dc86f8

Diff

@@ -625,7 +625,7 @@ theorem prod_eq_one [Monoid M] {l : List M} (hl : ∀ x ∈ l, x = (1 : M)) : l.
 #print List.exists_mem_ne_one_of_prod_ne_one /-
 @[to_additive]
 theorem exists_mem_ne_one_of_prod_ne_one [Monoid M] {l : List M} (h : l.Prod ≠ 1) :
-    ∃ x ∈ l, x ≠ (1 : M) := by simpa only [not_forall] using mt prod_eq_one h
+    ∃ x ∈ l, x ≠ (1 : M) := by simpa only [Classical.not_forall] using mt prod_eq_one h
 #align list.exists_mem_ne_one_of_prod_ne_one List.exists_mem_ne_one_of_prod_ne_one
 #align list.exists_mem_ne_zero_of_sum_ne_zero List.exists_mem_ne_zero_of_sum_ne_zero
 -/

6c5f73fd

bump to nightly-2023-10-07-06

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

d191b687

Diff

@@ -557,7 +557,7 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
 
 #print List.monotone_prod_take /-
 @[to_additive]
-theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
+theorem monotone_prod_take [CanonicallyOrderedCommMonoid M] (L : List M) :
     Monotone fun i => (L.take i).Prod :=
   by
   apply monotone_nat_of_le_succ fun n => _

6c5f73fd

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
-import Mathbin.Data.Int.Order.Basic
-import Mathbin.Data.List.Forall2
+import Data.Int.Order.Basic
+import Data.List.Forall2
 
 #align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"

6c5f73fd

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
-
-! This file was ported from Lean 3 source module data.list.big_operators.basic
-! leanprover-community/mathlib commit 6c5f73fd6f6cc83122788a80a27cdd54663609f4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Int.Order.Basic
 import Mathbin.Data.List.Forall2
 
+#align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"
+
 /-!
 # Sums and products from lists

6c5f73fd

bump to nightly-2023-06-18-23

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

3b5e23dc

Diff

@@ -70,7 +70,7 @@ theorem prod_append : (l₁ ++ l₂).Prod = l₁.Prod * l₂.Prod :=
 
 #print List.prod_concat /-
 @[to_additive]
-theorem prod_concat : (l.concat a).Prod = l.Prod * a := by
+theorem prod_concat : (l.push a).Prod = l.Prod * a := by
   rw [concat_eq_append, prod_append, prod_singleton]
 #align list.prod_concat List.prod_concat
 #align list.sum_concat List.sum_concat

6c5f73fd

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -31,18 +31,23 @@ section Monoid
 
 variable [Monoid M] [Monoid N] [Monoid P] {l l₁ l₂ : List M} {a : M}
 
+#print List.prod_nil /-
 @[simp, to_additive]
 theorem prod_nil : ([] : List M).Prod = 1 :=
   rfl
 #align list.prod_nil List.prod_nil
 #align list.sum_nil List.sum_nil
+-/
 
+#print List.prod_singleton /-
 @[to_additive]
 theorem prod_singleton : [a].Prod = a :=
   one_mul a
 #align list.prod_singleton List.prod_singleton
 #align list.sum_singleton List.sum_singleton
+-/
 
+#print List.prod_cons /-
 @[simp, to_additive]
 theorem prod_cons : (a :: l).Prod = a * l.Prod :=
   calc
@@ -51,7 +56,9 @@ theorem prod_cons : (a :: l).Prod = a * l.Prod :=
     _ = _ := foldl_assoc
 #align list.prod_cons List.prod_cons
 #align list.sum_cons List.sum_cons
+-/
 
+#print List.prod_append /-
 @[simp, to_additive]
 theorem prod_append : (l₁ ++ l₂).Prod = l₁.Prod * l₂.Prod :=
   calc
@@ -59,25 +66,33 @@ theorem prod_append : (l₁ ++ l₂).Prod = l₁.Prod * l₂.Prod :=
     _ = l₁.Prod * l₂.Prod := foldl_assoc
 #align list.prod_append List.prod_append
 #align list.sum_append List.sum_append
+-/
 
+#print List.prod_concat /-
 @[to_additive]
 theorem prod_concat : (l.concat a).Prod = l.Prod * a := by
   rw [concat_eq_append, prod_append, prod_singleton]
 #align list.prod_concat List.prod_concat
 #align list.sum_concat List.sum_concat
+-/
 
+#print List.prod_join /-
 @[simp, to_additive]
 theorem prod_join {l : List (List M)} : l.join.Prod = (l.map List.prod).Prod := by
   induction l <;> [rfl; simp only [*, List.join, map, prod_append, prod_cons]]
 #align list.prod_join List.prod_join
 #align list.sum_join List.sum_join
+-/
 
+#print List.prod_eq_foldr /-
 @[to_additive]
 theorem prod_eq_foldr : l.Prod = foldr (· * ·) 1 l :=
   List.recOn l rfl fun a l ihl => by rw [prod_cons, foldr_cons, ihl]
 #align list.prod_eq_foldr List.prod_eq_foldr
 #align list.sum_eq_foldr List.sum_eq_foldr
+-/
 
+#print List.prod_replicate /-
 @[simp, to_additive]
 theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).Prod = a ^ n :=
   by
@@ -86,20 +101,26 @@ theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).Prod = a ^ n :=
   · rw [List.replicate_succ, List.prod_cons, ih, pow_succ]
 #align list.prod_replicate List.prod_replicate
 #align list.sum_replicate List.sum_replicate
+-/
 
+#print List.prod_eq_pow_card /-
 @[to_additive sum_eq_card_nsmul]
 theorem prod_eq_pow_card (l : List M) (m : M) (h : ∀ x ∈ l, x = m) : l.Prod = m ^ l.length := by
   rw [← prod_replicate, ← eq_replicate_length.2 h]
 #align list.prod_eq_pow_card List.prod_eq_pow_card
 #align list.sum_eq_card_nsmul List.sum_eq_card_nsmul
+-/
 
+#print List.prod_hom_rel /-
 @[to_additive]
 theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι → N} (h₁ : r 1 1)
     (h₂ : ∀ ⦃i a b⦄, r a b → r (f i * a) (g i * b)) : r (l.map f).Prod (l.map g).Prod :=
   List.recOn l h₁ fun a l hl => by simp only [map_cons, prod_cons, h₂ hl]
 #align list.prod_hom_rel List.prod_hom_rel
 #align list.sum_hom_rel List.sum_hom_rel
+-/
 
+#print List.prod_hom /-
 @[to_additive]
 theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
     (l.map f).Prod = f l.Prod :=
@@ -108,7 +129,9 @@ theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
   exact l.foldl_hom _ _ _ 1 (map_mul f)
 #align list.prod_hom List.prod_hom
 #align list.sum_hom List.sum_hom
+-/
 
+#print List.prod_hom₂ /-
 @[to_additive]
 theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d)
     (hf' : f 1 1 = 1) (f₁ : ι → M) (f₂ : ι → N) :
@@ -120,27 +143,35 @@ theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a *
   · exact hf _ _ _ _
 #align list.prod_hom₂ List.prod_hom₂
 #align list.sum_hom₂ List.sum_hom₂
+-/
 
+#print List.prod_map_mul /-
 @[simp, to_additive]
 theorem prod_map_mul {α : Type _} [CommMonoid α] {l : List ι} {f g : ι → α} :
     (l.map fun i => f i * g i).Prod = (l.map f).Prod * (l.map g).Prod :=
   l.prod_hom₂ (· * ·) mul_mul_mul_comm (mul_one _) _ _
 #align list.prod_map_mul List.prod_map_mul
 #align list.sum_map_add List.sum_map_add
+-/
 
+#print List.prod_map_neg /-
 @[simp]
 theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
     (l.map Neg.neg).Prod = (-1) ^ l.length * l.Prod := by
   simpa only [id, neg_mul, one_mul, map_const', prod_replicate, map_id] using
     @prod_map_mul α α _ l (fun _ => -1) id
 #align list.prod_map_neg List.prod_map_neg
+-/
 
+#print List.prod_map_hom /-
 @[to_additive]
 theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type _} [MonoidHomClass G M N] (g : G) :
     (L.map (g ∘ f)).Prod = g (L.map f).Prod := by rw [← prod_hom, map_map]
 #align list.prod_map_hom List.prod_map_hom
 #align list.sum_map_hom List.sum_map_hom
+-/
 
+#print List.prod_isUnit /-
 @[to_additive]
 theorem prod_isUnit : ∀ {L : List M} (u : ∀ m ∈ L, IsUnit m), IsUnit L.Prod
   | [], _ => by simp
@@ -149,7 +180,9 @@ theorem prod_isUnit : ∀ {L : List M} (u : ∀ m ∈ L, IsUnit m), IsUnit L.Pro
     exact IsUnit.mul (u h (mem_cons_self h t)) (prod_is_unit fun m mt => u m (mem_cons_of_mem h mt))
 #align list.prod_is_unit List.prod_isUnit
 #align list.sum_is_add_unit List.sum_isAddUnit
+-/
 
+#print List.prod_isUnit_iff /-
 @[to_additive]
 theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
     IsUnit L.Prod ↔ ∀ m ∈ L, IsUnit m :=
@@ -161,7 +194,9 @@ theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
   exact fun m' h' => Or.elim (eq_or_mem_of_mem_cons h') (fun H => H.substr h.1) fun H => ih h.2 _ H
 #align list.prod_is_unit_iff List.prod_isUnit_iff
 #align list.sum_is_add_unit_iff List.sum_isAddUnit_iff
+-/
 
+#print List.prod_take_mul_prod_drop /-
 @[simp, to_additive]
 theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).Prod * (L.drop i).Prod = L.Prod
   | [], i => by simp [Nat.zero_le]
@@ -169,7 +204,9 @@ theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).Prod *
   | h :: t, n + 1 => by dsimp; rw [prod_cons, prod_cons, mul_assoc, prod_take_mul_prod_drop]
 #align list.prod_take_mul_prod_drop List.prod_take_mul_prod_drop
 #align list.sum_take_add_sum_drop List.sum_take_add_sum_drop
+-/
 
+#print List.prod_take_succ /-
 @[simp, to_additive]
 theorem prod_take_succ :
     ∀ (L : List M) (i : ℕ) (p), (L.take (i + 1)).Prod = (L.take i).Prod * L.nthLe i p
@@ -178,28 +215,36 @@ theorem prod_take_succ :
   | h :: t, n + 1, _ => by dsimp; rw [prod_cons, prod_cons, prod_take_succ, mul_assoc]
 #align list.prod_take_succ List.prod_take_succ
 #align list.sum_take_succ List.sum_take_succ
+-/
 
+#print List.length_pos_of_prod_ne_one /-
 /-- A list with product not one must have positive length. -/
 @[to_additive "A list with sum not zero must have positive length."]
 theorem length_pos_of_prod_ne_one (L : List M) (h : L.Prod ≠ 1) : 0 < L.length := by cases L;
   · contrapose h; simp; · simp
 #align list.length_pos_of_prod_ne_one List.length_pos_of_prod_ne_one
 #align list.length_pos_of_sum_ne_zero List.length_pos_of_sum_ne_zero
+-/
 
+#print List.length_pos_of_one_lt_prod /-
 /-- A list with product greater than one must have positive length. -/
 @[to_additive length_pos_of_sum_pos "A list with positive sum must have positive length."]
 theorem length_pos_of_one_lt_prod [Preorder M] (L : List M) (h : 1 < L.Prod) : 0 < L.length :=
   length_pos_of_prod_ne_one L h.ne'
 #align list.length_pos_of_one_lt_prod List.length_pos_of_one_lt_prod
 #align list.length_pos_of_sum_pos List.length_pos_of_sum_pos
+-/
 
+#print List.length_pos_of_prod_lt_one /-
 /-- A list with product less than one must have positive length. -/
 @[to_additive "A list with negative sum must have positive length."]
 theorem length_pos_of_prod_lt_one [Preorder M] (L : List M) (h : L.Prod < 1) : 0 < L.length :=
   length_pos_of_prod_ne_one L h.Ne
 #align list.length_pos_of_prod_lt_one List.length_pos_of_prod_lt_one
 #align list.length_pos_of_sum_neg List.length_pos_of_sum_neg
+-/
 
+#print List.prod_set /-
 @[to_additive]
 theorem prod_set :
     ∀ (L : List M) (n : ℕ) (a : M),
@@ -209,9 +254,11 @@ theorem prod_set :
   | [], _, _ => by simp [update_nth, (Nat.zero_le _).not_lt, Nat.zero_le]
 #align list.prod_update_nth List.prod_set
 #align list.sum_update_nth List.sum_set
+-/
 
 open MulOpposite
 
+#print List.get?_zero_mul_tail_prod /-
 /-- We'd like to state this as `L.head * L.tail.prod = L.prod`, but because `L.head` relies on an
 inhabited instance to return a garbage value on the empty list, this is not possible.
 Instead, we write the statement in terms of `(L.nth 0).get_or_else 1`.
@@ -222,7 +269,9 @@ theorem get?_zero_mul_tail_prod (l : List M) : (l.get? 0).getD 1 * l.tail.Prod =
   cases l <;> simp
 #align list.nth_zero_mul_tail_prod List.get?_zero_mul_tail_prod
 #align list.nth_zero_add_tail_sum List.get?_zero_add_tail_sum
+-/
 
+#print List.headI_mul_tail_prod_of_ne_nil /-
 /-- Same as `nth_zero_mul_tail_prod`, but avoiding the `list.head` garbage complication by requiring
 the list to be nonempty. -/
 @[to_additive
@@ -231,7 +280,9 @@ theorem headI_mul_tail_prod_of_ne_nil [Inhabited M] (l : List M) (h : l ≠ [])
     l.headI * l.tail.Prod = l.Prod := by cases l <;> [contradiction; simp]
 #align list.head_mul_tail_prod_of_ne_nil List.headI_mul_tail_prod_of_ne_nil
 #align list.head_add_tail_sum_of_ne_nil List.headI_add_tail_sum_of_ne_nil
+-/
 
+#print Commute.list_prod_right /-
 @[to_additive]
 theorem Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y x) :
     Commute y l.Prod := by
@@ -242,13 +293,17 @@ theorem Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y
     exact Commute.mul_right h.1 (IH h.2)
 #align commute.list_prod_right Commute.list_prod_right
 #align add_commute.list_sum_right AddCommute.list_sum_right
+-/
 
+#print Commute.list_prod_left /-
 @[to_additive]
 theorem Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Commute x y) : Commute l.Prod y :=
   (Commute.list_prod_right _ _ fun x hx => (h _ hx).symm).symm
 #align commute.list_prod_left Commute.list_prod_left
 #align add_commute.list_sum_left AddCommute.list_sum_left
+-/
 
+#print List.Forall₂.prod_le_prod' /-
 @[to_additive sum_le_sum]
 theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : Forall₂ (· ≤ ·) l₁ l₂) :
@@ -258,7 +313,9 @@ theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap
   · simpa only [prod_cons] using mul_le_mul' hab ih'
 #align list.forall₂.prod_le_prod' List.Forall₂.prod_le_prod'
 #align list.forall₂.sum_le_sum List.Forall₂.sum_le_sum
+-/
 
+#print List.Sublist.prod_le_prod' /-
 /-- If `l₁` is a sublist of `l₂` and all elements of `l₂` are greater than or equal to one, then
 `l₁.prod ≤ l₂.prod`. One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 1 ≤ a` instead
 of `∀ a ∈ l₂, 1 ≤ a` but this lemma is not yet in `mathlib`. -/
@@ -278,7 +335,9 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
     exact mul_le_mul_left' (ih' h₁.2) _
 #align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'
 #align list.sublist.sum_le_sum List.Sublist.sum_le_sum
+-/
 
+#print List.SublistForall₂.prod_le_prod' /-
 @[to_additive sum_le_sum]
 theorem SublistForall₂.prod_le_prod' [Preorder M]
     [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] [CovariantClass M M (· * ·) (· ≤ ·)]
@@ -288,7 +347,9 @@ theorem SublistForall₂.prod_le_prod' [Preorder M]
   hall.prod_le_prod'.trans <| hsub.prod_le_prod' h₁
 #align list.sublist_forall₂.prod_le_prod' List.SublistForall₂.prod_le_prod'
 #align list.sublist_forall₂.sum_le_sum List.SublistForall₂.sum_le_sum
+-/
 
+#print List.prod_le_prod' /-
 @[to_additive sum_le_sum]
 theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} {f g : ι → M} (h : ∀ i ∈ l, f i ≤ g i) :
@@ -296,7 +357,9 @@ theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·))
   Forall₂.prod_le_prod' <| by simpa
 #align list.prod_le_prod' List.prod_le_prod'
 #align list.sum_le_sum List.sum_le_sum
+-/
 
+#print List.prod_lt_prod' /-
 @[to_additive sum_lt_sum]
 theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
@@ -310,7 +373,9 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     mul_lt_mul_of_le_of_lt h₁.1 <| ihl h₁.2 h₂]
 #align list.prod_lt_prod' List.prod_lt_prod'
 #align list.sum_lt_sum List.sum_lt_sum
+-/
 
+#print List.prod_lt_prod_of_ne_nil /-
 @[to_additive]
 theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
@@ -320,7 +385,9 @@ theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· <
     (exists_mem_of_ne_nil l hl).imp fun i hi => ⟨hi, hlt i hi⟩
 #align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nil
 #align list.sum_lt_sum_of_ne_nil List.sum_lt_sum_of_ne_nil
+-/
 
+#print List.prod_le_pow_card /-
 @[to_additive sum_le_card_nsmul]
 theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n) :
@@ -328,7 +395,9 @@ theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * 
   simpa only [map_id'', map_const, prod_replicate] using prod_le_prod' h
 #align list.prod_le_pow_card List.prod_le_pow_card
 #align list.sum_le_card_nsmul List.sum_le_card_nsmul
+-/
 
+#print List.exists_lt_of_prod_lt' /-
 @[to_additive exists_lt_of_sum_lt]
 theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} (f g : ι → M)
@@ -336,7 +405,9 @@ theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap
   exact prod_le_prod' h
 #align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'
 #align list.exists_lt_of_sum_lt List.exists_lt_of_sum_lt
+-/
 
+#print List.exists_le_of_prod_le' /-
 @[to_additive exists_le_of_sum_le]
 theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
@@ -345,7 +416,9 @@ theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (·
   exact prod_lt_prod_of_ne_nil hl _ _ h
 #align list.exists_le_of_prod_le' List.exists_le_of_prod_le'
 #align list.exists_le_of_sum_le List.exists_le_of_sum_le
+-/
 
+#print List.one_le_prod_of_one_le /-
 @[to_additive sum_nonneg]
 theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
     (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) : 1 ≤ l.Prod :=
@@ -358,6 +431,7 @@ theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤
   exact one_le_mul (hl₁ hd (mem_cons_self hd tl)) (ih fun x h => hl₁ x (mem_cons_of_mem hd h))
 #align list.one_le_prod_of_one_le List.one_le_prod_of_one_le
 #align list.sum_nonneg List.sum_nonneg
+-/
 
 end Monoid
 
@@ -365,6 +439,7 @@ section MonoidWithZero
 
 variable [MonoidWithZero M₀]
 
+#print List.prod_eq_zero /-
 /-- If zero is an element of a list `L`, then `list.prod L = 0`. If the domain is a nontrivial
 monoid with zero with no divisors, then this implication becomes an `iff`, see
 `list.prod_eq_zero_iff`. -/
@@ -376,7 +451,9 @@ theorem prod_eq_zero {L : List M₀} (h : (0 : M₀) ∈ L) : L.Prod = 0 :=
     cases' (mem_cons_iff _ _ _).1 h with ha hL
     exacts [mul_eq_zero_of_left ha.symm _, mul_eq_zero_of_right _ (ihL hL)]
 #align list.prod_eq_zero List.prod_eq_zero
+-/
 
+#print List.prod_eq_zero_iff /-
 /-- Product of elements of a list `L` equals zero if and only if `0 ∈ L`. See also
 `list.prod_eq_zero` for an implication that needs weaker typeclass assumptions. -/
 @[simp]
@@ -386,11 +463,14 @@ theorem prod_eq_zero_iff [Nontrivial M₀] [NoZeroDivisors M₀] {L : List M₀}
   · simp
   · rw [prod_cons, mul_eq_zero, ihL, mem_cons_iff, eq_comm]
 #align list.prod_eq_zero_iff List.prod_eq_zero_iff
+-/
 
+#print List.prod_ne_zero /-
 theorem prod_ne_zero [Nontrivial M₀] [NoZeroDivisors M₀] {L : List M₀} (hL : (0 : M₀) ∉ L) :
     L.Prod ≠ 0 :=
   mt prod_eq_zero_iff.1 hL
 #align list.prod_ne_zero List.prod_ne_zero
+-/
 
 end MonoidWithZero
 
@@ -398,6 +478,7 @@ section Group
 
 variable [Group G]
 
+#print List.prod_inv_reverse /-
 /-- This is the `list.prod` version of `mul_inv_rev` -/
 @[to_additive "This is the `list.sum` version of `add_neg_rev`"]
 theorem prod_inv_reverse : ∀ L : List G, L.Prod⁻¹ = (L.map fun x => x⁻¹).reverse.Prod
@@ -405,14 +486,18 @@ theorem prod_inv_reverse : ∀ L : List G, L.Prod⁻¹ = (L.map fun x => x⁻¹)
   | x :: xs => by simp [prod_inv_reverse xs]
 #align list.prod_inv_reverse List.prod_inv_reverse
 #align list.sum_neg_reverse List.sum_neg_reverse
+-/
 
+#print List.prod_reverse_noncomm /-
 /-- A non-commutative variant of `list.prod_reverse` -/
 @[to_additive "A non-commutative variant of `list.sum_reverse`"]
 theorem prod_reverse_noncomm : ∀ L : List G, L.reverse.Prod = (L.map fun x => x⁻¹).Prod⁻¹ := by
   simp [prod_inv_reverse]
 #align list.prod_reverse_noncomm List.prod_reverse_noncomm
 #align list.sum_reverse_noncomm List.sum_reverse_noncomm
+-/
 
+#print List.prod_drop_succ /-
 /-- Counterpart to `list.prod_take_succ` when we have an inverse operation -/
 @[simp, to_additive "Counterpart to `list.sum_take_succ` when we have an negation operation"]
 theorem prod_drop_succ :
@@ -422,6 +507,7 @@ theorem prod_drop_succ :
   | x :: xs, i + 1, p => prod_drop_succ xs i _
 #align list.prod_drop_succ List.prod_drop_succ
 #align list.sum_drop_succ List.sum_drop_succ
+-/
 
 end Group
 
@@ -429,6 +515,7 @@ section CommGroup
 
 variable [CommGroup G]
 
+#print List.prod_inv /-
 /-- This is the `list.prod` version of `mul_inv` -/
 @[to_additive "This is the `list.sum` version of `add_neg`"]
 theorem prod_inv : ∀ L : List G, L.Prod⁻¹ = (L.map fun x => x⁻¹).Prod
@@ -436,7 +523,9 @@ theorem prod_inv : ∀ L : List G, L.Prod⁻¹ = (L.map fun x => x⁻¹).Prod
   | x :: xs => by simp [mul_comm, prod_inv xs]
 #align list.prod_inv List.prod_inv
 #align list.sum_neg List.sum_neg
+-/
 
+#print List.prod_set' /-
 /-- Alternative version of `list.prod_update_nth` when the list is over a group -/
 @[to_additive "Alternative version of `list.sum_update_nth` when the list is over a group"]
 theorem prod_set' (L : List G) (n : ℕ) (a : G) :
@@ -452,9 +541,11 @@ theorem prod_set' (L : List G) (n : ℕ) (a : G) :
       drop_eq_nil_of_le ((le_of_not_lt hn).trans n.le_succ)]
 #align list.prod_update_nth' List.prod_set'
 #align list.sum_update_nth' List.sum_set'
+-/
 
 end CommGroup
 
+#print List.eq_of_prod_take_eq /-
 @[to_additive]
 theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length)
     (h' : ∀ i ≤ L.length, (L.take i).Prod = (L'.take i).Prod) : L = L' :=
@@ -465,7 +556,9 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
   convert mul_left_cancel this
 #align list.eq_of_prod_take_eq List.eq_of_prod_take_eq
 #align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
+-/
 
+#print List.monotone_prod_take /-
 @[to_additive]
 theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
     Monotone fun i => (L.take i).Prod :=
@@ -477,7 +570,9 @@ theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
   · simp [take_all_of_le h, take_all_of_le (le_trans h (Nat.le_succ _))]
 #align list.monotone_prod_take List.monotone_prod_take
 #align list.monotone_sum_take List.monotone_sum_take
+-/
 
+#print List.one_lt_prod_of_one_lt /-
 @[to_additive sum_pos]
 theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
     ∀ (l : List M) (hl : ∀ x ∈ l, (1 : M) < x) (hl₂ : l ≠ []), 1 < l.Prod
@@ -491,7 +586,9 @@ theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
     apply le_of_lt ((b :: l).one_lt_prod_of_one_lt hl₁.2 (l.cons_ne_nil b))
 #align list.one_lt_prod_of_one_lt List.one_lt_prod_of_one_lt
 #align list.sum_pos List.sum_pos
+-/
 
+#print List.single_le_prod /-
 @[to_additive]
 theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) :
     ∀ x ∈ l, x ≤ l.Prod := by
@@ -503,14 +600,18 @@ theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l,
   · exact fun x H => le_mul_of_one_le_of_le hl₁.1 (l_ih hl₁.right x H)
 #align list.single_le_prod List.single_le_prod
 #align list.single_le_sum List.single_le_sum
+-/
 
+#print List.all_one_of_le_one_le_of_prod_eq_one /-
 @[to_additive all_zero_of_le_zero_le_of_sum_eq_zero]
 theorem all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
     (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) (hl₂ : l.Prod = 1) {x : M} (hx : x ∈ l) : x = 1 :=
   le_antisymm (hl₂ ▸ single_le_prod hl₁ _ hx) (hl₁ x hx)
 #align list.all_one_of_le_one_le_of_prod_eq_one List.all_one_of_le_one_le_of_prod_eq_one
 #align list.all_zero_of_le_zero_le_of_sum_eq_zero List.all_zero_of_le_zero_le_of_sum_eq_zero
+-/
 
+#print List.prod_eq_one /-
 /-- Slightly more general version of `list.prod_eq_one_iff` for a non-ordered `monoid` -/
 @[to_additive
       "Slightly more general version of `list.sum_eq_zero_iff`\n  for a non-ordered `add_monoid`"]
@@ -522,13 +623,17 @@ theorem prod_eq_one [Monoid M] {l : List M} (hl : ∀ x ∈ l, x = (1 : M)) : l.
     one_mul]
 #align list.prod_eq_one List.prod_eq_one
 #align list.sum_eq_zero List.sum_eq_zero
+-/
 
+#print List.exists_mem_ne_one_of_prod_ne_one /-
 @[to_additive]
 theorem exists_mem_ne_one_of_prod_ne_one [Monoid M] {l : List M} (h : l.Prod ≠ 1) :
     ∃ x ∈ l, x ≠ (1 : M) := by simpa only [not_forall] using mt prod_eq_one h
 #align list.exists_mem_ne_one_of_prod_ne_one List.exists_mem_ne_one_of_prod_ne_one
 #align list.exists_mem_ne_zero_of_sum_ne_zero List.exists_mem_ne_zero_of_sum_ne_zero
+-/
 
+#print List.sum_le_foldr_max /-
 -- TODO: develop theory of tropical rings
 theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M → N) (h0 : f 0 ≤ 0)
     (hadd : ∀ x y, f (x + y) ≤ max (f x) (f y)) (l : List M) : f l.Sum ≤ (l.map f).foldr max 0 :=
@@ -538,7 +643,9 @@ theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M →
   simp only [List.sum_cons, List.foldr_map, List.foldr] at IH ⊢
   exact (hadd _ _).trans (max_le_max le_rfl IH)
 #align list.sum_le_foldr_max List.sum_le_foldr_max
+-/
 
+#print List.prod_erase /-
 @[simp, to_additive]
 theorem prod_erase [DecidableEq M] [CommMonoid M] {a} :
     ∀ {l : List M}, a ∈ l → a * (l.eraseₓ a).Prod = l.Prod
@@ -548,7 +655,9 @@ theorem prod_erase [DecidableEq M] [CommMonoid M] {a} :
     · simp only [List.erase, if_neg (mt Eq.symm Ne), prod_cons, prod_erase h, mul_left_comm a b]
 #align list.prod_erase List.prod_erase
 #align list.sum_erase List.sum_erase
+-/
 
+#print List.prod_map_erase /-
 @[simp, to_additive]
 theorem prod_map_erase [DecidableEq ι] [CommMonoid M] (f : ι → M) {a} :
     ∀ {l : List ι}, a ∈ l → f a * ((l.eraseₓ a).map f).Prod = (l.map f).Prod
@@ -560,12 +669,14 @@ theorem prod_map_erase [DecidableEq ι] [CommMonoid M] (f : ι → M) {a} :
         mul_left_comm (f a) (f b)]
 #align list.prod_map_erase List.prod_map_erase
 #align list.sum_map_erase List.sum_map_erase
+-/
 
 #print List.sum_const_nat /-
 theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n := by rw [sum_replicate, smul_eq_mul]
 #align list.sum_const_nat List.sum_const_nat
 -/
 
+#print List.prod_pos /-
 /-- The product of a list of positive natural numbers is positive,
 and likewise for any nontrivial ordered semiring. -/
 theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R) < a) : 0 < l.Prod :=
@@ -575,7 +686,9 @@ theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R
   · rw [prod_cons]
     exact mul_pos (h _ <| mem_cons_self _ _) (ih fun a ha => h a <| mem_cons_of_mem _ ha)
 #align list.prod_pos List.prod_pos
+-/
 
+#print CanonicallyOrderedCommSemiring.list_prod_pos /-
 /-- A variant of `list.prod_pos` for `canonically_ordered_comm_semiring`. -/
 @[simp]
 theorem CanonicallyOrderedCommSemiring.list_prod_pos {α : Type _} [CanonicallyOrderedCommSemiring α]
@@ -585,6 +698,7 @@ theorem CanonicallyOrderedCommSemiring.list_prod_pos {α : Type _} [CanonicallyO
     simp_rw [prod_cons, mem_cons_iff, forall_eq_or_imp, CanonicallyOrderedCommSemiring.mul_pos,
       _root_.canonically_ordered_comm_semiring.list_prod_pos]
 #align canonically_ordered_comm_semiring.list_prod_pos CanonicallyOrderedCommSemiring.list_prod_pos
+-/
 
 /-!
 Several lemmas about sum/head/tail for `list ℕ`.
@@ -647,15 +761,18 @@ theorem alternatingProd_cons_cons' (a b : α) (l : List α) :
 
 end
 
+#print List.alternatingProd_cons_cons /-
 @[to_additive]
 theorem alternatingProd_cons_cons [DivInvMonoid α] (a b : α) (l : List α) :
     alternatingProd (a :: b :: l) = a / b * alternatingProd l := by
   rw [div_eq_mul_inv, alternating_prod_cons_cons']
 #align list.alternating_prod_cons_cons List.alternatingProd_cons_cons
 #align list.alternating_sum_cons_cons List.alternatingSum_cons_cons
+-/
 
 variable [CommGroup α]
 
+#print List.alternatingProd_cons' /-
 @[to_additive]
 theorem alternatingProd_cons' :
     ∀ (a : α) (l : List α), alternatingProd (a :: l) = a * (alternatingProd l)⁻¹
@@ -664,13 +781,16 @@ theorem alternatingProd_cons' :
     rw [alternating_prod_cons_cons', alternating_prod_cons' b l, mul_inv, inv_inv, mul_assoc]
 #align list.alternating_prod_cons' List.alternatingProd_cons'
 #align list.alternating_sum_cons' List.alternatingSum_cons'
+-/
 
+#print List.alternatingProd_cons /-
 @[simp, to_additive]
 theorem alternatingProd_cons (a : α) (l : List α) :
     alternatingProd (a :: l) = a / alternatingProd l := by
   rw [div_eq_mul_inv, alternating_prod_cons']
 #align list.alternating_prod_cons List.alternatingProd_cons
 #align list.alternating_sum_cons List.alternatingSum_cons
+-/
 
 end Alternating
 
@@ -704,21 +824,25 @@ section MonoidHom
 
 variable [Monoid M] [Monoid N]
 
+#print map_list_prod /-
 @[to_additive]
 theorem map_list_prod {F : Type _} [MonoidHomClass F M N] (f : F) (l : List M) :
     f l.Prod = (l.map f).Prod :=
   (l.prod_hom f).symm
 #align map_list_prod map_list_prod
 #align map_list_sum map_list_sum
+-/
 
 namespace MonoidHom
 
+#print MonoidHom.map_list_prod /-
 /-- Deprecated, use `_root_.map_list_prod` instead. -/
 @[to_additive "Deprecated, use `_root_.map_list_sum` instead."]
 protected theorem map_list_prod (f : M →* N) (l : List M) : f l.Prod = (l.map f).Prod :=
   map_list_prod f l
 #align monoid_hom.map_list_prod MonoidHom.map_list_prod
 #align add_monoid_hom.map_list_sum AddMonoidHom.map_list_sum
+-/
 
 end MonoidHom

6c5f73fd

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -49,7 +49,6 @@ theorem prod_cons : (a :: l).Prod = a * l.Prod :=
     (a :: l).Prod = foldl (· * ·) (a * 1) l := by
       simp only [List.prod, foldl_cons, one_mul, mul_one]
     _ = _ := foldl_assoc
-    
 #align list.prod_cons List.prod_cons
 #align list.sum_cons List.sum_cons
 
@@ -58,7 +57,6 @@ theorem prod_append : (l₁ ++ l₂).Prod = l₁.Prod * l₂.Prod :=
   calc
     (l₁ ++ l₂).Prod = foldl (· * ·) (foldl (· * ·) 1 l₁ * 1) l₂ := by simp [List.prod]
     _ = l₁.Prod * l₂.Prod := foldl_assoc
-    
 #align list.prod_append List.prod_append
 #align list.sum_append List.sum_append

6c5f73fd

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -70,7 +70,7 @@ theorem prod_concat : (l.concat a).Prod = l.Prod * a := by
 
 @[simp, to_additive]
 theorem prod_join {l : List (List M)} : l.join.Prod = (l.map List.prod).Prod := by
-  induction l <;> [rfl;simp only [*, List.join, map, prod_append, prod_cons]]
+  induction l <;> [rfl; simp only [*, List.join, map, prod_append, prod_cons]]
 #align list.prod_join List.prod_join
 #align list.sum_join List.sum_join
 
@@ -159,7 +159,7 @@ theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
   refine' ⟨fun h => _, prod_is_unit⟩
   induction' L with m L ih
   · exact fun m' h' => False.elim (not_mem_nil m' h')
-  rw [prod_cons, IsUnit.mul_iff] at h
+  rw [prod_cons, IsUnit.mul_iff] at h 
   exact fun m' h' => Or.elim (eq_or_mem_of_mem_cons h') (fun H => H.substr h.1) fun H => ih h.2 _ H
 #align list.prod_is_unit_iff List.prod_isUnit_iff
 #align list.sum_is_add_unit_iff List.sum_isAddUnit_iff
@@ -230,7 +230,7 @@ the list to be nonempty. -/
 @[to_additive
       "Same as `nth_zero_add_tail_sum`, but avoiding the `list.head` garbage complication\nby requiring the list to be nonempty."]
 theorem headI_mul_tail_prod_of_ne_nil [Inhabited M] (l : List M) (h : l ≠ []) :
-    l.headI * l.tail.Prod = l.Prod := by cases l <;> [contradiction;simp]
+    l.headI * l.tail.Prod = l.Prod := by cases l <;> [contradiction; simp]
 #align list.head_mul_tail_prod_of_ne_nil List.headI_mul_tail_prod_of_ne_nil
 #align list.head_add_tail_sum_of_ne_nil List.headI_add_tail_sum_of_ne_nil
 
@@ -239,7 +239,7 @@ theorem Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y
     Commute y l.Prod := by
   induction' l with z l IH
   · simp
-  · rw [List.forall_mem_cons] at h
+  · rw [List.forall_mem_cons] at h 
     rw [List.prod_cons]
     exact Commute.mul_right h.1 (IH h.2)
 #align commute.list_prod_right Commute.list_prod_right
@@ -272,10 +272,11 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
   by
   induction h; · rfl
   case cons l₁ l₂ a ih ih' =>
-    simp only [prod_cons, forall_mem_cons] at h₁⊢
+    simp only [prod_cons, forall_mem_cons] at h₁ ⊢
     exact (ih' h₁.2).trans (le_mul_of_one_le_left' h₁.1)
-  case cons2 l₁ l₂ a ih ih' =>
-    simp only [prod_cons, forall_mem_cons] at h₁⊢
+  case cons2 l₁ l₂ a ih
+    ih' =>
+    simp only [prod_cons, forall_mem_cons] at h₁ ⊢
     exact mul_le_mul_left' (ih' h₁.2) _
 #align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'
 #align list.sublist.sum_le_sum List.Sublist.sum_le_sum
@@ -305,9 +306,10 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i) : (l.map f).Prod < (l.map g).Prod :=
   by
   induction' l with i l ihl; · rcases h₂ with ⟨_, ⟨⟩, _⟩
-  simp only [ball_cons, bex_cons, map_cons, prod_cons] at h₁ h₂⊢
+  simp only [ball_cons, bex_cons, map_cons, prod_cons] at h₁ h₂ ⊢
   cases h₂
-  exacts[mul_lt_mul_of_lt_of_le h₂ (prod_le_prod' h₁.2), mul_lt_mul_of_le_of_lt h₁.1 <| ihl h₁.2 h₂]
+  exacts [mul_lt_mul_of_lt_of_le h₂ (prod_le_prod' h₁.2),
+    mul_lt_mul_of_le_of_lt h₁.1 <| ihl h₁.2 h₂]
 #align list.prod_lt_prod' List.prod_lt_prod'
 #align list.sum_lt_sum List.sum_lt_sum
 
@@ -374,7 +376,7 @@ theorem prod_eq_zero {L : List M₀} (h : (0 : M₀) ∈ L) : L.Prod = 0 :=
   · exact absurd h (not_mem_nil _)
   · rw [prod_cons]
     cases' (mem_cons_iff _ _ _).1 h with ha hL
-    exacts[mul_eq_zero_of_left ha.symm _, mul_eq_zero_of_right _ (ihL hL)]
+    exacts [mul_eq_zero_of_left ha.symm _, mul_eq_zero_of_right _ (ihL hL)]
 #align list.prod_eq_zero List.prod_eq_zero
 
 /-- Product of elements of a list `L` equals zero if and only if `0 ∈ L`. See also
@@ -461,7 +463,7 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
   by
   apply ext_le h fun i h₁ h₂ => _
   have : (L.take (i + 1)).Prod = (L'.take (i + 1)).Prod := h' _ (Nat.succ_le_of_lt h₁)
-  rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this
+  rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this 
   convert mul_left_cancel this
 #align list.eq_of_prod_take_eq List.eq_of_prod_take_eq
 #align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
@@ -485,7 +487,7 @@ theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
   | [b], h, _ => by simpa using h
   | a :: b :: l, hl₁, hl₂ =>
     by
-    simp only [forall_eq_or_imp, List.mem_cons _ a] at hl₁
+    simp only [forall_eq_or_imp, List.mem_cons _ a] at hl₁ 
     rw [List.prod_cons]
     apply one_lt_mul_of_lt_of_le' hl₁.1
     apply le_of_lt ((b :: l).one_lt_prod_of_one_lt hl₁.2 (l.cons_ne_nil b))
@@ -497,7 +499,7 @@ theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l,
     ∀ x ∈ l, x ≤ l.Prod := by
   induction l
   · simp
-  simp_rw [prod_cons, forall_mem_cons] at hl₁⊢
+  simp_rw [prod_cons, forall_mem_cons] at hl₁ ⊢
   constructor
   · exact le_mul_of_one_le_right' (one_le_prod_of_one_le hl₁.2)
   · exact fun x H => le_mul_of_one_le_of_le hl₁.1 (l_ih hl₁.right x H)
@@ -535,7 +537,7 @@ theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M →
   by
   induction' l with hd tl IH
   · simpa using h0
-  simp only [List.sum_cons, List.foldr_map, List.foldr] at IH⊢
+  simp only [List.sum_cons, List.foldr_map, List.foldr] at IH ⊢
   exact (hadd _ _).trans (max_le_max le_rfl IH)
 #align list.sum_le_foldr_max List.sum_le_foldr_max

6c5f73fd

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -31,36 +31,18 @@ section Monoid
 
 variable [Monoid M] [Monoid N] [Monoid P] {l l₁ l₂ : List M} {a : M}
 
-/- warning: list.prod_nil -> List.prod_nil is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.nil.{u1} M)) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.nil.{u1} M)) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align list.prod_nil List.prod_nilₓ'. -/
 @[simp, to_additive]
 theorem prod_nil : ([] : List M).Prod = 1 :=
   rfl
 #align list.prod_nil List.prod_nil
 #align list.sum_nil List.sum_nil
 
-/- warning: list.prod_singleton -> List.prod_singleton is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.cons.{u1} M a (List.nil.{u1} M))) a
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {a : M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.cons.{u1} M a (List.nil.{u1} M))) a
-Case conversion may be inaccurate. Consider using '#align list.prod_singleton List.prod_singletonₓ'. -/
 @[to_additive]
 theorem prod_singleton : [a].Prod = a :=
   one_mul a
 #align list.prod_singleton List.prod_singleton
 #align list.sum_singleton List.sum_singleton
 
-/- warning: list.prod_cons -> List.prod_cons is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M} {a : M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.cons.{u1} M a l)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M} {a : M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.cons.{u1} M a l)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
-Case conversion may be inaccurate. Consider using '#align list.prod_cons List.prod_consₓ'. -/
 @[simp, to_additive]
 theorem prod_cons : (a :: l).Prod = a * l.Prod :=
   calc
@@ -71,12 +53,6 @@ theorem prod_cons : (a :: l).Prod = a * l.Prod :=
 #align list.prod_cons List.prod_cons
 #align list.sum_cons List.sum_cons
 
-/- warning: list.prod_append -> List.prod_append is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Append.append.{u1} (List.{u1} M) (List.hasAppend.{u1} M) l₁ l₂)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (HAppend.hAppend.{u1, u1, u1} (List.{u1} M) (List.{u1} M) (List.{u1} M) (instHAppend.{u1} (List.{u1} M) (List.instAppendList.{u1} M)) l₁ l₂)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
-Case conversion may be inaccurate. Consider using '#align list.prod_append List.prod_appendₓ'. -/
 @[simp, to_additive]
 theorem prod_append : (l₁ ++ l₂).Prod = l₁.Prod * l₂.Prod :=
   calc
@@ -86,48 +62,24 @@ theorem prod_append : (l₁ ++ l₂).Prod = l₁.Prod * l₂.Prod :=
 #align list.prod_append List.prod_append
 #align list.sum_append List.sum_append
 
-/- warning: list.prod_concat -> List.prod_concat is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M} {a : M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.concat.{u1} M l a)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) a)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M} {a : M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.concat.{u1} M l a)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) a)
-Case conversion may be inaccurate. Consider using '#align list.prod_concat List.prod_concatₓ'. -/
 @[to_additive]
 theorem prod_concat : (l.concat a).Prod = l.Prod * a := by
   rw [concat_eq_append, prod_append, prod_singleton]
 #align list.prod_concat List.prod_concat
 #align list.sum_concat List.sum_concat
 
-/- warning: list.prod_join -> List.prod_join is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} (List.{u1} M)}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.join.{u1} M l)) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.map.{u1, u1} (List.{u1} M) M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) l))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} (List.{u1} M)}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.join.{u1} M l)) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.map.{u1, u1} (List.{u1} M) M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1)) l))
-Case conversion may be inaccurate. Consider using '#align list.prod_join List.prod_joinₓ'. -/
 @[simp, to_additive]
 theorem prod_join {l : List (List M)} : l.join.Prod = (l.map List.prod).Prod := by
   induction l <;> [rfl;simp only [*, List.join, map, prod_append, prod_cons]]
 #align list.prod_join List.prod_join
 #align list.sum_join List.sum_join
 
-/- warning: list.prod_eq_foldr -> List.prod_eq_foldr is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (List.foldr.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) l)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M}, Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (List.foldr.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.538 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.540 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.538 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.540) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) l)
-Case conversion may be inaccurate. Consider using '#align list.prod_eq_foldr List.prod_eq_foldrₓ'. -/
 @[to_additive]
 theorem prod_eq_foldr : l.Prod = foldr (· * ·) 1 l :=
   List.recOn l rfl fun a l ihl => by rw [prod_cons, foldr_cons, ihl]
 #align list.prod_eq_foldr List.prod_eq_foldr
 #align list.sum_eq_foldr List.sum_eq_foldr
 
-/- warning: list.prod_replicate -> List.prod_replicate is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : Nat) (a : M), Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.replicate.{u1} M n a)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) a n)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : Nat) (a : M), Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.replicate.{u1} M n a)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) a n)
-Case conversion may be inaccurate. Consider using '#align list.prod_replicate List.prod_replicateₓ'. -/
 @[simp, to_additive]
 theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).Prod = a ^ n :=
   by
@@ -137,24 +89,12 @@ theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).Prod = a ^ n :=
 #align list.prod_replicate List.prod_replicate
 #align list.sum_replicate List.sum_replicate
 
-/- warning: list.prod_eq_pow_card -> List.prod_eq_pow_card is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (l : List.{u1} M) (m : M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Eq.{succ u1} M x m)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) m (List.length.{u1} M l)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (l : List.{u1} M) (m : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (Eq.{succ u1} M x m)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) m (List.length.{u1} M l)))
-Case conversion may be inaccurate. Consider using '#align list.prod_eq_pow_card List.prod_eq_pow_cardₓ'. -/
 @[to_additive sum_eq_card_nsmul]
 theorem prod_eq_pow_card (l : List M) (m : M) (h : ∀ x ∈ l, x = m) : l.Prod = m ^ l.length := by
   rw [← prod_replicate, ← eq_replicate_length.2 h]
 #align list.prod_eq_pow_card List.prod_eq_pow_card
 #align list.sum_eq_card_nsmul List.sum_eq_card_nsmul
 
-/- warning: list.prod_hom_rel -> List.prod_hom_rel is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] (l : List.{u1} ι) {r : M -> N -> Prop} {f : ι -> M} {g : ι -> N}, (r (OfNat.ofNat.{u2} M 1 (OfNat.mk.{u2} M 1 (One.one.{u2} M (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (OfNat.ofNat.{u3} N 1 (OfNat.mk.{u3} N 1 (One.one.{u3} N (MulOneClass.toHasOne.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)))))) -> (forall {{i : ι}} {{a : M}} {{b : N}}, (r a b) -> (r (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (f i) a) (HMul.hMul.{u3, u3, u3} N N N (instHMul.{u3} N (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2))) (g i) b))) -> (r (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u3} N (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MulOneClass.toHasOne.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (List.map.{u1, u3} ι N g l)))
-but is expected to have type
-  forall {ι : Type.{u3}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (l : List.{u3} ι) {r : M -> N -> Prop} {f : ι -> M} {g : ι -> N}, (r (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (Monoid.toOne.{u2} M _inst_1))) (OfNat.ofNat.{u1} N 1 (One.toOfNat1.{u1} N (Monoid.toOne.{u1} N _inst_2)))) -> (forall {{i : ι}} {{a : M}} {{b : N}}, (r a b) -> (r (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (f i) a) (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2))) (g i) b))) -> (r (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u3, u2} ι M f l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u3, u1} ι N g l)))
-Case conversion may be inaccurate. Consider using '#align list.prod_hom_rel List.prod_hom_relₓ'. -/
 @[to_additive]
 theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι → N} (h₁ : r 1 1)
     (h₂ : ∀ ⦃i a b⦄, r a b → r (f i * a) (g i * b)) : r (l.map f).Prod (l.map g).Prod :=
@@ -162,12 +102,6 @@ theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι
 #align list.prod_hom_rel List.prod_hom_rel
 #align list.sum_hom_rel List.sum_hom_rel
 
-/- warning: list.prod_hom -> List.prod_hom is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (l : List.{u1} M) {F : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F), Eq.{succ u2} N (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_4))) f) l)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_4))) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
-but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u1}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u1} N] (l : List.{u3} M) {F : Type.{u2}} [_inst_4 : MonoidHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u3, u1} M N (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f) l)) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f (List.prod.{u3} M (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (Monoid.toOne.{u3} M _inst_1) l))
-Case conversion may be inaccurate. Consider using '#align list.prod_hom List.prod_homₓ'. -/
 @[to_additive]
 theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
     (l.map f).Prod = f l.Prod :=
@@ -177,12 +111,6 @@ theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
 #align list.prod_hom List.prod_hom
 #align list.sum_hom List.sum_hom
 
-/- warning: list.prod_hom₂ -> List.prod_hom₂ is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} {P : Type.{u4}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] [_inst_3 : Monoid.{u4} P] (l : List.{u1} ι) (f : M -> N -> P), (forall (a : M) (b : M) (c : N) (d : N), Eq.{succ u4} P (f (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) a b) (HMul.hMul.{u3, u3, u3} N N N (instHMul.{u3} N (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2))) c d)) (HMul.hMul.{u4, u4, u4} P P P (instHMul.{u4} P (MulOneClass.toHasMul.{u4} P (Monoid.toMulOneClass.{u4} P _inst_3))) (f a c) (f b d))) -> (Eq.{succ u4} P (f (OfNat.ofNat.{u2} M 1 (OfNat.mk.{u2} M 1 (One.one.{u2} M (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (OfNat.ofNat.{u3} N 1 (OfNat.mk.{u3} N 1 (One.one.{u3} N (MulOneClass.toHasOne.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)))))) (OfNat.ofNat.{u4} P 1 (OfNat.mk.{u4} P 1 (One.one.{u4} P (MulOneClass.toHasOne.{u4} P (Monoid.toMulOneClass.{u4} P _inst_3)))))) -> (forall (f₁ : ι -> M) (f₂ : ι -> N), Eq.{succ u4} P (List.prod.{u4} P (MulOneClass.toHasMul.{u4} P (Monoid.toMulOneClass.{u4} P _inst_3)) (MulOneClass.toHasOne.{u4} P (Monoid.toMulOneClass.{u4} P _inst_3)) (List.map.{u1, u4} ι P (fun (i : ι) => f (f₁ i) (f₂ i)) l)) (f (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f₁ l)) (List.prod.{u3} N (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MulOneClass.toHasOne.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (List.map.{u1, u3} ι N f₂ l))))
-but is expected to have type
-  forall {ι : Type.{u4}} {M : Type.{u2}} {N : Type.{u1}} {P : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] [_inst_3 : Monoid.{u3} P] (l : List.{u4} ι) (f : M -> N -> P), (forall (a : M) (b : M) (c : N) (d : N), Eq.{succ u3} P (f (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2))) c d)) (HMul.hMul.{u3, u3, u3} P P P (instHMul.{u3} P (MulOneClass.toMul.{u3} P (Monoid.toMulOneClass.{u3} P _inst_3))) (f a c) (f b d))) -> (Eq.{succ u3} P (f (OfNat.ofNat.{u2} M 1 (One.toOfNat1.{u2} M (Monoid.toOne.{u2} M _inst_1))) (OfNat.ofNat.{u1} N 1 (One.toOfNat1.{u1} N (Monoid.toOne.{u1} N _inst_2)))) (OfNat.ofNat.{u3} P 1 (One.toOfNat1.{u3} P (Monoid.toOne.{u3} P _inst_3)))) -> (forall (f₁ : ι -> M) (f₂ : ι -> N), Eq.{succ u3} P (List.prod.{u3} P (MulOneClass.toMul.{u3} P (Monoid.toMulOneClass.{u3} P _inst_3)) (Monoid.toOne.{u3} P _inst_3) (List.map.{u4, u3} ι P (fun (i : ι) => f (f₁ i) (f₂ i)) l)) (f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u4, u2} ι M f₁ l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u4, u1} ι N f₂ l))))
-Case conversion may be inaccurate. Consider using '#align list.prod_hom₂ List.prod_hom₂ₓ'. -/
 @[to_additive]
 theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d)
     (hf' : f 1 1 = 1) (f₁ : ι → M) (f₂ : ι → N) :
@@ -195,12 +123,6 @@ theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a *
 #align list.prod_hom₂ List.prod_hom₂
 #align list.sum_hom₂ List.sum_hom₂
 
-/- warning: list.prod_map_mul -> List.prod_map_mul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_4 : CommMonoid.{u2} α] {l : List.{u1} ι} {f : ι -> α} {g : ι -> α}, Eq.{succ u2} α (List.prod.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (MulOneClass.toHasOne.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (List.map.{u1, u2} ι α (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4)))) (f i) (g i)) l)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4)))) (List.prod.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (MulOneClass.toHasOne.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (List.map.{u1, u2} ι α f l)) (List.prod.{u2} α (MulOneClass.toHasMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (MulOneClass.toHasOne.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (List.map.{u1, u2} ι α g l)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_4 : CommMonoid.{u2} α] {l : List.{u1} ι} {f : ι -> α} {g : ι -> α}, Eq.{succ u2} α (List.prod.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (Monoid.toOne.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4)) (List.map.{u1, u2} ι α (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4)))) (f i) (g i)) l)) (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4)))) (List.prod.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (Monoid.toOne.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4)) (List.map.{u1, u2} ι α f l)) (List.prod.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4))) (Monoid.toOne.{u2} α (CommMonoid.toMonoid.{u2} α _inst_4)) (List.map.{u1, u2} ι α g l)))
-Case conversion may be inaccurate. Consider using '#align list.prod_map_mul List.prod_map_mulₓ'. -/
 @[simp, to_additive]
 theorem prod_map_mul {α : Type _} [CommMonoid α] {l : List ι} {f g : ι → α} :
     (l.map fun i => f i * g i).Prod = (l.map f).Prod * (l.map g).Prod :=
@@ -208,12 +130,6 @@ theorem prod_map_mul {α : Type _} [CommMonoid α] {l : List ι} {f g : ι → 
 #align list.prod_map_mul List.prod_map_mul
 #align list.sum_map_add List.sum_map_add
 
-/- warning: list.prod_map_neg -> List.prod_map_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_4 : CommMonoid.{u1} α] [_inst_5 : HasDistribNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4)))] (l : List.{u1} α), Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (List.map.{u1, u1} α α (Neg.neg.{u1} α (InvolutiveNeg.toHasNeg.{u1} α (HasDistribNeg.toHasInvolutiveNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) _inst_5))) l)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4)))) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (Neg.neg.{u1} α (InvolutiveNeg.toHasNeg.{u1} α (HasDistribNeg.toHasInvolutiveNeg.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) _inst_5)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))))))) (List.length.{u1} α l)) (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_4 : CommMonoid.{u1} α] [_inst_5 : HasDistribNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4)))] (l : List.{u1} α), Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4)) (List.map.{u1, u1} α α (Neg.neg.{u1} α (InvolutiveNeg.toNeg.{u1} α (HasDistribNeg.toInvolutiveNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) _inst_5))) l)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4)))) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (Neg.neg.{u1} α (InvolutiveNeg.toNeg.{u1} α (HasDistribNeg.toInvolutiveNeg.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) _inst_5)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))))) (List.length.{u1} α l)) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4)) l))
-Case conversion may be inaccurate. Consider using '#align list.prod_map_neg List.prod_map_negₓ'. -/
 @[simp]
 theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
     (l.map Neg.neg).Prod = (-1) ^ l.length * l.Prod := by
@@ -221,24 +137,12 @@ theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
     @prod_map_mul α α _ l (fun _ => -1) id
 #align list.prod_map_neg List.prod_map_neg
 
-/- warning: list.prod_map_hom -> List.prod_map_hom is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] (L : List.{u1} ι) (f : ι -> M) {G : Type.{u4}} [_inst_4 : MonoidHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (g : G), Eq.{succ u3} N (List.prod.{u3} N (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MulOneClass.toHasOne.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (List.map.{u1, u3} ι N (Function.comp.{succ u1, succ u2, succ u3} ι M N (coeFn.{succ u4, max (succ u2) (succ u3)} G (fun (_x : G) => M -> N) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} G M (fun (_x : M) => N) (MulHomClass.toFunLike.{u4, u2, u3} G M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_4))) g) f) L)) (coeFn.{succ u4, max (succ u2) (succ u3)} G (fun (_x : G) => M -> N) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} G M (fun (_x : M) => N) (MulHomClass.toFunLike.{u4, u2, u3} G M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_4))) g (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f L)))
-but is expected to have type
-  forall {ι : Type.{u4}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (L : List.{u4} ι) (f : ι -> M) {G : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (g : G), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u4, u1} ι N (Function.comp.{succ u4, succ u2, succ u1} ι M N (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g) f) L)) (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u4, u2} ι M f L)))
-Case conversion may be inaccurate. Consider using '#align list.prod_map_hom List.prod_map_homₓ'. -/
 @[to_additive]
 theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type _} [MonoidHomClass G M N] (g : G) :
     (L.map (g ∘ f)).Prod = g (L.map f).Prod := by rw [← prod_hom, map_map]
 #align list.prod_map_hom List.prod_map_hom
 #align list.sum_map_hom List.sum_map_hom
 
-/- warning: list.prod_is_unit -> List.prod_isUnit is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {L : List.{u1} M}, (forall (m : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) m L) -> (IsUnit.{u1} M _inst_1 m)) -> (IsUnit.{u1} M _inst_1 (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {L : List.{u1} M}, (forall (m : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) m L) -> (IsUnit.{u1} M _inst_1 m)) -> (IsUnit.{u1} M _inst_1 (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) L))
-Case conversion may be inaccurate. Consider using '#align list.prod_is_unit List.prod_isUnitₓ'. -/
 @[to_additive]
 theorem prod_isUnit : ∀ {L : List M} (u : ∀ m ∈ L, IsUnit m), IsUnit L.Prod
   | [], _ => by simp
@@ -248,12 +152,6 @@ theorem prod_isUnit : ∀ {L : List M} (u : ∀ m ∈ L, IsUnit m), IsUnit L.Pro
 #align list.prod_is_unit List.prod_isUnit
 #align list.sum_is_add_unit List.sum_isAddUnit
 
-/- warning: list.prod_is_unit_iff -> List.prod_isUnit_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_4 : CommMonoid.{u1} α] {L : List.{u1} α}, Iff (IsUnit.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4) (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) L)) (forall (m : α), (Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) m L) -> (IsUnit.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4) m))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_4 : CommMonoid.{u1} α] {L : List.{u1} α}, Iff (IsUnit.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4) (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4))) (Monoid.toOne.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4)) L)) (forall (m : α), (Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) m L) -> (IsUnit.{u1} α (CommMonoid.toMonoid.{u1} α _inst_4) m))
-Case conversion may be inaccurate. Consider using '#align list.prod_is_unit_iff List.prod_isUnit_iffₓ'. -/
 @[to_additive]
 theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
     IsUnit L.Prod ↔ ∀ m ∈ L, IsUnit m :=
@@ -266,12 +164,6 @@ theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
 #align list.prod_is_unit_iff List.prod_isUnit_iff
 #align list.sum_is_add_unit_iff List.sum_isAddUnit_iff
 
-/- warning: list.prod_take_mul_prod_drop -> List.prod_take_mul_prod_drop is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (L : List.{u1} M) (i : Nat), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.take.{u1} M i L)) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.drop.{u1} M i L))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (L : List.{u1} M) (i : Nat), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.take.{u1} M i L)) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.drop.{u1} M i L))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) L)
-Case conversion may be inaccurate. Consider using '#align list.prod_take_mul_prod_drop List.prod_take_mul_prod_dropₓ'. -/
 @[simp, to_additive]
 theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).Prod * (L.drop i).Prod = L.Prod
   | [], i => by simp [Nat.zero_le]
@@ -280,12 +172,6 @@ theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).Prod *
 #align list.prod_take_mul_prod_drop List.prod_take_mul_prod_drop
 #align list.sum_take_add_sum_drop List.sum_take_add_sum_drop
 
-/- warning: list.prod_take_succ -> List.prod_take_succ is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (L : List.{u1} M) (i : Nat) (p : LT.lt.{0} Nat Nat.hasLt i (List.length.{u1} M L)), Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.take.{u1} M (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) i (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) L)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.take.{u1} M i L)) (List.nthLe.{u1} M L i p))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (L : List.{u1} M) (i : Nat) (p : LT.lt.{0} Nat instLTNat i (List.length.{u1} M L)), Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.take.{u1} M (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) i (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) L)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.take.{u1} M i L)) (List.nthLe.{u1} M L i p))
-Case conversion may be inaccurate. Consider using '#align list.prod_take_succ List.prod_take_succₓ'. -/
 @[simp, to_additive]
 theorem prod_take_succ :
     ∀ (L : List M) (i : ℕ) (p), (L.take (i + 1)).Prod = (L.take i).Prod * L.nthLe i p
@@ -295,12 +181,6 @@ theorem prod_take_succ :
 #align list.prod_take_succ List.prod_take_succ
 #align list.sum_take_succ List.sum_take_succ
 
-/- warning: list.length_pos_of_prod_ne_one -> List.length_pos_of_prod_ne_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (L : List.{u1} M), (Ne.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (List.length.{u1} M L))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (L : List.{u1} M), (Ne.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) L) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) -> (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) (List.length.{u1} M L))
-Case conversion may be inaccurate. Consider using '#align list.length_pos_of_prod_ne_one List.length_pos_of_prod_ne_oneₓ'. -/
 /-- A list with product not one must have positive length. -/
 @[to_additive "A list with sum not zero must have positive length."]
 theorem length_pos_of_prod_ne_one (L : List M) (h : L.Prod ≠ 1) : 0 < L.length := by cases L;
@@ -308,12 +188,6 @@ theorem length_pos_of_prod_ne_one (L : List M) (h : L.Prod ≠ 1) : 0 < L.length
 #align list.length_pos_of_prod_ne_one List.length_pos_of_prod_ne_one
 #align list.length_pos_of_sum_ne_zero List.length_pos_of_sum_ne_zero
 
-/- warning: list.length_pos_of_one_lt_prod -> List.length_pos_of_one_lt_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L)) -> (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (List.length.{u1} M L))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) L)) -> (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) (List.length.{u1} M L))
-Case conversion may be inaccurate. Consider using '#align list.length_pos_of_one_lt_prod List.length_pos_of_one_lt_prodₓ'. -/
 /-- A list with product greater than one must have positive length. -/
 @[to_additive length_pos_of_sum_pos "A list with positive sum must have positive length."]
 theorem length_pos_of_one_lt_prod [Preorder M] (L : List M) (h : 1 < L.Prod) : 0 < L.length :=
@@ -321,12 +195,6 @@ theorem length_pos_of_one_lt_prod [Preorder M] (L : List M) (h : 1 < L.Prod) : 0
 #align list.length_pos_of_one_lt_prod List.length_pos_of_one_lt_prod
 #align list.length_pos_of_sum_pos List.length_pos_of_sum_pos
 
-/- warning: list.length_pos_of_prod_lt_one -> List.length_pos_of_prod_lt_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (List.length.{u1} M L))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) L) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) -> (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) (List.length.{u1} M L))
-Case conversion may be inaccurate. Consider using '#align list.length_pos_of_prod_lt_one List.length_pos_of_prod_lt_oneₓ'. -/
 /-- A list with product less than one must have positive length. -/
 @[to_additive "A list with negative sum must have positive length."]
 theorem length_pos_of_prod_lt_one [Preorder M] (L : List M) (h : L.Prod < 1) : 0 < L.length :=
@@ -334,12 +202,6 @@ theorem length_pos_of_prod_lt_one [Preorder M] (L : List M) (h : L.Prod < 1) : 0
 #align list.length_pos_of_prod_lt_one List.length_pos_of_prod_lt_one
 #align list.length_pos_of_sum_neg List.length_pos_of_sum_neg
 
-/- warning: list.prod_update_nth -> List.prod_set is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (L : List.{u1} M) (n : Nat) (a : M), Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.set.{u1} M L n a)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.take.{u1} M n L)) (ite.{succ u1} M (LT.lt.{0} Nat Nat.hasLt n (List.length.{u1} M L)) (Nat.decidableLt n (List.length.{u1} M L)) a (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.drop.{u1} M (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) L)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (L : List.{u1} M) (n : Nat) (a : M), Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.set.{u1} M L n a)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.take.{u1} M n L)) (ite.{succ u1} M (LT.lt.{0} Nat instLTNat n (List.length.{u1} M L)) (Nat.decLt n (List.length.{u1} M L)) a (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.drop.{u1} M (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) L)))
-Case conversion may be inaccurate. Consider using '#align list.prod_update_nth List.prod_setₓ'. -/
 @[to_additive]
 theorem prod_set :
     ∀ (L : List M) (n : ℕ) (a : M),
@@ -352,12 +214,6 @@ theorem prod_set :
 
 open MulOpposite
 
-/- warning: list.nth_zero_mul_tail_prod -> List.get?_zero_mul_tail_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (l : List.{u1} M), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Option.getD.{u1} M (List.get?.{u1} M l (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.tail.{u1} M l))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (l : List.{u1} M), Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Option.getD.{u1} M (List.get?.{u1} M l (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.tail.{u1} M l))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l)
-Case conversion may be inaccurate. Consider using '#align list.nth_zero_mul_tail_prod List.get?_zero_mul_tail_prodₓ'. -/
 /-- We'd like to state this as `L.head * L.tail.prod = L.prod`, but because `L.head` relies on an
 inhabited instance to return a garbage value on the empty list, this is not possible.
 Instead, we write the statement in terms of `(L.nth 0).get_or_else 1`.
@@ -369,12 +225,6 @@ theorem get?_zero_mul_tail_prod (l : List M) : (l.get? 0).getD 1 * l.tail.Prod =
 #align list.nth_zero_mul_tail_prod List.get?_zero_mul_tail_prod
 #align list.nth_zero_add_tail_sum List.get?_zero_add_tail_sum
 
-/- warning: list.head_mul_tail_prod_of_ne_nil -> List.headI_mul_tail_prod_of_ne_nil is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Inhabited.{succ u1} M] (l : List.{u1} M), (Ne.{succ u1} (List.{u1} M) l (List.nil.{u1} M)) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.headI.{u1} M _inst_4 l) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.tail.{u1} M l))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Inhabited.{succ u1} M] (l : List.{u1} M), (Ne.{succ u1} (List.{u1} M) l (List.nil.{u1} M)) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.headI.{u1} M _inst_4 l) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.tail.{u1} M l))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
-Case conversion may be inaccurate. Consider using '#align list.head_mul_tail_prod_of_ne_nil List.headI_mul_tail_prod_of_ne_nilₓ'. -/
 /-- Same as `nth_zero_mul_tail_prod`, but avoiding the `list.head` garbage complication by requiring
 the list to be nonempty. -/
 @[to_additive
@@ -384,12 +234,6 @@ theorem headI_mul_tail_prod_of_ne_nil [Inhabited M] (l : List M) (h : l ≠ [])
 #align list.head_mul_tail_prod_of_ne_nil List.headI_mul_tail_prod_of_ne_nil
 #align list.head_add_tail_sum_of_ne_nil List.headI_add_tail_sum_of_ne_nil
 
-/- warning: commute.list_prod_right -> Commute.list_prod_right is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (l : List.{u1} M) (y : M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Commute.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) y x)) -> (Commute.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) y (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (l : List.{u1} M) (y : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (Commute.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) y x)) -> (Commute.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) y (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
-Case conversion may be inaccurate. Consider using '#align commute.list_prod_right Commute.list_prod_rightₓ'. -/
 @[to_additive]
 theorem Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y x) :
     Commute y l.Prod := by
@@ -401,24 +245,12 @@ theorem Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y
 #align commute.list_prod_right Commute.list_prod_right
 #align add_commute.list_sum_right AddCommute.list_sum_right
 
-/- warning: commute.list_prod_left -> Commute.list_prod_left is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (l : List.{u1} M) (y : M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Commute.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) x y)) -> (Commute.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) y)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (l : List.{u1} M) (y : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (Commute.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) x y)) -> (Commute.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) y)
-Case conversion may be inaccurate. Consider using '#align commute.list_prod_left Commute.list_prod_leftₓ'. -/
 @[to_additive]
 theorem Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Commute x y) : Commute l.Prod y :=
   (Commute.list_prod_right _ _ fun x hx => (h _ hx).symm).symm
 #align commute.list_prod_left Commute.list_prod_left
 #align add_commute.list_sum_left AddCommute.list_sum_left
 
-/- warning: list.forall₂.prod_le_prod' -> List.Forall₂.prod_le_prod' is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4)) l₁ l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2800 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2802 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2800 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2802)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2815 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2817 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2815 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2817)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2834 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2836 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2834 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2836) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2849 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2851 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2849 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2851)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2869 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2871 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2869 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2871) l₁ l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
-Case conversion may be inaccurate. Consider using '#align list.forall₂.prod_le_prod' List.Forall₂.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : Forall₂ (· ≤ ·) l₁ l₂) :
@@ -429,12 +261,6 @@ theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap
 #align list.forall₂.prod_le_prod' List.Forall₂.prod_le_prod'
 #align list.forall₂.sum_le_sum List.Forall₂.sum_le_sum
 
-/- warning: list.sublist.prod_le_prod' -> List.Sublist.prod_le_prod' is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2954 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2956 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2954 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2956)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2969 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2971 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2969 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2971)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2988 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2990 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2988 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2990) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3003 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3005 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3003 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3005)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
-Case conversion may be inaccurate. Consider using '#align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'ₓ'. -/
 /-- If `l₁` is a sublist of `l₂` and all elements of `l₂` are greater than or equal to one, then
 `l₁.prod ≤ l₂.prod`. One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 1 ≤ a` instead
 of `∀ a ∈ l₂, 1 ≤ a` but this lemma is not yet in `mathlib`. -/
@@ -454,12 +280,6 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
 #align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'
 #align list.sublist.sum_le_sum List.Sublist.sum_le_sum
 
-/- warning: list.sublist_forall₂.prod_le_prod' -> List.SublistForall₂.prod_le_prod' is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4)) l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3144 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3146 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3144 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3146)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3159 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3161 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3159 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3161)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3178 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3180 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3178 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3180) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3193 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3195 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3193 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3195)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3213 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3215 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3213 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3215) l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
-Case conversion may be inaccurate. Consider using '#align list.sublist_forall₂.prod_le_prod' List.SublistForall₂.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem SublistForall₂.prod_le_prod' [Preorder M]
     [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] [CovariantClass M M (· * ·) (· ≤ ·)]
@@ -470,12 +290,6 @@ theorem SublistForall₂.prod_le_prod' [Preorder M]
 #align list.sublist_forall₂.prod_le_prod' List.SublistForall₂.prod_le_prod'
 #align list.sublist_forall₂.sum_le_sum List.SublistForall₂.sum_le_sum
 
-/- warning: list.prod_le_prod' -> List.prod_le_prod' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
-but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3329 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3331 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3329 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3331)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3344 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3346 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3344 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3346)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3363 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3365 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3363 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3365) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3378 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3380 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3378 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3380)] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
-Case conversion may be inaccurate. Consider using '#align list.prod_le_prod' List.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} {f g : ι → M} (h : ∀ i ∈ l, f i ≤ g i) :
@@ -484,12 +298,6 @@ theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·))
 #align list.prod_le_prod' List.prod_le_prod'
 #align list.sum_le_sum List.sum_le_sum
 
-/- warning: list.prod_lt_prod' -> List.prod_lt_prod' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
-but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3475 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3477 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3475 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3477) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3490 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3492 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3490 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3492)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3509 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3511 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3509 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3511) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3524 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3526 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3524 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3526)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3546 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3548 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3546 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3548)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3561 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3563 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3561 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3563)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3583 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3585 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3583 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3585)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3598 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3600 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3598 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3600)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
-Case conversion may be inaccurate. Consider using '#align list.prod_lt_prod' List.prod_lt_prod'ₓ'. -/
 @[to_additive sum_lt_sum]
 theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
@@ -503,12 +311,6 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
 #align list.prod_lt_prod' List.prod_lt_prod'
 #align list.sum_lt_sum List.sum_lt_sum
 
-/- warning: list.prod_lt_prod_of_ne_nil -> List.prod_lt_prod_of_ne_nil is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))))
-but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3775 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3777 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3775 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3777) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3790 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3792 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3790 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3792)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3809 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3811 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3809 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3811) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3824 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3826 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3824 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3826)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3846 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3848 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3846 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3848)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3861 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3863 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3861 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3863)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3883 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3885 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3883 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3885)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3898 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3900 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3898 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3900)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))))
-Case conversion may be inaccurate. Consider using '#align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nilₓ'. -/
 @[to_additive]
 theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
@@ -519,12 +321,6 @@ theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· <
 #align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nil
 #align list.sum_lt_sum_of_ne_nil List.sum_lt_sum_of_ne_nil
 
-/- warning: list.prod_le_pow_card -> List.prod_le_pow_card is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4032 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4034 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4032 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4034)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4047 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4049 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4047 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4049)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4066 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4068 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4066 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4068) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4081 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4083 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4081 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4083)] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
-Case conversion may be inaccurate. Consider using '#align list.prod_le_pow_card List.prod_le_pow_cardₓ'. -/
 @[to_additive sum_le_card_nsmul]
 theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n) :
@@ -533,12 +329,6 @@ theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * 
 #align list.prod_le_pow_card List.prod_le_pow_card
 #align list.sum_le_card_nsmul List.sum_le_card_nsmul
 
-/- warning: list.exists_lt_of_prod_lt' -> List.exists_lt_of_prod_lt' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f i) (g i))))
-but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4170 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4172 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4170 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4172)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4185 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4187 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4185 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4187)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4204 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4206 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4204 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4206) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4219 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4221 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4219 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4221)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f i) (g i))))
-Case conversion may be inaccurate. Consider using '#align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'ₓ'. -/
 @[to_additive exists_lt_of_sum_lt]
 theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} (f g : ι → M)
@@ -547,12 +337,6 @@ theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap
 #align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'
 #align list.exists_lt_of_sum_lt List.exists_lt_of_sum_lt
 
-/- warning: list.exists_le_of_prod_le' -> List.exists_le_of_prod_le' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) => LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f x) (g x)))))
-but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4338 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4340 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4338 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4340) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4353 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4355 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4353 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4355)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4372 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4374 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4372 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4374) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4387 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4389 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4387 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4389)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4409 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4411 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4409 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4411)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4424 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4426 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4424 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4426)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4446 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4448 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4446 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4448)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4461 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4463 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4461 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4463)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) x l) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f x) (g x)))))
-Case conversion may be inaccurate. Consider using '#align list.exists_le_of_prod_le' List.exists_le_of_prod_le'ₓ'. -/
 @[to_additive exists_le_of_sum_le]
 theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
@@ -562,12 +346,6 @@ theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (·
 #align list.exists_le_of_prod_le' List.exists_le_of_prod_le'
 #align list.exists_le_of_sum_le List.exists_le_of_sum_le
 
-/- warning: list.one_le_prod_of_one_le -> List.one_le_prod_of_one_le is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) x)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4590 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4592 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4590 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4592) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4605 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4607 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4605 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4607)] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) x)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
-Case conversion may be inaccurate. Consider using '#align list.one_le_prod_of_one_le List.one_le_prod_of_one_leₓ'. -/
 @[to_additive sum_nonneg]
 theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
     (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) : 1 ≤ l.Prod :=
@@ -587,12 +365,6 @@ section MonoidWithZero
 
 variable [MonoidWithZero M₀]
 
-/- warning: list.prod_eq_zero -> List.prod_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {M₀ : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M₀] {L : List.{u1} M₀}, (Membership.Mem.{u1, u1} M₀ (List.{u1} M₀) (List.hasMem.{u1} M₀) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)))))) L) -> (Eq.{succ u1} M₀ (List.prod.{u1} M₀ (MulZeroClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MulOneClass.toHasOne.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) L) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)))))))
-but is expected to have type
-  forall {M₀ : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M₀] {L : List.{u1} M₀}, (Membership.mem.{u1, u1} M₀ (List.{u1} M₀) (List.instMembershipList.{u1} M₀) (OfNat.ofNat.{u1} M₀ 0 (Zero.toOfNat0.{u1} M₀ (MonoidWithZero.toZero.{u1} M₀ _inst_1))) L) -> (Eq.{succ u1} M₀ (List.prod.{u1} M₀ (MulZeroClass.toMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (Monoid.toOne.{u1} M₀ (MonoidWithZero.toMonoid.{u1} M₀ _inst_1)) L) (OfNat.ofNat.{u1} M₀ 0 (Zero.toOfNat0.{u1} M₀ (MonoidWithZero.toZero.{u1} M₀ _inst_1))))
-Case conversion may be inaccurate. Consider using '#align list.prod_eq_zero List.prod_eq_zeroₓ'. -/
 /-- If zero is an element of a list `L`, then `list.prod L = 0`. If the domain is a nontrivial
 monoid with zero with no divisors, then this implication becomes an `iff`, see
 `list.prod_eq_zero_iff`. -/
@@ -605,12 +377,6 @@ theorem prod_eq_zero {L : List M₀} (h : (0 : M₀) ∈ L) : L.Prod = 0 :=
     exacts[mul_eq_zero_of_left ha.symm _, mul_eq_zero_of_right _ (ihL hL)]
 #align list.prod_eq_zero List.prod_eq_zero
 
-/- warning: list.prod_eq_zero_iff -> List.prod_eq_zero_iff is a dubious translation:
-lean 3 declaration is
-  forall {M₀ : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : Nontrivial.{u1} M₀] [_inst_3 : NoZeroDivisors.{u1} M₀ (MulZeroClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)))] {L : List.{u1} M₀}, Iff (Eq.{succ u1} M₀ (List.prod.{u1} M₀ (MulZeroClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MulOneClass.toHasOne.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) L) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))))))) (Membership.Mem.{u1, u1} M₀ (List.{u1} M₀) (List.hasMem.{u1} M₀) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)))))) L)
-but is expected to have type
-  forall {M₀ : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : Nontrivial.{u1} M₀] [_inst_3 : NoZeroDivisors.{u1} M₀ (MulZeroClass.toMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidWithZero.toZero.{u1} M₀ _inst_1)] {L : List.{u1} M₀}, Iff (Eq.{succ u1} M₀ (List.prod.{u1} M₀ (MulZeroClass.toMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (Monoid.toOne.{u1} M₀ (MonoidWithZero.toMonoid.{u1} M₀ _inst_1)) L) (OfNat.ofNat.{u1} M₀ 0 (Zero.toOfNat0.{u1} M₀ (MonoidWithZero.toZero.{u1} M₀ _inst_1)))) (Membership.mem.{u1, u1} M₀ (List.{u1} M₀) (List.instMembershipList.{u1} M₀) (OfNat.ofNat.{u1} M₀ 0 (Zero.toOfNat0.{u1} M₀ (MonoidWithZero.toZero.{u1} M₀ _inst_1))) L)
-Case conversion may be inaccurate. Consider using '#align list.prod_eq_zero_iff List.prod_eq_zero_iffₓ'. -/
 /-- Product of elements of a list `L` equals zero if and only if `0 ∈ L`. See also
 `list.prod_eq_zero` for an implication that needs weaker typeclass assumptions. -/
 @[simp]
@@ -621,12 +387,6 @@ theorem prod_eq_zero_iff [Nontrivial M₀] [NoZeroDivisors M₀] {L : List M₀}
   · rw [prod_cons, mul_eq_zero, ihL, mem_cons_iff, eq_comm]
 #align list.prod_eq_zero_iff List.prod_eq_zero_iff
 
-/- warning: list.prod_ne_zero -> List.prod_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {M₀ : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : Nontrivial.{u1} M₀] [_inst_3 : NoZeroDivisors.{u1} M₀ (MulZeroClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)))] {L : List.{u1} M₀}, (Not (Membership.Mem.{u1, u1} M₀ (List.{u1} M₀) (List.hasMem.{u1} M₀) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)))))) L)) -> (Ne.{succ u1} M₀ (List.prod.{u1} M₀ (MulZeroClass.toHasMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MulOneClass.toHasOne.{u1} M₀ (MulZeroOneClass.toMulOneClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) L) (OfNat.ofNat.{u1} M₀ 0 (OfNat.mk.{u1} M₀ 0 (Zero.zero.{u1} M₀ (MulZeroClass.toHasZero.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1)))))))
-but is expected to have type
-  forall {M₀ : Type.{u1}} [_inst_1 : MonoidWithZero.{u1} M₀] [_inst_2 : Nontrivial.{u1} M₀] [_inst_3 : NoZeroDivisors.{u1} M₀ (MulZeroClass.toMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (MonoidWithZero.toZero.{u1} M₀ _inst_1)] {L : List.{u1} M₀}, (Not (Membership.mem.{u1, u1} M₀ (List.{u1} M₀) (List.instMembershipList.{u1} M₀) (OfNat.ofNat.{u1} M₀ 0 (Zero.toOfNat0.{u1} M₀ (MonoidWithZero.toZero.{u1} M₀ _inst_1))) L)) -> (Ne.{succ u1} M₀ (List.prod.{u1} M₀ (MulZeroClass.toMul.{u1} M₀ (MulZeroOneClass.toMulZeroClass.{u1} M₀ (MonoidWithZero.toMulZeroOneClass.{u1} M₀ _inst_1))) (Monoid.toOne.{u1} M₀ (MonoidWithZero.toMonoid.{u1} M₀ _inst_1)) L) (OfNat.ofNat.{u1} M₀ 0 (Zero.toOfNat0.{u1} M₀ (MonoidWithZero.toZero.{u1} M₀ _inst_1))))
-Case conversion may be inaccurate. Consider using '#align list.prod_ne_zero List.prod_ne_zeroₓ'. -/
 theorem prod_ne_zero [Nontrivial M₀] [NoZeroDivisors M₀] {L : List M₀} (hL : (0 : M₀) ∉ L) :
     L.Prod ≠ 0 :=
   mt prod_eq_zero_iff.1 hL
@@ -638,12 +398,6 @@ section Group
 
 variable [Group G]
 
-/- warning: list.prod_inv_reverse -> List.prod_inv_reverse is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (L : List.{u1} G), Eq.{succ u1} G (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) L)) (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (List.reverse.{u1} G (List.map.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) x) L)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (L : List.{u1} G), Eq.{succ u1} G (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) L)) (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) (List.reverse.{u1} G (List.map.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) x) L)))
-Case conversion may be inaccurate. Consider using '#align list.prod_inv_reverse List.prod_inv_reverseₓ'. -/
 /-- This is the `list.prod` version of `mul_inv_rev` -/
 @[to_additive "This is the `list.sum` version of `add_neg_rev`"]
 theorem prod_inv_reverse : ∀ L : List G, L.Prod⁻¹ = (L.map fun x => x⁻¹).reverse.Prod
@@ -652,12 +406,6 @@ theorem prod_inv_reverse : ∀ L : List G, L.Prod⁻¹ = (L.map fun x => x⁻¹)
 #align list.prod_inv_reverse List.prod_inv_reverse
 #align list.sum_neg_reverse List.sum_neg_reverse
 
-/- warning: list.prod_reverse_noncomm -> List.prod_reverse_noncomm is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (L : List.{u1} G), Eq.{succ u1} G (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (List.reverse.{u1} G L)) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (List.map.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) x) L)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (L : List.{u1} G), Eq.{succ u1} G (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) (List.reverse.{u1} G L)) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) (List.map.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) x) L)))
-Case conversion may be inaccurate. Consider using '#align list.prod_reverse_noncomm List.prod_reverse_noncommₓ'. -/
 /-- A non-commutative variant of `list.prod_reverse` -/
 @[to_additive "A non-commutative variant of `list.sum_reverse`"]
 theorem prod_reverse_noncomm : ∀ L : List G, L.reverse.Prod = (L.map fun x => x⁻¹).Prod⁻¹ := by
@@ -665,12 +413,6 @@ theorem prod_reverse_noncomm : ∀ L : List G, L.reverse.Prod = (L.map fun x =>
 #align list.prod_reverse_noncomm List.prod_reverse_noncomm
 #align list.sum_reverse_noncomm List.sum_reverse_noncomm
 
-/- warning: list.prod_drop_succ -> List.prod_drop_succ is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (L : List.{u1} G) (i : Nat) (p : LT.lt.{0} Nat Nat.hasLt i (List.length.{u1} G L)), Eq.{succ u1} G (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (List.drop.{u1} G (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) i (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) L)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (List.nthLe.{u1} G L i p)) (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (List.drop.{u1} G i L)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (L : List.{u1} G) (i : Nat) (p : LT.lt.{0} Nat instLTNat i (List.length.{u1} G L)), Eq.{succ u1} G (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) (List.drop.{u1} G (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) i (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) L)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) (List.nthLe.{u1} G L i p)) (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) (List.drop.{u1} G i L)))
-Case conversion may be inaccurate. Consider using '#align list.prod_drop_succ List.prod_drop_succₓ'. -/
 /-- Counterpart to `list.prod_take_succ` when we have an inverse operation -/
 @[simp, to_additive "Counterpart to `list.sum_take_succ` when we have an negation operation"]
 theorem prod_drop_succ :
@@ -687,12 +429,6 @@ section CommGroup
 
 variable [CommGroup G]
 
-/- warning: list.prod_inv -> List.prod_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : CommGroup.{u1} G] (L : List.{u1} G), Eq.{succ u1} G (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))) (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) L)) (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (List.map.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))) x) L))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : CommGroup.{u1} G] (L : List.{u1} G), Eq.{succ u1} G (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) L)) (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) (List.map.{u1, u1} G G (fun (x : G) => Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) x) L))
-Case conversion may be inaccurate. Consider using '#align list.prod_inv List.prod_invₓ'. -/
 /-- This is the `list.prod` version of `mul_inv` -/
 @[to_additive "This is the `list.sum` version of `add_neg`"]
 theorem prod_inv : ∀ L : List G, L.Prod⁻¹ = (L.map fun x => x⁻¹).Prod
@@ -701,12 +437,6 @@ theorem prod_inv : ∀ L : List G, L.Prod⁻¹ = (L.map fun x => x⁻¹).Prod
 #align list.prod_inv List.prod_inv
 #align list.sum_neg List.sum_neg
 
-/- warning: list.prod_update_nth' -> List.prod_set' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : CommGroup.{u1} G] (L : List.{u1} G) (n : Nat) (a : G), Eq.{succ u1} G (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (List.set.{u1} G L n a)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1)))))) (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) L) (dite.{succ u1} G (LT.lt.{0} Nat Nat.hasLt n (List.length.{u1} G L)) (Nat.decidableLt n (List.length.{u1} G L)) (fun (hn : LT.lt.{0} Nat Nat.hasLt n (List.length.{u1} G L)) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1)))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))) (List.nthLe.{u1} G L n hn)) a) (fun (hn : Not (LT.lt.{0} Nat Nat.hasLt n (List.length.{u1} G L))) => OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))))))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : CommGroup.{u1} G] (L : List.{u1} G) (n : Nat) (a : G), Eq.{succ u1} G (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) (List.set.{u1} G L n a)) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1)))))) (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1))))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) L) (dite.{succ u1} G (LT.lt.{0} Nat instLTNat n (List.length.{u1} G L)) (Nat.decLt n (List.length.{u1} G L)) (fun (hn : LT.lt.{0} Nat instLTNat n (List.length.{u1} G L)) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_1)))))) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1))))) (List.nthLe.{u1} G L n hn)) a) (fun (hn : Not (LT.lt.{0} Nat instLTNat n (List.length.{u1} G L))) => OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (DivisionCommMonoid.toDivisionMonoid.{u1} G (CommGroup.toDivisionCommMonoid.{u1} G _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align list.prod_update_nth' List.prod_set'ₓ'. -/
 /-- Alternative version of `list.prod_update_nth` when the list is over a group -/
 @[to_additive "Alternative version of `list.sum_update_nth` when the list is over a group"]
 theorem prod_set' (L : List G) (n : ℕ) (a : G) :
@@ -725,12 +455,6 @@ theorem prod_set' (L : List G) (n : ℕ) (a : G) :
 
 end CommGroup
 
-/- warning: list.eq_of_prod_take_eq -> List.eq_of_prod_take_eq is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : LeftCancelMonoid.{u1} M] {L : List.{u1} M} {L' : List.{u1} M}, (Eq.{1} Nat (List.length.{u1} M L) (List.length.{u1} M L')) -> (forall (i : Nat), (LE.le.{0} Nat Nat.hasLe i (List.length.{u1} M L)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (LeftCancelMonoid.toMonoid.{u1} M _inst_1))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (LeftCancelMonoid.toMonoid.{u1} M _inst_1))) (List.take.{u1} M i L)) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (LeftCancelMonoid.toMonoid.{u1} M _inst_1))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (LeftCancelMonoid.toMonoid.{u1} M _inst_1))) (List.take.{u1} M i L')))) -> (Eq.{succ u1} (List.{u1} M) L L')
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : LeftCancelMonoid.{u1} M] {L : List.{u1} M} {L' : List.{u1} M}, (Eq.{1} Nat (List.length.{u1} M L) (List.length.{u1} M L')) -> (forall (i : Nat), (LE.le.{0} Nat instLENat i (List.length.{u1} M L)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (LeftCancelMonoid.toMonoid.{u1} M _inst_1))) (LeftCancelMonoid.toOne.{u1} M _inst_1) (List.take.{u1} M i L)) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (LeftCancelMonoid.toMonoid.{u1} M _inst_1))) (LeftCancelMonoid.toOne.{u1} M _inst_1) (List.take.{u1} M i L')))) -> (Eq.{succ u1} (List.{u1} M) L L')
-Case conversion may be inaccurate. Consider using '#align list.eq_of_prod_take_eq List.eq_of_prod_take_eqₓ'. -/
 @[to_additive]
 theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length)
     (h' : ∀ i ≤ L.length, (L.take i).Prod = (L'.take i).Prod) : L = L' :=
@@ -742,12 +466,6 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
 #align list.eq_of_prod_take_eq List.eq_of_prod_take_eq
 #align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
 
-/- warning: list.monotone_prod_take -> List.monotone_prod_take is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : CanonicallyOrderedMonoid.{u1} M] (L : List.{u1} M), Monotone.{0, u1} Nat M (PartialOrder.toPreorder.{0} Nat (OrderedCancelAddCommMonoid.toPartialOrder.{0} Nat (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} Nat Nat.strictOrderedSemiring))) (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M (CanonicallyOrderedMonoid.toOrderedCommMonoid.{u1} M _inst_1))) (fun (i : Nat) => List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M (CanonicallyOrderedMonoid.toOrderedCommMonoid.{u1} M _inst_1))))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M (CanonicallyOrderedMonoid.toOrderedCommMonoid.{u1} M _inst_1))))) (List.take.{u1} M i L))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : CanonicallyOrderedMonoid.{u1} M] (L : List.{u1} M), Monotone.{0, u1} Nat M (PartialOrder.toPreorder.{0} Nat (StrictOrderedSemiring.toPartialOrder.{0} Nat Nat.strictOrderedSemiring)) (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M (CanonicallyOrderedMonoid.toOrderedCommMonoid.{u1} M _inst_1))) (fun (i : Nat) => List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M (CanonicallyOrderedMonoid.toOrderedCommMonoid.{u1} M _inst_1))))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M (CanonicallyOrderedMonoid.toOrderedCommMonoid.{u1} M _inst_1)))) (List.take.{u1} M i L))
-Case conversion may be inaccurate. Consider using '#align list.monotone_prod_take List.monotone_prod_takeₓ'. -/
 @[to_additive]
 theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
     Monotone fun i => (L.take i).Prod :=
@@ -760,12 +478,6 @@ theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
 #align list.monotone_prod_take List.monotone_prod_take
 #align list.monotone_sum_take List.monotone_sum_take
 
-/- warning: list.one_lt_prod_of_one_lt -> List.one_lt_prod_of_one_lt is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] (l : List.{u1} M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (Ne.{succ u1} (List.{u1} M) l (List.nil.{u1} M)) -> (LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] (l : List.{u1} M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))) x)) -> (Ne.{succ u1} (List.{u1} M) l (List.nil.{u1} M)) -> (LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))) l))
-Case conversion may be inaccurate. Consider using '#align list.one_lt_prod_of_one_lt List.one_lt_prod_of_one_ltₓ'. -/
 @[to_additive sum_pos]
 theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
     ∀ (l : List M) (hl : ∀ x ∈ l, (1 : M) < x) (hl₂ : l ≠ []), 1 < l.Prod
@@ -780,12 +492,6 @@ theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
 #align list.one_lt_prod_of_one_lt List.one_lt_prod_of_one_lt
 #align list.sum_pos List.sum_pos
 
-/- warning: list.single_le_prod -> List.single_le_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) x (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))) x)) -> (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) x (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))) l)))
-Case conversion may be inaccurate. Consider using '#align list.single_le_prod List.single_le_prodₓ'. -/
 @[to_additive]
 theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) :
     ∀ x ∈ l, x ≤ l.Prod := by
@@ -798,12 +504,6 @@ theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l,
 #align list.single_le_prod List.single_le_prod
 #align list.single_le_sum List.single_le_sum
 
-/- warning: list.all_one_of_le_one_le_of_prod_eq_one -> List.all_one_of_le_one_le_of_prod_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))))) -> (forall {x : M}, (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))) x)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))) l) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))) -> (forall {x : M}, (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align list.all_one_of_le_one_le_of_prod_eq_one List.all_one_of_le_one_le_of_prod_eq_oneₓ'. -/
 @[to_additive all_zero_of_le_zero_le_of_sum_eq_zero]
 theorem all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
     (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) (hl₂ : l.Prod = 1) {x : M} (hx : x ∈ l) : x = 1 :=
@@ -811,12 +511,6 @@ theorem all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
 #align list.all_one_of_le_one_le_of_prod_eq_one List.all_one_of_le_one_le_of_prod_eq_one
 #align list.all_zero_of_le_zero_le_of_sum_eq_zero List.all_zero_of_le_zero_le_of_sum_eq_zero
 
-/- warning: list.prod_eq_one -> List.prod_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))))) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align list.prod_eq_one List.prod_eq_oneₓ'. -/
 /-- Slightly more general version of `list.prod_eq_one_iff` for a non-ordered `monoid` -/
 @[to_additive
       "Slightly more general version of `list.sum_eq_zero_iff`\n  for a non-ordered `add_monoid`"]
@@ -829,24 +523,12 @@ theorem prod_eq_one [Monoid M] {l : List M} (hl : ∀ x ∈ l, x = (1 : M)) : l.
 #align list.prod_eq_one List.prod_eq_one
 #align list.sum_eq_zero List.sum_eq_zero
 
-/- warning: list.exists_mem_ne_one_of_prod_ne_one -> List.exists_mem_ne_one_of_prod_ne_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M}, (Ne.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (Exists.{succ u1} M (fun (x : M) => Exists.{0} (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) (fun (H : Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) => Ne.{succ u1} M x (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {l : List.{u1} M}, (Ne.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) -> (Exists.{succ u1} M (fun (x : M) => And (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) (Ne.{succ u1} M x (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align list.exists_mem_ne_one_of_prod_ne_one List.exists_mem_ne_one_of_prod_ne_oneₓ'. -/
 @[to_additive]
 theorem exists_mem_ne_one_of_prod_ne_one [Monoid M] {l : List M} (h : l.Prod ≠ 1) :
     ∃ x ∈ l, x ≠ (1 : M) := by simpa only [not_forall] using mt prod_eq_one h
 #align list.exists_mem_ne_one_of_prod_ne_one List.exists_mem_ne_one_of_prod_ne_one
 #align list.exists_mem_ne_zero_of_sum_ne_zero List.exists_mem_ne_zero_of_sum_ne_zero
 
-/- warning: list.sum_le_foldr_max -> List.sum_le_foldr_max is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] (f : M -> N), (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))))) (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) -> (forall (x : M) (y : M), LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x y)) (LinearOrder.max.{u2} N _inst_3 (f x) (f y))) -> (forall (l : List.{u1} M), LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (List.sum.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)) (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)) l)) (List.foldr.{u2, u2} N N (LinearOrder.max.{u2} N _inst_3) (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (List.map.{u1, u2} M N f l)))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : AddMonoid.{u2} M] [_inst_2 : AddMonoid.{u1} N] [_inst_3 : LinearOrder.{u1} N] (f : M -> N), (LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N (SemilatticeInf.toPartialOrder.{u1} N (Lattice.toSemilatticeInf.{u1} N (DistribLattice.toLattice.{u1} N (instDistribLattice.{u1} N _inst_3)))))) (f (OfNat.ofNat.{u2} M 0 (Zero.toOfNat0.{u2} M (AddMonoid.toZero.{u2} M _inst_1)))) (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N (AddMonoid.toZero.{u1} N _inst_2)))) -> (forall (x : M) (y : M), LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N (SemilatticeInf.toPartialOrder.{u1} N (Lattice.toSemilatticeInf.{u1} N (DistribLattice.toLattice.{u1} N (instDistribLattice.{u1} N _inst_3)))))) (f (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M (AddZeroClass.toAdd.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_1))) x y)) (Max.max.{u1} N (LinearOrder.toMax.{u1} N _inst_3) (f x) (f y))) -> (forall (l : List.{u2} M), LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N (SemilatticeInf.toPartialOrder.{u1} N (Lattice.toSemilatticeInf.{u1} N (DistribLattice.toLattice.{u1} N (instDistribLattice.{u1} N _inst_3)))))) (f (List.sum.{u2} M (AddZeroClass.toAdd.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_1)) (AddMonoid.toZero.{u2} M _inst_1) l)) (List.foldr.{u1, u1} N N (Max.max.{u1} N (LinearOrder.toMax.{u1} N _inst_3)) (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N (AddMonoid.toZero.{u1} N _inst_2))) (List.map.{u2, u1} M N f l)))
-Case conversion may be inaccurate. Consider using '#align list.sum_le_foldr_max List.sum_le_foldr_maxₓ'. -/
 -- TODO: develop theory of tropical rings
 theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M → N) (h0 : f 0 ≤ 0)
     (hadd : ∀ x y, f (x + y) ≤ max (f x) (f y)) (l : List M) : f l.Sum ≤ (l.map f).foldr max 0 :=
@@ -857,12 +539,6 @@ theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M →
   exact (hadd _ _).trans (max_le_max le_rfl IH)
 #align list.sum_le_foldr_max List.sum_le_foldr_max
 
-/- warning: list.prod_erase -> List.prod_erase is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} M] [_inst_2 : CommMonoid.{u1} M] {a : M} {l : List.{u1} M}, (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)))) a (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (List.eraseₓ.{u1} M (fun (a : M) (b : M) => _inst_1 a b) l a))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) l))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} M] [_inst_2 : CommMonoid.{u1} M] {a : M} {l : List.{u1} M}, (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)))) a (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) (List.erase.{u1} M (instBEq.{u1} M (fun (a : M) (b : M) => _inst_1 a b)) l a))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) l))
-Case conversion may be inaccurate. Consider using '#align list.prod_erase List.prod_eraseₓ'. -/
 @[simp, to_additive]
 theorem prod_erase [DecidableEq M] [CommMonoid M] {a} :
     ∀ {l : List M}, a ∈ l → a * (l.eraseₓ a).Prod = l.Prod
@@ -873,12 +549,6 @@ theorem prod_erase [DecidableEq M] [CommMonoid M] {a} :
 #align list.prod_erase List.prod_erase
 #align list.sum_erase List.sum_erase
 
-/- warning: list.prod_map_erase -> List.prod_map_erase is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : DecidableEq.{succ u1} ι] [_inst_2 : CommMonoid.{u2} M] (f : ι -> M) {a : ι} {l : List.{u1} ι}, (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) a l) -> (Eq.{succ u2} M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2)))) (f a) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))) (List.map.{u1, u2} ι M f (List.eraseₓ.{u1} ι (fun (a : ι) (b : ι) => _inst_1 a b) l a)))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_2))) (List.map.{u1, u2} ι M f l)))
-but is expected to have type
-  forall {ι : Type.{u2}} {M : Type.{u1}} [_inst_1 : DecidableEq.{succ u2} ι] [_inst_2 : CommMonoid.{u1} M] (f : ι -> M) {a : ι} {l : List.{u2} ι}, (Membership.mem.{u2, u2} ι (List.{u2} ι) (List.instMembershipList.{u2} ι) a l) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)))) (f a) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) (List.map.{u2, u1} ι M f (List.erase.{u2} ι (instBEq.{u2} ι (fun (a : ι) (b : ι) => _inst_1 a b)) l a)))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) (List.map.{u2, u1} ι M f l)))
-Case conversion may be inaccurate. Consider using '#align list.prod_map_erase List.prod_map_eraseₓ'. -/
 @[simp, to_additive]
 theorem prod_map_erase [DecidableEq ι] [CommMonoid M] (f : ι → M) {a} :
     ∀ {l : List ι}, a ∈ l → f a * ((l.eraseₓ a).map f).Prod = (l.map f).Prod
@@ -896,12 +566,6 @@ theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n := by rw [sum_re
 #align list.sum_const_nat List.sum_const_nat
 -/
 
-/- warning: list.prod_pos -> List.prod_pos is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (l : List.{u1} R), (forall (a : R), (Membership.Mem.{u1, u1} R (List.{u1} R) (List.hasMem.{u1} R) a l) -> (LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) a)) -> (LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) (List.prod.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (AddMonoidWithOne.toOne.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) l))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (l : List.{u1} R), (forall (a : R), (Membership.mem.{u1, u1} R (List.{u1} R) (List.instMembershipList.{u1} R) a l) -> (LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) a)) -> (LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (List.prod.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))) (Semiring.toOne.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)) l))
-Case conversion may be inaccurate. Consider using '#align list.prod_pos List.prod_posₓ'. -/
 /-- The product of a list of positive natural numbers is positive,
 and likewise for any nontrivial ordered semiring. -/
 theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R) < a) : 0 < l.Prod :=
@@ -912,12 +576,6 @@ theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R
     exact mul_pos (h _ <| mem_cons_self _ _) (ih fun a ha => h a <| mem_cons_of_mem _ ha)
 #align list.prod_pos List.prod_pos
 
-/- warning: canonically_ordered_comm_semiring.list_prod_pos -> CanonicallyOrderedCommSemiring.list_prod_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CanonicallyOrderedCommSemiring.{u1} α] [_inst_2 : Nontrivial.{u1} α] {l : List.{u1} α}, Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))))))) (List.prod.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))))) (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))))) l)) (forall (x : α), (Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))))))) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CanonicallyOrderedCommSemiring.{u1} α] [_inst_2 : Nontrivial.{u1} α] {l : List.{u1} α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedSemiring.toPartialOrder.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α (CommSemiring.toCommMonoidWithZero.{u1} α (CanonicallyOrderedCommSemiring.toCommSemiring.{u1} α _inst_1))))) (List.prod.{u1} α (CanonicallyOrderedCommSemiring.toMul.{u1} α _inst_1) (CanonicallyOrderedCommSemiring.toOne.{u1} α _inst_1) l)) (forall (x : α), (Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedSemiring.toPartialOrder.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α (CommSemiring.toCommMonoidWithZero.{u1} α (CanonicallyOrderedCommSemiring.toCommSemiring.{u1} α _inst_1))))) x))
-Case conversion may be inaccurate. Consider using '#align canonically_ordered_comm_semiring.list_prod_pos CanonicallyOrderedCommSemiring.list_prod_posₓ'. -/
 /-- A variant of `list.prod_pos` for `canonically_ordered_comm_semiring`. -/
 @[simp]
 theorem CanonicallyOrderedCommSemiring.list_prod_pos {α : Type _} [CanonicallyOrderedCommSemiring α]
@@ -989,12 +647,6 @@ theorem alternatingProd_cons_cons' (a b : α) (l : List α) :
 
 end
 
-/- warning: list.alternating_prod_cons_cons -> List.alternatingProd_cons_cons is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} α] (a : α) (b : α) (l : List.{u1} α), Eq.{succ u1} α (List.alternatingProd.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1))) (DivInvMonoid.toHasInv.{u1} α _inst_1) (List.cons.{u1} α a (List.cons.{u1} α b l))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α _inst_1)) a b) (List.alternatingProd.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1))) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1))) (DivInvMonoid.toHasInv.{u1} α _inst_1) l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DivInvMonoid.{u1} α] (a : α) (b : α) (l : List.{u1} α), Eq.{succ u1} α (List.alternatingProd.{u1} α (Monoid.toOne.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1))) (DivInvMonoid.toInv.{u1} α _inst_1) (List.cons.{u1} α a (List.cons.{u1} α b l))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1)))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α _inst_1)) a b) (List.alternatingProd.{u1} α (Monoid.toOne.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1)) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α _inst_1))) (DivInvMonoid.toInv.{u1} α _inst_1) l))
-Case conversion may be inaccurate. Consider using '#align list.alternating_prod_cons_cons List.alternatingProd_cons_consₓ'. -/
 @[to_additive]
 theorem alternatingProd_cons_cons [DivInvMonoid α] (a b : α) (l : List α) :
     alternatingProd (a :: b :: l) = a / b * alternatingProd l := by
@@ -1004,12 +656,6 @@ theorem alternatingProd_cons_cons [DivInvMonoid α] (a b : α) (l : List α) :
 
 variable [CommGroup α]
 
-/- warning: list.alternating_prod_cons' -> List.alternatingProd_cons' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] (a : α) (l : List.{u1} α), Eq.{succ u1} α (List.alternatingProd.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) (List.cons.{u1} α a l)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) (List.alternatingProd.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) l)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] (a : α) (l : List.{u1} α), Eq.{succ u1} α (List.alternatingProd.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) (List.cons.{u1} α a l)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) (List.alternatingProd.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) l)))
-Case conversion may be inaccurate. Consider using '#align list.alternating_prod_cons' List.alternatingProd_cons'ₓ'. -/
 @[to_additive]
 theorem alternatingProd_cons' :
     ∀ (a : α) (l : List α), alternatingProd (a :: l) = a * (alternatingProd l)⁻¹
@@ -1019,12 +665,6 @@ theorem alternatingProd_cons' :
 #align list.alternating_prod_cons' List.alternatingProd_cons'
 #align list.alternating_sum_cons' List.alternatingSum_cons'
 
-/- warning: list.alternating_prod_cons -> List.alternatingProd_cons is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] (a : α) (l : List.{u1} α), Eq.{succ u1} α (List.alternatingProd.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) (List.cons.{u1} α a l)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a (List.alternatingProd.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) l))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] (a : α) (l : List.{u1} α), Eq.{succ u1} α (List.alternatingProd.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) (List.cons.{u1} α a l)) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a (List.alternatingProd.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))) (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) l))
-Case conversion may be inaccurate. Consider using '#align list.alternating_prod_cons List.alternatingProd_consₓ'. -/
 @[simp, to_additive]
 theorem alternatingProd_cons (a : α) (l : List α) :
     alternatingProd (a :: l) = a / alternatingProd l := by
@@ -1064,12 +704,6 @@ section MonoidHom
 
 variable [Monoid M] [Monoid N]
 
-/- warning: map_list_prod -> map_list_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F) (l : List.{u1} M), Eq.{succ u2} N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)) (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f) l))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f) l))
-Case conversion may be inaccurate. Consider using '#align map_list_prod map_list_prodₓ'. -/
 @[to_additive]
 theorem map_list_prod {F : Type _} [MonoidHomClass F M N] (f : F) (l : List M) :
     f l.Prod = (l.map f).Prod :=
@@ -1079,12 +713,6 @@ theorem map_list_prod {F : Type _} [MonoidHomClass F M N] (f : F) (l : List M) :
 
 namespace MonoidHom
 
-/- warning: monoid_hom.map_list_prod -> MonoidHom.map_list_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (l : List.{u1} M), Eq.{succ u2} N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)) (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f) l))
-but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f) l))
-Case conversion may be inaccurate. Consider using '#align monoid_hom.map_list_prod MonoidHom.map_list_prodₓ'. -/
 /-- Deprecated, use `_root_.map_list_prod` instead. -/
 @[to_additive "Deprecated, use `_root_.map_list_sum` instead."]
 protected theorem map_list_prod (f : M →* N) (l : List M) : f l.Prod = (l.map f).Prod :=

6c5f73fd

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -132,8 +132,7 @@ Case conversion may be inaccurate. Consider using '#align list.prod_replicate Li
 theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).Prod = a ^ n :=
   by
   induction' n with n ih
-  · rw [pow_zero]
-    rfl
+  · rw [pow_zero]; rfl
   · rw [List.replicate_succ, List.prod_cons, ih, pow_succ]
 #align list.prod_replicate List.prod_replicate
 #align list.sum_replicate List.sum_replicate
@@ -277,9 +276,7 @@ Case conversion may be inaccurate. Consider using '#align list.prod_take_mul_pro
 theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).Prod * (L.drop i).Prod = L.Prod
   | [], i => by simp [Nat.zero_le]
   | L, 0 => by simp
-  | h :: t, n + 1 => by
-    dsimp
-    rw [prod_cons, prod_cons, mul_assoc, prod_take_mul_prod_drop]
+  | h :: t, n + 1 => by dsimp; rw [prod_cons, prod_cons, mul_assoc, prod_take_mul_prod_drop]
 #align list.prod_take_mul_prod_drop List.prod_take_mul_prod_drop
 #align list.sum_take_add_sum_drop List.sum_take_add_sum_drop
 
@@ -294,9 +291,7 @@ theorem prod_take_succ :
     ∀ (L : List M) (i : ℕ) (p), (L.take (i + 1)).Prod = (L.take i).Prod * L.nthLe i p
   | [], i, p => by cases p
   | h :: t, 0, _ => by simp
-  | h :: t, n + 1, _ => by
-    dsimp
-    rw [prod_cons, prod_cons, prod_take_succ, mul_assoc]
+  | h :: t, n + 1, _ => by dsimp; rw [prod_cons, prod_cons, prod_take_succ, mul_assoc]
 #align list.prod_take_succ List.prod_take_succ
 #align list.sum_take_succ List.sum_take_succ
 
@@ -308,12 +303,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align list.length_pos_of_prod_ne_one List.length_pos_of_prod_ne_oneₓ'. -/
 /-- A list with product not one must have positive length. -/
 @[to_additive "A list with sum not zero must have positive length."]
-theorem length_pos_of_prod_ne_one (L : List M) (h : L.Prod ≠ 1) : 0 < L.length :=
-  by
-  cases L
-  · contrapose h
-    simp
-  · simp
+theorem length_pos_of_prod_ne_one (L : List M) (h : L.Prod ≠ 1) : 0 < L.length := by cases L;
+  · contrapose h; simp; · simp
 #align list.length_pos_of_prod_ne_one List.length_pos_of_prod_ne_one
 #align list.length_pos_of_sum_ne_zero List.length_pos_of_sum_ne_zero
 
@@ -551,9 +542,7 @@ Case conversion may be inaccurate. Consider using '#align list.exists_lt_of_prod
 @[to_additive exists_lt_of_sum_lt]
 theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} (f g : ι → M)
-    (h : (l.map f).Prod < (l.map g).Prod) : ∃ i ∈ l, f i < g i :=
-  by
-  contrapose! h
+    (h : (l.map f).Prod < (l.map g).Prod) : ∃ i ∈ l, f i < g i := by contrapose! h;
   exact prod_le_prod' h
 #align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'
 #align list.exists_lt_of_sum_lt List.exists_lt_of_sum_lt
@@ -568,9 +557,7 @@ Case conversion may be inaccurate. Consider using '#align list.exists_le_of_prod
 theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
     [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (hl : l ≠ []) (f g : ι → M)
-    (h : (l.map f).Prod ≤ (l.map g).Prod) : ∃ x ∈ l, f x ≤ g x :=
-  by
-  contrapose! h
+    (h : (l.map f).Prod ≤ (l.map g).Prod) : ∃ x ∈ l, f x ≤ g x := by contrapose! h;
   exact prod_lt_prod_of_ne_nil hl _ _ h
 #align list.exists_le_of_prod_le' List.exists_le_of_prod_le'
 #align list.exists_le_of_sum_le List.exists_le_of_sum_le
@@ -950,11 +937,7 @@ If desired, we could add a class stating that `default = 0`.
 
 #print List.headI_add_tail_sum /-
 /-- This relies on `default ℕ = 0`. -/
-theorem headI_add_tail_sum (L : List ℕ) : L.headI + L.tail.Sum = L.Sum :=
-  by
-  cases L
-  · simp
-    rfl
+theorem headI_add_tail_sum (L : List ℕ) : L.headI + L.tail.Sum = L.Sum := by cases L; · simp; rfl;
   · simp
 #align list.head_add_tail_sum List.headI_add_tail_sum
 -/

6c5f73fd

bump to nightly-2023-05-24-06

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

fbc7b476

Diff

@@ -106,7 +106,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align list.prod_join List.prod_joinₓ'. -/
 @[simp, to_additive]
 theorem prod_join {l : List (List M)} : l.join.Prod = (l.map List.prod).Prod := by
-  induction l <;> [rfl, simp only [*, List.join, map, prod_append, prod_cons]]
+  induction l <;> [rfl;simp only [*, List.join, map, prod_append, prod_cons]]
 #align list.prod_join List.prod_join
 #align list.sum_join List.sum_join
 
@@ -389,7 +389,7 @@ the list to be nonempty. -/
 @[to_additive
       "Same as `nth_zero_add_tail_sum`, but avoiding the `list.head` garbage complication\nby requiring the list to be nonempty."]
 theorem headI_mul_tail_prod_of_ne_nil [Inhabited M] (l : List M) (h : l ≠ []) :
-    l.headI * l.tail.Prod = l.Prod := by cases l <;> [contradiction, simp]
+    l.headI * l.tail.Prod = l.Prod := by cases l <;> [contradiction;simp]
 #align list.head_mul_tail_prod_of_ne_nil List.headI_mul_tail_prod_of_ne_nil
 #align list.head_add_tail_sum_of_ne_nil List.headI_add_tail_sum_of_ne_nil

6c5f73fd

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -167,7 +167,7 @@ theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (l : List.{u1} M) {F : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F), Eq.{succ u2} N (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_4))) f) l)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_4))) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
 but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u1}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u1} N] (l : List.{u3} M) {F : Type.{u2}} [_inst_4 : MonoidHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u3, u1} M N (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f) l)) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f (List.prod.{u3} M (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (Monoid.toOne.{u3} M _inst_1) l))
+  forall {M : Type.{u3}} {N : Type.{u1}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u1} N] (l : List.{u3} M) {F : Type.{u2}} [_inst_4 : MonoidHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u3, u1} M N (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f) l)) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f (List.prod.{u3} M (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (Monoid.toOne.{u3} M _inst_1) l))
 Case conversion may be inaccurate. Consider using '#align list.prod_hom List.prod_homₓ'. -/
 @[to_additive]
 theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
@@ -226,7 +226,7 @@ theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] (L : List.{u1} ι) (f : ι -> M) {G : Type.{u4}} [_inst_4 : MonoidHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (g : G), Eq.{succ u3} N (List.prod.{u3} N (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MulOneClass.toHasOne.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (List.map.{u1, u3} ι N (Function.comp.{succ u1, succ u2, succ u3} ι M N (coeFn.{succ u4, max (succ u2) (succ u3)} G (fun (_x : G) => M -> N) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} G M (fun (_x : M) => N) (MulHomClass.toFunLike.{u4, u2, u3} G M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_4))) g) f) L)) (coeFn.{succ u4, max (succ u2) (succ u3)} G (fun (_x : G) => M -> N) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} G M (fun (_x : M) => N) (MulHomClass.toFunLike.{u4, u2, u3} G M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_4))) g (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f L)))
 but is expected to have type
-  forall {ι : Type.{u4}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (L : List.{u4} ι) (f : ι -> M) {G : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (g : G), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u4, u1} ι N (Function.comp.{succ u4, succ u2, succ u1} ι M N (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g) f) L)) (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u4, u2} ι M f L)))
+  forall {ι : Type.{u4}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (L : List.{u4} ι) (f : ι -> M) {G : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (g : G), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u4, u1} ι N (Function.comp.{succ u4, succ u2, succ u1} ι M N (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g) f) L)) (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u4, u2} ι M f L)))
 Case conversion may be inaccurate. Consider using '#align list.prod_map_hom List.prod_map_homₓ'. -/
 @[to_additive]
 theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type _} [MonoidHomClass G M N] (g : G) :
@@ -426,7 +426,7 @@ theorem Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Commute x
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4)) l₁ l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2795 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2797 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2795 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2797)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2810 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2812 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2810 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2812)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2829 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2831 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2829 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2831) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2844 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2846 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2844 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2846)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2864 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2866 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2864 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2866) l₁ l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2800 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2802 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2800 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2802)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2815 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2817 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2815 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2817)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2834 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2836 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2834 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2836) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2849 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2851 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2849 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2851)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2869 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2871 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2869 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2871) l₁ l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.forall₂.prod_le_prod' List.Forall₂.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -442,7 +442,7 @@ theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2949 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2951 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2949 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2951)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2964 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2966 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2964 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2966)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2983 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2985 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2983 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2985) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2998 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3000 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2998 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3000)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2954 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2956 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2954 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2956)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2969 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2971 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2969 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2971)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2988 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2990 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2988 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2990) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3003 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3005 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3003 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3005)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'ₓ'. -/
 /-- If `l₁` is a sublist of `l₂` and all elements of `l₂` are greater than or equal to one, then
 `l₁.prod ≤ l₂.prod`. One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 1 ≤ a` instead
@@ -467,7 +467,7 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4)) l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3139 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3141 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3139 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3141)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3154 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3156 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3154 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3156)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3173 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3175 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3173 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3175) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3188 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3190 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3188 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3190)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3208 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3210 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3208 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3210) l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3144 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3146 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3144 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3146)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3159 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3161 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3159 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3161)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3178 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3180 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3178 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3180) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3193 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3195 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3193 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3195)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3213 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3215 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3213 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3215) l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.sublist_forall₂.prod_le_prod' List.SublistForall₂.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem SublistForall₂.prod_le_prod' [Preorder M]
@@ -483,7 +483,7 @@ theorem SublistForall₂.prod_le_prod' [Preorder M]
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3322 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3324 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3322 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3324)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3337 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3339 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3337 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3339)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3356 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3358 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3356 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3358) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3371 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3373 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3371 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3373)] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3329 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3331 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3329 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3331)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3344 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3346 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3344 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3346)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3363 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3365 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3363 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3365) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3378 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3380 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3378 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3380)] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_le_prod' List.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -497,7 +497,7 @@ theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·))
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3468 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3470 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3468 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3470) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3483 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3485 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3483 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3485)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3502 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3504 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3502 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3504) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3517 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3519 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3517 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3519)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3539 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3541 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3539 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3541)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3554 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3556 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3554 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3556)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3576 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3578 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3576 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3578)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3591 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3593 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3591 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3593)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3475 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3477 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3475 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3477) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3490 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3492 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3490 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3492)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3509 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3511 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3509 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3511) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3524 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3526 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3524 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3526)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3546 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3548 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3546 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3548)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3561 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3563 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3561 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3563)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3583 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3585 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3583 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3585)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3598 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3600 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3598 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3600)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_lt_prod' List.prod_lt_prod'ₓ'. -/
 @[to_additive sum_lt_sum]
 theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -516,7 +516,7 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3768 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3770 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3768 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3770) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3783 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3785 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3783 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3785)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3802 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3804 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3802 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3804) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3817 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3819 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3817 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3819)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3839 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3841 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3839 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3841)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3854 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3856 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3854 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3856)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3876 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3878 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3876 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3878)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3891 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3893 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3891 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3893)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3775 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3777 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3775 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3777) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3790 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3792 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3790 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3792)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3809 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3811 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3809 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3811) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3824 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3826 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3824 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3826)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3846 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3848 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3846 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3848)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3861 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3863 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3861 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3863)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3883 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3885 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3883 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3885)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3898 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3900 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3898 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3900)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))))
 Case conversion may be inaccurate. Consider using '#align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nilₓ'. -/
 @[to_additive]
 theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -532,7 +532,7 @@ theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· <
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4025 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4027 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4025 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4027)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4040 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4042 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4040 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4042)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4059 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4061 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4059 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4061) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4074 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4076 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4074 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4076)] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4032 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4034 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4032 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4034)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4047 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4049 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4047 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4049)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4066 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4068 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4066 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4068) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4081 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4083 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4081 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4083)] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_le_pow_card List.prod_le_pow_cardₓ'. -/
 @[to_additive sum_le_card_nsmul]
 theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -546,7 +546,7 @@ theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * 
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f i) (g i))))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4163 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4165 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4163 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4165)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4178 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4180 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4178 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4180)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4197 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4199 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4197 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4199) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4212 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4214 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4212 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4214)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f i) (g i))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4170 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4172 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4170 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4172)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4185 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4187 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4185 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4187)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4204 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4206 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4204 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4206) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4219 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4221 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4219 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4221)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f i) (g i))))
 Case conversion may be inaccurate. Consider using '#align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'ₓ'. -/
 @[to_additive exists_lt_of_sum_lt]
 theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -562,7 +562,7 @@ theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) => LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f x) (g x)))))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4331 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4333 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4331 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4333) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4346 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4348 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4346 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4348)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4365 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4367 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4365 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4367) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4380 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4382 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4380 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4382)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4402 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4404 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4402 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4404)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4417 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4419 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4417 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4419)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4439 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4441 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4439 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4441)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4454 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4456 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4454 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4456)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) x l) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f x) (g x)))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4338 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4340 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4338 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4340) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4353 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4355 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4353 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4355)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4372 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4374 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4372 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4374) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4387 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4389 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4387 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4389)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4409 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4411 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4409 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4411)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4424 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4426 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4424 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4426)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4446 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4448 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4446 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4448)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4461 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4463 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4461 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4463)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) x l) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f x) (g x)))))
 Case conversion may be inaccurate. Consider using '#align list.exists_le_of_prod_le' List.exists_le_of_prod_le'ₓ'. -/
 @[to_additive exists_le_of_sum_le]
 theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -579,7 +579,7 @@ theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (·
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) x)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4583 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4585 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4583 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4585) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4598 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4600 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4598 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4600)] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) x)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4590 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4592 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4590 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4592) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4605 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4607 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4605 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4607)] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) x)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
 Case conversion may be inaccurate. Consider using '#align list.one_le_prod_of_one_le List.one_le_prod_of_one_leₓ'. -/
 @[to_additive sum_nonneg]
 theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
@@ -1085,7 +1085,7 @@ variable [Monoid M] [Monoid N]
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F) (l : List.{u1} M), Eq.{succ u2} N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)) (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f) l))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f) l))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f) l))
 Case conversion may be inaccurate. Consider using '#align map_list_prod map_list_prodₓ'. -/
 @[to_additive]
 theorem map_list_prod {F : Type _} [MonoidHomClass F M N] (f : F) (l : List M) :
@@ -1100,7 +1100,7 @@ namespace MonoidHom
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (l : List.{u1} M), Eq.{succ u2} N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)) (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f) l))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f) l))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f) l))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_list_prod MonoidHom.map_list_prodₓ'. -/
 /-- Deprecated, use `_root_.map_list_prod` instead. -/
 @[to_additive "Deprecated, use `_root_.map_list_sum` instead."]

6c5f73fd

bump to nightly-2023-05-16-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

9cb92e8c

Diff

@@ -319,7 +319,7 @@ theorem length_pos_of_prod_ne_one (L : List M) (h : L.Prod ≠ 1) : 0 < L.length
 
 /- warning: list.length_pos_of_one_lt_prod -> List.length_pos_of_one_lt_prod is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L)) -> (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (List.length.{u1} M L))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L)) -> (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (List.length.{u1} M L))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) L)) -> (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) (List.length.{u1} M L))
 Case conversion may be inaccurate. Consider using '#align list.length_pos_of_one_lt_prod List.length_pos_of_one_lt_prodₓ'. -/
@@ -332,7 +332,7 @@ theorem length_pos_of_one_lt_prod [Preorder M] (L : List M) (h : 1 < L.Prod) : 0
 
 /- warning: list.length_pos_of_prod_lt_one -> List.length_pos_of_prod_lt_one is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (List.length.{u1} M L))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toHasLt.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) L) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero))) (List.length.{u1} M L))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] (L : List.{u1} M), (LT.lt.{u1} M (Preorder.toLT.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) L) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) -> (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0)) (List.length.{u1} M L))
 Case conversion may be inaccurate. Consider using '#align list.length_pos_of_prod_lt_one List.length_pos_of_prod_lt_oneₓ'. -/
@@ -424,7 +424,7 @@ theorem Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Commute x
 
 /- warning: list.forall₂.prod_le_prod' -> List.Forall₂.prod_le_prod' is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4)) l₁ l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4)) l₁ l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2795 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2797 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2795 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2797)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2810 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2812 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2810 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2812)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2829 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2831 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2829 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2831) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2844 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2846 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2844 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2846)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2864 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2866 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2864 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2866) l₁ l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.forall₂.prod_le_prod' List.Forall₂.prod_le_prod'ₓ'. -/
@@ -440,7 +440,7 @@ theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap
 
 /- warning: list.sublist.prod_le_prod' -> List.Sublist.prod_le_prod' is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2949 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2951 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2949 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2951)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2964 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2966 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2964 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2966)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2983 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2985 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2983 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2985) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2998 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3000 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2998 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3000)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'ₓ'. -/
@@ -465,7 +465,7 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
 
 /- warning: list.sublist_forall₂.prod_le_prod' -> List.SublistForall₂.prod_le_prod' is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4)) l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4)) l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3139 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3141 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3139 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3141)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3154 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3156 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3154 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3156)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3173 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3175 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3173 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3175) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3188 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3190 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3188 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3190)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3208 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3210 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3208 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3210) l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.sublist_forall₂.prod_le_prod' List.SublistForall₂.prod_le_prod'ₓ'. -/
@@ -481,7 +481,7 @@ theorem SublistForall₂.prod_le_prod' [Preorder M]
 
 /- warning: list.prod_le_prod' -> List.prod_le_prod' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
 but is expected to have type
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3322 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3324 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3322 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3324)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3337 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3339 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3337 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3339)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3356 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3358 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3356 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3358) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3371 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3373 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3371 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3373)] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_le_prod' List.prod_le_prod'ₓ'. -/
@@ -495,7 +495,7 @@ theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·))
 
 /- warning: list.prod_lt_prod' -> List.prod_lt_prod' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
 but is expected to have type
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3468 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3470 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3468 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3470) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3483 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3485 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3483 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3485)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3502 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3504 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3502 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3504) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3517 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3519 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3517 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3519)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3539 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3541 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3539 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3541)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3554 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3556 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3554 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3556)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3576 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3578 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3576 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3578)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3591 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3593 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3591 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3593)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_lt_prod' List.prod_lt_prod'ₓ'. -/
@@ -514,7 +514,7 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
 
 /- warning: list.prod_lt_prod_of_ne_nil -> List.prod_lt_prod_of_ne_nil is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M _inst_4))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toHasLt.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))))
 but is expected to have type
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3768 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3770 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3768 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3770) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3783 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3785 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3783 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3785)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3802 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3804 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3802 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3804) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3817 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3819 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3817 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3819)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3839 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3841 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3839 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3841)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3854 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3856 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3854 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3856)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3876 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3878 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3876 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3878)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3891 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3893 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3891 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3893)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))))
 Case conversion may be inaccurate. Consider using '#align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nilₓ'. -/
@@ -530,7 +530,7 @@ theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· <
 
 /- warning: list.prod_le_pow_card -> List.prod_le_pow_card is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4025 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4027 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4025 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4027)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4040 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4042 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4040 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4042)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4059 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4061 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4059 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4061) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4074 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4076 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4074 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4076)] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_le_pow_card List.prod_le_pow_cardₓ'. -/
@@ -544,7 +544,7 @@ theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * 
 
 /- warning: list.exists_lt_of_prod_lt' -> List.exists_lt_of_prod_lt' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f i) (g i))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f i) (g i))))
 but is expected to have type
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4163 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4165 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4163 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4165)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4178 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4180 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4178 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4180)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4197 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4199 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4197 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4199) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4212 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4214 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4212 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4214)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f i) (g i))))
 Case conversion may be inaccurate. Consider using '#align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'ₓ'. -/
@@ -560,7 +560,7 @@ theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap
 
 /- warning: list.exists_le_of_prod_le' -> List.exists_le_of_prod_le' is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f x) (g x)))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toHasLt.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) => LE.le.{u2} M (Preorder.toHasLe.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f x) (g x)))))
 but is expected to have type
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4331 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4333 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4331 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4333) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4346 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4348 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4346 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4348)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4365 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4367 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4365 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4367) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4380 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4382 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4380 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4382)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4402 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4404 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4402 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4404)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4417 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4419 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4417 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4419)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4439 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4441 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4439 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4441)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4454 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4456 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4454 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4456)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) x l) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f x) (g x)))))
 Case conversion may be inaccurate. Consider using '#align list.exists_le_of_prod_le' List.exists_le_of_prod_le'ₓ'. -/
@@ -577,7 +577,7 @@ theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (·
 
 /- warning: list.one_le_prod_of_one_le -> List.one_le_prod_of_one_le is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) x)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4))] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) x)) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4583 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4585 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4583 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4585) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4598 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4600 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4598 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4600)] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) x)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
 Case conversion may be inaccurate. Consider using '#align list.one_le_prod_of_one_le List.one_le_prod_of_one_leₓ'. -/
@@ -775,7 +775,7 @@ theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
 
 /- warning: list.one_lt_prod_of_one_lt -> List.one_lt_prod_of_one_lt is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] (l : List.{u1} M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (Ne.{succ u1} (List.{u1} M) l (List.nil.{u1} M)) -> (LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l))
+  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] (l : List.{u1} M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (Ne.{succ u1} (List.{u1} M) l (List.nil.{u1} M)) -> (LT.lt.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] (l : List.{u1} M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))) x)) -> (Ne.{succ u1} (List.{u1} M) l (List.nil.{u1} M)) -> (LT.lt.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))) l))
 Case conversion may be inaccurate. Consider using '#align list.one_lt_prod_of_one_lt List.one_lt_prod_of_one_ltₓ'. -/
@@ -795,7 +795,7 @@ theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
 
 /- warning: list.single_le_prod -> List.single_le_prod is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) x (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l)))
+  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) x (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l)))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))) x)) -> (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) x (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))) l)))
 Case conversion may be inaccurate. Consider using '#align list.single_le_prod List.single_le_prodₓ'. -/
@@ -813,7 +813,7 @@ theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l,
 
 /- warning: list.all_one_of_le_one_le_of_prod_eq_one -> List.all_one_of_le_one_le_of_prod_eq_one is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))))) -> (forall {x : M}, (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))))))
+  forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))))) x)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) l) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))))) -> (forall {x : M}, (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))))))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : OrderedCommMonoid.{u1} M] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (OrderedCommMonoid.toPartialOrder.{u1} M _inst_1))) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))))) x)) -> (Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))) (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1))) l) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))) -> (forall {x : M}, (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (Eq.{succ u1} M x (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M (CommMonoid.toMonoid.{u1} M (OrderedCommMonoid.toCommMonoid.{u1} M _inst_1)))))))
 Case conversion may be inaccurate. Consider using '#align list.all_one_of_le_one_le_of_prod_eq_one List.all_one_of_le_one_le_of_prod_eq_oneₓ'. -/
@@ -856,7 +856,7 @@ theorem exists_mem_ne_one_of_prod_ne_one [Monoid M] {l : List M} (h : l.Prod ≠
 
 /- warning: list.sum_le_foldr_max -> List.sum_le_foldr_max is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] (f : M -> N), (LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))))) (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) -> (forall (x : M) (y : M), LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x y)) (LinearOrder.max.{u2} N _inst_3 (f x) (f y))) -> (forall (l : List.{u1} M), LE.le.{u2} N (Preorder.toLE.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (List.sum.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)) (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)) l)) (List.foldr.{u2, u2} N N (LinearOrder.max.{u2} N _inst_3) (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (List.map.{u1, u2} M N f l)))
+  forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : AddMonoid.{u1} M] [_inst_2 : AddMonoid.{u2} N] [_inst_3 : LinearOrder.{u2} N] (f : M -> N), (LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)))))) (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2)))))) -> (forall (x : M) (y : M), LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1))) x y)) (LinearOrder.max.{u2} N _inst_3 (f x) (f y))) -> (forall (l : List.{u1} M), LE.le.{u2} N (Preorder.toHasLe.{u2} N (PartialOrder.toPreorder.{u2} N (SemilatticeInf.toPartialOrder.{u2} N (Lattice.toSemilatticeInf.{u2} N (LinearOrder.toLattice.{u2} N _inst_3))))) (f (List.sum.{u1} M (AddZeroClass.toHasAdd.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)) (AddZeroClass.toHasZero.{u1} M (AddMonoid.toAddZeroClass.{u1} M _inst_1)) l)) (List.foldr.{u2, u2} N N (LinearOrder.max.{u2} N _inst_3) (OfNat.ofNat.{u2} N 0 (OfNat.mk.{u2} N 0 (Zero.zero.{u2} N (AddZeroClass.toHasZero.{u2} N (AddMonoid.toAddZeroClass.{u2} N _inst_2))))) (List.map.{u1, u2} M N f l)))
 but is expected to have type
   forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : AddMonoid.{u2} M] [_inst_2 : AddMonoid.{u1} N] [_inst_3 : LinearOrder.{u1} N] (f : M -> N), (LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N (SemilatticeInf.toPartialOrder.{u1} N (Lattice.toSemilatticeInf.{u1} N (DistribLattice.toLattice.{u1} N (instDistribLattice.{u1} N _inst_3)))))) (f (OfNat.ofNat.{u2} M 0 (Zero.toOfNat0.{u2} M (AddMonoid.toZero.{u2} M _inst_1)))) (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N (AddMonoid.toZero.{u1} N _inst_2)))) -> (forall (x : M) (y : M), LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N (SemilatticeInf.toPartialOrder.{u1} N (Lattice.toSemilatticeInf.{u1} N (DistribLattice.toLattice.{u1} N (instDistribLattice.{u1} N _inst_3)))))) (f (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M (AddZeroClass.toAdd.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_1))) x y)) (Max.max.{u1} N (LinearOrder.toMax.{u1} N _inst_3) (f x) (f y))) -> (forall (l : List.{u2} M), LE.le.{u1} N (Preorder.toLE.{u1} N (PartialOrder.toPreorder.{u1} N (SemilatticeInf.toPartialOrder.{u1} N (Lattice.toSemilatticeInf.{u1} N (DistribLattice.toLattice.{u1} N (instDistribLattice.{u1} N _inst_3)))))) (f (List.sum.{u2} M (AddZeroClass.toAdd.{u2} M (AddMonoid.toAddZeroClass.{u2} M _inst_1)) (AddMonoid.toZero.{u2} M _inst_1) l)) (List.foldr.{u1, u1} N N (Max.max.{u1} N (LinearOrder.toMax.{u1} N _inst_3)) (OfNat.ofNat.{u1} N 0 (Zero.toOfNat0.{u1} N (AddMonoid.toZero.{u1} N _inst_2))) (List.map.{u2, u1} M N f l)))
 Case conversion may be inaccurate. Consider using '#align list.sum_le_foldr_max List.sum_le_foldr_maxₓ'. -/
@@ -911,7 +911,7 @@ theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n := by rw [sum_re
 
 /- warning: list.prod_pos -> List.prod_pos is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (l : List.{u1} R), (forall (a : R), (Membership.Mem.{u1, u1} R (List.{u1} R) (List.hasMem.{u1} R) a l) -> (LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) a)) -> (LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) (List.prod.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (AddMonoidWithOne.toOne.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) l))
+  forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (l : List.{u1} R), (forall (a : R), (Membership.Mem.{u1, u1} R (List.{u1} R) (List.hasMem.{u1} R) a l) -> (LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) a)) -> (LT.lt.{u1} R (Preorder.toHasLt.{u1} R (PartialOrder.toPreorder.{u1} R (OrderedCancelAddCommMonoid.toPartialOrder.{u1} R (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{u1} R _inst_1)))) (OfNat.ofNat.{u1} R 0 (OfNat.mk.{u1} R 0 (Zero.zero.{u1} R (MulZeroClass.toHasZero.{u1} R (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))))))) (List.prod.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (AddMonoidWithOne.toOne.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) l))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_1 : StrictOrderedSemiring.{u1} R] (l : List.{u1} R), (forall (a : R), (Membership.mem.{u1, u1} R (List.{u1} R) (List.instMembershipList.{u1} R) a l) -> (LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) a)) -> (LT.lt.{u1} R (Preorder.toLT.{u1} R (PartialOrder.toPreorder.{u1} R (StrictOrderedSemiring.toPartialOrder.{u1} R _inst_1))) (OfNat.ofNat.{u1} R 0 (Zero.toOfNat0.{u1} R (MonoidWithZero.toZero.{u1} R (Semiring.toMonoidWithZero.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1))))) (List.prod.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)))) (Semiring.toOne.{u1} R (StrictOrderedSemiring.toSemiring.{u1} R _inst_1)) l))
 Case conversion may be inaccurate. Consider using '#align list.prod_pos List.prod_posₓ'. -/
@@ -927,7 +927,7 @@ theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R
 
 /- warning: canonically_ordered_comm_semiring.list_prod_pos -> CanonicallyOrderedCommSemiring.list_prod_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CanonicallyOrderedCommSemiring.{u1} α] [_inst_2 : Nontrivial.{u1} α] {l : List.{u1} α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))))))) (List.prod.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))))) (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))))) l)) (forall (x : α), (Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))))))) x))
+  forall {α : Type.{u1}} [_inst_1 : CanonicallyOrderedCommSemiring.{u1} α] [_inst_2 : Nontrivial.{u1} α] {l : List.{u1} α}, Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))))))) (List.prod.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))))) (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))))) l)) (forall (x : α), (Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))))))) x))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : CanonicallyOrderedCommSemiring.{u1} α] [_inst_2 : Nontrivial.{u1} α] {l : List.{u1} α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedSemiring.toPartialOrder.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α (CommSemiring.toCommMonoidWithZero.{u1} α (CanonicallyOrderedCommSemiring.toCommSemiring.{u1} α _inst_1))))) (List.prod.{u1} α (CanonicallyOrderedCommSemiring.toMul.{u1} α _inst_1) (CanonicallyOrderedCommSemiring.toOne.{u1} α _inst_1) l)) (forall (x : α), (Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedSemiring.toPartialOrder.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α (CommSemiring.toCommMonoidWithZero.{u1} α (CanonicallyOrderedCommSemiring.toCommSemiring.{u1} α _inst_1))))) x))
 Case conversion may be inaccurate. Consider using '#align canonically_ordered_comm_semiring.list_prod_pos CanonicallyOrderedCommSemiring.list_prod_posₓ'. -/

6c5f73fd

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -167,7 +167,7 @@ theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (l : List.{u1} M) {F : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F), Eq.{succ u2} N (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_4))) f) l)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_4))) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
 but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u1}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u1} N] (l : List.{u3} M) {F : Type.{u2}} [_inst_4 : MonoidHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u3, u1} M N (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f) l)) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f (List.prod.{u3} M (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (Monoid.toOne.{u3} M _inst_1) l))
+  forall {M : Type.{u3}} {N : Type.{u1}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u1} N] (l : List.{u3} M) {F : Type.{u2}} [_inst_4 : MonoidHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u3, u1} M N (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f) l)) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f (List.prod.{u3} M (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (Monoid.toOne.{u3} M _inst_1) l))
 Case conversion may be inaccurate. Consider using '#align list.prod_hom List.prod_homₓ'. -/
 @[to_additive]
 theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
@@ -226,7 +226,7 @@ theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] (L : List.{u1} ι) (f : ι -> M) {G : Type.{u4}} [_inst_4 : MonoidHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (g : G), Eq.{succ u3} N (List.prod.{u3} N (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MulOneClass.toHasOne.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (List.map.{u1, u3} ι N (Function.comp.{succ u1, succ u2, succ u3} ι M N (coeFn.{succ u4, max (succ u2) (succ u3)} G (fun (_x : G) => M -> N) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} G M (fun (_x : M) => N) (MulHomClass.toFunLike.{u4, u2, u3} G M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_4))) g) f) L)) (coeFn.{succ u4, max (succ u2) (succ u3)} G (fun (_x : G) => M -> N) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} G M (fun (_x : M) => N) (MulHomClass.toFunLike.{u4, u2, u3} G M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_4))) g (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f L)))
 but is expected to have type
-  forall {ι : Type.{u4}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (L : List.{u4} ι) (f : ι -> M) {G : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (g : G), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u4, u1} ι N (Function.comp.{succ u4, succ u2, succ u1} ι M N (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g) f) L)) (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u4, u2} ι M f L)))
+  forall {ι : Type.{u4}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (L : List.{u4} ι) (f : ι -> M) {G : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (g : G), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u4, u1} ι N (Function.comp.{succ u4, succ u2, succ u1} ι M N (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g) f) L)) (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u4, u2} ι M f L)))
 Case conversion may be inaccurate. Consider using '#align list.prod_map_hom List.prod_map_homₓ'. -/
 @[to_additive]
 theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type _} [MonoidHomClass G M N] (g : G) :
@@ -426,7 +426,7 @@ theorem Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Commute x
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4)) l₁ l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2788 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2790 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2788 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2790)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2803 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2805 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2803 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2805)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2822 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2824 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2822 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2824) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2837 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2839 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2837 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2839)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2857 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2859 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2857 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2859) l₁ l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2795 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2797 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2795 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2797)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2810 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2812 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2810 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2812)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2829 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2831 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2829 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2831) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2844 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2846 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2844 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2846)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Forall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2864 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2866 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2864 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2866) l₁ l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.forall₂.prod_le_prod' List.Forall₂.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -442,7 +442,7 @@ theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2942 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2944 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2942 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2944)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2957 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2959 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2957 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2959)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2976 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2978 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2976 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2978) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2991 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2993 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2991 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2993)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2949 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2951 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2949 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2951)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2964 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2966 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2964 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2966)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2983 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2985 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2983 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2985) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2998 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3000 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.2998 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3000)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.Sublist.{u1} M l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'ₓ'. -/
 /-- If `l₁` is a sublist of `l₂` and all elements of `l₂` are greater than or equal to one, then
 `l₁.prod ≤ l₂.prod`. One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 1 ≤ a` instead
@@ -467,7 +467,7 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4)) l₁ l₂) -> (forall (a : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₁) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l₂))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3132 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3134 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3132 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3134)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3147 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3149 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3147 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3149)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3166 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3168 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3166 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3168) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3181 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3183 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3181 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3183)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3201 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3203 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3201 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3203) l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3139 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3141 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3139 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3141)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3154 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3156 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3154 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3156)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3173 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3175 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3173 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3175) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3188 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3190 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3188 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3190)] {l₁ : List.{u1} M} {l₂ : List.{u1} M}, (List.SublistForall₂.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3208 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3210 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3208 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3210) l₁ l₂) -> (forall (a : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) a l₂) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) a)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₁) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l₂))
 Case conversion may be inaccurate. Consider using '#align list.sublist_forall₂.prod_le_prod' List.SublistForall₂.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem SublistForall₂.prod_le_prod' [Preorder M]
@@ -483,7 +483,7 @@ theorem SublistForall₂.prod_le_prod' [Preorder M]
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3315 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3317 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3315 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3317)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3330 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3332 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3330 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3332)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3349 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3351 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3349 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3351) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3364 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3366 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3364 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3366)] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3322 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3324 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3322 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3324)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3337 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3339 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3337 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3339)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3356 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3358 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3356 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3358) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3371 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3373 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3371 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3373)] {l : List.{u1} ι} {f : ι -> M} {g : ι -> M}, (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_le_prod' List.prod_le_prod'ₓ'. -/
 @[to_additive sum_le_sum]
 theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -497,7 +497,7 @@ theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·))
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l)))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3461 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3463 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3461 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3463) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3476 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3478 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3476 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3478)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3495 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3497 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3495 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3497) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3510 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3512 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3510 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3512)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3532 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3534 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3532 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3534)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3547 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3549 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3547 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3549)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3569 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3571 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3569 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3571)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3584 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3586 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3584 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3586)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3468 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3470 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3468 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3470) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3483 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3485 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3483 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3485)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3502 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3504 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3502 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3504) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3517 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3519 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3517 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3519)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3539 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3541 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3539 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3541)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3554 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3556 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3554 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3556)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3576 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3578 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3576 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3578)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3591 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3593 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3591 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3593)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) (f i) (g i))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i)))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_lt_prod' List.prod_lt_prod'ₓ'. -/
 @[to_additive sum_lt_sum]
 theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -516,7 +516,7 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3761 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3763 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3761 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3763) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3776 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3778 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3776 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3778)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3795 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3797 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3795 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3797) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3810 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3812 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3810 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3812)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3832 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3834 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3832 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3834)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3847 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3849 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3847 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3849)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3869 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3871 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3869 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3871)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3884 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3886 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3884 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3886)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : Preorder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3768 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3770 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3768 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3770) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3783 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3785 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3783 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3785)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3802 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3804 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3802 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3804) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3817 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3819 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3817 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3819)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3839 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3841 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3839 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3841)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3854 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3856 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3854 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3856)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3876 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3878 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3876 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3878)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3891 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3893 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3891 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.3893)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (forall (i : ι), (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (f i) (g i))) -> (LT.lt.{u2} M (Preorder.toLT.{u2} M _inst_4) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))))
 Case conversion may be inaccurate. Consider using '#align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nilₓ'. -/
 @[to_additive]
 theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -532,7 +532,7 @@ theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· <
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] [_inst_6 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4018 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4020 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4018 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4020)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4033 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4035 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4033 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4035)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4052 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4054 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4052 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4054) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4067 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4069 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4067 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4069)] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4025 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4027 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4025 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4027)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4040 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4042 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4040 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4042)] [_inst_6 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4059 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4061 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4059 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4061) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4074 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4076 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4074 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4076)] (l : List.{u1} M) (n : M), (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x n)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n (List.length.{u1} M l)))
 Case conversion may be inaccurate. Consider using '#align list.prod_le_pow_card List.prod_le_pow_cardₓ'. -/
 @[to_additive sum_le_card_nsmul]
 theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -546,7 +546,7 @@ theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * 
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) i l) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f i) (g i))))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4156 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4158 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4156 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4158)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4171 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4173 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4171 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4173)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4190 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4192 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4190 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4192) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4205 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4207 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4205 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4207)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f i) (g i))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4163 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4165 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4163 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4165)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4178 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4180 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4178 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4180)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4197 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4199 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4197 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4199) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4212 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4214 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4212 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4214)] {l : List.{u1} ι} (f : ι -> M) (g : ι -> M), (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (i : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) i l) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f i) (g i))))
 Case conversion may be inaccurate. Consider using '#align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'ₓ'. -/
 @[to_additive exists_lt_of_sum_lt]
 theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -562,7 +562,7 @@ theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_6 : CovariantClass.{u2, u2} M M (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))))] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => Exists.{0} (Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) (fun (H : Membership.Mem.{u1, u1} ι (List.{u1} ι) (List.hasMem.{u1} ι) x l) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (LinearOrder.toLattice.{u2} M _inst_4))))) (f x) (g x)))))
 but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4324 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4326 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4324 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4326) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4339 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4341 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4339 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4341)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4358 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4360 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4358 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4360) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4373 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4375 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4373 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4375)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4395 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4397 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4395 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4397)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4410 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4412 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4410 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4412)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4432 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4434 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4432 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4434)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4447 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4449 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4447 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4449)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) x l) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f x) (g x)))))
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_4 : LinearOrder.{u2} M] [_inst_5 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4331 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4333 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4331 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4333) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4346 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4348 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4346 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4348)] [_inst_6 : CovariantClass.{u2, u2} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4365 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4367 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4365 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4367) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4380 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4382 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4380 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4382)] [_inst_7 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4402 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4404 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4402 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4404)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4417 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4419 : M) => LT.lt.{u2} M (Preorder.toLT.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4417 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4419)] [_inst_8 : CovariantClass.{u2, u2} M M (Function.swap.{succ u2, succ u2, succ u2} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4439 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4441 : M) => HMul.hMul.{u2, u2, u2} M M M (instHMul.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4439 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4441)) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4454 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4456 : M) => LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4454 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4456)] {l : List.{u1} ι}, (Ne.{succ u1} (List.{u1} ι) l (List.nil.{u1} ι)) -> (forall (f : ι -> M) (g : ι -> M), (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M f l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u1, u2} ι M g l))) -> (Exists.{succ u1} ι (fun (x : ι) => And (Membership.mem.{u1, u1} ι (List.{u1} ι) (List.instMembershipList.{u1} ι) x l) (LE.le.{u2} M (Preorder.toLE.{u2} M (PartialOrder.toPreorder.{u2} M (SemilatticeInf.toPartialOrder.{u2} M (Lattice.toSemilatticeInf.{u2} M (DistribLattice.toLattice.{u2} M (instDistribLattice.{u2} M _inst_4)))))) (f x) (g x)))))
 Case conversion may be inaccurate. Consider using '#align list.exists_le_of_prod_le' List.exists_le_of_prod_le'ₓ'. -/
 @[to_additive exists_le_of_sum_le]
 theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -579,7 +579,7 @@ theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (·
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4))] {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) x)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4576 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4578 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4576 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4578) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4591 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4593 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4591 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4593)] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) x)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_4 : Preorder.{u1} M] [_inst_5 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4583 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4585 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4583 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4585) (fun (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4598 : M) (x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4600 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4598 x._@.Mathlib.Data.List.BigOperators.Basic._hyg.4600)] {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) x)) -> (LE.le.{u1} M (Preorder.toLE.{u1} M _inst_4) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l))
 Case conversion may be inaccurate. Consider using '#align list.one_le_prod_of_one_le List.one_le_prod_of_one_leₓ'. -/
 @[to_additive sum_nonneg]
 theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
@@ -1085,7 +1085,7 @@ variable [Monoid M] [Monoid N]
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F) (l : List.{u1} M), Eq.{succ u2} N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)) (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f) l))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f) l))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f) l))
 Case conversion may be inaccurate. Consider using '#align map_list_prod map_list_prodₓ'. -/
 @[to_additive]
 theorem map_list_prod {F : Type _} [MonoidHomClass F M N] (f : F) (l : List M) :
@@ -1100,7 +1100,7 @@ namespace MonoidHom
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (l : List.{u1} M), Eq.{succ u2} N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)) (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f) l))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f) l))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f) l))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_list_prod MonoidHom.map_list_prodₓ'. -/
 /-- Deprecated, use `_root_.map_list_prod` instead. -/
 @[to_additive "Deprecated, use `_root_.map_list_sum` instead."]

6c5f73fd

bump to nightly-2023-03-08-18

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

10f15343

Diff

@@ -167,7 +167,7 @@ theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (l : List.{u1} M) {F : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F), Eq.{succ u2} N (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_4))) f) l)) (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_4))) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l))
 but is expected to have type
-  forall {M : Type.{u3}} {N : Type.{u1}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u1} N] (l : List.{u3} M) {F : Type.{u2}} [_inst_4 : MonoidHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u3, u1} M N (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f) l)) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f (List.prod.{u3} M (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (Monoid.toOne.{u3} M _inst_1) l))
+  forall {M : Type.{u3}} {N : Type.{u1}} [_inst_1 : Monoid.{u3} M] [_inst_2 : Monoid.{u1} N] (l : List.{u3} M) {F : Type.{u2}} [_inst_4 : MonoidHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u3, u1} M N (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f) l)) (FunLike.coe.{succ u2, succ u3, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u2, u3, u1} F M N (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u3, u1} F M N (Monoid.toMulOneClass.{u3} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) f (List.prod.{u3} M (MulOneClass.toMul.{u3} M (Monoid.toMulOneClass.{u3} M _inst_1)) (Monoid.toOne.{u3} M _inst_1) l))
 Case conversion may be inaccurate. Consider using '#align list.prod_hom List.prod_homₓ'. -/
 @[to_additive]
 theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
@@ -226,7 +226,7 @@ theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
 lean 3 declaration is
   forall {ι : Type.{u1}} {M : Type.{u2}} {N : Type.{u3}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u3} N] (L : List.{u1} ι) (f : ι -> M) {G : Type.{u4}} [_inst_4 : MonoidHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (g : G), Eq.{succ u3} N (List.prod.{u3} N (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MulOneClass.toHasOne.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (List.map.{u1, u3} ι N (Function.comp.{succ u1, succ u2, succ u3} ι M N (coeFn.{succ u4, max (succ u2) (succ u3)} G (fun (_x : G) => M -> N) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} G M (fun (_x : M) => N) (MulHomClass.toFunLike.{u4, u2, u3} G M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_4))) g) f) L)) (coeFn.{succ u4, max (succ u2) (succ u3)} G (fun (_x : G) => M -> N) (FunLike.hasCoeToFun.{succ u4, succ u2, succ u3} G M (fun (_x : M) => N) (MulHomClass.toFunLike.{u4, u2, u3} G M N (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u4, u2, u3} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_4))) g (List.prod.{u2} M (MulOneClass.toHasMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toHasOne.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (List.map.{u1, u2} ι M f L)))
 but is expected to have type
-  forall {ι : Type.{u4}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (L : List.{u4} ι) (f : ι -> M) {G : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (g : G), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u4, u1} ι N (Function.comp.{succ u4, succ u2, succ u1} ι M N (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g) f) L)) (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u4, u2} ι M f L)))
+  forall {ι : Type.{u4}} {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (L : List.{u4} ι) (f : ι -> M) {G : Type.{u3}} [_inst_4 : MonoidHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (g : G), Eq.{succ u1} N (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u4, u1} ι N (Function.comp.{succ u4, succ u2, succ u1} ι M N (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g) f) L)) (FunLike.coe.{succ u3, succ u2, succ u1} G M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} G M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} G M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_4)) g (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u4, u2} ι M f L)))
 Case conversion may be inaccurate. Consider using '#align list.prod_map_hom List.prod_map_homₓ'. -/
 @[to_additive]
 theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type _} [MonoidHomClass G M N] (g : G) :
@@ -1085,7 +1085,7 @@ variable [Monoid M] [Monoid N]
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F) (l : List.{u1} M), Eq.{succ u2} N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)) (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f) l))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f) l))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] {F : Type.{u3}} [_inst_3 : MonoidHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)] (f : F) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{succ u3, succ u2, succ u1} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u3, u2, u1} F M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u2, u1} F M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) _inst_3)) f) l))
 Case conversion may be inaccurate. Consider using '#align map_list_prod map_list_prodₓ'. -/
 @[to_additive]
 theorem map_list_prod {F : Type _} [MonoidHomClass F M N] (f : F) (l : List M) :
@@ -1100,7 +1100,7 @@ namespace MonoidHom
 lean 3 declaration is
   forall {M : Type.{u1}} {N : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : Monoid.{u2} N] (f : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (l : List.{u1} M), Eq.{succ u2} N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l)) (List.prod.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MulOneClass.toHasOne.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (List.map.{u1, u2} M N (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) (fun (_x : MonoidHom.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) => M -> N) (MonoidHom.hasCoeToFun.{u1, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)) f) l))
 but is expected to have type
-  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f) l))
+  forall {M : Type.{u2}} {N : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : Monoid.{u1} N] (f : MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) (l : List.{u2} M), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l)) (List.prod.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (Monoid.toOne.{u1} N _inst_2) (List.map.{u2, u1} M N (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N _inst_2)) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)) M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2) (MonoidHom.monoidHomClass.{u2, u1} M N (Monoid.toMulOneClass.{u2} M _inst_1) (Monoid.toMulOneClass.{u1} N _inst_2)))) f) l))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_list_prod MonoidHom.map_list_prodₓ'. -/
 /-- Deprecated, use `_root_.map_list_prod` instead. -/
 @[to_additive "Deprecated, use `_root_.map_list_sum` instead."]

6c5f73fd

bump to nightly-2023-02-25-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/271bf175e6c51b8d31d6c0107b7bb4a967c7277e

2eb4cae7

Diff

@@ -925,6 +925,12 @@ theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R
     exact mul_pos (h _ <| mem_cons_self _ _) (ih fun a ha => h a <| mem_cons_of_mem _ ha)
 #align list.prod_pos List.prod_pos
 
+/- warning: canonically_ordered_comm_semiring.list_prod_pos -> CanonicallyOrderedCommSemiring.list_prod_pos is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : CanonicallyOrderedCommSemiring.{u1} α] [_inst_2 : Nontrivial.{u1} α] {l : List.{u1} α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))))))) (List.prod.{u1} α (Distrib.toHasMul.{u1} α (NonUnitalNonAssocSemiring.toDistrib.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))))) (AddMonoidWithOne.toOne.{u1} α (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} α (NonAssocSemiring.toAddCommMonoidWithOne.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))))) l)) (forall (x : α), (Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α (OrderedSemiring.toOrderedAddCommMonoid.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (NonUnitalNonAssocSemiring.toMulZeroClass.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α (OrderedSemiring.toSemiring.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1)))))))))) x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : CanonicallyOrderedCommSemiring.{u1} α] [_inst_2 : Nontrivial.{u1} α] {l : List.{u1} α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedSemiring.toPartialOrder.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α (CommSemiring.toCommMonoidWithZero.{u1} α (CanonicallyOrderedCommSemiring.toCommSemiring.{u1} α _inst_1))))) (List.prod.{u1} α (CanonicallyOrderedCommSemiring.toMul.{u1} α _inst_1) (CanonicallyOrderedCommSemiring.toOne.{u1} α _inst_1) l)) (forall (x : α), (Membership.mem.{u1, u1} α (List.{u1} α) (List.instMembershipList.{u1} α) x l) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedSemiring.toPartialOrder.{u1} α (OrderedCommSemiring.toOrderedSemiring.{u1} α (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (CommMonoidWithZero.toZero.{u1} α (CommSemiring.toCommMonoidWithZero.{u1} α (CanonicallyOrderedCommSemiring.toCommSemiring.{u1} α _inst_1))))) x))
+Case conversion may be inaccurate. Consider using '#align canonically_ordered_comm_semiring.list_prod_pos CanonicallyOrderedCommSemiring.list_prod_posₓ'. -/
 /-- A variant of `list.prod_pos` for `canonically_ordered_comm_semiring`. -/
 @[simp]
 theorem CanonicallyOrderedCommSemiring.list_prod_pos {α : Type _} [CanonicallyOrderedCommSemiring α]
@@ -1045,21 +1051,29 @@ theorem alternatingProd_cons (a : α) (l : List α) :
 
 end Alternating
 
+#print List.sum_nat_mod /-
 theorem sum_nat_mod (l : List ℕ) (n : ℕ) : l.Sum % n = (l.map (· % n)).Sum % n := by
   induction l <;> simp [Nat.add_mod, *]
 #align list.sum_nat_mod List.sum_nat_mod
+-/
 
+#print List.prod_nat_mod /-
 theorem prod_nat_mod (l : List ℕ) (n : ℕ) : l.Prod % n = (l.map (· % n)).Prod % n := by
   induction l <;> simp [Nat.mul_mod, *]
 #align list.prod_nat_mod List.prod_nat_mod
+-/
 
+#print List.sum_int_mod /-
 theorem sum_int_mod (l : List ℤ) (n : ℤ) : l.Sum % n = (l.map (· % n)).Sum % n := by
   induction l <;> simp [Int.add_emod, *]
 #align list.sum_int_mod List.sum_int_mod
+-/
 
+#print List.prod_int_mod /-
 theorem prod_int_mod (l : List ℤ) (n : ℤ) : l.Prod % n = (l.map (· % n)).Prod % n := by
   induction l <;> simp [Int.mul_emod, *]
 #align list.prod_int_mod List.prod_int_mod
+-/
 
 end List

6c5f73fd

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

6c5f73fd

chore: adapt to multiple goal linter 1 (#12338)

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -106,7 +106,8 @@ theorem prod_cons : (a :: l).prod = a * l.prod :=
 lemma prod_induction
     (p : M → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ l, p x) :
     p l.prod := by
-  induction' l with a l ih; simpa
+  induction' l with a l ih
+  · simpa
   rw [List.prod_cons]
   simp only [Bool.not_eq_true, List.mem_cons, forall_eq_or_imp] at base
   exact hom _ _ (base.1) (ih base.2)

6c5f73fd

chore: backports from #11997, adaptations for nightly-2024-04-07 (#12176)

These are changes from #11997, the latest adaptation PR for nightly-2024-04-07, which can be made directly on master.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

02293f49

Diff

@@ -443,8 +443,7 @@ lemma prod_mul_prod_eq_prod_zipWith_mul_prod_drop :
     conv =>
       lhs; rw [mul_assoc]; right; rw [mul_comm, mul_assoc]; right
       rw [mul_comm, prod_mul_prod_eq_prod_zipWith_mul_prod_drop xs ys]
-    simp only [Nat.add_eq, add_zero]
-    ac_rfl
+    simp [mul_assoc]
 #align list.prod_mul_prod_eq_prod_zip_with_mul_prod_drop List.prod_mul_prod_eq_prod_zipWith_mul_prod_drop
 #align list.sum_add_sum_eq_sum_zip_with_add_sum_drop List.sum_add_sum_eq_sum_zipWith_add_sum_drop

6c5f73fd

chore: tidy various files (#12042)

8856dfd0

Diff

@@ -357,9 +357,10 @@ lemma prod_range_succ' (f : ℕ → M) (n : ℕ) :
 @[to_additive]
 lemma prod_erase_of_comm [DecidableEq M] (ha : a ∈ l) (comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x) :
     a * (l.erase a).prod = l.prod := by
-  induction' l with b l ih; simp only [not_mem_nil] at ha
+  induction' l with b l ih
+  · simp only [not_mem_nil] at ha
   obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem ha
-  simp only [erase_cons_head, prod_cons]
+  · simp only [erase_cons_head, prod_cons]
   rw [List.erase, beq_false_of_ne ne.symm, List.prod_cons, List.prod_cons, ← mul_assoc,
     comm a ha b (l.mem_cons_self b), mul_assoc,
     ih h fun x hx y hy ↦ comm _ (List.mem_cons_of_mem b hx) _ (List.mem_cons_of_mem b hy)]

6c5f73fd

chore: Split Data.{Nat,Int}{.Order}.Basic in group vs ring instances (#11924)

Scatter the content of Data.Nat.Basic across:

Data.Nat.Defs for the lemmas having no dependencies
Algebra.Group.Nat for the monoid instances and the few miscellaneous lemmas needing them.
Algebra.Ring.Nat for the semiring instance and the few miscellaneous lemmas following it.

Similarly, scatter

Data.Int.Basic across Data.Int.Defs, Algebra.Group.Int, Algebra.Ring.Int
Data.Nat.Order.Basic across Data.Nat.Defs, Algebra.Order.Group.Nat, Algebra.Order.Ring.Nat
Data.Int.Order.Basic across Data.Int.Defs, Algebra.Order.Group.Int, Algebra.Order.Ring.Int

Also move a few lemmas from Data.Nat.Order.Lemmas to Data.Nat.Defs.

Before pre_11924

After post_11924

47062a71

Diff

@@ -4,14 +4,14 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
 import Mathlib.Algebra.Ring.Commute
-import Mathlib.Data.Int.Basic
+import Mathlib.Algebra.Ring.Int
+import Mathlib.Algebra.Ring.Nat
 import Mathlib.Data.List.Dedup
 import Mathlib.Data.List.ProdSigma
 import Mathlib.Data.List.Join
 import Mathlib.Data.List.Perm
 import Mathlib.Data.List.Range
 import Mathlib.Data.List.Rotate
-import Mathlib.Data.Nat.Basic
 
 #align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"

6c5f73fd

chore(Data/List): Do not depend on algebra (#11845)

Remove dependencies on algebra in the Data.List folder except for:

Data.List.EditDistance: Actually relies on algebra. Maybe should be moved?
Data.List.Card: Completely unused and redundant.
Data.List.Cycle: Relies on Fintype, which shouldn't rely on algebra but it's hard to fix right now. Maybe should be moved?
Data.List.Func: Completely unused and redundant.
Data.List.Lex: That's order theory. Could be moved.
Data.List.Prime. That's algebra. Should definitely be moved.
Data.List.Sym: Relies on Multiset, which shouldn't rely on algebra but it's hard to fix right now. Maybe should be moved?
Data.List.ToFinsupp: That's algebra. Should definitely be moved.

As a consequence, move the big operators lemmas that were in there to Algebra.BigOperators.List.Basic. For the lemmas that were Nat-specific and not about auxiliary definitions, keep a version of them in the original file but stated using Nat.sum.

Before pre_11845

After post_11845

f9e043cb

Diff

@@ -7,6 +7,8 @@ import Mathlib.Algebra.Ring.Commute
 import Mathlib.Data.Int.Basic
 import Mathlib.Data.List.Dedup
 import Mathlib.Data.List.ProdSigma
+import Mathlib.Data.List.Join
+import Mathlib.Data.List.Perm
 import Mathlib.Data.List.Range
 import Mathlib.Data.List.Rotate
 import Mathlib.Data.Nat.Basic
@@ -382,10 +384,26 @@ lemma prod_eq_pow_single [DecidableEq M] (a : M) (h : ∀ a', a' ≠ a → a' 
 #align list.prod_eq_pow_single List.prod_eq_pow_single
 #align list.sum_eq_nsmul_single List.sum_eq_nsmul_single
 
+/-- If elements of a list commute with each other, then their product does not
+depend on the order of elements. -/
+@[to_additive "If elements of a list additively commute with each other, then their sum does not
+depend on the order of elements."]
+lemma Perm.prod_eq' (h : l₁ ~ l₂) (hc : l₁.Pairwise Commute) : l₁.prod = l₂.prod := by
+  refine h.foldl_eq' ?_ _
+  apply Pairwise.forall_of_forall
+  · intro x y h z
+    exact (h z).symm
+  · intros; rfl
+  · apply hc.imp
+    intro a b h z
+    rw [mul_assoc z, mul_assoc z, h]
+#align list.perm.prod_eq' List.Perm.prod_eq'
+#align list.perm.sum_eq' List.Perm.sum_eq'
+
 end Monoid
 
 section CommMonoid
-variable [CommMonoid M] {a : M} {l : List M}
+variable [CommMonoid M] {a : M} {l l₁ l₂ : List M}
 
 @[to_additive (attr := simp)]
 lemma prod_erase [DecidableEq M] (ha : a ∈ l) : a * (l.erase a).prod = l.prod :=
@@ -404,6 +422,14 @@ lemma prod_map_erase [DecidableEq α] (f : α → M) {a} :
 #align list.prod_map_erase List.prod_map_erase
 #align list.sum_map_erase List.sum_map_erase
 
+@[to_additive] lemma Perm.prod_eq (h : Perm l₁ l₂) : prod l₁ = prod l₂ := h.fold_op_eq
+#align list.perm.prod_eq List.Perm.prod_eq
+#align list.perm.sum_eq List.Perm.sum_eq
+
+@[to_additive] lemma prod_reverse (l : List M) : prod l.reverse = prod l := (reverse_perm l).prod_eq
+#align list.prod_reverse List.prod_reverse
+#align list.sum_reverse List.sum_reverse
+
 @[to_additive]
 lemma prod_mul_prod_eq_prod_zipWith_mul_prod_drop :
     ∀ l l' : List M,
@@ -707,4 +733,49 @@ lemma ranges_join (l : List ℕ) : l.ranges.join = range l.sum := by simp [range
 lemma mem_mem_ranges_iff_lt_sum (l : List ℕ) {n : ℕ} :
     (∃ s ∈ l.ranges, n ∈ s) ↔ n < l.sum := by simp [mem_mem_ranges_iff_lt_natSum]
 
+@[simp]
+theorem length_join (L : List (List α)) : length (join L) = sum (map length L) := by
+  induction L <;> [rfl; simp only [*, join, map, sum_cons, length_append]]
+#align list.length_join List.length_join
+
+lemma countP_join (p : α → Bool) : ∀ L : List (List α), countP p L.join = (L.map (countP p)).sum
+  | [] => rfl
+  | a :: l => by rw [join, countP_append, map_cons, sum_cons, countP_join _ l]
+#align list.countp_join List.countP_join
+
+lemma count_join [BEq α] (L : List (List α)) (a : α) : L.join.count a = (L.map (count a)).sum :=
+  countP_join _ _
+#align list.count_join List.count_join
+
+@[simp]
+theorem length_bind (l : List α) (f : α → List β) :
+    length (List.bind l f) = sum (map (length ∘ f) l) := by rw [List.bind, length_join, map_map]
+#align list.length_bind List.length_bind
+
+lemma countP_bind (p : β → Bool) (l : List α) (f : α → List β) :
+    countP p (l.bind f) = sum (map (countP p ∘ f) l) := by rw [List.bind, countP_join, map_map]
+
+lemma count_bind [BEq β] (l : List α) (f : α → List β) (x : β) :
+    count x (l.bind f) = sum (map (count x ∘ f) l) := countP_bind _ _ _
+#align list.count_bind List.count_bind
+
+/-- In a join, taking the first elements up to an index which is the sum of the lengths of the
+first `i` sublists, is the same as taking the join of the first `i` sublists. -/
+lemma take_sum_join (L : List (List α)) (i : ℕ) :
+    L.join.take ((L.map length).take i).sum = (L.take i).join := by simpa using take_sum_join' _ _
+#align list.take_sum_join List.take_sum_join
+
+/-- In a join, dropping all the elements up to an index which is the sum of the lengths of the
+first `i` sublists, is the same as taking the join after dropping the first `i` sublists. -/
+lemma drop_sum_join (L : List (List α)) (i : ℕ) :
+    L.join.drop ((L.map length).take i).sum = (L.drop i).join := by simpa using drop_sum_join' _ _
+#align list.drop_sum_join List.drop_sum_join
+
+/-- In a join of sublists, taking the slice between the indices `A` and `B - 1` gives back the
+original sublist of index `i` if `A` is the sum of the lengths of sublists of index `< i`, and
+`B` is the sum of the lengths of sublists of index `≤ i`. -/
+lemma drop_take_succ_join_eq_get (L : List (List α)) (i : Fin L.length) :
+    (L.join.take ((L.map length).take (i + 1)).sum).drop ((L.map length).take i).sum = get L i := by
+  simpa using drop_take_succ_join_eq_get' _ _
+
 end List

6c5f73fd

chore(Algebra/BigOperators/List): Use Std lemmas (#11725)

Make Algebra.BigOperators.List.Basic, Data.List.Chain not depend on Data.Nat.Order.Basic by using Nat-specific Std lemmas rather than general mathlib ones. I leave the Data.Nat.Basic import since Algebra.BigOperators.List.Basic is algebra territory.
Make Algebra.BigOperators.List.Basic not depend on Algebra.Divisibility.Basic. I'm not too sure about that one since they already are algebra. My motivation is that they involve ring-like objects while big operators are about group-like objects, but this is in some sense a second order refactor.
As a consequence, move the divisibility and MonoidWithZero lemmas from Algebra.BigOperators.List.Basic to Algebra.BigOperators.List.Lemmas.
Move the content of Algebra.BigOperators.List.Defs to Algebra.BigOperators.List.Basic since no file imported the former without the latter and their imports are becoming very close after this PR.
Make Data.List.Count, Data.List.Dedup, Data.List.ProdSigma, Data.List.Zip not depend on Algebra.BigOperators.List.Basic.
As a consequence, move the big operators lemmas that were in there to Algebra.BigOperators.List.Basic. For the lemmas that were Nat -specific, keep a version of them stated using Nat.sum.
To help with this, add Nat.sum_eq_listSum (l : List Nat) : Nat.sum l = l.sum.

f7519d5e

Diff

@@ -3,16 +3,13 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
-import Mathlib.Algebra.BigOperators.List.Defs
-import Mathlib.Data.List.Forall2
-import Mathlib.Algebra.Divisibility.Basic
 import Mathlib.Algebra.Ring.Commute
-import Mathlib.Data.Nat.Order.Basic
 import Mathlib.Data.Int.Basic
 import Mathlib.Data.List.Dedup
 import Mathlib.Data.List.ProdSigma
 import Mathlib.Data.List.Range
 import Mathlib.Data.List.Rotate
+import Mathlib.Data.Nat.Basic
 
 #align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"
 
@@ -21,12 +18,45 @@ import Mathlib.Data.List.Rotate
 
 This file provides basic results about `List.prod`, `List.sum`, which calculate the product and sum
 of elements of a list and `List.alternatingProd`, `List.alternatingSum`, their alternating
-counterparts. These are defined in [`Algebra.BigOperators.List.Defs`](./Defs).
+counterparts.
 -/
 
+-- Make sure we haven't imported `Data.Nat.Order.Basic`
+assert_not_exists OrderedSub
+
+-- TODO
+-- assert_not_exists Ring
+
 variable {ι α β γ M N P M₀ G R : Type*}
 
 namespace List
+section Defs
+
+/-- Product of a list.
+
+`List.prod [a, b, c] = ((1 * a) * b) * c` -/
+@[to_additive "Sum of a list.\n\n`List.sum [a, b, c] = ((0 + a) + b) + c`"]
+def prod {α} [Mul α] [One α] : List α → α :=
+  foldl (· * ·) 1
+#align list.prod List.prod
+#align list.sum List.sum
+
+/-- The alternating sum of a list. -/
+def alternatingSum {G : Type*} [Zero G] [Add G] [Neg G] : List G → G
+  | [] => 0
+  | g :: [] => g
+  | g :: h :: t => g + -h + alternatingSum t
+#align list.alternating_sum List.alternatingSum
+
+/-- The alternating product of a list. -/
+@[to_additive existing]
+def alternatingProd {G : Type*} [One G] [Mul G] [Inv G] : List G → G
+  | [] => 1
+  | g :: [] => g
+  | g :: h :: t => g * h⁻¹ * alternatingProd t
+#align list.alternating_prod List.alternatingProd
+
+end Defs
 
 section MulOneClass
 
@@ -248,7 +278,8 @@ theorem prod_set :
       (L.set n a).prod =
         ((L.take n).prod * if n < L.length then a else 1) * (L.drop (n + 1)).prod
   | x :: xs, 0, a => by simp [set]
-  | x :: xs, i + 1, a => by simp [set, prod_set xs i a, mul_assoc, Nat.succ_eq_add_one]
+  | x :: xs, i + 1, a => by
+    simp [set, prod_set xs i a, mul_assoc, Nat.succ_eq_add_one, Nat.add_lt_add_iff_right]
   | [], _, _ => by simp [set, (Nat.zero_le _).not_lt, Nat.zero_le]
 #align list.prod_update_nth List.prod_set
 #align list.sum_update_nth List.sum_set
@@ -309,10 +340,7 @@ lemma prod_range_succ' (f : ℕ → M) (n : ℕ) :
 #align list.prod_range_succ' List.prod_range_succ'
 #align list.sum_range_succ' List.sum_range_succ'
 
-/-- Slightly more general version of `List.prod_eq_one_iff` for a non-ordered `Monoid` -/
-@[to_additive
-      "Slightly more general version of `List.sum_eq_zero_iff` for a non-ordered `AddMonoid`"]
-lemma prod_eq_one (hl : ∀ x ∈ l, x = 1) : l.prod = 1 := by
+@[to_additive] lemma prod_eq_one (hl : ∀ x ∈ l, x = 1) : l.prod = 1 := by
   induction' l with i l hil
   · rfl
   rw [List.prod_cons, hil fun x hx ↦ hl _ (mem_cons_of_mem i hx), hl _ (mem_cons_self i l), one_mul]
@@ -403,37 +431,15 @@ lemma prod_mul_prod_eq_prod_zipWith_of_length_eq (l l' : List M) (h : l.length =
 
 end CommMonoid
 
-section MonoidWithZero
-
-variable [MonoidWithZero M₀]
-
-/-- If zero is an element of a list `L`, then `List.prod L = 0`. If the domain is a nontrivial
-monoid with zero with no divisors, then this implication becomes an `iff`, see
-`List.prod_eq_zero_iff`. -/
-theorem prod_eq_zero {L : List M₀} (h : (0 : M₀) ∈ L) : L.prod = 0 := by
-  induction' L with a L ihL
-  · exact absurd h (not_mem_nil _)
-  · rw [prod_cons]
-    cases' mem_cons.1 h with ha hL
-    exacts [mul_eq_zero_of_left ha.symm _, mul_eq_zero_of_right _ (ihL hL)]
-#align list.prod_eq_zero List.prod_eq_zero
-
-/-- Product of elements of a list `L` equals zero if and only if `0 ∈ L`. See also
-`List.prod_eq_zero` for an implication that needs weaker typeclass assumptions. -/
-@[simp]
-theorem prod_eq_zero_iff [Nontrivial M₀] [NoZeroDivisors M₀] {L : List M₀} :
-    L.prod = 0 ↔ (0 : M₀) ∈ L := by
-  induction' L with a L ihL
-  · simp
-  · rw [prod_cons, mul_eq_zero, ihL, mem_cons, eq_comm]
-#align list.prod_eq_zero_iff List.prod_eq_zero_iff
-
-theorem prod_ne_zero [Nontrivial M₀] [NoZeroDivisors M₀] {L : List M₀} (hL : (0 : M₀) ∉ L) :
-    L.prod ≠ 0 :=
-  mt prod_eq_zero_iff.1 hL
-#align list.prod_ne_zero List.prod_ne_zero
-
-end MonoidWithZero
+@[to_additive]
+lemma eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length)
+    (h' : ∀ i ≤ L.length, (L.take i).prod = (L'.take i).prod) : L = L' := by
+  refine ext_get h fun i h₁ h₂ => ?_
+  have : (L.take (i + 1)).prod = (L'.take (i + 1)).prod := h' _ (Nat.succ_le_of_lt h₁)
+  rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this
+  convert mul_left_cancel this
+#align list.eq_of_prod_take_eq List.eq_of_prod_take_eq
+#align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
 
 section Group
 
@@ -529,16 +535,6 @@ theorem sum_zipWith_distrib_left [Semiring γ] (f : α → β → γ) (n : γ) (
     · simp [hl, mul_add]
 #align list.sum_zip_with_distrib_left List.sum_zipWith_distrib_left
 
-@[to_additive]
-theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length)
-    (h' : ∀ i ≤ L.length, (L.take i).prod = (L'.take i).prod) : L = L' := by
-  refine ext_get h fun i h₁ h₂ => ?_
-  have : (L.take (i + 1)).prod = (L'.take (i + 1)).prod := h' _ (Nat.succ_le_of_lt h₁)
-  rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this
-  convert mul_left_cancel this
-#align list.eq_of_prod_take_eq List.eq_of_prod_take_eq
-#align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
-
 theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
   sum_replicate m n
 #align list.sum_const_nat List.sum_const_nat
@@ -561,7 +557,7 @@ theorem headI_le_sum (L : List ℕ) : L.headI ≤ L.sum :=
 
 /-- This relies on `default ℕ = 0`. -/
 theorem tail_sum (L : List ℕ) : L.tail.sum = L.sum - L.headI := by
-  rw [← headI_add_tail_sum L, add_comm, @add_tsub_cancel_right]
+  rw [← headI_add_tail_sum L, add_comm, Nat.add_sub_cancel_right]
 #align list.tail_sum List.tail_sum
 
 section Alternating
@@ -619,11 +615,15 @@ theorem alternatingProd_cons (a : α) (l : List α) :
 end Alternating
 
 lemma sum_nat_mod (l : List ℕ) (n : ℕ) : l.sum % n = (l.map (· % n)).sum % n := by
-  induction l <;> simp [Nat.add_mod, *]
+  induction' l with a l ih
+  · simp only [Nat.zero_mod, map_nil]
+  · simpa only [map_cons, sum_cons, Nat.mod_add_mod, Nat.add_mod_mod] using congr((a + $ih) % n)
 #align list.sum_nat_mod List.sum_nat_mod
 
 lemma prod_nat_mod (l : List ℕ) (n : ℕ) : l.prod % n = (l.map (· % n)).prod % n := by
-  induction l <;> simp [Nat.mul_mod, *]
+  induction' l with a l ih
+  · simp only [Nat.zero_mod, map_nil]
+  · simpa only [prod_cons, map_cons, Nat.mod_mul_mod, Nat.mul_mod_mod] using congr((a * $ih) % n)
 #align list.prod_nat_mod List.prod_nat_mod
 
 lemma sum_int_mod (l : List ℤ) (n : ℤ) : l.sum % n = (l.map (· % n)).sum % n := by

6c5f73fd

chore: Sort big operator order lemmas (#11750)

Take the content of

some of Algebra.BigOperators.List.Basic
some of Algebra.BigOperators.List.Lemmas
some of Algebra.BigOperators.Multiset.Basic
some of Algebra.BigOperators.Multiset.Lemmas
Algebra.BigOperators.Multiset.Order
Algebra.BigOperators.Order

and sort it into six files:

Algebra.Order.BigOperators.Group.List. I credit Yakov for https://github.com/leanprover-community/mathlib/pull/8543.
Algebra.Order.BigOperators.Group.Multiset. Copyright inherited from Algebra.BigOperators.Multiset.Order.
Algebra.Order.BigOperators.Group.Finset. Copyright inherited from Algebra.BigOperators.Order.
Algebra.Order.BigOperators.Ring.List. I credit Stuart for https://github.com/leanprover-community/mathlib/pull/10184.
Algebra.Order.BigOperators.Ring.Multiset. I credit Ruben for https://github.com/leanprover-community/mathlib/pull/8787.
Algebra.Order.BigOperators.Ring.Finset. I credit Floris for https://github.com/leanprover-community/mathlib/pull/1294.

Here are the design decisions at play:

Pure algebra and big operators algebra shouldn't import (algebraic) order theory. This PR makes that better, but not perfect because we still import Data.Nat.Order.Basic in a few List files.
It's Algebra.Order.BigOperators instead of Algebra.BigOperators.Order because algebraic order theory is more of a theory than big operators algebra. Another reason is that algebraic order theory is the only way to mix pure order and pure algebra, while there are more ways to mix pure finiteness and pure algebra than just big operators.
There are separate files for group/monoid lemmas vs ring lemmas. Groups/monoids are the natural setup for big operators, so their lemmas shouldn't be mixed with ring lemmas that involves both addition and multiplication. As a result, everything under Algebra.Order.BigOperators.Group should be additivisable (except a few Nat- or Int-specific lemmas). In contrast, things under Algebra.Order.BigOperators.Ring are more prone to having heavy imports.
Lemmas are separated according to List vs Multiset vs Finset. This is not strictly necessary, and can be relaxed in cases where there aren't that many lemmas to be had. As an example, I could split out the AbsoluteValue lemmas from Algebra.Order.BigOperators.Ring.Finset to a file Algebra.Order.BigOperators.Ring.AbsoluteValue and it could stay this way until too many lemmas are in this file (or a split is needed for import reasons), in which case we would need files Algebra.Order.BigOperators.Ring.AbsoluteValue.Finset, Algebra.Order.BigOperators.Ring.AbsoluteValue.Multiset, etc...
Finsupp big operator and finprod/finsum order lemmas also belong in Algebra.Order.BigOperators. I haven't done so in this PR because the diff is big enough like that.

3cc22ef5

Diff

@@ -354,118 +354,6 @@ lemma prod_eq_pow_single [DecidableEq M] (a : M) (h : ∀ a', a' ≠ a → a' 
 #align list.prod_eq_pow_single List.prod_eq_pow_single
 #align list.sum_eq_nsmul_single List.sum_eq_nsmul_single
 
-@[to_additive sum_le_sum]
-theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
-    [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : Forall₂ (· ≤ ·) l₁ l₂) :
-    l₁.prod ≤ l₂.prod := by
-  induction' h with a b la lb hab ih ih'
-  · rfl
-  · simpa only [prod_cons] using mul_le_mul' hab ih'
-#align list.forall₂.prod_le_prod' List.Forall₂.prod_le_prod'
-#align list.forall₂.sum_le_sum List.Forall₂.sum_le_sum
-
-/-- If `l₁` is a sublist of `l₂` and all elements of `l₂` are greater than or equal to one, then
-`l₁.prod ≤ l₂.prod`. One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 1 ≤ a` instead
-of `∀ a ∈ l₂, 1 ≤ a` but this lemma is not yet in `mathlib`. -/
-@[to_additive sum_le_sum "If `l₁` is a sublist of `l₂` and all elements of `l₂` are nonnegative,
-  then `l₁.sum ≤ l₂.sum`.
-  One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 0 ≤ a` instead of `∀ a ∈ l₂, 0 ≤ a`
-  but this lemma is not yet in `mathlib`."]
-theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
-    [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : l₁ <+ l₂)
-    (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) : l₁.prod ≤ l₂.prod := by
-  induction h with
-  | slnil => rfl
-  | cons a _ ih' =>
-    simp only [prod_cons, forall_mem_cons] at h₁ ⊢
-    exact (ih' h₁.2).trans (le_mul_of_one_le_left' h₁.1)
-  | cons₂ a _ ih' =>
-    simp only [prod_cons, forall_mem_cons] at h₁ ⊢
-    exact mul_le_mul_left' (ih' h₁.2) _
-#align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'
-#align list.sublist.sum_le_sum List.Sublist.sum_le_sum
-
-@[to_additive sum_le_sum]
-theorem SublistForall₂.prod_le_prod' [Preorder M]
-    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] [CovariantClass M M (· * ·) (· ≤ ·)]
-    {l₁ l₂ : List M} (h : SublistForall₂ (· ≤ ·) l₁ l₂) (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) :
-    l₁.prod ≤ l₂.prod :=
-  let ⟨_, hall, hsub⟩ := sublistForall₂_iff.1 h
-  hall.prod_le_prod'.trans <| hsub.prod_le_prod' h₁
-#align list.sublist_forall₂.prod_le_prod' List.SublistForall₂.prod_le_prod'
-#align list.sublist_forall₂.sum_le_sum List.SublistForall₂.sum_le_sum
-
-@[to_additive sum_le_sum]
-theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
-    [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} {f g : ι → M} (h : ∀ i ∈ l, f i ≤ g i) :
-    (l.map f).prod ≤ (l.map g).prod :=
-  Forall₂.prod_le_prod' <| by simpa
-#align list.prod_le_prod' List.prod_le_prod'
-#align list.sum_le_sum List.sum_le_sum
-
-@[to_additive sum_lt_sum]
-theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
-    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
-    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (f g : ι → M)
-    (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod := by
-  induction' l with i l ihl
-  · rcases h₂ with ⟨_, ⟨⟩, _⟩
-  simp only [forall_mem_cons, exists_mem_cons, map_cons, prod_cons] at h₁ h₂ ⊢
-  cases h₂
-  · exact mul_lt_mul_of_lt_of_le ‹_› (prod_le_prod' h₁.2)
-  · exact mul_lt_mul_of_le_of_lt h₁.1 <| ihl h₁.2 ‹_›
-#align list.prod_lt_prod' List.prod_lt_prod'
-#align list.sum_lt_sum List.sum_lt_sum
-
-@[to_additive]
-theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
-    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
-    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (hl : l ≠ []) (f g : ι → M)
-    (hlt : ∀ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod :=
-  (prod_lt_prod' f g fun i hi => (hlt i hi).le) <|
-    (exists_mem_of_ne_nil l hl).imp fun i hi => ⟨hi, hlt i hi⟩
-#align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nil
-#align list.sum_lt_sum_of_ne_nil List.sum_lt_sum_of_ne_nil
-
-@[to_additive sum_le_card_nsmul]
-theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
-    [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n) :
-    l.prod ≤ n ^ l.length := by
-      simpa only [map_id', map_const', prod_replicate] using prod_le_prod' h
-#align list.prod_le_pow_card List.prod_le_pow_card
-#align list.sum_le_card_nsmul List.sum_le_card_nsmul
-
-@[to_additive exists_lt_of_sum_lt]
-theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
-    [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} (f g : ι → M)
-    (h : (l.map f).prod < (l.map g).prod) : ∃ i ∈ l, f i < g i := by
-  contrapose! h
-  exact prod_le_prod' h
-#align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'
-#align list.exists_lt_of_sum_lt List.exists_lt_of_sum_lt
-
-@[to_additive exists_le_of_sum_le]
-theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
-    [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
-    [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (hl : l ≠ []) (f g : ι → M)
-    (h : (l.map f).prod ≤ (l.map g).prod) : ∃ x ∈ l, f x ≤ g x := by
-  contrapose! h
-  exact prod_lt_prod_of_ne_nil hl _ _ h
-#align list.exists_le_of_prod_le' List.exists_le_of_prod_le'
-#align list.exists_le_of_sum_le List.exists_le_of_sum_le
-
-@[to_additive sum_nonneg]
-theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
-    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) : 1 ≤ l.prod := by
-  -- We don't use `pow_card_le_prod` to avoid assumption
-  -- [covariant_class M M (function.swap (*)) (≤)]
-  induction' l with hd tl ih
-  · rfl
-  rw [prod_cons]
-  exact one_le_mul (hl₁ hd (mem_cons_self hd tl)) (ih fun x h => hl₁ x (mem_cons_of_mem hd h))
-#align list.one_le_prod_of_one_le List.one_le_prod_of_one_le
-#align list.sum_nonneg List.sum_nonneg
-
 end Monoid
 
 section CommMonoid
@@ -651,84 +539,10 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
 #align list.eq_of_prod_take_eq List.eq_of_prod_take_eq
 #align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
 
-@[to_additive]
-theorem monotone_prod_take [CanonicallyOrderedCommMonoid M] (L : List M) :
-    Monotone fun i => (L.take i).prod := by
-  refine' monotone_nat_of_le_succ fun n => _
-  cases' lt_or_le n L.length with h h
-  · rw [prod_take_succ _ _ h]
-    exact le_self_mul
-  · simp [take_all_of_le h, take_all_of_le (le_trans h (Nat.le_succ _))]
-#align list.monotone_prod_take List.monotone_prod_take
-#align list.monotone_sum_take List.monotone_sum_take
-
-@[to_additive sum_pos]
-theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
-    ∀ l : List M, (∀ x ∈ l, (1 : M) < x) → l ≠ [] → 1 < l.prod
-  | [], _, h => (h rfl).elim
-  | [b], h, _ => by simpa using h
-  | a :: b :: l, hl₁, _ => by
-    simp only [forall_eq_or_imp, List.mem_cons] at hl₁
-    rw [List.prod_cons]
-    apply one_lt_mul_of_lt_of_le' hl₁.1
-    apply le_of_lt ((b :: l).one_lt_prod_of_one_lt _ (l.cons_ne_nil b))
-    intro x hx; cases hx
-    · exact hl₁.2.1
-    · exact hl₁.2.2 _ ‹_›
-#align list.one_lt_prod_of_one_lt List.one_lt_prod_of_one_lt
-#align list.sum_pos List.sum_pos
-
-@[to_additive]
-theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) :
-    ∀ x ∈ l, x ≤ l.prod := by
-  induction l
-  · simp
-  simp_rw [prod_cons, forall_mem_cons] at hl₁ ⊢
-  constructor
-  case cons.left => exact le_mul_of_one_le_right' (one_le_prod_of_one_le hl₁.2)
-  case cons.right hd tl ih => exact fun x H => le_mul_of_one_le_of_le hl₁.1 (ih hl₁.right x H)
-#align list.single_le_prod List.single_le_prod
-#align list.single_le_sum List.single_le_sum
-
-@[to_additive all_zero_of_le_zero_le_of_sum_eq_zero]
-theorem all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
-    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) (hl₂ : l.prod = 1) {x : M} (hx : x ∈ l) : x = 1 :=
-  _root_.le_antisymm (hl₂ ▸ single_le_prod hl₁ _ hx) (hl₁ x hx)
-#align list.all_one_of_le_one_le_of_prod_eq_one List.all_one_of_le_one_le_of_prod_eq_one
-#align list.all_zero_of_le_zero_le_of_sum_eq_zero List.all_zero_of_le_zero_le_of_sum_eq_zero
-
--- TODO: develop theory of tropical rings
-theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M → N) (h0 : f 0 ≤ 0)
-    (hadd : ∀ x y, f (x + y) ≤ max (f x) (f y)) (l : List M) : f l.sum ≤ (l.map f).foldr max 0 := by
-  induction' l with hd tl IH
-  · simpa using h0
-  simp only [List.sum_cons, List.foldr_map, List.foldr] at IH ⊢
-  exact (hadd _ _).trans (max_le_max le_rfl IH)
-#align list.sum_le_foldr_max List.sum_le_foldr_max
-
 theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
   sum_replicate m n
 #align list.sum_const_nat List.sum_const_nat
 
-/-- The product of a list of positive natural numbers is positive,
-and likewise for any nontrivial ordered semiring. -/
-theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R) < a) :
-    0 < l.prod := by
-  induction' l with a l ih
-  · simp
-  · rw [prod_cons]
-    exact mul_pos (h _ <| mem_cons_self _ _) (ih fun a ha => h a <| mem_cons_of_mem _ ha)
-#align list.prod_pos List.prod_pos
-
-/-- A variant of `List.prod_pos` for `CanonicallyOrderedCommSemiring`. -/
-@[simp] lemma _root_.CanonicallyOrderedCommSemiring.list_prod_pos
-    {α : Type*} [CanonicallyOrderedCommSemiring α] [Nontrivial α] :
-    ∀ {l : List α}, 0 < l.prod ↔ (∀ x ∈ l, (0 : α) < x)
-  | [] => by simp
-  | (x :: xs) => by simp_rw [prod_cons, forall_mem_cons, CanonicallyOrderedCommSemiring.mul_pos,
-    list_prod_pos]
-#align canonically_ordered_comm_semiring.list_prod_pos CanonicallyOrderedCommSemiring.list_prod_pos
-
 /-!
 Several lemmas about sum/head/tail for `List ℕ`.
 These are hard to generalize well, as they rely on the fact that `default ℕ = 0`.

6c5f73fd

chore(Data/List): Depend less on big operators (#11741)

Make Data.List.Count, Data.List.Dedup, Data.List.ProdSigma, Data.List.Range, Data.List.Rotate, Data.List.Zip not depend on Data.List.BigOperators.Basic.
As a consequence, move the big operators lemmas that were in there to Data.List.BigOperators.Basic. For the lemmas that were Nat-specific, keep a version of them in the original file but stated using Nat.sum.
To help with this, add Nat.sum_eq_listSum (l : List Nat) : Nat.sum l = l.sum.

9158f323

Diff

@@ -9,6 +9,10 @@ import Mathlib.Algebra.Divisibility.Basic
 import Mathlib.Algebra.Ring.Commute
 import Mathlib.Data.Nat.Order.Basic
 import Mathlib.Data.Int.Basic
+import Mathlib.Data.List.Dedup
+import Mathlib.Data.List.ProdSigma
+import Mathlib.Data.List.Range
+import Mathlib.Data.List.Rotate
 
 #align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"
 
@@ -20,7 +24,7 @@ of elements of a list and `List.alternatingProd`, `List.alternatingSum`, their a
 counterparts. These are defined in [`Algebra.BigOperators.List.Defs`](./Defs).
 -/
 
-variable {ι α M N P M₀ G R : Type*}
+variable {ι α β γ M N P M₀ G R : Type*}
 
 namespace List
 
@@ -288,6 +292,68 @@ theorem _root_.Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Com
 #align commute.list_prod_left Commute.list_prod_left
 #align add_commute.list_sum_left AddCommute.list_sum_left
 
+@[to_additive] lemma prod_range_succ (f : ℕ → M) (n : ℕ) :
+    ((range n.succ).map f).prod = ((range n).map f).prod * f n := by
+  rw [range_succ, map_append, map_singleton, prod_append, prod_cons, prod_nil, mul_one]
+#align list.prod_range_succ List.prod_range_succ
+#align list.sum_range_succ List.sum_range_succ
+
+/-- A variant of `prod_range_succ` which pulls off the first term in the product rather than the
+last. -/
+@[to_additive
+"A variant of `sum_range_succ` which pulls off the first term in the sum rather than the last."]
+lemma prod_range_succ' (f : ℕ → M) (n : ℕ) :
+    ((range n.succ).map f).prod = f 0 * ((range n).map fun i ↦ f i.succ).prod :=
+  Nat.recOn n (show 1 * f 0 = f 0 * 1 by rw [one_mul, mul_one]) fun _ hd => by
+    rw [List.prod_range_succ, hd, mul_assoc, ← List.prod_range_succ]
+#align list.prod_range_succ' List.prod_range_succ'
+#align list.sum_range_succ' List.sum_range_succ'
+
+/-- Slightly more general version of `List.prod_eq_one_iff` for a non-ordered `Monoid` -/
+@[to_additive
+      "Slightly more general version of `List.sum_eq_zero_iff` for a non-ordered `AddMonoid`"]
+lemma prod_eq_one (hl : ∀ x ∈ l, x = 1) : l.prod = 1 := by
+  induction' l with i l hil
+  · rfl
+  rw [List.prod_cons, hil fun x hx ↦ hl _ (mem_cons_of_mem i hx), hl _ (mem_cons_self i l), one_mul]
+#align list.prod_eq_one List.prod_eq_one
+#align list.sum_eq_zero List.sum_eq_zero
+
+@[to_additive] lemma exists_mem_ne_one_of_prod_ne_one (h : l.prod ≠ 1) :
+    ∃ x ∈ l, x ≠ (1 : M) := by simpa only [not_forall, exists_prop] using mt prod_eq_one h
+#align list.exists_mem_ne_one_of_prod_ne_one List.exists_mem_ne_one_of_prod_ne_one
+#align list.exists_mem_ne_zero_of_sum_ne_zero List.exists_mem_ne_zero_of_sum_ne_zero
+
+@[to_additive]
+lemma prod_erase_of_comm [DecidableEq M] (ha : a ∈ l) (comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x) :
+    a * (l.erase a).prod = l.prod := by
+  induction' l with b l ih; simp only [not_mem_nil] at ha
+  obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem ha
+  simp only [erase_cons_head, prod_cons]
+  rw [List.erase, beq_false_of_ne ne.symm, List.prod_cons, List.prod_cons, ← mul_assoc,
+    comm a ha b (l.mem_cons_self b), mul_assoc,
+    ih h fun x hx y hy ↦ comm _ (List.mem_cons_of_mem b hx) _ (List.mem_cons_of_mem b hy)]
+
+@[to_additive]
+lemma prod_map_eq_pow_single [DecidableEq α] {l : List α} (a : α) (f : α → M)
+    (hf : ∀ a', a' ≠ a → a' ∈ l → f a' = 1) : (l.map f).prod = f a ^ l.count a := by
+  induction' l with a' as h generalizing a
+  · rw [map_nil, prod_nil, count_nil, _root_.pow_zero]
+  · specialize h a fun a' ha' hfa' => hf a' ha' (mem_cons_of_mem _ hfa')
+    rw [List.map_cons, List.prod_cons, count_cons, h]
+    split_ifs with ha'
+    · rw [ha', _root_.pow_succ']
+    · rw [hf a' (Ne.symm ha') (List.mem_cons_self a' as), one_mul, add_zero]
+#align list.prod_map_eq_pow_single List.prod_map_eq_pow_single
+#align list.sum_map_eq_nsmul_single List.sum_map_eq_nsmul_single
+
+@[to_additive]
+lemma prod_eq_pow_single [DecidableEq M] (a : M) (h : ∀ a', a' ≠ a → a' ∈ l → a' = 1) :
+    l.prod = a ^ l.count a :=
+  _root_.trans (by rw [map_id]) (prod_map_eq_pow_single a id h)
+#align list.prod_eq_pow_single List.prod_eq_pow_single
+#align list.sum_eq_nsmul_single List.sum_eq_nsmul_single
+
 @[to_additive sum_le_sum]
 theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : Forall₂ (· ≤ ·) l₁ l₂) :
@@ -402,6 +468,53 @@ theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤
 
 end Monoid
 
+section CommMonoid
+variable [CommMonoid M] {a : M} {l : List M}
+
+@[to_additive (attr := simp)]
+lemma prod_erase [DecidableEq M] (ha : a ∈ l) : a * (l.erase a).prod = l.prod :=
+  prod_erase_of_comm ha fun x _ y _ ↦ mul_comm x y
+#align list.prod_erase List.prod_erase
+#align list.sum_erase List.sum_erase
+
+@[to_additive (attr := simp)]
+lemma prod_map_erase [DecidableEq α] (f : α → M) {a} :
+    ∀ {l : List α}, a ∈ l → f a * ((l.erase a).map f).prod = (l.map f).prod
+  | b :: l, h => by
+    obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem h
+    · simp only [map, erase_cons_head, prod_cons]
+    · simp only [map, erase_cons_tail _ (not_beq_of_ne ne.symm), prod_cons, prod_map_erase _ h,
+        mul_left_comm (f a) (f b)]
+#align list.prod_map_erase List.prod_map_erase
+#align list.sum_map_erase List.sum_map_erase
+
+@[to_additive]
+lemma prod_mul_prod_eq_prod_zipWith_mul_prod_drop :
+    ∀ l l' : List M,
+      l.prod * l'.prod =
+        (zipWith (· * ·) l l').prod * (l.drop l'.length).prod * (l'.drop l.length).prod
+  | [], ys => by simp [Nat.zero_le]
+  | xs, [] => by simp [Nat.zero_le]
+  | x :: xs, y :: ys => by
+    simp only [drop, length, zipWith_cons_cons, prod_cons]
+    conv =>
+      lhs; rw [mul_assoc]; right; rw [mul_comm, mul_assoc]; right
+      rw [mul_comm, prod_mul_prod_eq_prod_zipWith_mul_prod_drop xs ys]
+    simp only [Nat.add_eq, add_zero]
+    ac_rfl
+#align list.prod_mul_prod_eq_prod_zip_with_mul_prod_drop List.prod_mul_prod_eq_prod_zipWith_mul_prod_drop
+#align list.sum_add_sum_eq_sum_zip_with_add_sum_drop List.sum_add_sum_eq_sum_zipWith_add_sum_drop
+
+@[to_additive]
+lemma prod_mul_prod_eq_prod_zipWith_of_length_eq (l l' : List M) (h : l.length = l'.length) :
+    l.prod * l'.prod = (zipWith (· * ·) l l').prod := by
+  apply (prod_mul_prod_eq_prod_zipWith_mul_prod_drop l l').trans
+  rw [← h, drop_length, h, drop_length, prod_nil, mul_one, mul_one]
+#align list.prod_mul_prod_eq_prod_zip_with_of_length_eq List.prod_mul_prod_eq_prod_zipWith_of_length_eq
+#align list.sum_add_sum_eq_sum_zip_with_of_length_eq List.sum_add_sum_eq_sum_zipWith_of_length_eq
+
+end CommMonoid
+
 section MonoidWithZero
 
 variable [MonoidWithZero M₀]
@@ -472,6 +585,16 @@ theorem prod_range_div' (n : ℕ) (f : ℕ → G) :
   · exact (div_self' (f 0)).symm
   · rw [range_succ, map_append, map_singleton, prod_append, prod_singleton, h, div_mul_div_cancel']
 
+lemma prod_rotate_eq_one_of_prod_eq_one :
+    ∀ {l : List G} (_ : l.prod = 1) (n : ℕ), (l.rotate n).prod = 1
+  | [], _, _ => by simp
+  | a :: l, hl, n => by
+    have : n % List.length (a :: l) ≤ List.length (a :: l) := le_of_lt (Nat.mod_lt _ (by simp))
+    rw [← List.take_append_drop (n % List.length (a :: l)) (a :: l)] at hl;
+      rw [← rotate_mod, rotate_eq_drop_append_take this, List.prod_append, mul_eq_one_iff_inv_eq, ←
+        one_mul (List.prod _)⁻¹, ← hl, List.prod_append, mul_assoc, mul_inv_self, mul_one]
+#align list.prod_rotate_eq_one_of_prod_eq_one List.prod_rotate_eq_one_of_prod_eq_one
+
 end Group
 
 section CommGroup
@@ -508,6 +631,16 @@ theorem prod_set' (L : List G) (n : ℕ) (a : G) :
 
 end CommGroup
 
+@[simp]
+theorem sum_zipWith_distrib_left [Semiring γ] (f : α → β → γ) (n : γ) (l : List α) (l' : List β) :
+    (l.zipWith (fun x y => n * f x y) l').sum = n * (l.zipWith f l').sum := by
+  induction' l with hd tl hl generalizing f n l'
+  · simp
+  · cases' l' with hd' tl'
+    · simp
+    · simp [hl, mul_add]
+#align list.sum_zip_with_distrib_left List.sum_zipWith_distrib_left
+
 @[to_additive]
 theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length = L'.length)
     (h' : ∀ i ≤ L.length, (L.take i).prod = (L'.take i).prod) : L = L' := by
@@ -564,23 +697,6 @@ theorem all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
 #align list.all_one_of_le_one_le_of_prod_eq_one List.all_one_of_le_one_le_of_prod_eq_one
 #align list.all_zero_of_le_zero_le_of_sum_eq_zero List.all_zero_of_le_zero_le_of_sum_eq_zero
 
-/-- Slightly more general version of `List.prod_eq_one_iff` for a non-ordered `Monoid` -/
-@[to_additive
-      "Slightly more general version of `List.sum_eq_zero_iff` for a non-ordered `AddMonoid`"]
-theorem prod_eq_one [Monoid M] {l : List M} (hl : ∀ x ∈ l, x = (1 : M)) : l.prod = 1 := by
-  induction' l with i l hil
-  · rfl
-  rw [List.prod_cons, hil fun x hx => hl _ (mem_cons_of_mem i hx), hl _ (mem_cons_self i l),
-    one_mul]
-#align list.prod_eq_one List.prod_eq_one
-#align list.sum_eq_zero List.sum_eq_zero
-
-@[to_additive]
-theorem exists_mem_ne_one_of_prod_ne_one [Monoid M] {l : List M} (h : l.prod ≠ 1) :
-    ∃ x ∈ l, x ≠ (1 : M) := by simpa only [not_forall, exists_prop] using mt prod_eq_one h
-#align list.exists_mem_ne_one_of_prod_ne_one List.exists_mem_ne_one_of_prod_ne_one
-#align list.exists_mem_ne_zero_of_sum_ne_zero List.exists_mem_ne_zero_of_sum_ne_zero
-
 -- TODO: develop theory of tropical rings
 theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M → N) (h0 : f 0 ≤ 0)
     (hadd : ∀ x y, f (x + y) ≤ max (f x) (f y)) (l : List M) : f l.sum ≤ (l.map f).foldr max 0 := by
@@ -590,35 +706,6 @@ theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M →
   exact (hadd _ _).trans (max_le_max le_rfl IH)
 #align list.sum_le_foldr_max List.sum_le_foldr_max
 
-@[to_additive]
-theorem prod_erase_of_comm [DecidableEq M] [Monoid M] {a} {l : List M} (ha : a ∈ l)
-    (comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x) :
-    a * (l.erase a).prod = l.prod := by
-  induction' l with b l ih; simp only [not_mem_nil] at ha
-  obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem ha
-  simp only [erase_cons_head, prod_cons]
-  rw [List.erase, beq_false_of_ne ne.symm, List.prod_cons, List.prod_cons, ← mul_assoc,
-    comm a ha b (l.mem_cons_self b), mul_assoc,
-    ih h fun x hx y hy ↦ comm _ (List.mem_cons_of_mem b hx) _ (List.mem_cons_of_mem b hy)]
-
-@[to_additive (attr := simp)]
-theorem prod_erase [DecidableEq M] [CommMonoid M] {a} {l : List M} (ha : a ∈ l) :
-    a * (l.erase a).prod = l.prod :=
-  prod_erase_of_comm ha fun x _ y _ ↦ mul_comm x y
-#align list.prod_erase List.prod_erase
-#align list.sum_erase List.sum_erase
-
-@[to_additive (attr := simp)]
-theorem prod_map_erase [DecidableEq ι] [CommMonoid M] (f : ι → M) {a} :
-    ∀ {l : List ι}, a ∈ l → f a * ((l.erase a).map f).prod = (l.map f).prod
-  | b :: l, h => by
-    obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem h
-    · simp only [map, erase_cons_head, prod_cons]
-    · simp only [map, erase_cons_tail _ (not_beq_of_ne ne.symm), prod_cons, prod_map_erase _ h,
-        mul_left_comm (f a) (f b)]
-#align list.prod_map_erase List.prod_map_erase
-#align list.sum_map_erase List.sum_map_erase
-
 theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
   sum_replicate m n
 #align list.sum_const_nat List.sum_const_nat
@@ -733,6 +820,38 @@ lemma prod_int_mod (l : List ℤ) (n : ℤ) : l.prod % n = (l.map (· % n)).prod
   induction l <;> simp [Int.mul_emod, *]
 #align list.prod_int_mod List.prod_int_mod
 
+variable [DecidableEq α]
+
+/-- Summing the count of `x` over a list filtered by some `p` is just `countP` applied to `p` -/
+theorem sum_map_count_dedup_filter_eq_countP (p : α → Bool) (l : List α) :
+    ((l.dedup.filter p).map fun x => l.count x).sum = l.countP p := by
+  induction' l with a as h
+  · simp
+  · simp_rw [List.countP_cons, List.count_cons, List.sum_map_add]
+    congr 1
+    · refine' _root_.trans _ h
+      by_cases ha : a ∈ as
+      · simp [dedup_cons_of_mem ha]
+      · simp only [dedup_cons_of_not_mem ha, List.filter]
+        match p a with
+        | true => simp only [List.map_cons, List.sum_cons, List.count_eq_zero.2 ha, zero_add]
+        | false => simp only
+    · by_cases hp : p a
+      · refine' _root_.trans (sum_map_eq_nsmul_single a _ fun _ h _ => by simp [h]) _
+        simp [hp, count_dedup]
+      · refine' _root_.trans (List.sum_eq_zero fun n hn => _) (by simp [hp])
+        obtain ⟨a', ha'⟩ := List.mem_map.1 hn
+        split_ifs at ha' with ha
+        · simp only [ha, mem_filter, mem_dedup, find?, mem_cons, true_or, hp,
+            and_false, false_and] at ha'
+        · exact ha'.2.symm
+#align list.sum_map_count_dedup_filter_eq_countp List.sum_map_count_dedup_filter_eq_countP
+
+theorem sum_map_count_dedup_eq_length (l : List α) :
+    (l.dedup.map fun x => l.count x).sum = l.length := by
+  simpa using sum_map_count_dedup_filter_eq_countP (fun _ => True) l
+#align list.sum_map_count_dedup_eq_length List.sum_map_count_dedup_eq_length
+
 end List
 
 section MonoidHom
@@ -758,3 +877,20 @@ protected theorem map_list_prod (f : M →* N) (l : List M) : f l.prod = (l.map
 end MonoidHom
 
 end MonoidHom
+
+@[simp] lemma Nat.sum_eq_listSum (l : List ℕ) : Nat.sum l = l.sum :=
+  (List.foldl_eq_foldr Nat.add_comm Nat.add_assoc _ _).symm
+
+namespace List
+
+lemma length_sigma {σ : α → Type*} (l₁ : List α) (l₂ : ∀ a, List (σ a)) :
+    length (l₁.sigma l₂) = (l₁.map fun a ↦ length (l₂ a)).sum := by simp [length_sigma']
+#align list.length_sigma List.length_sigma
+
+lemma ranges_join (l : List ℕ) : l.ranges.join = range l.sum := by simp [ranges_join']
+
+/-- Any entry of any member of `l.ranges` is strictly smaller than `l.sum`. -/
+lemma mem_mem_ranges_iff_lt_sum (l : List ℕ) {n : ℕ} :
+    (∃ s ∈ l.ranges, n ∈ s) ↔ n < l.sum := by simp [mem_mem_ranges_iff_lt_natSum]
+
+end List

6c5f73fd

move(Data/List/BigOperators): Move to Algebra.BigOperators.List (#11729)

This is algebra and should be foldered as such.

f09ccf67

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
-import Mathlib.Data.List.BigOperators.Defs
+import Mathlib.Algebra.BigOperators.List.Defs
 import Mathlib.Data.List.Forall2
 import Mathlib.Algebra.Divisibility.Basic
 import Mathlib.Algebra.Ring.Commute
@@ -17,7 +17,7 @@ import Mathlib.Data.Int.Basic
 
 This file provides basic results about `List.prod`, `List.sum`, which calculate the product and sum
 of elements of a list and `List.alternatingProd`, `List.alternatingSum`, their alternating
-counterparts. These are defined in [`Data.List.BigOperators.Defs`](./Defs).
+counterparts. These are defined in [`Algebra.BigOperators.List.Defs`](./Defs).
 -/
 
 variable {ι α M N P M₀ G R : Type*}

6c5f73fd

change the order of operation in zsmulRec and nsmulRec (#11451)

We change the following field in the definition of an additive commutative monoid:

 nsmul_succ : ∀ (n : ℕ) (x : G),
-  AddMonoid.nsmul (n + 1) x = x + AddMonoid.nsmul n x
+  AddMonoid.nsmul (n + 1) x = AddMonoid.nsmul n x + x

where the latter is more natural

We adjust the definitions of ^ in monoids, groups, etc. Originally there was a warning comment about why this natural order was preferred

use x * npowRec n x and not npowRec n x * x in the definition to make sure that definitional unfolding of npowRec is blocked, to avoid deep recursion issues.

but it seems to no longer apply.

Remarks on the PR :

pow_succ and pow_succ' have switched their meanings.
Most of the time, the proofs were adjusted by priming/unpriming one lemma, or exchanging left and right; a few proofs were more complicated to adjust.
In particular, [Mathlib/NumberTheory/RamificationInertia.lean] used Ideal.IsPrime.mul_mem_pow which is defined in [Mathlib/RingTheory/DedekindDomain/Ideal.lean]. Changing the order of operation forced me to add the symmetric lemma Ideal.IsPrime.mem_pow_mul.
the docstring for Cauchy condensation test in [Mathlib/Analysis/PSeries.lean] was mathematically incorrect, I added the mention that the function is antitone.

9a3feeae

Diff

@@ -107,7 +107,7 @@ theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).prod = a ^ n := by
   induction' n with n ih
   · rw [pow_zero]
     rfl
-  · rw [replicate_succ, prod_cons, ih, pow_succ]
+  · rw [replicate_succ, prod_cons, ih, pow_succ']
 #align list.prod_replicate List.prod_replicate
 #align list.sum_replicate List.sum_replicate

6c5f73fd

feat: add lemma List.prod_map_one (#11112)

Adds the lemma, and to_additive tags it

2d2e953b

Diff

@@ -24,9 +24,9 @@ variable {ι α M N P M₀ G R : Type*}
 
 namespace List
 
-section Monoid
+section MulOneClass
 
-variable [Monoid M] [Monoid N] [Monoid P] {l l₁ l₂ : List M} {a : M}
+variable [MulOneClass M] {l : List M} {a : M}
 
 @[to_additive (attr := simp)]
 theorem prod_nil : ([] : List M).prod = 1 :=
@@ -40,6 +40,23 @@ theorem prod_singleton : [a].prod = a :=
 #align list.prod_singleton List.prod_singleton
 #align list.sum_singleton List.sum_singleton
 
+@[to_additive (attr := simp)]
+theorem prod_one_cons : (1 :: l).prod = l.prod := by
+  rw [prod, foldl, mul_one]
+
+@[to_additive]
+theorem prod_map_one {l : List ι} :
+    (l.map fun _ => (1 : M)).prod = 1 := by
+  induction l with
+  | nil => rfl
+  | cons hd tl ih => rw [map_cons, prod_one_cons, ih]
+
+end MulOneClass
+
+section Monoid
+
+variable [Monoid M] [Monoid N] [Monoid P] {l l₁ l₂ : List M} {a : M}
+
 @[to_additive (attr := simp)]
 theorem prod_cons : (a :: l).prod = a * l.prod :=
   calc

6c5f73fd

chore(List/BigOperators): generalize a lemma (#11644)

List.prod_map_neg doesn't need a CommMonoid.

e2e83b9d

Diff

@@ -6,6 +6,7 @@ Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 import Mathlib.Data.List.BigOperators.Defs
 import Mathlib.Data.List.Forall2
 import Mathlib.Algebra.Divisibility.Basic
+import Mathlib.Algebra.Ring.Commute
 import Mathlib.Data.Nat.Order.Basic
 import Mathlib.Data.Int.Basic
 
@@ -144,10 +145,9 @@ theorem prod_map_mul {α : Type*} [CommMonoid α] {l : List ι} {f g : ι → α
 #align list.sum_map_add List.sum_map_add
 
 @[simp]
-theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
+theorem prod_map_neg [HasDistribNeg M] (l : List M) :
     (l.map Neg.neg).prod = (-1) ^ l.length * l.prod := by
-  simpa only [id_eq, neg_mul, one_mul, map_const', prod_replicate, map_id]
-    using @prod_map_mul α α _ l (fun _ => -1) id
+  induction l <;> simp [*, pow_succ, ((Commute.neg_one_left _).pow_left _).left_comm]
 #align list.prod_map_neg List.prod_map_neg
 
 @[to_additive]

6c5f73fd

feat(GroupTheory/FixedPointFree): New file (#11091)

This PR adds a new file containing the definition of fixed-point-free automorphisms and some basic properties.

8b3db4c3

Diff

@@ -447,6 +447,14 @@ theorem prod_drop_succ :
 #align list.prod_drop_succ List.prod_drop_succ
 #align list.sum_drop_succ List.sum_drop_succ
 
+/-- Cancellation of a telescoping product. -/
+@[to_additive "Cancellation of a telescoping sum."]
+theorem prod_range_div' (n : ℕ) (f : ℕ → G) :
+    ((range n).map fun k ↦ f k / f (k + 1)).prod = f 0 / f n := by
+  induction' n with n h
+  · exact (div_self' (f 0)).symm
+  · rw [range_succ, map_append, map_singleton, prod_append, prod_singleton, h, div_mul_div_cancel']
+
 end Group
 
 section CommGroup
@@ -461,6 +469,13 @@ theorem prod_inv : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).prod
 #align list.prod_inv List.prod_inv
 #align list.sum_neg List.sum_neg
 
+/-- Cancellation of a telescoping product. -/
+@[to_additive "Cancellation of a telescoping sum."]
+theorem prod_range_div (n : ℕ) (f : ℕ → G) :
+    ((range n).map fun k ↦ f (k + 1) / f k).prod = f n / f 0 := by
+  have h : ((·⁻¹) ∘ fun k ↦ f (k + 1) / f k) = fun k ↦ f k / f (k + 1) := by ext; apply inv_div
+  rw [← inv_inj, prod_inv, map_map, inv_div, h, prod_range_div']
+
 /-- Alternative version of `List.prod_set` when the list is over a group -/
 @[to_additive "Alternative version of `List.sum_set` when the list is over a group"]
 theorem prod_set' (L : List G) (n : ℕ) (a : G) :

6c5f73fd

chore: avoid some unused variables (#11583)

These will be caught by the linter in a future lean version.

818ec230

Diff

@@ -202,8 +202,7 @@ theorem prod_take_succ :
 @[to_additive "A list with sum not zero must have positive length."]
 theorem length_pos_of_prod_ne_one (L : List M) (h : L.prod ≠ 1) : 0 < L.length := by
   cases L
-  · contrapose h
-    simp
+  · simp at h
   · simp
 #align list.length_pos_of_prod_ne_one List.length_pos_of_prod_ne_one
 #align list.length_pos_of_sum_ne_zero List.length_pos_of_sum_ne_zero

6c5f73fd

chore(Mathlib/Data/List/Basic): minimize imports (#11497)

Use Nat specialized theorems, and omega, where necessary to avoid needing to import the abstract ordered algebra hierarchy for basic results about List.

Import graph between Mathlib.Order.Basic and Mathlib.Data.List.Basic:

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

4bf0be48

Diff

@@ -6,6 +6,7 @@ Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 import Mathlib.Data.List.BigOperators.Defs
 import Mathlib.Data.List.Forall2
 import Mathlib.Algebra.Divisibility.Basic
+import Mathlib.Data.Nat.Order.Basic
 import Mathlib.Data.Int.Basic
 
 #align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"

6c5f73fd

chore: more squeeze_simps arising from linter (#11259)

The squeezing continues! All found by the linter at #11246.

927ac925

Diff

@@ -562,8 +562,9 @@ theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M →
 theorem prod_erase_of_comm [DecidableEq M] [Monoid M] {a} {l : List M} (ha : a ∈ l)
     (comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x) :
     a * (l.erase a).prod = l.prod := by
-  induction' l with b l ih; simp at ha
-  obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem ha; simp
+  induction' l with b l ih; simp only [not_mem_nil] at ha
+  obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem ha
+  simp only [erase_cons_head, prod_cons]
   rw [List.erase, beq_false_of_ne ne.symm, List.prod_cons, List.prod_cons, ← mul_assoc,
     comm a ha b (l.mem_cons_self b), mul_assoc,
     ih h fun x hx y hy ↦ comm _ (List.mem_cons_of_mem b hx) _ (List.mem_cons_of_mem b hy)]

6c5f73fd

chore: bump dependencies (#10954)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Riccardo Brasca <riccardo.brasca@gmail.com>

a62da66e

Diff

@@ -581,7 +581,7 @@ theorem prod_map_erase [DecidableEq ι] [CommMonoid M] (f : ι → M) {a} :
   | b :: l, h => by
     obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem h
     · simp only [map, erase_cons_head, prod_cons]
-    · simp only [map, erase_cons_tail _ ne.symm, prod_cons, prod_map_erase _ h,
+    · simp only [map, erase_cons_tail _ (not_beq_of_ne ne.symm), prod_cons, prod_map_erase _ h,
         mul_left_comm (f a) (f b)]
 #align list.prod_map_erase List.prod_map_erase
 #align list.sum_map_erase List.sum_map_erase

6c5f73fd

refactor(Data/FunLike): use unbundled inheritance from FunLike (#8386)

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

`simp` not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

c6a73d4f

Diff

@@ -113,7 +113,7 @@ theorem rel_prod {R : M → N → Prop} (h : R 1 1) (hf : (R ⇒ R ⇒ R) (· *
 #align list.rel_sum List.rel_sum
 
 @[to_additive]
-theorem prod_hom (l : List M) {F : Type*} [MonoidHomClass F M N] (f : F) :
+theorem prod_hom (l : List M) {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) :
     (l.map f).prod = f l.prod := by
   simp only [prod, foldl_map, ← map_one f]
   exact l.foldl_hom f (· * ·) (· * f ·) 1 (fun x y => (map_mul f x y).symm)
@@ -150,7 +150,8 @@ theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
 #align list.prod_map_neg List.prod_map_neg
 
 @[to_additive]
-theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type*} [MonoidHomClass G M N] (g : G) :
+theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type*} [FunLike G M N] [MonoidHomClass G M N]
+    (g : G) :
     (L.map (g ∘ f)).prod = g (L.map f).prod := by rw [← prod_hom, map_map]
 #align list.prod_map_hom List.prod_map_hom
 #align list.sum_map_hom List.sum_map_hom
@@ -706,7 +707,7 @@ section MonoidHom
 variable [Monoid M] [Monoid N]
 
 @[to_additive]
-theorem map_list_prod {F : Type*} [MonoidHomClass F M N] (f : F) (l : List M) :
+theorem map_list_prod {F : Type*} [FunLike F M N] [MonoidHomClass F M N] (f : F) (l : List M) :
     f l.prod = (l.map f).prod :=
   (l.prod_hom f).symm
 #align map_list_prod map_list_prod

6c5f73fd

chore: tidy various files (#10007)

4b37d531

Diff

@@ -14,7 +14,7 @@ import Mathlib.Data.Int.Basic
 # Sums and products from lists
 
 This file provides basic results about `List.prod`, `List.sum`, which calculate the product and sum
-of elements of a list and `List.alternating_prod`, `List.alternating_sum`, their alternating
+of elements of a list and `List.alternatingProd`, `List.alternatingSum`, their alternating
 counterparts. These are defined in [`Data.List.BigOperators.Defs`](./Defs).
 -/

6c5f73fd

chore: reduce imports (#9830)

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

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

f4c4ca61

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
-import Mathlib.Algebra.Opposites
 import Mathlib.Data.List.BigOperators.Defs
-import Mathlib.Data.Int.Order.Basic
 import Mathlib.Data.List.Forall2
+import Mathlib.Algebra.Divisibility.Basic
+import Mathlib.Data.Int.Basic
 
 #align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"
 
@@ -231,8 +231,6 @@ theorem prod_set :
 #align list.prod_update_nth List.prod_set
 #align list.sum_update_nth List.sum_set
 
-open MulOpposite
-
 /-- We'd like to state this as `L.headI * L.tail.prod = L.prod`, but because `L.headI` relies on an
 inhabited instance to return a garbage value on the empty list, this is not possible.
 Instead, we write the statement in terms of `(L.get? 0).getD 1`.

6c5f73fd

chore: Move Int and Nat cast lemmas (#9503)

Part of #9411

e1b05c51

Diff

@@ -3,6 +3,7 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
+import Mathlib.Algebra.Opposites
 import Mathlib.Data.List.BigOperators.Defs
 import Mathlib.Data.Int.Order.Basic
 import Mathlib.Data.List.Forall2

6c5f73fd

style: use cases x with | ... instead of cases x; case => ... (#9321)

This converts usages of the pattern

cases h
case inl h' => ...
case inr h' => ...

which derive from mathported code, to the "structured cases" syntax:

cases h with
| inl h' => ...
| inr h' => ...

The case where the subgoals are handled with · instead of case is more contentious (and much more numerous) so I left those alone. This pattern also appears with cases', induction, induction', and rcases. Furthermore, there is a similar transformation for by_cases:

by_cases h : cond
case pos => ...
case neg => ...

is replaced by:

if h : cond then
  ...
else
  ...

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

e04a464d

Diff

@@ -291,12 +291,12 @@ of `∀ a ∈ l₂, 1 ≤ a` but this lemma is not yet in `mathlib`. -/
 theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : l₁ <+ l₂)
     (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) : l₁.prod ≤ l₂.prod := by
-  induction h
-  case slnil => rfl
-  case cons l₁ l₂ a _ ih' =>
+  induction h with
+  | slnil => rfl
+  | cons a _ ih' =>
     simp only [prod_cons, forall_mem_cons] at h₁ ⊢
     exact (ih' h₁.2).trans (le_mul_of_one_le_left' h₁.1)
-  case cons₂ l₁ l₂ a _ ih' =>
+  | cons₂ a _ ih' =>
     simp only [prod_cons, forall_mem_cons] at h₁ ⊢
     exact mul_le_mul_left' (ih' h₁.2) _
 #align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'

6c5f73fd

chore(*): use ∃ x ∈ s, _ instead of ∃ (x) (_ : x ∈ s), _ (#9184)

Search for [∀∃].*(_ and manually replace some occurrences with more readable versions. In case of ∀, the new expressions are defeq to the old ones. In case of ∃, they differ by exists_prop.

In some rare cases, golf proofs that needed fixing.

14c72960

Diff

@@ -155,7 +155,7 @@ theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type*} [MonoidHomClass G
 #align list.sum_map_hom List.sum_map_hom
 
 @[to_additive]
-theorem prod_isUnit : ∀ {L : List M} (_ : ∀ m ∈ L, IsUnit m), IsUnit L.prod
+theorem prod_isUnit : ∀ {L : List M}, (∀ m ∈ L, IsUnit m) → IsUnit L.prod
   | [], _ => by simp
   | h :: t, u => by
     simp only [List.prod_cons]
@@ -499,7 +499,7 @@ theorem monotone_prod_take [CanonicallyOrderedCommMonoid M] (L : List M) :
 
 @[to_additive sum_pos]
 theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
-    ∀ (l : List M) (_ : ∀ x ∈ l, (1 : M) < x) (_ : l ≠ []), 1 < l.prod
+    ∀ l : List M, (∀ x ∈ l, (1 : M) < x) → l ≠ [] → 1 < l.prod
   | [], _, h => (h rfl).elim
   | [b], h, _ => by simpa using h
   | a :: b :: l, hl₁, _ => by

6c5f73fd

chore: bump Std dependency to leanprover/std4#432 (#9094)

This covers these changes in Std: https://github.com/leanprover/std4/compare/6b4cf96c89e53cfcd73350bbcd90333a051ff4f0...[9dd24a34](https://github.com/leanprover-community/mathlib/commit/9dd24a3493cceefa2bede383f21e4ef548990b68)

Int.ofNat_natAbs_eq_of_nonneg has become Int.natAbs_of_nonneg (and one argument has become implicit)
List.map_id'' and List.map_id' have exchanged names. (Yay naming things using primes!)
Some meta functions have moved to Std and can be deleted here.

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

b3a1d74f

Diff

@@ -348,7 +348,7 @@ theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· <
 theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n) :
     l.prod ≤ n ^ l.length := by
-      simpa only [map_id'', map_const', prod_replicate] using prod_le_prod' h
+      simpa only [map_id', map_const', prod_replicate] using prod_le_prod' h
 #align list.prod_le_pow_card List.prod_le_pow_card
 #align list.sum_le_card_nsmul List.sum_le_card_nsmul

6c5f73fd

chore: reduce imports of Data.List.Defs (#8635)

Currently Data.List.Defs depends on Algebra.Group.Defs, rather unnecessarily.

(This then prevents importing Data.List.Defs into Tactic.Common, without breaking various assert_not_exists statements.)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: thorimur <68410468+thorimur@users.noreply.github.com>

7df4ff91

Diff

@@ -3,6 +3,7 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 -/
+import Mathlib.Data.List.BigOperators.Defs
 import Mathlib.Data.Int.Order.Basic
 import Mathlib.Data.List.Forall2
 
@@ -13,10 +14,9 @@ import Mathlib.Data.List.Forall2
 
 This file provides basic results about `List.prod`, `List.sum`, which calculate the product and sum
 of elements of a list and `List.alternating_prod`, `List.alternating_sum`, their alternating
-counterparts. These are defined in [`Data.List.Defs`](./Defs).
+counterparts. These are defined in [`Data.List.BigOperators.Defs`](./Defs).
 -/
 
-
 variable {ι α M N P M₀ G R : Type*}
 
 namespace List
@@ -104,6 +104,13 @@ theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι
 #align list.prod_hom_rel List.prod_hom_rel
 #align list.sum_hom_rel List.sum_hom_rel
 
+@[to_additive]
+theorem rel_prod {R : M → N → Prop} (h : R 1 1) (hf : (R ⇒ R ⇒ R) (· * ·) (· * ·)) :
+    (Forall₂ R ⇒ R) prod prod :=
+  rel_foldl hf h
+#align list.rel_prod List.rel_prod
+#align list.rel_sum List.rel_sum
+
 @[to_additive]
 theorem prod_hom (l : List M) {F : Type*} [MonoidHomClass F M N] (f : F) :
     (l.map f).prod = f l.prod := by

6c5f73fd

chore: bump to v4.3.0-rc2 (#8366)

PR contents

This is the supremum of

#8284
#8056
#8023
#8332
#8226 (already approved)
#7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

switching to using explicit lemmas that have the intended level of application
(config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

40b64f79

Diff

@@ -610,7 +610,7 @@ If desired, we could add a class stating that `default = 0`.
 
 /-- This relies on `default ℕ = 0`. -/
 theorem headI_add_tail_sum (L : List ℕ) : L.headI + L.tail.sum = L.sum := by
-  cases L <;> simp
+  cases L <;> simp; rfl
 #align list.head_add_tail_sum List.headI_add_tail_sum
 
 /-- This relies on `default ℕ = 0`. -/

6c5f73fd

feat: expand Finset.noncommProd API (#8155)

edcf9202

Diff

@@ -46,6 +46,15 @@ theorem prod_cons : (a :: l).prod = a * l.prod :=
 #align list.prod_cons List.prod_cons
 #align list.sum_cons List.sum_cons
 
+@[to_additive]
+lemma prod_induction
+    (p : M → Prop) (hom : ∀ a b, p a → p b → p (a * b)) (unit : p 1) (base : ∀ x ∈ l, p x) :
+    p l.prod := by
+  induction' l with a l ih; simpa
+  rw [List.prod_cons]
+  simp only [Bool.not_eq_true, List.mem_cons, forall_eq_or_imp] at base
+  exact hom _ _ (base.1) (ih base.2)
+
 @[to_additive (attr := simp)]
 theorem prod_append : (l₁ ++ l₂).prod = l₁.prod * l₂.prod :=
   calc
@@ -542,13 +551,20 @@ theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M →
   exact (hadd _ _).trans (max_le_max le_rfl IH)
 #align list.sum_le_foldr_max List.sum_le_foldr_max
 
+@[to_additive]
+theorem prod_erase_of_comm [DecidableEq M] [Monoid M] {a} {l : List M} (ha : a ∈ l)
+    (comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x) :
+    a * (l.erase a).prod = l.prod := by
+  induction' l with b l ih; simp at ha
+  obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem ha; simp
+  rw [List.erase, beq_false_of_ne ne.symm, List.prod_cons, List.prod_cons, ← mul_assoc,
+    comm a ha b (l.mem_cons_self b), mul_assoc,
+    ih h fun x hx y hy ↦ comm _ (List.mem_cons_of_mem b hx) _ (List.mem_cons_of_mem b hy)]
+
 @[to_additive (attr := simp)]
-theorem prod_erase [DecidableEq M] [CommMonoid M] {a} :
-    ∀ {l : List M}, a ∈ l → a * (l.erase a).prod = l.prod
-  | b :: l, h => by
-    obtain rfl | ⟨ne, h⟩ := Decidable.List.eq_or_ne_mem_of_mem h
-    · simp only [List.erase, if_pos, prod_cons, beq_self_eq_true]
-    · simp only [List.erase, beq_false_of_ne ne.symm, prod_cons, prod_erase h, mul_left_comm a b]
+theorem prod_erase [DecidableEq M] [CommMonoid M] {a} {l : List M} (ha : a ∈ l) :
+    a * (l.erase a).prod = l.prod :=
+  prod_erase_of_comm ha fun x _ y _ ↦ mul_comm x y
 #align list.prod_erase List.prod_erase
 #align list.sum_erase List.sum_erase

6c5f73fd

chore: refactor prod_take_succ to List.get (#8043)

Needed to finish what was started in #8039

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

5561bd39

Diff

@@ -170,14 +170,12 @@ theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).prod *
 
 @[to_additive (attr := simp)]
 theorem prod_take_succ :
-    ∀ (L : List M) (i : ℕ) (p), (L.take (i + 1)).prod = (L.take i).prod * L.nthLe i p
+    ∀ (L : List M) (i : ℕ) (p), (L.take (i + 1)).prod = (L.take i).prod * L.get ⟨i, p⟩
   | [], i, p => by cases p
   | h :: t, 0, _ => rfl
   | h :: t, n + 1, p => by
     dsimp
-    rw [prod_cons, prod_cons, prod_take_succ t n (Nat.lt_of_succ_lt_succ p), mul_assoc,
-      nthLe_cons, dif_neg (Nat.add_one_ne_zero _)]
-    simp
+    rw [prod_cons, prod_cons, prod_take_succ t n (Nat.lt_of_succ_lt_succ p), mul_assoc]
 #align list.prod_take_succ List.prod_take_succ
 #align list.sum_take_succ List.sum_take_succ
 
@@ -422,14 +420,13 @@ theorem prod_reverse_noncomm : ∀ L : List G, L.reverse.prod = (L.map fun x =>
 #align list.prod_reverse_noncomm List.prod_reverse_noncomm
 #align list.sum_reverse_noncomm List.sum_reverse_noncomm
 
-set_option linter.deprecated false in
 /-- Counterpart to `List.prod_take_succ` when we have an inverse operation -/
 @[to_additive (attr := simp)
   "Counterpart to `List.sum_take_succ` when we have a negation operation"]
 theorem prod_drop_succ :
-    ∀ (L : List G) (i : ℕ) (p), (L.drop (i + 1)).prod = (L.nthLe i p)⁻¹ * (L.drop i).prod
+    ∀ (L : List G) (i : ℕ) (p), (L.drop (i + 1)).prod = (L.get ⟨i, p⟩)⁻¹ * (L.drop i).prod
   | [], i, p => False.elim (Nat.not_lt_zero _ p)
-  | x :: xs, 0, _ => by simp [nthLe]
+  | x :: xs, 0, _ => by simp
   | x :: xs, i + 1, p => prod_drop_succ xs i _
 #align list.prod_drop_succ List.prod_drop_succ
 #align list.sum_drop_succ List.sum_drop_succ
@@ -451,7 +448,7 @@ theorem prod_inv : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).prod
 /-- Alternative version of `List.prod_set` when the list is over a group -/
 @[to_additive "Alternative version of `List.sum_set` when the list is over a group"]
 theorem prod_set' (L : List G) (n : ℕ) (a : G) :
-    (L.set n a).prod = L.prod * if hn : n < L.length then (L.nthLe n hn)⁻¹ * a else 1 := by
+    (L.set n a).prod = L.prod * if hn : n < L.length then (L.get ⟨n, hn⟩)⁻¹ * a else 1 := by
   refine (prod_set L n a).trans ?_
   split_ifs with hn
   · rw [mul_comm _ a, mul_assoc a, prod_drop_succ L n hn, mul_comm _ (drop n L).prod, ←

6c5f73fd

chore: rename CanonicallyOrderedAddMonoid to ..AddCommMonoid (#7503)

Renames:

CanonicallyOrderedMonoid -> CanonicallyOrderedCommMonoid

CanonicallyOrderedAddMonoid -> CanonicallyOrderedAddCommMonoid

CanonicallyLinearOrderedMonoid -> CanonicallyLinearOrderedCommMonoid

CanonicallyLinearOrderedAddMonoid -> CanonicallyLinearOrderedAddCommMonoid

f3bc24c3

Diff

@@ -474,7 +474,7 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
 #align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
 
 @[to_additive]
-theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
+theorem monotone_prod_take [CanonicallyOrderedCommMonoid M] (L : List M) :
     Monotone fun i => (L.take i).prod := by
   refine' monotone_nat_of_le_succ fun n => _
   cases' lt_or_le n L.length with h h

6c5f73fd

chore: attempt to fix broken links in docs (#7350)

For example, the page of Mathlib.Data.List.BigOperators.Basic is trying to link to Mathlib.Data.List.Defs using ./defs but that becomes ../../../../././defs and a broken link.

Co-authored-by: Malvin Gattinger <malvin@w4eg.de>

fe2c350a

Diff

@@ -13,7 +13,7 @@ import Mathlib.Data.List.Forall2
 
 This file provides basic results about `List.prod`, `List.sum`, which calculate the product and sum
 of elements of a list and `List.alternating_prod`, `List.alternating_sum`, their alternating
-counterparts. These are defined in [`Data.List.Defs`](./defs).
+counterparts. These are defined in [`Data.List.Defs`](./Defs).
 -/

6c5f73fd

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -17,7 +17,7 @@ counterparts. These are defined in [`Data.List.Defs`](./defs).
 -/
 
 
-variable {ι α M N P M₀ G R : Type _}
+variable {ι α M N P M₀ G R : Type*}
 
 namespace List
 
@@ -96,7 +96,7 @@ theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι
 #align list.sum_hom_rel List.sum_hom_rel
 
 @[to_additive]
-theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
+theorem prod_hom (l : List M) {F : Type*} [MonoidHomClass F M N] (f : F) :
     (l.map f).prod = f l.prod := by
   simp only [prod, foldl_map, ← map_one f]
   exact l.foldl_hom f (· * ·) (· * f ·) 1 (fun x y => (map_mul f x y).symm)
@@ -119,7 +119,7 @@ theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a *
 #align list.sum_hom₂ List.sum_hom₂
 
 @[to_additive (attr := simp)]
-theorem prod_map_mul {α : Type _} [CommMonoid α] {l : List ι} {f g : ι → α} :
+theorem prod_map_mul {α : Type*} [CommMonoid α] {l : List ι} {f g : ι → α} :
     (l.map fun i => f i * g i).prod = (l.map f).prod * (l.map g).prod :=
   l.prod_hom₂ (· * ·) mul_mul_mul_comm (mul_one _) _ _
 #align list.prod_map_mul List.prod_map_mul
@@ -133,7 +133,7 @@ theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
 #align list.prod_map_neg List.prod_map_neg
 
 @[to_additive]
-theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type _} [MonoidHomClass G M N] (g : G) :
+theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type*} [MonoidHomClass G M N] (g : G) :
     (L.map (g ∘ f)).prod = g (L.map f).prod := by rw [← prod_hom, map_map]
 #align list.prod_map_hom List.prod_map_hom
 #align list.sum_map_hom List.sum_map_hom
@@ -148,7 +148,7 @@ theorem prod_isUnit : ∀ {L : List M} (_ : ∀ m ∈ L, IsUnit m), IsUnit L.pro
 #align list.sum_is_add_unit List.sum_isAddUnit
 
 @[to_additive]
-theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
+theorem prod_isUnit_iff {α : Type*} [CommMonoid α] {L : List α} :
     IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m := by
   refine' ⟨fun h => _, prod_isUnit⟩
   induction' L with m L ih
@@ -582,7 +582,7 @@ theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R
 
 /-- A variant of `List.prod_pos` for `CanonicallyOrderedCommSemiring`. -/
 @[simp] lemma _root_.CanonicallyOrderedCommSemiring.list_prod_pos
-    {α : Type _} [CanonicallyOrderedCommSemiring α] [Nontrivial α] :
+    {α : Type*} [CanonicallyOrderedCommSemiring α] [Nontrivial α] :
     ∀ {l : List α}, 0 < l.prod ↔ (∀ x ∈ l, (0 : α) < x)
   | [] => by simp
   | (x :: xs) => by simp_rw [prod_cons, forall_mem_cons, CanonicallyOrderedCommSemiring.mul_pos,
@@ -687,7 +687,7 @@ section MonoidHom
 variable [Monoid M] [Monoid N]
 
 @[to_additive]
-theorem map_list_prod {F : Type _} [MonoidHomClass F M N] (f : F) (l : List M) :
+theorem map_list_prod {F : Type*} [MonoidHomClass F M N] (f : F) (l : List M) :
     f l.prod = (l.map f).prod :=
   (l.prod_hom f).symm
 #align map_list_prod map_list_prod

6c5f73fd

chore: use · instead of . (#6085)

898a8e78

Diff

@@ -99,7 +99,7 @@ theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι
 theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
     (l.map f).prod = f l.prod := by
   simp only [prod, foldl_map, ← map_one f]
-  exact l.foldl_hom f (. * .) (. * f .) 1 (fun x y => (map_mul f x y).symm)
+  exact l.foldl_hom f (· * ·) (· * f ·) 1 (fun x y => (map_mul f x y).symm)
 #align list.prod_hom List.prod_hom
 #align list.sum_hom List.sum_hom

6c5f73fd

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
-
-! This file was ported from Lean 3 source module data.list.big_operators.basic
-! leanprover-community/mathlib commit 6c5f73fd6f6cc83122788a80a27cdd54663609f4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Int.Order.Basic
 import Mathlib.Data.List.Forall2
 
+#align_import data.list.big_operators.basic from "leanprover-community/mathlib"@"6c5f73fd6f6cc83122788a80a27cdd54663609f4"
+
 /-!
 # Sums and products from lists

6c5f73fd

chore: clean up spacing around at and goals (#5387)

Changes are of the form

some_tactic at h⊢ -> some_tactic at h ⊢
some_tactic at h -> some_tactic at h

2a870323

Diff

@@ -283,10 +283,10 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
   induction h
   case slnil => rfl
   case cons l₁ l₂ a _ ih' =>
-    simp only [prod_cons, forall_mem_cons] at h₁⊢
+    simp only [prod_cons, forall_mem_cons] at h₁ ⊢
     exact (ih' h₁.2).trans (le_mul_of_one_le_left' h₁.1)
   case cons₂ l₁ l₂ a _ ih' =>
-    simp only [prod_cons, forall_mem_cons] at h₁⊢
+    simp only [prod_cons, forall_mem_cons] at h₁ ⊢
     exact mul_le_mul_left' (ih' h₁.2) _
 #align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'
 #align list.sublist.sum_le_sum List.Sublist.sum_le_sum
@@ -316,7 +316,7 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod := by
   induction' l with i l ihl
   · rcases h₂ with ⟨_, ⟨⟩, _⟩
-  simp only [forall_mem_cons, exists_mem_cons, map_cons, prod_cons] at h₁ h₂⊢
+  simp only [forall_mem_cons, exists_mem_cons, map_cons, prod_cons] at h₁ h₂ ⊢
   cases h₂
   · exact mul_lt_mul_of_lt_of_le ‹_› (prod_le_prod' h₁.2)
   · exact mul_lt_mul_of_le_of_lt h₁.1 <| ihl h₁.2 ‹_›
@@ -508,7 +508,7 @@ theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l,
     ∀ x ∈ l, x ≤ l.prod := by
   induction l
   · simp
-  simp_rw [prod_cons, forall_mem_cons] at hl₁⊢
+  simp_rw [prod_cons, forall_mem_cons] at hl₁ ⊢
   constructor
   case cons.left => exact le_mul_of_one_le_right' (one_le_prod_of_one_le hl₁.2)
   case cons.right hd tl ih => exact fun x H => le_mul_of_one_le_of_le hl₁.1 (ih hl₁.right x H)
@@ -544,7 +544,7 @@ theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M →
     (hadd : ∀ x y, f (x + y) ≤ max (f x) (f y)) (l : List M) : f l.sum ≤ (l.map f).foldr max 0 := by
   induction' l with hd tl IH
   · simpa using h0
-  simp only [List.sum_cons, List.foldr_map, List.foldr] at IH⊢
+  simp only [List.sum_cons, List.foldr_map, List.foldr] at IH ⊢
   exact (hadd _ _).trans (max_le_max le_rfl IH)
 #align list.sum_le_foldr_max List.sum_le_foldr_max

6c5f73fd

chore: fix grammar 2/3 (#5002)

Part 2 of #5001

9e80ae3b

Diff

@@ -428,7 +428,7 @@ theorem prod_reverse_noncomm : ∀ L : List G, L.reverse.prod = (L.map fun x =>
 set_option linter.deprecated false in
 /-- Counterpart to `List.prod_take_succ` when we have an inverse operation -/
 @[to_additive (attr := simp)
-  "Counterpart to `List.sum_take_succ` when we have an negation operation"]
+  "Counterpart to `List.sum_take_succ` when we have a negation operation"]
 theorem prod_drop_succ :
     ∀ (L : List G) (i : ℕ) (p), (L.drop (i + 1)).prod = (L.nthLe i p)⁻¹ * (L.drop i).prod
   | [], i, p => False.elim (Nat.not_lt_zero _ p)

6c5f73fd

chore: add space after exacts (#4945)

Too often tempted to change these during other PRs, so doing a mass edit here.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

bf799bb9

Diff

@@ -386,7 +386,7 @@ theorem prod_eq_zero {L : List M₀} (h : (0 : M₀) ∈ L) : L.prod = 0 := by
   · exact absurd h (not_mem_nil _)
   · rw [prod_cons]
     cases' mem_cons.1 h with ha hL
-    exacts[mul_eq_zero_of_left ha.symm _, mul_eq_zero_of_right _ (ihL hL)]
+    exacts [mul_eq_zero_of_left ha.symm _, mul_eq_zero_of_right _ (ihL hL)]
 #align list.prod_eq_zero List.prod_eq_zero
 
 /-- Product of elements of a list `L` equals zero if and only if `0 ∈ L`. See also

6c5f73fd

chore: update std 05-22 (#4248)

The main breaking change is that tac <;> [t1, t2] is now written tac <;> [t1; t2], to avoid clashing with tactics like cases and use that take comma-separated lists.

ac36b28e

Diff

@@ -65,7 +65,7 @@ theorem prod_concat : (l.concat a).prod = l.prod * a := by
 
 @[to_additive (attr := simp)]
 theorem prod_join {l : List (List M)} : l.join.prod = (l.map List.prod).prod := by
-  induction l <;> [rfl, simp only [*, List.join, map, prod_append, prod_cons]]
+  induction l <;> [rfl; simp only [*, List.join, map, prod_append, prod_cons]]
 #align list.prod_join List.prod_join
 #align list.sum_join List.sum_join
 
@@ -238,7 +238,7 @@ theorem get?_zero_mul_tail_prod (l : List M) : (l.get? 0).getD 1 * l.tail.prod =
 @[to_additive "Same as `get?_zero_add_tail_sum`, but avoiding the `List.headI` garbage complication
   by requiring the list to be nonempty."]
 theorem headI_mul_tail_prod_of_ne_nil [Inhabited M] (l : List M) (h : l ≠ []) :
-    l.headI * l.tail.prod = l.prod := by cases l <;> [contradiction, simp]
+    l.headI * l.tail.prod = l.prod := by cases l <;> [contradiction; simp]
 #align list.head_mul_tail_prod_of_ne_nil List.headI_mul_tail_prod_of_ne_nil
 #align list.head_add_tail_sum_of_ne_nil List.headI_add_tail_sum_of_ne_nil

6c5f73fd

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -492,8 +492,7 @@ theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
     ∀ (l : List M) (_ : ∀ x ∈ l, (1 : M) < x) (_ : l ≠ []), 1 < l.prod
   | [], _, h => (h rfl).elim
   | [b], h, _ => by simpa using h
-  | a :: b :: l, hl₁, _ =>
-    by
+  | a :: b :: l, hl₁, _ => by
     simp only [forall_eq_or_imp, List.mem_cons] at hl₁
     rw [List.prod_cons]
     apply one_lt_mul_of_lt_of_le' hl₁.1

6c5f73fd

chore: fix #align lines (#3640)

This PR fixes two things:

Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

2b42dc7c

Diff

@@ -46,7 +46,6 @@ theorem prod_cons : (a :: l).prod = a * l.prod :=
     (a :: l).prod = foldl (· * ·) (a * 1) l :=
       by simp only [List.prod, foldl_cons, one_mul, mul_one]
     _ = _ := foldl_assoc
-
 #align list.prod_cons List.prod_cons
 #align list.sum_cons List.sum_cons
 
@@ -55,7 +54,6 @@ theorem prod_append : (l₁ ++ l₂).prod = l₁.prod * l₂.prod :=
   calc
     (l₁ ++ l₂).prod = foldl (· * ·) (foldl (· * ·) 1 l₁ * 1) l₂ := by simp [List.prod]
     _ = l₁.prod * l₂.prod := foldl_assoc
-
 #align list.prod_append List.prod_append
 #align list.sum_append List.sum_append
 
@@ -183,7 +181,6 @@ theorem prod_take_succ :
     rw [prod_cons, prod_cons, prod_take_succ t n (Nat.lt_of_succ_lt_succ p), mul_assoc,
       nthLe_cons, dif_neg (Nat.add_one_ne_zero _)]
     simp
-
 #align list.prod_take_succ List.prod_take_succ
 #align list.sum_take_succ List.sum_take_succ

6c5f73fd

feat: add/generalize lemmas about WithTop/WithBot (#2406)

Some of these lemmas are generalized from ENNReal while porting Data.Real.ENNReal. Backported to Mathlib 3 in leanprover-community/mathlib#18487, now forward-porting back to Mathlib 4. Also forward-porting leanprover-community/mathlib#18391

357d16b1

Diff

@@ -4,10 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 
 ! This file was ported from Lean 3 source module data.list.big_operators.basic
-! leanprover-community/mathlib commit 47adfab39a11a072db552f47594bf8ed2cf8a722
+! leanprover-community/mathlib commit 6c5f73fd6f6cc83122788a80a27cdd54663609f4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
+import Mathlib.Data.Int.Order.Basic
 import Mathlib.Data.List.Forall2
 
 /-!
@@ -586,18 +587,24 @@ theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R
     exact mul_pos (h _ <| mem_cons_self _ _) (ih fun a ha => h a <| mem_cons_of_mem _ ha)
 #align list.prod_pos List.prod_pos
 
+/-- A variant of `List.prod_pos` for `CanonicallyOrderedCommSemiring`. -/
+@[simp] lemma _root_.CanonicallyOrderedCommSemiring.list_prod_pos
+    {α : Type _} [CanonicallyOrderedCommSemiring α] [Nontrivial α] :
+    ∀ {l : List α}, 0 < l.prod ↔ (∀ x ∈ l, (0 : α) < x)
+  | [] => by simp
+  | (x :: xs) => by simp_rw [prod_cons, forall_mem_cons, CanonicallyOrderedCommSemiring.mul_pos,
+    list_prod_pos]
+#align canonically_ordered_comm_semiring.list_prod_pos CanonicallyOrderedCommSemiring.list_prod_pos
+
 /-!
 Several lemmas about sum/head/tail for `List ℕ`.
 These are hard to generalize well, as they rely on the fact that `default ℕ = 0`.
 If desired, we could add a class stating that `default = 0`.
 -/
 
-
 /-- This relies on `default ℕ = 0`. -/
 theorem headI_add_tail_sum (L : List ℕ) : L.headI + L.tail.sum = L.sum := by
-  cases L
-  · simp
-  · simp
+  cases L <;> simp
 #align list.head_add_tail_sum List.headI_add_tail_sum
 
 /-- This relies on `default ℕ = 0`. -/
@@ -664,6 +671,22 @@ theorem alternatingProd_cons (a : α) (l : List α) :
 
 end Alternating
 
+lemma sum_nat_mod (l : List ℕ) (n : ℕ) : l.sum % n = (l.map (· % n)).sum % n := by
+  induction l <;> simp [Nat.add_mod, *]
+#align list.sum_nat_mod List.sum_nat_mod
+
+lemma prod_nat_mod (l : List ℕ) (n : ℕ) : l.prod % n = (l.map (· % n)).prod % n := by
+  induction l <;> simp [Nat.mul_mod, *]
+#align list.prod_nat_mod List.prod_nat_mod
+
+lemma sum_int_mod (l : List ℤ) (n : ℤ) : l.sum % n = (l.map (· % n)).sum % n := by
+  induction l <;> simp [Int.add_emod, *]
+#align list.sum_int_mod List.sum_int_mod
+
+lemma prod_int_mod (l : List ℤ) (n : ℤ) : l.prod % n = (l.map (· % n)).prod % n := by
+  induction l <;> simp [Int.mul_emod, *]
+#align list.prod_int_mod List.prod_int_mod
+
 end List
 
 section MonoidHom

47adfab3

chore: bump to leanprover/lean4:nightly-2023-02-10 (#2188)

5bbbc25c

Diff

@@ -607,7 +607,7 @@ theorem headI_le_sum (L : List ℕ) : L.headI ≤ L.sum :=
 
 /-- This relies on `default ℕ = 0`. -/
 theorem tail_sum (L : List ℕ) : L.tail.sum = L.sum - L.headI := by
-  rw [← headI_add_tail_sum L, add_comm, add_tsub_cancel_right]
+  rw [← headI_add_tail_sum L, add_comm, @add_tsub_cancel_right]
 #align list.tail_sum List.tail_sum
 
 section Alternating

47adfab3

chore: sync some sha sums (#2116)

Part of the List.repeat -> List.replicate refactor. On Mathlib 4 side, I removed mentions of List.repeat in #1475 and #1579

e37d93e3

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Floris van Doorn, Sébastien Gouëzel, Alex J. Best
 
 ! This file was ported from Lean 3 source module data.list.big_operators.basic
-! leanprover-community/mathlib commit 26f081a2fb920140ed5bc5cc5344e84bcc7cb2b2
+! leanprover-community/mathlib commit 47adfab39a11a072db552f47594bf8ed2cf8a722
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

26f081a2

chore: add #align statements for to_additive decls (#1816)

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

ed378238

Diff

@@ -31,11 +31,13 @@ variable [Monoid M] [Monoid N] [Monoid P] {l l₁ l₂ : List M} {a : M}
 theorem prod_nil : ([] : List M).prod = 1 :=
   rfl
 #align list.prod_nil List.prod_nil
+#align list.sum_nil List.sum_nil
 
 @[to_additive]
 theorem prod_singleton : [a].prod = a :=
   one_mul a
 #align list.prod_singleton List.prod_singleton
+#align list.sum_singleton List.sum_singleton
 
 @[to_additive (attr := simp)]
 theorem prod_cons : (a :: l).prod = a * l.prod :=
@@ -45,6 +47,7 @@ theorem prod_cons : (a :: l).prod = a * l.prod :=
     _ = _ := foldl_assoc
 
 #align list.prod_cons List.prod_cons
+#align list.sum_cons List.sum_cons
 
 @[to_additive (attr := simp)]
 theorem prod_append : (l₁ ++ l₂).prod = l₁.prod * l₂.prod :=
@@ -53,22 +56,26 @@ theorem prod_append : (l₁ ++ l₂).prod = l₁.prod * l₂.prod :=
     _ = l₁.prod * l₂.prod := foldl_assoc
 
 #align list.prod_append List.prod_append
+#align list.sum_append List.sum_append
 
 @[to_additive]
 theorem prod_concat : (l.concat a).prod = l.prod * a := by
   rw [concat_eq_append, prod_append, prod_singleton]
 #align list.prod_concat List.prod_concat
+#align list.sum_concat List.sum_concat
 
 @[to_additive (attr := simp)]
 theorem prod_join {l : List (List M)} : l.join.prod = (l.map List.prod).prod := by
   induction l <;> [rfl, simp only [*, List.join, map, prod_append, prod_cons]]
 #align list.prod_join List.prod_join
+#align list.sum_join List.sum_join
 
 @[to_additive]
 theorem prod_eq_foldr : ∀ {l : List M}, l.prod = foldr (· * ·) 1 l
   | [] => rfl
   | cons a l => by rw [prod_cons, foldr_cons, prod_eq_foldr]
 #align list.prod_eq_foldr List.prod_eq_foldr
+#align list.sum_eq_foldr List.sum_eq_foldr
 
 @[to_additive (attr := simp)]
 theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).prod = a ^ n := by
@@ -77,17 +84,20 @@ theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).prod = a ^ n := by
     rfl
   · rw [replicate_succ, prod_cons, ih, pow_succ]
 #align list.prod_replicate List.prod_replicate
+#align list.sum_replicate List.sum_replicate
 
 @[to_additive sum_eq_card_nsmul]
 theorem prod_eq_pow_card (l : List M) (m : M) (h : ∀ x ∈ l, x = m) : l.prod = m ^ l.length := by
   rw [← prod_replicate, ← List.eq_replicate.mpr ⟨rfl, h⟩]
 #align list.prod_eq_pow_card List.prod_eq_pow_card
+#align list.sum_eq_card_nsmul List.sum_eq_card_nsmul
 
 @[to_additive]
 theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι → N} (h₁ : r 1 1)
     (h₂ : ∀ ⦃i a b⦄, r a b → r (f i * a) (g i * b)) : r (l.map f).prod (l.map g).prod :=
   List.recOn l h₁ fun a l hl => by simp only [map_cons, prod_cons, h₂ hl]
 #align list.prod_hom_rel List.prod_hom_rel
+#align list.sum_hom_rel List.sum_hom_rel
 
 @[to_additive]
 theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
@@ -95,6 +105,7 @@ theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
   simp only [prod, foldl_map, ← map_one f]
   exact l.foldl_hom f (. * .) (. * f .) 1 (fun x y => (map_mul f x y).symm)
 #align list.prod_hom List.prod_hom
+#align list.sum_hom List.sum_hom
 
 @[to_additive]
 theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d)
@@ -109,12 +120,14 @@ theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a *
   intros
   exact hf _ _ _ _
 #align list.prod_hom₂ List.prod_hom₂
+#align list.sum_hom₂ List.sum_hom₂
 
 @[to_additive (attr := simp)]
 theorem prod_map_mul {α : Type _} [CommMonoid α] {l : List ι} {f g : ι → α} :
     (l.map fun i => f i * g i).prod = (l.map f).prod * (l.map g).prod :=
   l.prod_hom₂ (· * ·) mul_mul_mul_comm (mul_one _) _ _
 #align list.prod_map_mul List.prod_map_mul
+#align list.sum_map_add List.sum_map_add
 
 @[simp]
 theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
@@ -127,6 +140,7 @@ theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
 theorem prod_map_hom (L : List ι) (f : ι → M) {G : Type _} [MonoidHomClass G M N] (g : G) :
     (L.map (g ∘ f)).prod = g (L.map f).prod := by rw [← prod_hom, map_map]
 #align list.prod_map_hom List.prod_map_hom
+#align list.sum_map_hom List.sum_map_hom
 
 @[to_additive]
 theorem prod_isUnit : ∀ {L : List M} (_ : ∀ m ∈ L, IsUnit m), IsUnit L.prod
@@ -135,6 +149,7 @@ theorem prod_isUnit : ∀ {L : List M} (_ : ∀ m ∈ L, IsUnit m), IsUnit L.pro
     simp only [List.prod_cons]
     exact IsUnit.mul (u h (mem_cons_self h t)) (prod_isUnit fun m mt => u m (mem_cons_of_mem h mt))
 #align list.prod_is_unit List.prod_isUnit
+#align list.sum_is_add_unit List.sum_isAddUnit
 
 @[to_additive]
 theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
@@ -145,6 +160,7 @@ theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
   rw [prod_cons, IsUnit.mul_iff] at h
   exact fun m' h' => Or.elim (eq_or_mem_of_mem_cons h') (fun H => H.substr h.1) fun H => ih h.2 _ H
 #align list.prod_is_unit_iff List.prod_isUnit_iff
+#align list.sum_is_add_unit_iff List.sum_isAddUnit_iff
 
 @[to_additive (attr := simp)]
 theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).prod * (L.drop i).prod = L.prod
@@ -154,6 +170,7 @@ theorem prod_take_mul_prod_drop : ∀ (L : List M) (i : ℕ), (L.take i).prod *
     dsimp
     rw [prod_cons, prod_cons, mul_assoc, prod_take_mul_prod_drop t]
 #align list.prod_take_mul_prod_drop List.prod_take_mul_prod_drop
+#align list.sum_take_add_sum_drop List.sum_take_add_sum_drop
 
 @[to_additive (attr := simp)]
 theorem prod_take_succ :
@@ -167,6 +184,7 @@ theorem prod_take_succ :
     simp
 
 #align list.prod_take_succ List.prod_take_succ
+#align list.sum_take_succ List.sum_take_succ
 
 /-- A list with product not one must have positive length. -/
 @[to_additive "A list with sum not zero must have positive length."]
@@ -176,18 +194,21 @@ theorem length_pos_of_prod_ne_one (L : List M) (h : L.prod ≠ 1) : 0 < L.length
     simp
   · simp
 #align list.length_pos_of_prod_ne_one List.length_pos_of_prod_ne_one
+#align list.length_pos_of_sum_ne_zero List.length_pos_of_sum_ne_zero
 
 /-- A list with product greater than one must have positive length. -/
 @[to_additive length_pos_of_sum_pos "A list with positive sum must have positive length."]
 theorem length_pos_of_one_lt_prod [Preorder M] (L : List M) (h : 1 < L.prod) : 0 < L.length :=
   length_pos_of_prod_ne_one L h.ne'
 #align list.length_pos_of_one_lt_prod List.length_pos_of_one_lt_prod
+#align list.length_pos_of_sum_pos List.length_pos_of_sum_pos
 
 /-- A list with product less than one must have positive length. -/
 @[to_additive "A list with negative sum must have positive length."]
 theorem length_pos_of_prod_lt_one [Preorder M] (L : List M) (h : L.prod < 1) : 0 < L.length :=
   length_pos_of_prod_ne_one L h.ne
 #align list.length_pos_of_prod_lt_one List.length_pos_of_prod_lt_one
+#align list.length_pos_of_sum_neg List.length_pos_of_sum_neg
 
 @[to_additive]
 theorem prod_set :
@@ -198,6 +219,7 @@ theorem prod_set :
   | x :: xs, i + 1, a => by simp [set, prod_set xs i a, mul_assoc, Nat.succ_eq_add_one]
   | [], _, _ => by simp [set, (Nat.zero_le _).not_lt, Nat.zero_le]
 #align list.prod_update_nth List.prod_set
+#align list.sum_update_nth List.sum_set
 
 open MulOpposite
 
@@ -211,6 +233,7 @@ Instead, we write the statement in terms of `(L.get? 0).getD 1`.
 theorem get?_zero_mul_tail_prod (l : List M) : (l.get? 0).getD 1 * l.tail.prod = l.prod := by
   cases l <;> simp
 #align list.nth_zero_mul_tail_prod List.get?_zero_mul_tail_prod
+#align list.nth_zero_add_tail_sum List.get?_zero_add_tail_sum
 
 /-- Same as `get?_zero_mul_tail_prod`, but avoiding the `List.headI` garbage complication by
   requiring the list to be nonempty. -/
@@ -219,6 +242,7 @@ theorem get?_zero_mul_tail_prod (l : List M) : (l.get? 0).getD 1 * l.tail.prod =
 theorem headI_mul_tail_prod_of_ne_nil [Inhabited M] (l : List M) (h : l ≠ []) :
     l.headI * l.tail.prod = l.prod := by cases l <;> [contradiction, simp]
 #align list.head_mul_tail_prod_of_ne_nil List.headI_mul_tail_prod_of_ne_nil
+#align list.head_add_tail_sum_of_ne_nil List.headI_add_tail_sum_of_ne_nil
 
 @[to_additive]
 theorem _root_.Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Commute y x) :
@@ -229,12 +253,14 @@ theorem _root_.Commute.list_prod_right (l : List M) (y : M) (h : ∀ x ∈ l, Co
     rw [List.prod_cons]
     exact Commute.mul_right h.1 (IH h.2)
 #align commute.list_prod_right Commute.list_prod_right
+#align add_commute.list_sum_right AddCommute.list_sum_right
 
 @[to_additive]
 theorem _root_.Commute.list_prod_left (l : List M) (y : M) (h : ∀ x ∈ l, Commute x y) :
     Commute l.prod y :=
   ((Commute.list_prod_right _ _) fun _ hx => (h _ hx).symm).symm
 #align commute.list_prod_left Commute.list_prod_left
+#align add_commute.list_sum_left AddCommute.list_sum_left
 
 @[to_additive sum_le_sum]
 theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -244,6 +270,7 @@ theorem Forall₂.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap
   · rfl
   · simpa only [prod_cons] using mul_le_mul' hab ih'
 #align list.forall₂.prod_le_prod' List.Forall₂.prod_le_prod'
+#align list.forall₂.sum_le_sum List.Forall₂.sum_le_sum
 
 /-- If `l₁` is a sublist of `l₂` and all elements of `l₂` are greater than or equal to one, then
 `l₁.prod ≤ l₂.prod`. One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 1 ≤ a` instead
@@ -264,6 +291,7 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
     simp only [prod_cons, forall_mem_cons] at h₁⊢
     exact mul_le_mul_left' (ih' h₁.2) _
 #align list.sublist.prod_le_prod' List.Sublist.prod_le_prod'
+#align list.sublist.sum_le_sum List.Sublist.sum_le_sum
 
 @[to_additive sum_le_sum]
 theorem SublistForall₂.prod_le_prod' [Preorder M]
@@ -273,6 +301,7 @@ theorem SublistForall₂.prod_le_prod' [Preorder M]
   let ⟨_, hall, hsub⟩ := sublistForall₂_iff.1 h
   hall.prod_le_prod'.trans <| hsub.prod_le_prod' h₁
 #align list.sublist_forall₂.prod_le_prod' List.SublistForall₂.prod_le_prod'
+#align list.sublist_forall₂.sum_le_sum List.SublistForall₂.sum_le_sum
 
 @[to_additive sum_le_sum]
 theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -280,6 +309,7 @@ theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·))
     (l.map f).prod ≤ (l.map g).prod :=
   Forall₂.prod_le_prod' <| by simpa
 #align list.prod_le_prod' List.prod_le_prod'
+#align list.sum_le_sum List.sum_le_sum
 
 @[to_additive sum_lt_sum]
 theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -293,6 +323,7 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
   · exact mul_lt_mul_of_lt_of_le ‹_› (prod_le_prod' h₁.2)
   · exact mul_lt_mul_of_le_of_lt h₁.1 <| ihl h₁.2 ‹_›
 #align list.prod_lt_prod' List.prod_lt_prod'
+#align list.sum_lt_sum List.sum_lt_sum
 
 @[to_additive]
 theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -302,6 +333,7 @@ theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· <
   (prod_lt_prod' f g fun i hi => (hlt i hi).le) <|
     (exists_mem_of_ne_nil l hl).imp fun i hi => ⟨hi, hlt i hi⟩
 #align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nil
+#align list.sum_lt_sum_of_ne_nil List.sum_lt_sum_of_ne_nil
 
 @[to_additive sum_le_card_nsmul]
 theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -309,6 +341,7 @@ theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * 
     l.prod ≤ n ^ l.length := by
       simpa only [map_id'', map_const', prod_replicate] using prod_le_prod' h
 #align list.prod_le_pow_card List.prod_le_pow_card
+#align list.sum_le_card_nsmul List.sum_le_card_nsmul
 
 @[to_additive exists_lt_of_sum_lt]
 theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
@@ -317,6 +350,7 @@ theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap
   contrapose! h
   exact prod_le_prod' h
 #align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'
+#align list.exists_lt_of_sum_lt List.exists_lt_of_sum_lt
 
 @[to_additive exists_le_of_sum_le]
 theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
@@ -326,6 +360,7 @@ theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (·
   contrapose! h
   exact prod_lt_prod_of_ne_nil hl _ _ h
 #align list.exists_le_of_prod_le' List.exists_le_of_prod_le'
+#align list.exists_le_of_sum_le List.exists_le_of_sum_le
 
 @[to_additive sum_nonneg]
 theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
@@ -337,6 +372,7 @@ theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤
   rw [prod_cons]
   exact one_le_mul (hl₁ hd (mem_cons_self hd tl)) (ih fun x h => hl₁ x (mem_cons_of_mem hd h))
 #align list.one_le_prod_of_one_le List.one_le_prod_of_one_le
+#align list.sum_nonneg List.sum_nonneg
 
 end Monoid
 
@@ -382,12 +418,14 @@ theorem prod_inv_reverse : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹)
   | [] => by simp
   | x :: xs => by simp [prod_inv_reverse xs]
 #align list.prod_inv_reverse List.prod_inv_reverse
+#align list.sum_neg_reverse List.sum_neg_reverse
 
 /-- A non-commutative variant of `List.prod_reverse` -/
 @[to_additive "A non-commutative variant of `List.sum_reverse`"]
 theorem prod_reverse_noncomm : ∀ L : List G, L.reverse.prod = (L.map fun x => x⁻¹).prod⁻¹ := by
   simp [prod_inv_reverse]
 #align list.prod_reverse_noncomm List.prod_reverse_noncomm
+#align list.sum_reverse_noncomm List.sum_reverse_noncomm
 
 set_option linter.deprecated false in
 /-- Counterpart to `List.prod_take_succ` when we have an inverse operation -/
@@ -399,6 +437,7 @@ theorem prod_drop_succ :
   | x :: xs, 0, _ => by simp [nthLe]
   | x :: xs, i + 1, p => prod_drop_succ xs i _
 #align list.prod_drop_succ List.prod_drop_succ
+#align list.sum_drop_succ List.sum_drop_succ
 
 end Group
 
@@ -412,6 +451,7 @@ theorem prod_inv : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).prod
   | [] => by simp
   | x :: xs => by simp [mul_comm, prod_inv xs]
 #align list.prod_inv List.prod_inv
+#align list.sum_neg List.sum_neg
 
 /-- Alternative version of `List.prod_set` when the list is over a group -/
 @[to_additive "Alternative version of `List.sum_set` when the list is over a group"]
@@ -424,6 +464,7 @@ theorem prod_set' (L : List G) (n : ℕ) (a : G) :
   · simp only [take_all_of_le (le_of_not_lt hn), prod_nil, mul_one,
       drop_eq_nil_of_le ((le_of_not_lt hn).trans n.le_succ)]
 #align list.prod_update_nth' List.prod_set'
+#align list.sum_update_nth' List.sum_set'
 
 end CommGroup
 
@@ -435,6 +476,7 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
   rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this
   convert mul_left_cancel this
 #align list.eq_of_prod_take_eq List.eq_of_prod_take_eq
+#align list.eq_of_sum_take_eq List.eq_of_sum_take_eq
 
 @[to_additive]
 theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
@@ -445,6 +487,7 @@ theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
     exact le_self_mul
   · simp [take_all_of_le h, take_all_of_le (le_trans h (Nat.le_succ _))]
 #align list.monotone_prod_take List.monotone_prod_take
+#align list.monotone_sum_take List.monotone_sum_take
 
 @[to_additive sum_pos]
 theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
@@ -461,6 +504,7 @@ theorem one_lt_prod_of_one_lt [OrderedCommMonoid M] :
     · exact hl₁.2.1
     · exact hl₁.2.2 _ ‹_›
 #align list.one_lt_prod_of_one_lt List.one_lt_prod_of_one_lt
+#align list.sum_pos List.sum_pos
 
 @[to_additive]
 theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) :
@@ -472,12 +516,14 @@ theorem single_le_prod [OrderedCommMonoid M] {l : List M} (hl₁ : ∀ x ∈ l,
   case cons.left => exact le_mul_of_one_le_right' (one_le_prod_of_one_le hl₁.2)
   case cons.right hd tl ih => exact fun x H => le_mul_of_one_le_of_le hl₁.1 (ih hl₁.right x H)
 #align list.single_le_prod List.single_le_prod
+#align list.single_le_sum List.single_le_sum
 
 @[to_additive all_zero_of_le_zero_le_of_sum_eq_zero]
 theorem all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
     (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) (hl₂ : l.prod = 1) {x : M} (hx : x ∈ l) : x = 1 :=
   _root_.le_antisymm (hl₂ ▸ single_le_prod hl₁ _ hx) (hl₁ x hx)
 #align list.all_one_of_le_one_le_of_prod_eq_one List.all_one_of_le_one_le_of_prod_eq_one
+#align list.all_zero_of_le_zero_le_of_sum_eq_zero List.all_zero_of_le_zero_le_of_sum_eq_zero
 
 /-- Slightly more general version of `List.prod_eq_one_iff` for a non-ordered `Monoid` -/
 @[to_additive
@@ -488,11 +534,13 @@ theorem prod_eq_one [Monoid M] {l : List M} (hl : ∀ x ∈ l, x = (1 : M)) : l.
   rw [List.prod_cons, hil fun x hx => hl _ (mem_cons_of_mem i hx), hl _ (mem_cons_self i l),
     one_mul]
 #align list.prod_eq_one List.prod_eq_one
+#align list.sum_eq_zero List.sum_eq_zero
 
 @[to_additive]
 theorem exists_mem_ne_one_of_prod_ne_one [Monoid M] {l : List M} (h : l.prod ≠ 1) :
     ∃ x ∈ l, x ≠ (1 : M) := by simpa only [not_forall, exists_prop] using mt prod_eq_one h
 #align list.exists_mem_ne_one_of_prod_ne_one List.exists_mem_ne_one_of_prod_ne_one
+#align list.exists_mem_ne_zero_of_sum_ne_zero List.exists_mem_ne_zero_of_sum_ne_zero
 
 -- TODO: develop theory of tropical rings
 theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M → N) (h0 : f 0 ≤ 0)
@@ -511,6 +559,7 @@ theorem prod_erase [DecidableEq M] [CommMonoid M] {a} :
     · simp only [List.erase, if_pos, prod_cons, beq_self_eq_true]
     · simp only [List.erase, beq_false_of_ne ne.symm, prod_cons, prod_erase h, mul_left_comm a b]
 #align list.prod_erase List.prod_erase
+#align list.sum_erase List.sum_erase
 
 @[to_additive (attr := simp)]
 theorem prod_map_erase [DecidableEq ι] [CommMonoid M] (f : ι → M) {a} :
@@ -521,6 +570,7 @@ theorem prod_map_erase [DecidableEq ι] [CommMonoid M] (f : ι → M) {a} :
     · simp only [map, erase_cons_tail _ ne.symm, prod_cons, prod_map_erase _ h,
         mul_left_comm (f a) (f b)]
 #align list.prod_map_erase List.prod_map_erase
+#align list.sum_map_erase List.sum_map_erase
 
 theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
   sum_replicate m n
@@ -570,17 +620,20 @@ variable [One α] [Mul α] [Inv α]
 theorem alternatingProd_nil : alternatingProd ([] : List α) = 1 :=
   rfl
 #align list.alternating_prod_nil List.alternatingProd_nil
+#align list.alternating_sum_nil List.alternatingSum_nil
 
 @[to_additive (attr := simp)]
 theorem alternatingProd_singleton (a : α) : alternatingProd [a] = a :=
   rfl
 #align list.alternating_prod_singleton List.alternatingProd_singleton
+#align list.alternating_sum_singleton List.alternatingSum_singleton
 
 @[to_additive]
 theorem alternatingProd_cons_cons' (a b : α) (l : List α) :
     alternatingProd (a :: b :: l) = a * b⁻¹ * alternatingProd l :=
   rfl
 #align list.alternating_prod_cons_cons' List.alternatingProd_cons_cons'
+#align list.alternating_sum_cons_cons' List.alternatingSum_cons_cons'
 
 end
 
@@ -589,6 +642,7 @@ theorem alternatingProd_cons_cons [DivInvMonoid α] (a b : α) (l : List α) :
     alternatingProd (a :: b :: l) = a / b * alternatingProd l := by
   rw [div_eq_mul_inv, alternatingProd_cons_cons']
 #align list.alternating_prod_cons_cons List.alternatingProd_cons_cons
+#align list.alternating_sum_cons_cons List.alternatingSum_cons_cons
 
 variable [CommGroup α]
 
@@ -599,12 +653,14 @@ theorem alternatingProd_cons' :
   | a, b :: l => by
     rw [alternatingProd_cons_cons', alternatingProd_cons' b l, mul_inv, inv_inv, mul_assoc]
 #align list.alternating_prod_cons' List.alternatingProd_cons'
+#align list.alternating_sum_cons' List.alternatingSum_cons'
 
 @[to_additive (attr := simp)]
 theorem alternatingProd_cons (a : α) (l : List α) :
     alternatingProd (a :: l) = a / alternatingProd l := by
   rw [div_eq_mul_inv, alternatingProd_cons']
 #align list.alternating_prod_cons List.alternatingProd_cons
+#align list.alternating_sum_cons List.alternatingSum_cons
 
 end Alternating
 
@@ -619,6 +675,7 @@ theorem map_list_prod {F : Type _} [MonoidHomClass F M N] (f : F) (l : List M) :
     f l.prod = (l.map f).prod :=
   (l.prod_hom f).symm
 #align map_list_prod map_list_prod
+#align map_list_sum map_list_sum
 
 namespace MonoidHom
 
@@ -627,6 +684,7 @@ namespace MonoidHom
 protected theorem map_list_prod (f : M →* N) (l : List M) : f l.prod = (l.map f).prod :=
   map_list_prod f l
 #align monoid_hom.map_list_prod MonoidHom.map_list_prod
+#align add_monoid_hom.map_list_sum AddMonoidHom.map_list_sum
 
 end MonoidHom

26f081a2

chore: format by line breaks with long lines (#1529)

This was done semi-automatically with some regular expressions in vim in contrast to the fully automatic https://github.com/leanprover-community/mathlib4/pull/1523.

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

1050066f

Diff

@@ -528,8 +528,8 @@ theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
 
 /-- The product of a list of positive natural numbers is positive,
 and likewise for any nontrivial ordered semiring. -/
-theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R) < a) : 0 < l.prod :=
-  by
+theorem prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R) < a) :
+    0 < l.prod := by
   induction' l with a l ih
   · simp
   · rw [prod_cons]

26f081a2

chore: format by line breaks (#1523)

During porting, I usually fix the desired format we seem to want for the line breaks around by with

awk '{do {{if (match($0, "^  by$") && length(p) < 98) {p=p " by";} else {if (NR!=1) {print p}; p=$0}}} while (getline == 1) if (getline==0) print p}' Mathlib/File/Im/Working/On.lean

I noticed there are some more files that slipped through.

This pull request is the result of running this command:

grep -lr "^  by\$" Mathlib | xargs -n 1 awk -i inplace '{do {{if (match($0, "^  by$") && length(p) < 98 && not (match(p, "^[ \t]*--"))) {p=p " by";} else {if (NR!=1) {print p}; p=$0}}} while (getline == 1) if (getline==0) print p}'

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

d6d859a7

Diff

@@ -91,8 +91,7 @@ theorem prod_hom_rel (l : List ι) {r : M → N → Prop} {f : ι → M} {g : ι
 
 @[to_additive]
 theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
-    (l.map f).prod = f l.prod :=
-  by
+    (l.map f).prod = f l.prod := by
   simp only [prod, foldl_map, ← map_one f]
   exact l.foldl_hom f (. * .) (. * f .) 1 (fun x y => (map_mul f x y).symm)
 #align list.prod_hom List.prod_hom
@@ -100,8 +99,7 @@ theorem prod_hom (l : List M) {F : Type _} [MonoidHomClass F M N] (f : F) :
 @[to_additive]
 theorem prod_hom₂ (l : List ι) (f : M → N → P) (hf : ∀ a b c d, f (a * b) (c * d) = f a c * f b d)
     (hf' : f 1 1 = 1) (f₁ : ι → M) (f₂ : ι → N) :
-    (l.map fun i => f (f₁ i) (f₂ i)).prod = f (l.map f₁).prod (l.map f₂).prod :=
-  by
+    (l.map fun i => f (f₁ i) (f₂ i)).prod = f (l.map f₁).prod (l.map f₂).prod := by
   simp only [prod, foldl_map]
   -- Porting note: next 3 lines used to be
   -- convert l.foldl_hom₂ (fun a b => f a b) _ _ _ _ _ fun a b i => _
@@ -140,8 +138,7 @@ theorem prod_isUnit : ∀ {L : List M} (_ : ∀ m ∈ L, IsUnit m), IsUnit L.pro
 
 @[to_additive]
 theorem prod_isUnit_iff {α : Type _} [CommMonoid α] {L : List α} :
-    IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m :=
-  by
+    IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m := by
   refine' ⟨fun h => _, prod_isUnit⟩
   induction' L with m L ih
   · exact fun m' h' => False.elim (not_mem_nil m' h')
@@ -173,8 +170,7 @@ theorem prod_take_succ :
 
 /-- A list with product not one must have positive length. -/
 @[to_additive "A list with sum not zero must have positive length."]
-theorem length_pos_of_prod_ne_one (L : List M) (h : L.prod ≠ 1) : 0 < L.length :=
-  by
+theorem length_pos_of_prod_ne_one (L : List M) (h : L.prod ≠ 1) : 0 < L.length := by
   cases L
   · contrapose h
     simp
@@ -258,8 +254,7 @@ of `∀ a ∈ l₂, 1 ≤ a` but this lemma is not yet in `mathlib`. -/
   but this lemma is not yet in `mathlib`."]
 theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : l₁ <+ l₂)
-    (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) : l₁.prod ≤ l₂.prod :=
-  by
+    (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) : l₁.prod ≤ l₂.prod := by
   induction h
   case slnil => rfl
   case cons l₁ l₂ a _ ih' =>
@@ -290,8 +285,7 @@ theorem prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·))
 theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
     [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (f g : ι → M)
-    (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod :=
-  by
+    (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod := by
   induction' l with i l ihl
   · rcases h₂ with ⟨_, ⟨⟩, _⟩
   simp only [forall_mem_cons, exists_mem_cons, map_cons, prod_cons] at h₁ h₂⊢
@@ -319,8 +313,7 @@ theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * 
 @[to_additive exists_lt_of_sum_lt]
 theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] {l : List ι} (f g : ι → M)
-    (h : (l.map f).prod < (l.map g).prod) : ∃ i ∈ l, f i < g i :=
-  by
+    (h : (l.map f).prod < (l.map g).prod) : ∃ i ∈ l, f i < g i := by
   contrapose! h
   exact prod_le_prod' h
 #align list.exists_lt_of_prod_lt' List.exists_lt_of_prod_lt'
@@ -329,16 +322,14 @@ theorem exists_lt_of_prod_lt' [LinearOrder M] [CovariantClass M M (Function.swap
 theorem exists_le_of_prod_le' [LinearOrder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] [CovariantClass M M (Function.swap (· * ·)) (· < ·)]
     [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (hl : l ≠ []) (f g : ι → M)
-    (h : (l.map f).prod ≤ (l.map g).prod) : ∃ x ∈ l, f x ≤ g x :=
-  by
+    (h : (l.map f).prod ≤ (l.map g).prod) : ∃ x ∈ l, f x ≤ g x := by
   contrapose! h
   exact prod_lt_prod_of_ne_nil hl _ _ h
 #align list.exists_le_of_prod_le' List.exists_le_of_prod_le'
 
 @[to_additive sum_nonneg]
 theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)] {l : List M}
-    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) : 1 ≤ l.prod :=
-  by
+    (hl₁ : ∀ x ∈ l, (1 : M) ≤ x) : 1 ≤ l.prod := by
   -- We don't use `pow_card_le_prod` to avoid assumption
   -- [covariant_class M M (function.swap (*)) (≤)]
   induction' l with hd tl ih
@@ -356,8 +347,7 @@ variable [MonoidWithZero M₀]
 /-- If zero is an element of a list `L`, then `List.prod L = 0`. If the domain is a nontrivial
 monoid with zero with no divisors, then this implication becomes an `iff`, see
 `List.prod_eq_zero_iff`. -/
-theorem prod_eq_zero {L : List M₀} (h : (0 : M₀) ∈ L) : L.prod = 0 :=
-  by
+theorem prod_eq_zero {L : List M₀} (h : (0 : M₀) ∈ L) : L.prod = 0 := by
   induction' L with a L ihL
   · exact absurd h (not_mem_nil _)
   · rw [prod_cons]
@@ -426,8 +416,7 @@ theorem prod_inv : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).prod
 /-- Alternative version of `List.prod_set` when the list is over a group -/
 @[to_additive "Alternative version of `List.sum_set` when the list is over a group"]
 theorem prod_set' (L : List G) (n : ℕ) (a : G) :
-    (L.set n a).prod = L.prod * if hn : n < L.length then (L.nthLe n hn)⁻¹ * a else 1 :=
-  by
+    (L.set n a).prod = L.prod * if hn : n < L.length then (L.nthLe n hn)⁻¹ * a else 1 := by
   refine (prod_set L n a).trans ?_
   split_ifs with hn
   · rw [mul_comm _ a, mul_assoc a, prod_drop_succ L n hn, mul_comm _ (drop n L).prod, ←
@@ -449,8 +438,7 @@ theorem eq_of_prod_take_eq [LeftCancelMonoid M] {L L' : List M} (h : L.length =
 
 @[to_additive]
 theorem monotone_prod_take [CanonicallyOrderedMonoid M] (L : List M) :
-    Monotone fun i => (L.take i).prod :=
-  by
+    Monotone fun i => (L.take i).prod := by
   refine' monotone_nat_of_le_succ fun n => _
   cases' lt_or_le n L.length with h h
   · rw [prod_take_succ _ _ h]
@@ -494,8 +482,7 @@ theorem all_one_of_le_one_le_of_prod_eq_one [OrderedCommMonoid M] {l : List M}
 /-- Slightly more general version of `List.prod_eq_one_iff` for a non-ordered `Monoid` -/
 @[to_additive
       "Slightly more general version of `List.sum_eq_zero_iff` for a non-ordered `AddMonoid`"]
-theorem prod_eq_one [Monoid M] {l : List M} (hl : ∀ x ∈ l, x = (1 : M)) : l.prod = 1 :=
-  by
+theorem prod_eq_one [Monoid M] {l : List M} (hl : ∀ x ∈ l, x = (1 : M)) : l.prod = 1 := by
   induction' l with i l hil
   · rfl
   rw [List.prod_cons, hil fun x hx => hl _ (mem_cons_of_mem i hx), hl _ (mem_cons_self i l),
@@ -509,8 +496,7 @@ theorem exists_mem_ne_one_of_prod_ne_one [Monoid M] {l : List M} (h : l.prod ≠
 
 -- TODO: develop theory of tropical rings
 theorem sum_le_foldr_max [AddMonoid M] [AddMonoid N] [LinearOrder N] (f : M → N) (h0 : f 0 ≤ 0)
-    (hadd : ∀ x y, f (x + y) ≤ max (f x) (f y)) (l : List M) : f l.sum ≤ (l.map f).foldr max 0 :=
-  by
+    (hadd : ∀ x y, f (x + y) ≤ max (f x) (f y)) (l : List M) : f l.sum ≤ (l.map f).foldr max 0 := by
   induction' l with hd tl IH
   · simpa using h0
   simp only [List.sum_cons, List.foldr_map, List.foldr] at IH⊢

26f081a2

chore: tidy various files (#1595)

6fe10b88

Diff

@@ -260,7 +260,8 @@ theorem Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (
     [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : l₁ <+ l₂)
     (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) : l₁.prod ≤ l₂.prod :=
   by
-  induction h; · rfl
+  induction h
+  case slnil => rfl
   case cons l₁ l₂ a _ ih' =>
     simp only [prod_cons, forall_mem_cons] at h₁⊢
     exact (ih' h₁.2).trans (le_mul_of_one_le_left' h₁.1)
@@ -291,7 +292,8 @@ theorem prod_lt_prod' [Preorder M] [CovariantClass M M (· * ·) (· < ·)]
     [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)] {l : List ι} (f g : ι → M)
     (h₁ : ∀ i ∈ l, f i ≤ g i) (h₂ : ∃ i ∈ l, f i < g i) : (l.map f).prod < (l.map g).prod :=
   by
-  induction' l with i l ihl; · rcases h₂ with ⟨_, ⟨⟩, _⟩
+  induction' l with i l ihl
+  · rcases h₂ with ⟨_, ⟨⟩, _⟩
   simp only [forall_mem_cons, exists_mem_cons, map_cons, prod_cons] at h₁ h₂⊢
   cases h₂
   · exact mul_lt_mul_of_lt_of_le ‹_› (prod_le_prod' h₁.2)
@@ -339,7 +341,7 @@ theorem one_le_prod_of_one_le [Preorder M] [CovariantClass M M (· * ·) (· ≤
   by
   -- We don't use `pow_card_le_prod` to avoid assumption
   -- [covariant_class M M (function.swap (*)) (≤)]
-  induction' l with hd tl ih;
+  induction' l with hd tl ih
   · rfl
   rw [prod_cons]
   exact one_le_mul (hl₁ hd (mem_cons_self hd tl)) (ih fun x h => hl₁ x (mem_cons_of_mem hd h))
@@ -426,13 +428,11 @@ theorem prod_inv : ∀ L : List G, L.prod⁻¹ = (L.map fun x => x⁻¹).prod
 theorem prod_set' (L : List G) (n : ℕ) (a : G) :
     (L.set n a).prod = L.prod * if hn : n < L.length then (L.nthLe n hn)⁻¹ * a else 1 :=
   by
-  refine' (prod_set L n a).trans _
+  refine (prod_set L n a).trans ?_
   split_ifs with hn
-  ·
-    rw [mul_comm _ a, mul_assoc a, prod_drop_succ L n hn, mul_comm _ (drop n L).prod, ←
+  · rw [mul_comm _ a, mul_assoc a, prod_drop_succ L n hn, mul_comm _ (drop n L).prod, ←
       mul_assoc (take n L).prod, prod_take_mul_prod_drop, mul_comm a, mul_assoc]
-  ·
-    simp only [take_all_of_le (le_of_not_lt hn), prod_nil, mul_one,
+  · simp only [take_all_of_le (le_of_not_lt hn), prod_nil, mul_one,
       drop_eq_nil_of_le ((le_of_not_lt hn).trans n.le_succ)]
 #align list.prod_update_nth' List.prod_set'
 
@@ -581,44 +581,44 @@ section
 variable [One α] [Mul α] [Inv α]
 
 @[to_additive (attr := simp)]
-theorem alternating_prod_nil : alternatingProd ([] : List α) = 1 :=
+theorem alternatingProd_nil : alternatingProd ([] : List α) = 1 :=
   rfl
-#align list.alternating_prod_nil List.alternating_prod_nil
+#align list.alternating_prod_nil List.alternatingProd_nil
 
 @[to_additive (attr := simp)]
-theorem alternating_prod_singleton (a : α) : alternatingProd [a] = a :=
+theorem alternatingProd_singleton (a : α) : alternatingProd [a] = a :=
   rfl
-#align list.alternating_prod_singleton List.alternating_prod_singleton
+#align list.alternating_prod_singleton List.alternatingProd_singleton
 
 @[to_additive]
-theorem alternating_prod_cons_cons' (a b : α) (l : List α) :
+theorem alternatingProd_cons_cons' (a b : α) (l : List α) :
     alternatingProd (a :: b :: l) = a * b⁻¹ * alternatingProd l :=
   rfl
-#align list.alternating_prod_cons_cons' List.alternating_prod_cons_cons'
+#align list.alternating_prod_cons_cons' List.alternatingProd_cons_cons'
 
 end
 
 @[to_additive]
-theorem alternating_prod_cons_cons [DivInvMonoid α] (a b : α) (l : List α) :
+theorem alternatingProd_cons_cons [DivInvMonoid α] (a b : α) (l : List α) :
     alternatingProd (a :: b :: l) = a / b * alternatingProd l := by
-  rw [div_eq_mul_inv, alternating_prod_cons_cons']
-#align list.alternating_prod_cons_cons List.alternating_prod_cons_cons
+  rw [div_eq_mul_inv, alternatingProd_cons_cons']
+#align list.alternating_prod_cons_cons List.alternatingProd_cons_cons
 
 variable [CommGroup α]
 
 @[to_additive]
-theorem alternating_prod_cons' :
+theorem alternatingProd_cons' :
     ∀ (a : α) (l : List α), alternatingProd (a :: l) = a * (alternatingProd l)⁻¹
-  | a, [] => by rw [alternating_prod_nil, inv_one, mul_one, alternating_prod_singleton]
+  | a, [] => by rw [alternatingProd_nil, inv_one, mul_one, alternatingProd_singleton]
   | a, b :: l => by
-    rw [alternating_prod_cons_cons', alternating_prod_cons' b l, mul_inv, inv_inv, mul_assoc]
-#align list.alternating_prod_cons' List.alternating_prod_cons'
+    rw [alternatingProd_cons_cons', alternatingProd_cons' b l, mul_inv, inv_inv, mul_assoc]
+#align list.alternating_prod_cons' List.alternatingProd_cons'
 
 @[to_additive (attr := simp)]
-theorem alternating_prod_cons (a : α) (l : List α) :
+theorem alternatingProd_cons (a : α) (l : List α) :
     alternatingProd (a :: l) = a / alternatingProd l := by
-  rw [div_eq_mul_inv, alternating_prod_cons']
-#align list.alternating_prod_cons List.alternating_prod_cons
+  rw [div_eq_mul_inv, alternatingProd_cons']
+#align list.alternating_prod_cons List.alternatingProd_cons
 
 end Alternating

26f081a2

Refactor: drop List.repeat (#1579)

Mathlib 3 migrated to list.replicate in leanprover-community/mathlib#18127 (merged) and leanprover-community/mathlib#18181 (awaiting review).

75764ca4

Diff

@@ -71,17 +71,12 @@ theorem prod_eq_foldr : ∀ {l : List M}, l.prod = foldr (· * ·) 1 l
 #align list.prod_eq_foldr List.prod_eq_foldr
 
 @[to_additive (attr := simp)]
-theorem prod_replicate (a : M) (n : ℕ) : (List.replicate n a).prod = a ^ n := by
+theorem prod_replicate (n : ℕ) (a : M) : (replicate n a).prod = a ^ n := by
   induction' n with n ih
   · rw [pow_zero]
     rfl
-  · rw [List.replicate_succ, List.prod_cons, ih, pow_succ]
-
-set_option linter.deprecated false in
-/-- Deprecated: use `List.prod_replicate` instead. -/
-@[to_additive (attr := deprecated) "Deprecated: use `List.sum_replicate` instead."]
-theorem prod_repeat (a : M) (n : ℕ) : (List.repeat a n).prod = a ^ n := by simp
-#align list.prod_repeat List.prod_repeat
+  · rw [replicate_succ, prod_cons, ih, pow_succ]
+#align list.prod_replicate List.prod_replicate
 
 @[to_additive sum_eq_card_nsmul]
 theorem prod_eq_pow_card (l : List M) (m : M) (h : ∀ x ∈ l, x = m) : l.prod = m ^ l.length := by
@@ -125,23 +120,9 @@ theorem prod_map_mul {α : Type _} [CommMonoid α] {l : List ι} {f g : ι → 
 
 @[simp]
 theorem prod_map_neg {α} [CommMonoid α] [HasDistribNeg α] (l : List α) :
-    (l.map Neg.neg).prod = (-1) ^ l.length * l.prod :=
-  by
-  convert @prod_map_mul α α _ l (fun _ => -1) id
-  · ext
-    rw [neg_one_mul]
-    rfl
-  · -- Porting note: proof used to be
-    -- convert (prod_repeat _ _).symm
-    -- rw [eq_repeat]
-    -- use l.length_map _
-    -- intro
-    -- rw [mem_map]
-    -- rintro ⟨_, _, rfl⟩
-    -- rfl
-    rw [prod_eq_pow_card _ (-1:α) _, length_map]
-    simp
-  · rw [map_id]
+    (l.map Neg.neg).prod = (-1) ^ l.length * l.prod := by
+  simpa only [id_eq, neg_mul, one_mul, map_const', prod_replicate, map_id]
+    using @prod_map_mul α α _ l (fun _ => -1) id
 #align list.prod_map_neg List.prod_map_neg
 
 @[to_additive]
@@ -326,16 +307,11 @@ theorem prod_lt_prod_of_ne_nil [Preorder M] [CovariantClass M M (· * ·) (· <
     (exists_mem_of_ne_nil l hl).imp fun i hi => ⟨hi, hlt i hi⟩
 #align list.prod_lt_prod_of_ne_nil List.prod_lt_prod_of_ne_nil
 
-set_option linter.deprecated false in
 @[to_additive sum_le_card_nsmul]
 theorem prod_le_pow_card [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
     [CovariantClass M M (· * ·) (· ≤ ·)] (l : List M) (n : M) (h : ∀ x ∈ l, x ≤ n) :
     l.prod ≤ n ^ l.length := by
-      -- Porting note: proof used to be
-      -- simpa only [map_id'', map_const, prod_repeat] using prod_le_prod' h
-      have := prod_le_prod' h
-      erw [map_id'', map_const', prod_repeat] at this
-      exact this
+      simpa only [map_id'', map_const', prod_replicate] using prod_le_prod' h
 #align list.prod_le_pow_card List.prod_le_pow_card
 
 @[to_additive exists_lt_of_sum_lt]
@@ -560,10 +536,8 @@ theorem prod_map_erase [DecidableEq ι] [CommMonoid M] (f : ι → M) {a} :
         mul_left_comm (f a) (f b)]
 #align list.prod_map_erase List.prod_map_erase
 
--- Porting note: Should this not be `to_additive` of a multiplicative statement?
--- @[simp] -- Porting note: simp can prove this up to commutativity
-theorem sum_const_nat (m n : ℕ) : sum (List.replicate n m) = m * n := by
-  simp only [sum_replicate, smul_eq_mul, mul_comm]
+theorem sum_const_nat (m n : ℕ) : sum (replicate m n) = m * n :=
+  sum_replicate m n
 #align list.sum_const_nat List.sum_const_nat
 
 /-- The product of a list of positive natural numbers is positive,
@@ -584,8 +558,7 @@ If desired, we could add a class stating that `default = 0`.
 
 
 /-- This relies on `default ℕ = 0`. -/
-theorem headI_add_tail_sum (L : List ℕ) : L.headI + L.tail.sum = L.sum :=
-  by
+theorem headI_add_tail_sum (L : List ℕ) : L.headI + L.tail.sum = L.sum := by
   cases L
   · simp
   · simp

26f081a2

feat: port Data.List.BigOperators.Basic (#1380)

Initial file copy from mathport
Mathbin -> Mathlib; add import to Mathlib.lean

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

68d8ac54

`data.list.big_operators.basic` ⟷ `Mathlib.Data.List.BigOperators.Basic`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Important changes

Remaining issues

Slower (failing) search

`simp` not firing sometimes

Missing instances due to unification failing

Workaround for issues

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 2 + 86

data.list.big_operators.basic ⟷ Mathlib.Data.List.BigOperators.Basic

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Important changes

Remaining issues

Slower (failing) search

simp not firing sometimes

Missing instances due to unification failing

Workaround for issues

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Dependencies 2 + 86

`data.list.big_operators.basic` ⟷ `Mathlib.Data.List.BigOperators.Basic`

`simp` not firing sometimes