combinatorics.additive.e_transform ⟷ Mathlib.Combinatorics.Additive.ETransform

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

@@ -48,65 +48,65 @@ section CommGroup
 
 variable [CommGroup α] (e : α) (x : Finset α × Finset α)
 
-#print Finset.mulDysonEtransform /-
+#print Finset.mulDysonETransform /-
 /-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
 product of the two sets. -/
 @[to_additive
       "The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This\nreduces the sum of the two sets.",
   simps]
-def mulDysonEtransform : Finset α × Finset α :=
+def mulDysonETransform : Finset α × Finset α :=
   (x.1 ∪ e • x.2, x.2 ∩ e⁻¹ • x.1)
-#align finset.mul_dyson_e_transform Finset.mulDysonEtransform
-#align finset.add_dyson_e_transform Finset.addDysonEtransform
+#align finset.mul_dyson_e_transform Finset.mulDysonETransform
+#align finset.add_dyson_e_transform Finset.addDysonETransform
 -/
 
-#print Finset.mulDysonEtransform.subset /-
+#print Finset.mulDysonETransform.subset /-
 @[to_additive]
-theorem mulDysonEtransform.subset :
-    (mulDysonEtransform e x).1 * (mulDysonEtransform e x).2 ⊆ x.1 * x.2 :=
+theorem mulDysonETransform.subset :
+    (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2 :=
   by
   refine' union_mul_inter_subset_union.trans (union_subset subset.rfl _)
   rw [mul_smul_comm, smul_mul_assoc, inv_smul_smul, mul_comm]
   rfl
-#align finset.mul_dyson_e_transform.subset Finset.mulDysonEtransform.subset
-#align finset.add_dyson_e_transform.subset Finset.addDysonEtransform.subset
+#align finset.mul_dyson_e_transform.subset Finset.mulDysonETransform.subset
+#align finset.add_dyson_e_transform.subset Finset.addDysonETransform.subset
 -/
 
-#print Finset.mulDysonEtransform.card /-
+#print Finset.mulDysonETransform.card /-
 @[to_additive]
-theorem mulDysonEtransform.card :
-    (mulDysonEtransform e x).1.card + (mulDysonEtransform e x).2.card = x.1.card + x.2.card :=
+theorem mulDysonETransform.card :
+    (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card :=
   by
   dsimp
   rw [← card_smul_finset e (_ ∩ _), smul_finset_inter, smul_inv_smul, inter_comm,
     card_union_add_card_inter, card_smul_finset]
-#align finset.mul_dyson_e_transform.card Finset.mulDysonEtransform.card
-#align finset.add_dyson_e_transform.card Finset.addDysonEtransform.card
+#align finset.mul_dyson_e_transform.card Finset.mulDysonETransform.card
+#align finset.add_dyson_e_transform.card Finset.addDysonETransform.card
 -/
 
-#print Finset.mulDysonEtransform_idem /-
+#print Finset.mulDysonETransform_idem /-
 @[simp, to_additive]
-theorem mulDysonEtransform_idem :
-    mulDysonEtransform e (mulDysonEtransform e x) = mulDysonEtransform e x :=
+theorem mulDysonETransform_idem :
+    mulDysonETransform e (mulDysonETransform e x) = mulDysonETransform e x :=
   by
   ext : 1 <;> dsimp
   · rw [smul_finset_inter, smul_inv_smul, inter_comm, union_eq_left_iff_subset]
     exact inter_subset_union
   · rw [smul_finset_union, inv_smul_smul, union_comm, inter_eq_left_iff_subset]
     exact inter_subset_union
-#align finset.mul_dyson_e_transform_idem Finset.mulDysonEtransform_idem
-#align finset.add_dyson_e_transform_idem Finset.addDysonEtransform_idem
+#align finset.mul_dyson_e_transform_idem Finset.mulDysonETransform_idem
+#align finset.add_dyson_e_transform_idem Finset.addDysonETransform_idem
 -/
 
 variable {e x}
 
-#print Finset.mulDysonEtransform.smul_finset_snd_subset_fst /-
+#print Finset.mulDysonETransform.smul_finset_snd_subset_fst /-
 @[to_additive]
-theorem mulDysonEtransform.smul_finset_snd_subset_fst :
-    e • (mulDysonEtransform e x).2 ⊆ (mulDysonEtransform e x).1 := by dsimp;
+theorem mulDysonETransform.smul_finset_snd_subset_fst :
+    e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1 := by dsimp;
   rw [smul_finset_inter, smul_inv_smul, inter_comm]; exact inter_subset_union
-#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonEtransform.smul_finset_snd_subset_fst
-#align finset.add_dyson_e_transform.vadd_finset_snd_subset_fst Finset.addDysonEtransform.vadd_finset_snd_subset_fst
+#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonETransform.smul_finset_snd_subset_fst
+#align finset.add_dyson_e_transform.vadd_finset_snd_subset_fst Finset.addDysonETransform.vadd_finset_snd_subset_fst
 -/
 
 end CommGroup
@@ -126,98 +126,98 @@ section Group
 
 variable [Group α] (e : α) (x : Finset α × Finset α)
 
-#print Finset.mulEtransformLeft /-
+#print Finset.mulETransformLeft /-
 /-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
 product of the two sets. -/
 @[to_additive
       "An **e-transform**. Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This\nreduces the sum of the two sets.",
   simps]
-def mulEtransformLeft : Finset α × Finset α :=
+def mulETransformLeft : Finset α × Finset α :=
   (x.1 ∩ op e • x.1, x.2 ∪ e⁻¹ • x.2)
-#align finset.mul_e_transform_left Finset.mulEtransformLeft
-#align finset.add_e_transform_left Finset.addEtransformLeft
+#align finset.mul_e_transform_left Finset.mulETransformLeft
+#align finset.add_e_transform_left Finset.addETransformLeft
 -/
 
-#print Finset.mulEtransformRight /-
+#print Finset.mulETransformRight /-
 /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the product of
 the two sets. -/
 @[to_additive
       "An **e-transform**. Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the\nsum of the two sets.",
   simps]
-def mulEtransformRight : Finset α × Finset α :=
+def mulETransformRight : Finset α × Finset α :=
   (x.1 ∪ op e • x.1, x.2 ∩ e⁻¹ • x.2)
-#align finset.mul_e_transform_right Finset.mulEtransformRight
-#align finset.add_e_transform_right Finset.addEtransformRight
+#align finset.mul_e_transform_right Finset.mulETransformRight
+#align finset.add_e_transform_right Finset.addETransformRight
 -/
 
-#print Finset.mulEtransformLeft_one /-
+#print Finset.mulETransformLeft_one /-
 @[simp, to_additive]
-theorem mulEtransformLeft_one : mulEtransformLeft 1 x = x := by simp [mul_e_transform_left]
-#align finset.mul_e_transform_left_one Finset.mulEtransformLeft_one
-#align finset.add_e_transform_left_zero Finset.addEtransformLeft_zero
+theorem mulETransformLeft_one : mulETransformLeft 1 x = x := by simp [mul_e_transform_left]
+#align finset.mul_e_transform_left_one Finset.mulETransformLeft_one
+#align finset.add_e_transform_left_zero Finset.addETransformLeft_zero
 -/
 
-#print Finset.mulEtransformRight_one /-
+#print Finset.mulETransformRight_one /-
 @[simp, to_additive]
-theorem mulEtransformRight_one : mulEtransformRight 1 x = x := by simp [mul_e_transform_right]
-#align finset.mul_e_transform_right_one Finset.mulEtransformRight_one
-#align finset.add_e_transform_right_zero Finset.addEtransformRight_zero
+theorem mulETransformRight_one : mulETransformRight 1 x = x := by simp [mul_e_transform_right]
+#align finset.mul_e_transform_right_one Finset.mulETransformRight_one
+#align finset.add_e_transform_right_zero Finset.addETransformRight_zero
 -/
 
-#print Finset.mulEtransformLeft.fst_mul_snd_subset /-
+#print Finset.mulETransformLeft.fst_mul_snd_subset /-
 @[to_additive]
-theorem mulEtransformLeft.fst_mul_snd_subset :
-    (mulEtransformLeft e x).1 * (mulEtransformLeft e x).2 ⊆ x.1 * x.2 :=
+theorem mulETransformLeft.fst_mul_snd_subset :
+    (mulETransformLeft e x).1 * (mulETransformLeft e x).2 ⊆ x.1 * x.2 :=
   by
   refine' inter_mul_union_subset_union.trans (union_subset subset.rfl _)
   rw [op_smul_finset_mul_eq_mul_smul_finset, smul_inv_smul]
   rfl
-#align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulEtransformLeft.fst_mul_snd_subset
-#align finset.add_e_transform_left.fst_add_snd_subset Finset.addEtransformLeft.fst_add_snd_subset
+#align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulETransformLeft.fst_mul_snd_subset
+#align finset.add_e_transform_left.fst_add_snd_subset Finset.addETransformLeft.fst_add_snd_subset
 -/
 
-#print Finset.mulEtransformRight.fst_mul_snd_subset /-
+#print Finset.mulETransformRight.fst_mul_snd_subset /-
 @[to_additive]
-theorem mulEtransformRight.fst_mul_snd_subset :
-    (mulEtransformRight e x).1 * (mulEtransformRight e x).2 ⊆ x.1 * x.2 :=
+theorem mulETransformRight.fst_mul_snd_subset :
+    (mulETransformRight e x).1 * (mulETransformRight e x).2 ⊆ x.1 * x.2 :=
   by
   refine' union_mul_inter_subset_union.trans (union_subset subset.rfl _)
   rw [op_smul_finset_mul_eq_mul_smul_finset, smul_inv_smul]
   rfl
-#align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulEtransformRight.fst_mul_snd_subset
-#align finset.add_e_transform_right.fst_add_snd_subset Finset.addEtransformRight.fst_add_snd_subset
+#align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulETransformRight.fst_mul_snd_subset
+#align finset.add_e_transform_right.fst_add_snd_subset Finset.addETransformRight.fst_add_snd_subset
 -/
 
-#print Finset.mulEtransformLeft.card /-
+#print Finset.mulETransformLeft.card /-
 @[to_additive]
-theorem mulEtransformLeft.card :
-    (mulEtransformLeft e x).1.card + (mulEtransformRight e x).1.card = 2 * x.1.card :=
+theorem mulETransformLeft.card :
+    (mulETransformLeft e x).1.card + (mulETransformRight e x).1.card = 2 * x.1.card :=
   (card_inter_add_card_union _ _).trans <| by rw [card_smul_finset, two_mul]
-#align finset.mul_e_transform_left.card Finset.mulEtransformLeft.card
-#align finset.add_e_transform_left.card Finset.addEtransformLeft.card
+#align finset.mul_e_transform_left.card Finset.mulETransformLeft.card
+#align finset.add_e_transform_left.card Finset.addETransformLeft.card
 -/
 
-#print Finset.mulEtransformRight.card /-
+#print Finset.mulETransformRight.card /-
 @[to_additive]
-theorem mulEtransformRight.card :
-    (mulEtransformLeft e x).2.card + (mulEtransformRight e x).2.card = 2 * x.2.card :=
+theorem mulETransformRight.card :
+    (mulETransformLeft e x).2.card + (mulETransformRight e x).2.card = 2 * x.2.card :=
   (card_union_add_card_inter _ _).trans <| by rw [card_smul_finset, two_mul]
-#align finset.mul_e_transform_right.card Finset.mulEtransformRight.card
-#align finset.add_e_transform_right.card Finset.addEtransformRight.card
+#align finset.mul_e_transform_right.card Finset.mulETransformRight.card
+#align finset.add_e_transform_right.card Finset.addETransformRight.card
 -/
 
-#print Finset.MulEtransform.card /-
+#print Finset.MulETransform.card /-
 /-- This statement is meant to be combined with `le_or_lt_of_add_le_add` and similar lemmas. -/
 @[to_additive AddETransform.card
       "This statement is meant to be combined with\n`le_or_lt_of_add_le_add` and similar lemmas."]
-protected theorem MulEtransform.card :
-    (mulEtransformLeft e x).1.card + (mulEtransformLeft e x).2.card +
-        ((mulEtransformRight e x).1.card + (mulEtransformRight e x).2.card) =
+protected theorem MulETransform.card :
+    (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
+        ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
       x.1.card + x.2.card + (x.1.card + x.2.card) :=
   by
   rw [add_add_add_comm, mul_e_transform_left.card, mul_e_transform_right.card, ← mul_add, two_mul]
-#align finset.mul_e_transform.card Finset.MulEtransform.card
-#align finset.add_e_transform.card Finset.AddEtransform.card
+#align finset.mul_e_transform.card Finset.MulETransform.card
+#align finset.add_e_transform.card Finset.AddETransform.card
 -/
 
 end Group
@@ -226,20 +226,20 @@ section CommGroup
 
 variable [CommGroup α] (e : α) (x : Finset α × Finset α)
 
-#print Finset.mulEtransformLeft_inv /-
+#print Finset.mulETransformLeft_inv /-
 @[simp, to_additive]
-theorem mulEtransformLeft_inv : mulEtransformLeft e⁻¹ x = (mulEtransformRight e x.symm).symm := by
+theorem mulETransformLeft_inv : mulETransformLeft e⁻¹ x = (mulETransformRight e x.symm).symm := by
   simp [-op_inv, op_smul_eq_smul, mul_e_transform_left, mul_e_transform_right]
-#align finset.mul_e_transform_left_inv Finset.mulEtransformLeft_inv
-#align finset.add_e_transform_left_neg Finset.addEtransformLeft_neg
+#align finset.mul_e_transform_left_inv Finset.mulETransformLeft_inv
+#align finset.add_e_transform_left_neg Finset.addETransformLeft_neg
 -/
 
-#print Finset.mulEtransformRight_inv /-
+#print Finset.mulETransformRight_inv /-
 @[simp, to_additive]
-theorem mulEtransformRight_inv : mulEtransformRight e⁻¹ x = (mulEtransformLeft e x.symm).symm := by
+theorem mulETransformRight_inv : mulETransformRight e⁻¹ x = (mulETransformLeft e x.symm).symm := by
   simp [-op_inv, op_smul_eq_smul, mul_e_transform_left, mul_e_transform_right]
-#align finset.mul_e_transform_right_inv Finset.mulEtransformRight_inv
-#align finset.add_e_transform_right_neg Finset.addEtransformRight_neg
+#align finset.mul_e_transform_right_inv Finset.mulETransformRight_inv
+#align finset.add_e_transform_right_neg Finset.addETransformRight_neg
 -/
 
 end CommGroup

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

@@ -3,7 +3,7 @@ Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathbin.Data.Finset.Pointwise
+import Data.Finset.Pointwise
 
 #align_import combinatorics.additive.e_transform from "leanprover-community/mathlib"@"d64d67d000b974f0d86a2be7918cf800be6271c8"
 

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

@@ -2,14 +2,11 @@
 Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module combinatorics.additive.e_transform
-! leanprover-community/mathlib commit d64d67d000b974f0d86a2be7918cf800be6271c8
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Finset.Pointwise
 
+#align_import combinatorics.additive.e_transform from "leanprover-community/mathlib"@"d64d67d000b974f0d86a2be7918cf800be6271c8"
+
 /-!
 # e-transforms
 

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

@@ -63,6 +63,7 @@ def mulDysonEtransform : Finset α × Finset α :=
 #align finset.add_dyson_e_transform Finset.addDysonEtransform
 -/
 
+#print Finset.mulDysonEtransform.subset /-
 @[to_additive]
 theorem mulDysonEtransform.subset :
     (mulDysonEtransform e x).1 * (mulDysonEtransform e x).2 ⊆ x.1 * x.2 :=
@@ -72,6 +73,7 @@ theorem mulDysonEtransform.subset :
   rfl
 #align finset.mul_dyson_e_transform.subset Finset.mulDysonEtransform.subset
 #align finset.add_dyson_e_transform.subset Finset.addDysonEtransform.subset
+-/
 
 #print Finset.mulDysonEtransform.card /-
 @[to_additive]
@@ -101,12 +103,14 @@ theorem mulDysonEtransform_idem :
 
 variable {e x}
 
+#print Finset.mulDysonEtransform.smul_finset_snd_subset_fst /-
 @[to_additive]
 theorem mulDysonEtransform.smul_finset_snd_subset_fst :
     e • (mulDysonEtransform e x).2 ⊆ (mulDysonEtransform e x).1 := by dsimp;
   rw [smul_finset_inter, smul_inv_smul, inter_comm]; exact inter_subset_union
 #align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonEtransform.smul_finset_snd_subset_fst
 #align finset.add_dyson_e_transform.vadd_finset_snd_subset_fst Finset.addDysonEtransform.vadd_finset_snd_subset_fst
+-/
 
 end CommGroup
 
@@ -149,16 +153,21 @@ def mulEtransformRight : Finset α × Finset α :=
 #align finset.add_e_transform_right Finset.addEtransformRight
 -/
 
+#print Finset.mulEtransformLeft_one /-
 @[simp, to_additive]
 theorem mulEtransformLeft_one : mulEtransformLeft 1 x = x := by simp [mul_e_transform_left]
 #align finset.mul_e_transform_left_one Finset.mulEtransformLeft_one
 #align finset.add_e_transform_left_zero Finset.addEtransformLeft_zero
+-/
 
+#print Finset.mulEtransformRight_one /-
 @[simp, to_additive]
 theorem mulEtransformRight_one : mulEtransformRight 1 x = x := by simp [mul_e_transform_right]
 #align finset.mul_e_transform_right_one Finset.mulEtransformRight_one
 #align finset.add_e_transform_right_zero Finset.addEtransformRight_zero
+-/
 
+#print Finset.mulEtransformLeft.fst_mul_snd_subset /-
 @[to_additive]
 theorem mulEtransformLeft.fst_mul_snd_subset :
     (mulEtransformLeft e x).1 * (mulEtransformLeft e x).2 ⊆ x.1 * x.2 :=
@@ -168,7 +177,9 @@ theorem mulEtransformLeft.fst_mul_snd_subset :
   rfl
 #align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulEtransformLeft.fst_mul_snd_subset
 #align finset.add_e_transform_left.fst_add_snd_subset Finset.addEtransformLeft.fst_add_snd_subset
+-/
 
+#print Finset.mulEtransformRight.fst_mul_snd_subset /-
 @[to_additive]
 theorem mulEtransformRight.fst_mul_snd_subset :
     (mulEtransformRight e x).1 * (mulEtransformRight e x).2 ⊆ x.1 * x.2 :=
@@ -178,6 +189,7 @@ theorem mulEtransformRight.fst_mul_snd_subset :
   rfl
 #align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulEtransformRight.fst_mul_snd_subset
 #align finset.add_e_transform_right.fst_add_snd_subset Finset.addEtransformRight.fst_add_snd_subset
+-/
 
 #print Finset.mulEtransformLeft.card /-
 @[to_additive]
@@ -217,17 +229,21 @@ section CommGroup
 
 variable [CommGroup α] (e : α) (x : Finset α × Finset α)
 
+#print Finset.mulEtransformLeft_inv /-
 @[simp, to_additive]
 theorem mulEtransformLeft_inv : mulEtransformLeft e⁻¹ x = (mulEtransformRight e x.symm).symm := by
   simp [-op_inv, op_smul_eq_smul, mul_e_transform_left, mul_e_transform_right]
 #align finset.mul_e_transform_left_inv Finset.mulEtransformLeft_inv
 #align finset.add_e_transform_left_neg Finset.addEtransformLeft_neg
+-/
 
+#print Finset.mulEtransformRight_inv /-
 @[simp, to_additive]
 theorem mulEtransformRight_inv : mulEtransformRight e⁻¹ x = (mulEtransformLeft e x.symm).symm := by
   simp [-op_inv, op_smul_eq_smul, mul_e_transform_left, mul_e_transform_right]
 #align finset.mul_e_transform_right_inv Finset.mulEtransformRight_inv
 #align finset.add_e_transform_right_neg Finset.addEtransformRight_neg
+-/
 
 end CommGroup
 

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

@@ -38,7 +38,7 @@ Prove the invariance property of the Dyson e-transform.
 
 open MulOpposite
 
-open Pointwise
+open scoped Pointwise
 
 variable {α : Type _} [DecidableEq α]
 

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

@@ -63,12 +63,6 @@ def mulDysonEtransform : Finset α × Finset α :=
 #align finset.add_dyson_e_transform Finset.addDysonEtransform
 -/
 
-/- warning: finset.mul_dyson_e_transform.subset -> Finset.mulDysonEtransform.subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
-Case conversion may be inaccurate. Consider using '#align finset.mul_dyson_e_transform.subset Finset.mulDysonEtransform.subsetₓ'. -/
 @[to_additive]
 theorem mulDysonEtransform.subset :
     (mulDysonEtransform e x).1 * (mulDysonEtransform e x).2 ⊆ x.1 * x.2 :=
@@ -107,12 +101,6 @@ theorem mulDysonEtransform_idem :
 
 variable {e x}
 
-/- warning: finset.mul_dyson_e_transform.smul_finset_snd_subset_fst -> Finset.mulDysonEtransform.smul_finset_snd_subset_fst is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] {e : α} {x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)}, HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) (SMul.smul.{u1, u1} α (Finset.{u1} α) (Finset.smulFinset.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) (Mul.toSMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) e (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] {e : α} {x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)}, HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) (HSMul.hSMul.{u1, u1, u1} α (Finset.{u1} α) (Finset.{u1} α) (instHSMul.{u1, u1} α (Finset.{u1} α) (Finset.smulFinset.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) (MulAction.toSMul.{u1, u1} α α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) e (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))
-Case conversion may be inaccurate. Consider using '#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonEtransform.smul_finset_snd_subset_fstₓ'. -/
 @[to_additive]
 theorem mulDysonEtransform.smul_finset_snd_subset_fst :
     e • (mulDysonEtransform e x).2 ⊆ (mulDysonEtransform e x).1 := by dsimp;
@@ -161,34 +149,16 @@ def mulEtransformRight : Finset α × Finset α :=
 #align finset.add_e_transform_right Finset.addEtransformRight
 -/
 
-/- warning: finset.mul_e_transform_left_one -> Finset.mulEtransformLeft_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2))))))) x) x
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_2)))))) x) x
-Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_left_one Finset.mulEtransformLeft_oneₓ'. -/
 @[simp, to_additive]
 theorem mulEtransformLeft_one : mulEtransformLeft 1 x = x := by simp [mul_e_transform_left]
 #align finset.mul_e_transform_left_one Finset.mulEtransformLeft_one
 #align finset.add_e_transform_left_zero Finset.addEtransformLeft_zero
 
-/- warning: finset.mul_e_transform_right_one -> Finset.mulEtransformRight_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2))))))) x) x
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_2)))))) x) x
-Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_right_one Finset.mulEtransformRight_oneₓ'. -/
 @[simp, to_additive]
 theorem mulEtransformRight_one : mulEtransformRight 1 x = x := by simp [mul_e_transform_right]
 #align finset.mul_e_transform_right_one Finset.mulEtransformRight_one
 #align finset.add_e_transform_right_zero Finset.addEtransformRight_zero
 
-/- warning: finset.mul_e_transform_left.fst_mul_snd_subset -> Finset.mulEtransformLeft.fst_mul_snd_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
-Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulEtransformLeft.fst_mul_snd_subsetₓ'. -/
 @[to_additive]
 theorem mulEtransformLeft.fst_mul_snd_subset :
     (mulEtransformLeft e x).1 * (mulEtransformLeft e x).2 ⊆ x.1 * x.2 :=
@@ -199,12 +169,6 @@ theorem mulEtransformLeft.fst_mul_snd_subset :
 #align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulEtransformLeft.fst_mul_snd_subset
 #align finset.add_e_transform_left.fst_add_snd_subset Finset.addEtransformLeft.fst_add_snd_subset
 
-/- warning: finset.mul_e_transform_right.fst_mul_snd_subset -> Finset.mulEtransformRight.fst_mul_snd_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
-Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulEtransformRight.fst_mul_snd_subsetₓ'. -/
 @[to_additive]
 theorem mulEtransformRight.fst_mul_snd_subset :
     (mulEtransformRight e x).1 * (mulEtransformRight e x).2 ⊆ x.1 * x.2 :=
@@ -253,24 +217,12 @@ section CommGroup
 
 variable [CommGroup α] (e : α) (x : Finset α × Finset α)
 
-/- warning: finset.mul_e_transform_left_inv -> Finset.mulEtransformLeft_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))) e) x) (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) e (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_2))))) e) x) (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) e (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x)))
-Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_left_inv Finset.mulEtransformLeft_invₓ'. -/
 @[simp, to_additive]
 theorem mulEtransformLeft_inv : mulEtransformLeft e⁻¹ x = (mulEtransformRight e x.symm).symm := by
   simp [-op_inv, op_smul_eq_smul, mul_e_transform_left, mul_e_transform_right]
 #align finset.mul_e_transform_left_inv Finset.mulEtransformLeft_inv
 #align finset.add_e_transform_left_neg Finset.addEtransformLeft_neg
 
-/- warning: finset.mul_e_transform_right_inv -> Finset.mulEtransformRight_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))) e) x) (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) e (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_2))))) e) x) (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) e (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x)))
-Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_right_inv Finset.mulEtransformRight_invₓ'. -/
 @[simp, to_additive]
 theorem mulEtransformRight_inv : mulEtransformRight e⁻¹ x = (mulEtransformLeft e x.symm).symm := by
   simp [-op_inv, op_smul_eq_smul, mul_e_transform_left, mul_e_transform_right]

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

@@ -115,11 +115,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonEtransform.smul_finset_snd_subset_fstₓ'. -/
 @[to_additive]
 theorem mulDysonEtransform.smul_finset_snd_subset_fst :
-    e • (mulDysonEtransform e x).2 ⊆ (mulDysonEtransform e x).1 :=
-  by
-  dsimp
-  rw [smul_finset_inter, smul_inv_smul, inter_comm]
-  exact inter_subset_union
+    e • (mulDysonEtransform e x).2 ⊆ (mulDysonEtransform e x).1 := by dsimp;
+  rw [smul_finset_inter, smul_inv_smul, inter_comm]; exact inter_subset_union
 #align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonEtransform.smul_finset_snd_subset_fst
 #align finset.add_dyson_e_transform.vadd_finset_snd_subset_fst Finset.addDysonEtransform.vadd_finset_snd_subset_fst
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/06a655b5fcfbda03502f9158bbf6c0f1400886f9

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 
 ! This file was ported from Lean 3 source module combinatorics.additive.e_transform
-! leanprover-community/mathlib commit 207c92594599a06e7c134f8d00a030a83e6c7259
+! leanprover-community/mathlib commit d64d67d000b974f0d86a2be7918cf800be6271c8
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Data.Finset.Pointwise
 /-!
 # e-transforms
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 e-transforms are a family of transformations of pairs of finite sets that aim to reduce the size
 of the sumset while keeping some invariant the same. This file defines a few of them, to be used
 as internals of other proofs.

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

@@ -48,59 +48,77 @@ section CommGroup
 
 variable [CommGroup α] (e : α) (x : Finset α × Finset α)
 
+#print Finset.mulDysonEtransform /-
 /-- The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e • t, t ∩ e⁻¹ • s)`. This reduces the
 product of the two sets. -/
 @[to_additive
       "The **Dyson e-transform**. Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This\nreduces the sum of the two sets.",
   simps]
-def mulDysonETransform : Finset α × Finset α :=
+def mulDysonEtransform : Finset α × Finset α :=
   (x.1 ∪ e • x.2, x.2 ∩ e⁻¹ • x.1)
-#align finset.mul_dyson_e_transform Finset.mulDysonETransform
-#align finset.add_dyson_e_transform Finset.addDysonETransform
+#align finset.mul_dyson_e_transform Finset.mulDysonEtransform
+#align finset.add_dyson_e_transform Finset.addDysonEtransform
+-/
 
+/- warning: finset.mul_dyson_e_transform.subset -> Finset.mulDysonEtransform.subset is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
+Case conversion may be inaccurate. Consider using '#align finset.mul_dyson_e_transform.subset Finset.mulDysonEtransform.subsetₓ'. -/
 @[to_additive]
-theorem mulDysonETransform.subset :
-    (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2 :=
+theorem mulDysonEtransform.subset :
+    (mulDysonEtransform e x).1 * (mulDysonEtransform e x).2 ⊆ x.1 * x.2 :=
   by
   refine' union_mul_inter_subset_union.trans (union_subset subset.rfl _)
   rw [mul_smul_comm, smul_mul_assoc, inv_smul_smul, mul_comm]
   rfl
-#align finset.mul_dyson_e_transform.subset Finset.mulDysonETransform.subset
-#align finset.add_dyson_e_transform.subset Finset.addDysonETransform.subset
+#align finset.mul_dyson_e_transform.subset Finset.mulDysonEtransform.subset
+#align finset.add_dyson_e_transform.subset Finset.addDysonEtransform.subset
 
+#print Finset.mulDysonEtransform.card /-
 @[to_additive]
-theorem mulDysonETransform.card :
-    (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card :=
+theorem mulDysonEtransform.card :
+    (mulDysonEtransform e x).1.card + (mulDysonEtransform e x).2.card = x.1.card + x.2.card :=
   by
   dsimp
   rw [← card_smul_finset e (_ ∩ _), smul_finset_inter, smul_inv_smul, inter_comm,
     card_union_add_card_inter, card_smul_finset]
-#align finset.mul_dyson_e_transform.card Finset.mulDysonETransform.card
-#align finset.add_dyson_e_transform.card Finset.addDysonETransform.card
+#align finset.mul_dyson_e_transform.card Finset.mulDysonEtransform.card
+#align finset.add_dyson_e_transform.card Finset.addDysonEtransform.card
+-/
 
+#print Finset.mulDysonEtransform_idem /-
 @[simp, to_additive]
-theorem mulDysonETransform_idem :
-    mulDysonETransform e (mulDysonETransform e x) = mulDysonETransform e x :=
+theorem mulDysonEtransform_idem :
+    mulDysonEtransform e (mulDysonEtransform e x) = mulDysonEtransform e x :=
   by
   ext : 1 <;> dsimp
   · rw [smul_finset_inter, smul_inv_smul, inter_comm, union_eq_left_iff_subset]
     exact inter_subset_union
   · rw [smul_finset_union, inv_smul_smul, union_comm, inter_eq_left_iff_subset]
     exact inter_subset_union
-#align finset.mul_dyson_e_transform_idem Finset.mulDysonETransform_idem
-#align finset.add_dyson_e_transform_idem Finset.add_dyson_e_transform_idem
+#align finset.mul_dyson_e_transform_idem Finset.mulDysonEtransform_idem
+#align finset.add_dyson_e_transform_idem Finset.addDysonEtransform_idem
+-/
 
 variable {e x}
 
+/- warning: finset.mul_dyson_e_transform.smul_finset_snd_subset_fst -> Finset.mulDysonEtransform.smul_finset_snd_subset_fst is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] {e : α} {x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)}, HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) (SMul.smul.{u1, u1} α (Finset.{u1} α) (Finset.smulFinset.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) (Mul.toSMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) e (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] {e : α} {x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)}, HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) (HSMul.hSMul.{u1, u1, u1} α (Finset.{u1} α) (Finset.{u1} α) (instHSMul.{u1, u1} α (Finset.{u1} α) (Finset.smulFinset.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) (MulAction.toSMul.{u1, u1} α α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))))))) e (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulDysonEtransform.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))
+Case conversion may be inaccurate. Consider using '#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonEtransform.smul_finset_snd_subset_fstₓ'. -/
 @[to_additive]
-theorem mulDysonETransform.smul_finset_snd_subset_fst :
-    e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1 :=
+theorem mulDysonEtransform.smul_finset_snd_subset_fst :
+    e • (mulDysonEtransform e x).2 ⊆ (mulDysonEtransform e x).1 :=
   by
   dsimp
   rw [smul_finset_inter, smul_inv_smul, inter_comm]
   exact inter_subset_union
-#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonETransform.smul_finset_snd_subset_fst
-#align finset.add_dyson_e_transform.vadd_finset_snd_subset_fst Finset.addDysonETransform.vadd_finset_snd_subset_fst
+#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonEtransform.smul_finset_snd_subset_fst
+#align finset.add_dyson_e_transform.vadd_finset_snd_subset_fst Finset.addDysonEtransform.vadd_finset_snd_subset_fst
 
 end CommGroup
 
@@ -119,81 +137,115 @@ section Group
 
 variable [Group α] (e : α) (x : Finset α × Finset α)
 
+#print Finset.mulEtransformLeft /-
 /-- An **e-transform**. Turns `(s, t)` into `(s ∩ s • e, t ∪ e⁻¹ • t)`. This reduces the
 product of the two sets. -/
 @[to_additive
       "An **e-transform**. Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This\nreduces the sum of the two sets.",
   simps]
-def mulETransformLeft : Finset α × Finset α :=
+def mulEtransformLeft : Finset α × Finset α :=
   (x.1 ∩ op e • x.1, x.2 ∪ e⁻¹ • x.2)
-#align finset.mul_e_transform_left Finset.mulETransformLeft
-#align finset.add_e_transform_left Finset.addETransformLeft
+#align finset.mul_e_transform_left Finset.mulEtransformLeft
+#align finset.add_e_transform_left Finset.addEtransformLeft
+-/
 
+#print Finset.mulEtransformRight /-
 /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the product of
 the two sets. -/
 @[to_additive
       "An **e-transform**. Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the\nsum of the two sets.",
   simps]
-def mulETransformRight : Finset α × Finset α :=
+def mulEtransformRight : Finset α × Finset α :=
   (x.1 ∪ op e • x.1, x.2 ∩ e⁻¹ • x.2)
-#align finset.mul_e_transform_right Finset.mulETransformRight
-#align finset.add_e_transform_right Finset.addETransformRight
+#align finset.mul_e_transform_right Finset.mulEtransformRight
+#align finset.add_e_transform_right Finset.addEtransformRight
+-/
 
+/- warning: finset.mul_e_transform_left_one -> Finset.mulEtransformLeft_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2))))))) x) x
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_2)))))) x) x
+Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_left_one Finset.mulEtransformLeft_oneₓ'. -/
 @[simp, to_additive]
-theorem mulETransformLeft_one : mulETransformLeft 1 x = x := by simp [mul_e_transform_left]
-#align finset.mul_e_transform_left_one Finset.mulETransformLeft_one
-#align finset.add_e_transform_left_zero Finset.add_e_transform_left_zero
-
+theorem mulEtransformLeft_one : mulEtransformLeft 1 x = x := by simp [mul_e_transform_left]
+#align finset.mul_e_transform_left_one Finset.mulEtransformLeft_one
+#align finset.add_e_transform_left_zero Finset.addEtransformLeft_zero
+
+/- warning: finset.mul_e_transform_right_one -> Finset.mulEtransformRight_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2))))))) x) x
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_2)))))) x) x
+Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_right_one Finset.mulEtransformRight_oneₓ'. -/
 @[simp, to_additive]
-theorem mulETransformRight_one : mulETransformRight 1 x = x := by simp [mul_e_transform_right]
-#align finset.mul_e_transform_right_one Finset.mulETransformRight_one
-#align finset.add_e_transform_right_zero Finset.add_e_transform_right_zero
-
+theorem mulEtransformRight_one : mulEtransformRight 1 x = x := by simp [mul_e_transform_right]
+#align finset.mul_e_transform_right_one Finset.mulEtransformRight_one
+#align finset.add_e_transform_right_zero Finset.addEtransformRight_zero
+
+/- warning: finset.mul_e_transform_left.fst_mul_snd_subset -> Finset.mulEtransformLeft.fst_mul_snd_subset is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
+Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulEtransformLeft.fst_mul_snd_subsetₓ'. -/
 @[to_additive]
-theorem mulETransformLeft.fst_mul_snd_subset :
-    (mulETransformLeft e x).1 * (mulETransformLeft e x).2 ⊆ x.1 * x.2 :=
+theorem mulEtransformLeft.fst_mul_snd_subset :
+    (mulEtransformLeft e x).1 * (mulEtransformLeft e x).2 ⊆ x.1 * x.2 :=
   by
   refine' inter_mul_union_subset_union.trans (union_subset subset.rfl _)
   rw [op_smul_finset_mul_eq_mul_smul_finset, smul_inv_smul]
   rfl
-#align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulETransformLeft.fst_mul_snd_subset
-#align finset.add_e_transform_left.fst_add_snd_subset Finset.addETransformLeft.fst_add_snd_subset
-
+#align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulEtransformLeft.fst_mul_snd_subset
+#align finset.add_e_transform_left.fst_add_snd_subset Finset.addEtransformLeft.fst_add_snd_subset
+
+/- warning: finset.mul_e_transform_right.fst_mul_snd_subset -> Finset.mulEtransformRight.fst_mul_snd_subset is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Group.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x)) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 e x))) (HMul.hMul.{u1, u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.{u1} α) (instHMul.{u1} (Finset.{u1} α) (Finset.mul.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_2)))))) (Prod.fst.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x) (Prod.snd.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x))
+Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulEtransformRight.fst_mul_snd_subsetₓ'. -/
 @[to_additive]
-theorem mulETransformRight.fst_mul_snd_subset :
-    (mulETransformRight e x).1 * (mulETransformRight e x).2 ⊆ x.1 * x.2 :=
+theorem mulEtransformRight.fst_mul_snd_subset :
+    (mulEtransformRight e x).1 * (mulEtransformRight e x).2 ⊆ x.1 * x.2 :=
   by
   refine' union_mul_inter_subset_union.trans (union_subset subset.rfl _)
   rw [op_smul_finset_mul_eq_mul_smul_finset, smul_inv_smul]
   rfl
-#align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulETransformRight.fst_mul_snd_subset
-#align finset.add_e_transform_right.fst_add_snd_subset Finset.addETransformRight.fst_add_snd_subset
+#align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulEtransformRight.fst_mul_snd_subset
+#align finset.add_e_transform_right.fst_add_snd_subset Finset.addEtransformRight.fst_add_snd_subset
 
+#print Finset.mulEtransformLeft.card /-
 @[to_additive]
-theorem mulETransformLeft.card :
-    (mulETransformLeft e x).1.card + (mulETransformRight e x).1.card = 2 * x.1.card :=
+theorem mulEtransformLeft.card :
+    (mulEtransformLeft e x).1.card + (mulEtransformRight e x).1.card = 2 * x.1.card :=
   (card_inter_add_card_union _ _).trans <| by rw [card_smul_finset, two_mul]
-#align finset.mul_e_transform_left.card Finset.mulETransformLeft.card
-#align finset.add_e_transform_left.card Finset.addETransformLeft.card
+#align finset.mul_e_transform_left.card Finset.mulEtransformLeft.card
+#align finset.add_e_transform_left.card Finset.addEtransformLeft.card
+-/
 
+#print Finset.mulEtransformRight.card /-
 @[to_additive]
-theorem mulETransformRight.card :
-    (mulETransformLeft e x).2.card + (mulETransformRight e x).2.card = 2 * x.2.card :=
+theorem mulEtransformRight.card :
+    (mulEtransformLeft e x).2.card + (mulEtransformRight e x).2.card = 2 * x.2.card :=
   (card_union_add_card_inter _ _).trans <| by rw [card_smul_finset, two_mul]
-#align finset.mul_e_transform_right.card Finset.mulETransformRight.card
-#align finset.add_e_transform_right.card Finset.addETransformRight.card
+#align finset.mul_e_transform_right.card Finset.mulEtransformRight.card
+#align finset.add_e_transform_right.card Finset.addEtransformRight.card
+-/
 
+#print Finset.MulEtransform.card /-
 /-- This statement is meant to be combined with `le_or_lt_of_add_le_add` and similar lemmas. -/
 @[to_additive AddETransform.card
       "This statement is meant to be combined with\n`le_or_lt_of_add_le_add` and similar lemmas."]
-protected theorem MulETransform.card :
-    (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
-        ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
+protected theorem MulEtransform.card :
+    (mulEtransformLeft e x).1.card + (mulEtransformLeft e x).2.card +
+        ((mulEtransformRight e x).1.card + (mulEtransformRight e x).2.card) =
       x.1.card + x.2.card + (x.1.card + x.2.card) :=
   by
   rw [add_add_add_comm, mul_e_transform_left.card, mul_e_transform_right.card, ← mul_add, two_mul]
-#align finset.mul_e_transform.card Finset.MulETransform.card
-#align add_e_transform.card AddETransform.card
+#align finset.mul_e_transform.card Finset.MulEtransform.card
+#align finset.add_e_transform.card Finset.AddEtransform.card
+-/
 
 end Group
 
@@ -201,17 +253,29 @@ section CommGroup
 
 variable [CommGroup α] (e : α) (x : Finset α × Finset α)
 
+/- warning: finset.mul_e_transform_left_inv -> Finset.mulEtransformLeft_inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))) e) x) (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) e (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_2))))) e) x) (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) e (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x)))
+Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_left_inv Finset.mulEtransformLeft_invₓ'. -/
 @[simp, to_additive]
-theorem mulETransformLeft_inv : mulETransformLeft e⁻¹ x = (mulETransformRight e x.symm).symm := by
+theorem mulEtransformLeft_inv : mulEtransformLeft e⁻¹ x = (mulEtransformRight e x.symm).symm := by
   simp [-op_inv, op_smul_eq_smul, mul_e_transform_left, mul_e_transform_right]
-#align finset.mul_e_transform_left_inv Finset.mulETransformLeft_inv
-#align finset.add_e_transform_left_neg Finset.add_e_transform_left_neg
-
+#align finset.mul_e_transform_left_inv Finset.mulEtransformLeft_inv
+#align finset.add_e_transform_left_neg Finset.addEtransformLeft_neg
+
+/- warning: finset.mul_e_transform_right_inv -> Finset.mulEtransformRight_inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_2))) e) x) (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) e (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : CommGroup.{u1} α] (e : α) (x : Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)), Eq.{succ u1} (Prod.{u1, u1} (Finset.{u1} α) (Finset.{u1} α)) (Finset.mulEtransformRight.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_2))))) e) x) (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) (Finset.mulEtransformLeft.{u1} α (fun (a : α) (b : α) => _inst_1 a b) (CommGroup.toGroup.{u1} α _inst_2) e (Prod.swap.{u1, u1} (Finset.{u1} α) (Finset.{u1} α) x)))
+Case conversion may be inaccurate. Consider using '#align finset.mul_e_transform_right_inv Finset.mulEtransformRight_invₓ'. -/
 @[simp, to_additive]
-theorem mulETransformRight_inv : mulETransformRight e⁻¹ x = (mulETransformLeft e x.symm).symm := by
+theorem mulEtransformRight_inv : mulEtransformRight e⁻¹ x = (mulEtransformLeft e x.symm).symm := by
   simp [-op_inv, op_smul_eq_smul, mul_e_transform_left, mul_e_transform_right]
-#align finset.mul_e_transform_right_inv Finset.mulETransformRight_inv
-#align finset.add_e_transform_right_neg Finset.add_e_transform_right_neg
+#align finset.mul_e_transform_right_inv Finset.mulEtransformRight_inv
+#align finset.add_e_transform_right_neg Finset.addEtransformRight_neg
 
 end CommGroup
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/88fcb83fe7996142dfcfe7368d31304a9adc874a

Everything was wrong here.

@@ -16,11 +16,11 @@ as internals of other proofs.
 
 ## Main declarations
 
-* `Finset.mulDysonEtransform`: The Dyson e-transform. Replaces `(s, t)` by
+* `Finset.mulDysonETransform`: The Dyson e-transform. Replaces `(s, t)` by
   `(s ∪ e • t, t ∩ e⁻¹ • s)`. The additive version preserves `|s ∩ [1, m]| + |t ∩ [1, m - e]|`.
-* `Finset.mulEtransformLeft`/`Finset.mulEtransformRight`: Replace `(s, t)` by
+* `Finset.mulETransformLeft`/`Finset.mulETransformRight`: Replace `(s, t)` by
   `(s ∩ s • e, t ∪ e⁻¹ • t)` and `(s ∪ s • e, t ∩ e⁻¹ • t)`. Preserve (together) the sum of
-  the cardinalities (see `Finset.MulEtransform.card`). In particular, one of the two transforms
+  the cardinalities (see `Finset.MulETransform.card`). In particular, one of the two transforms
   increases the sum of the cardinalities and the other one decreases it. See
   `le_or_lt_of_add_le_add` and around.
 
@@ -49,49 +49,49 @@ variable [CommGroup α] (e : α) (x : Finset α × Finset α)
 product of the two sets. -/
 @[to_additive (attr := simps) "The **Dyson e-transform**.
 Turns `(s, t)` into `(s ∪ e +ᵥ t, t ∩ -e +ᵥ s)`. This reduces the sum of the two sets."]
-def mulDysonEtransform : Finset α × Finset α :=
+def mulDysonETransform : Finset α × Finset α :=
   (x.1 ∪ e • x.2, x.2 ∩ e⁻¹ • x.1)
-#align finset.mul_dyson_e_transform Finset.mulDysonEtransform
-#align finset.add_dyson_e_transform Finset.addDysonEtransform
+#align finset.mul_dyson_e_transform Finset.mulDysonETransform
+#align finset.add_dyson_e_transform Finset.addDysonETransform
 
 @[to_additive]
-theorem mulDysonEtransform.subset :
-    (mulDysonEtransform e x).1 * (mulDysonEtransform e x).2 ⊆ x.1 * x.2 := by
+theorem mulDysonETransform.subset :
+    (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2 := by
   refine' union_mul_inter_subset_union.trans (union_subset Subset.rfl _)
   rw [mul_smul_comm, smul_mul_assoc, inv_smul_smul, mul_comm]
-#align finset.mul_dyson_e_transform.subset Finset.mulDysonEtransform.subset
-#align finset.add_dyson_e_transform.subset Finset.addDysonEtransform.subset
+#align finset.mul_dyson_e_transform.subset Finset.mulDysonETransform.subset
+#align finset.add_dyson_e_transform.subset Finset.addDysonETransform.subset
 
 @[to_additive]
-theorem mulDysonEtransform.card :
-    (mulDysonEtransform e x).1.card + (mulDysonEtransform e x).2.card = x.1.card + x.2.card := by
+theorem mulDysonETransform.card :
+    (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card := by
   dsimp
   rw [← card_smul_finset e (_ ∩ _), smul_finset_inter, smul_inv_smul, inter_comm,
     card_union_add_card_inter, card_smul_finset]
-#align finset.mul_dyson_e_transform.card Finset.mulDysonEtransform.card
-#align finset.add_dyson_e_transform.card Finset.addDysonEtransform.card
+#align finset.mul_dyson_e_transform.card Finset.mulDysonETransform.card
+#align finset.add_dyson_e_transform.card Finset.addDysonETransform.card
 
 @[to_additive (attr := simp)]
-theorem mulDysonEtransform_idem :
-    mulDysonEtransform e (mulDysonEtransform e x) = mulDysonEtransform e x := by
+theorem mulDysonETransform_idem :
+    mulDysonETransform e (mulDysonETransform e x) = mulDysonETransform e x := by
   ext : 1 <;> dsimp
   · rw [smul_finset_inter, smul_inv_smul, inter_comm, union_eq_left]
     exact inter_subset_union
   · rw [smul_finset_union, inv_smul_smul, union_comm, inter_eq_left]
     exact inter_subset_union
-#align finset.mul_dyson_e_transform_idem Finset.mulDysonEtransform_idem
-#align finset.add_dyson_e_transform_idem Finset.addDysonEtransform_idem
+#align finset.mul_dyson_e_transform_idem Finset.mulDysonETransform_idem
+#align finset.add_dyson_e_transform_idem Finset.addDysonETransform_idem
 
 variable {e x}
 
 @[to_additive]
-theorem mulDysonEtransform.smul_finset_snd_subset_fst :
-    e • (mulDysonEtransform e x).2 ⊆ (mulDysonEtransform e x).1 := by
+theorem mulDysonETransform.smul_finset_snd_subset_fst :
+    e • (mulDysonETransform e x).2 ⊆ (mulDysonETransform e x).1 := by
   dsimp
   rw [smul_finset_inter, smul_inv_smul, inter_comm]
   exact inter_subset_union
-#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonEtransform.smul_finset_snd_subset_fst
-#align finset.add_dyson_e_transform.vadd_finset_snd_subset_fst Finset.addDysonEtransform.vadd_finset_snd_subset_fst
+#align finset.mul_dyson_e_transform.smul_finset_snd_subset_fst Finset.mulDysonETransform.smul_finset_snd_subset_fst
+#align finset.add_dyson_e_transform.vadd_finset_snd_subset_fst Finset.addDysonETransform.vadd_finset_snd_subset_fst
 
 end CommGroup
 
@@ -114,70 +114,70 @@ variable [Group α] (e : α) (x : Finset α × Finset α)
 product of the two sets. -/
 @[to_additive (attr := simps) "An **e-transform**.
 Turns `(s, t)` into `(s ∩ s +ᵥ e, t ∪ -e +ᵥ t)`. This reduces the sum of the two sets."]
-def mulEtransformLeft : Finset α × Finset α :=
+def mulETransformLeft : Finset α × Finset α :=
   (x.1 ∩ op e • x.1, x.2 ∪ e⁻¹ • x.2)
-#align finset.mul_e_transform_left Finset.mulEtransformLeft
-#align finset.add_e_transform_left Finset.addEtransformLeft
+#align finset.mul_e_transform_left Finset.mulETransformLeft
+#align finset.add_e_transform_left Finset.addETransformLeft
 
 /-- An **e-transform**. Turns `(s, t)` into `(s ∪ s • e, t ∩ e⁻¹ • t)`. This reduces the
 product of the two sets. -/
 @[to_additive (attr := simps) "An **e-transform**.
 Turns `(s, t)` into `(s ∪ s +ᵥ e, t ∩ -e +ᵥ t)`. This reduces the sum of the two sets."]
-def mulEtransformRight : Finset α × Finset α :=
+def mulETransformRight : Finset α × Finset α :=
   (x.1 ∪ op e • x.1, x.2 ∩ e⁻¹ • x.2)
-#align finset.mul_e_transform_right Finset.mulEtransformRight
-#align finset.add_e_transform_right Finset.addEtransformRight
+#align finset.mul_e_transform_right Finset.mulETransformRight
+#align finset.add_e_transform_right Finset.addETransformRight
 
 @[to_additive (attr := simp)]
-theorem mulEtransformLeft_one : mulEtransformLeft 1 x = x := by simp [mulEtransformLeft]
-#align finset.mul_e_transform_left_one Finset.mulEtransformLeft_one
-#align finset.add_e_transform_left_zero Finset.addEtransformLeft_zero
+theorem mulETransformLeft_one : mulETransformLeft 1 x = x := by simp [mulETransformLeft]
+#align finset.mul_e_transform_left_one Finset.mulETransformLeft_one
+#align finset.add_e_transform_left_zero Finset.addETransformLeft_zero
 
 @[to_additive (attr := simp)]
-theorem mulEtransformRight_one : mulEtransformRight 1 x = x := by simp [mulEtransformRight]
-#align finset.mul_e_transform_right_one Finset.mulEtransformRight_one
-#align finset.add_e_transform_right_zero Finset.addEtransformRight_zero
+theorem mulETransformRight_one : mulETransformRight 1 x = x := by simp [mulETransformRight]
+#align finset.mul_e_transform_right_one Finset.mulETransformRight_one
+#align finset.add_e_transform_right_zero Finset.addETransformRight_zero
 
 @[to_additive]
-theorem mulEtransformLeft.fst_mul_snd_subset :
-    (mulEtransformLeft e x).1 * (mulEtransformLeft e x).2 ⊆ x.1 * x.2 := by
+theorem mulETransformLeft.fst_mul_snd_subset :
+    (mulETransformLeft e x).1 * (mulETransformLeft e x).2 ⊆ x.1 * x.2 := by
   refine' inter_mul_union_subset_union.trans (union_subset Subset.rfl _)
   rw [op_smul_finset_mul_eq_mul_smul_finset, smul_inv_smul]
-#align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulEtransformLeft.fst_mul_snd_subset
-#align finset.add_e_transform_left.fst_add_snd_subset Finset.addEtransformLeft.fst_add_snd_subset
+#align finset.mul_e_transform_left.fst_mul_snd_subset Finset.mulETransformLeft.fst_mul_snd_subset
+#align finset.add_e_transform_left.fst_add_snd_subset Finset.addETransformLeft.fst_add_snd_subset
 
 @[to_additive]
-theorem mulEtransformRight.fst_mul_snd_subset :
-    (mulEtransformRight e x).1 * (mulEtransformRight e x).2 ⊆ x.1 * x.2 := by
+theorem mulETransformRight.fst_mul_snd_subset :
+    (mulETransformRight e x).1 * (mulETransformRight e x).2 ⊆ x.1 * x.2 := by
   refine' union_mul_inter_subset_union.trans (union_subset Subset.rfl _)
   rw [op_smul_finset_mul_eq_mul_smul_finset, smul_inv_smul]
-#align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulEtransformRight.fst_mul_snd_subset
-#align finset.add_e_transform_right.fst_add_snd_subset Finset.addEtransformRight.fst_add_snd_subset
+#align finset.mul_e_transform_right.fst_mul_snd_subset Finset.mulETransformRight.fst_mul_snd_subset
+#align finset.add_e_transform_right.fst_add_snd_subset Finset.addETransformRight.fst_add_snd_subset
 
 @[to_additive]
-theorem mulEtransformLeft.card :
-    (mulEtransformLeft e x).1.card + (mulEtransformRight e x).1.card = 2 * x.1.card :=
+theorem mulETransformLeft.card :
+    (mulETransformLeft e x).1.card + (mulETransformRight e x).1.card = 2 * x.1.card :=
   (card_inter_add_card_union _ _).trans <| by rw [card_smul_finset, two_mul]
-#align finset.mul_e_transform_left.card Finset.mulEtransformLeft.card
-#align finset.add_e_transform_left.card Finset.addEtransformLeft.card
+#align finset.mul_e_transform_left.card Finset.mulETransformLeft.card
+#align finset.add_e_transform_left.card Finset.addETransformLeft.card
 
 @[to_additive]
-theorem mulEtransformRight.card :
-    (mulEtransformLeft e x).2.card + (mulEtransformRight e x).2.card = 2 * x.2.card :=
+theorem mulETransformRight.card :
+    (mulETransformLeft e x).2.card + (mulETransformRight e x).2.card = 2 * x.2.card :=
   (card_union_add_card_inter _ _).trans <| by rw [card_smul_finset, two_mul]
-#align finset.mul_e_transform_right.card Finset.mulEtransformRight.card
-#align finset.add_e_transform_right.card Finset.addEtransformRight.card
+#align finset.mul_e_transform_right.card Finset.mulETransformRight.card
+#align finset.add_e_transform_right.card Finset.addETransformRight.card
 
 /-- This statement is meant to be combined with `le_or_lt_of_add_le_add` and similar lemmas. -/
-@[to_additive AddEtransform.card "This statement is meant to be combined with
+@[to_additive AddETransform.card "This statement is meant to be combined with
 `le_or_lt_of_add_le_add` and similar lemmas."]
-protected theorem MulEtransform.card :
-    (mulEtransformLeft e x).1.card + (mulEtransformLeft e x).2.card +
-        ((mulEtransformRight e x).1.card + (mulEtransformRight e x).2.card) =
+protected theorem MulETransform.card :
+    (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
+        ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
       x.1.card + x.2.card + (x.1.card + x.2.card) := by
-  rw [add_add_add_comm, mulEtransformLeft.card, mulEtransformRight.card, ← mul_add, two_mul]
-#align finset.mul_e_transform.card Finset.MulEtransform.card
-#align finset.add_e_transform.card Finset.AddEtransform.card
+  rw [add_add_add_comm, mulETransformLeft.card, mulETransformRight.card, ← mul_add, two_mul]
+#align finset.mul_e_transform.card Finset.MulETransform.card
+#align finset.add_e_transform.card Finset.AddETransform.card
 
 end Group
 
@@ -186,16 +186,16 @@ section CommGroup
 variable [CommGroup α] (e : α) (x : Finset α × Finset α)
 
 @[to_additive (attr := simp)]
-theorem mulEtransformLeft_inv : mulEtransformLeft e⁻¹ x = (mulEtransformRight e x.swap).swap := by
-  simp [-op_inv, op_smul_eq_smul, mulEtransformLeft, mulEtransformRight]
-#align finset.mul_e_transform_left_inv Finset.mulEtransformLeft_inv
-#align finset.add_e_transform_left_neg Finset.addEtransformLeft_neg
+theorem mulETransformLeft_inv : mulETransformLeft e⁻¹ x = (mulETransformRight e x.swap).swap := by
+  simp [-op_inv, op_smul_eq_smul, mulETransformLeft, mulETransformRight]
+#align finset.mul_e_transform_left_inv Finset.mulETransformLeft_inv
+#align finset.add_e_transform_left_neg Finset.addETransformLeft_neg
 
 @[to_additive (attr := simp)]
-theorem mulEtransformRight_inv : mulEtransformRight e⁻¹ x = (mulEtransformLeft e x.swap).swap := by
-  simp [-op_inv, op_smul_eq_smul, mulEtransformLeft, mulEtransformRight]
-#align finset.mul_e_transform_right_inv Finset.mulEtransformRight_inv
-#align finset.add_e_transform_right_neg Finset.addEtransformRight_neg
+theorem mulETransformRight_inv : mulETransformRight e⁻¹ x = (mulETransformLeft e x.swap).swap := by
+  simp [-op_inv, op_smul_eq_smul, mulETransformLeft, mulETransformRight]
+#align finset.mul_e_transform_right_inv Finset.mulETransformRight_inv
+#align finset.add_e_transform_right_neg Finset.addETransformRight_neg
 
 end CommGroup
 

Rename union_eq_left_iff_subset to union_eq_left to match sup_eq_left. Similarly for the right and inter versions.

@@ -75,9 +75,9 @@ theorem mulDysonEtransform.card :
 theorem mulDysonEtransform_idem :
     mulDysonEtransform e (mulDysonEtransform e x) = mulDysonEtransform e x := by
   ext : 1 <;> dsimp
-  · rw [smul_finset_inter, smul_inv_smul, inter_comm, union_eq_left_iff_subset]
+  · rw [smul_finset_inter, smul_inv_smul, inter_comm, union_eq_left]
     exact inter_subset_union
-  · rw [smul_finset_union, inv_smul_smul, union_comm, inter_eq_left_iff_subset]
+  · rw [smul_finset_union, inv_smul_smul, union_comm, inter_eq_left]
     exact inter_subset_union
 #align finset.mul_dyson_e_transform_idem Finset.mulDysonEtransform_idem
 #align finset.add_dyson_e_transform_idem Finset.addDysonEtransform_idem

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

This has nice performance benefits.

@@ -34,7 +34,7 @@ open MulOpposite
 
 open Pointwise
 
-variable {α : Type _} [DecidableEq α]
+variable {α : Type*} [DecidableEq α]
 
 namespace Finset
 

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module combinatorics.additive.e_transform
-! leanprover-community/mathlib commit 207c92594599a06e7c134f8d00a030a83e6c7259
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Finset.Pointwise
 
+#align_import combinatorics.additive.e_transform from "leanprover-community/mathlib"@"207c92594599a06e7c134f8d00a030a83e6c7259"
+
 /-!
 # e-transforms
 

Co-authored-by: Yaël Dillies <yael.dillies@gmail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>