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

@@ -3,7 +3,7 @@ Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Thomas Browning
 -/
-import Algebra.Hom.GroupAction
+import GroupTheory.GroupAction.Hom
 import Data.Fintype.BigOperators
 import Dynamics.PeriodicPts
 import GroupTheory.GroupAction.ConjAct

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

@@ -302,7 +302,18 @@ noncomputable def selfEquivSigmaOrbitsQuotientStabilizer' {φ : Ω → β}
       "**Class formula** for a finite group acting on a finite type. See\n`add_action.card_eq_sum_card_add_group_div_card_stabilizer` for a specialized version using\n`quotient.out'`."]
 theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [Fintype Ω]
     [∀ b : β, Fintype <| stabilizer α b] {φ : Ω → β} (hφ : LeftInverse Quotient.mk'' φ) :
-    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) := by classical
+    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) := by
+  classical
+  have :
+    ∀ ω : Ω,
+      Fintype.card α / Fintype.card ↥(stabilizer α (φ ω)) = Fintype.card (α ⧸ stabilizer α (φ ω)) :=
+    by
+    intro ω
+    rw [Fintype.card_congr (@Subgroup.groupEquivQuotientProdSubgroup α _ (stabilizer α <| φ ω)),
+      Fintype.card_prod, Nat.mul_div_cancel]
+    exact fintype.card_pos_iff.mpr (by infer_instance)
+  simp_rw [this, ← Fintype.card_sigma,
+    Fintype.card_congr (self_equiv_sigma_orbits_quotient_stabilizer' α β hφ)]
 #align mul_action.card_eq_sum_card_group_div_card_stabilizer' MulAction.card_eq_sum_card_group_div_card_stabilizer'
 #align add_action.card_eq_sum_card_add_group_sub_card_stabilizer' AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer'
 -/

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

@@ -302,18 +302,7 @@ noncomputable def selfEquivSigmaOrbitsQuotientStabilizer' {φ : Ω → β}
       "**Class formula** for a finite group acting on a finite type. See\n`add_action.card_eq_sum_card_add_group_div_card_stabilizer` for a specialized version using\n`quotient.out'`."]
 theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [Fintype Ω]
     [∀ b : β, Fintype <| stabilizer α b] {φ : Ω → β} (hφ : LeftInverse Quotient.mk'' φ) :
-    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) := by
-  classical
-  have :
-    ∀ ω : Ω,
-      Fintype.card α / Fintype.card ↥(stabilizer α (φ ω)) = Fintype.card (α ⧸ stabilizer α (φ ω)) :=
-    by
-    intro ω
-    rw [Fintype.card_congr (@Subgroup.groupEquivQuotientProdSubgroup α _ (stabilizer α <| φ ω)),
-      Fintype.card_prod, Nat.mul_div_cancel]
-    exact fintype.card_pos_iff.mpr (by infer_instance)
-  simp_rw [this, ← Fintype.card_sigma,
-    Fintype.card_congr (self_equiv_sigma_orbits_quotient_stabilizer' α β hφ)]
+    Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) := by classical
 #align mul_action.card_eq_sum_card_group_div_card_stabilizer' MulAction.card_eq_sum_card_group_div_card_stabilizer'
 #align add_action.card_eq_sum_card_add_group_sub_card_stabilizer' AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer'
 -/

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

@@ -70,7 +70,7 @@ instance left_quotientAction : QuotientAction α H :=
 
 #print MulAction.right_quotientAction /-
 @[to_additive]
-instance right_quotientAction : QuotientAction H.normalizer.opposite H :=
+instance right_quotientAction : QuotientAction H.normalizer.opEquiv H :=
   ⟨fun b c _ _ => by
     rwa [smul_def, smul_def, smul_eq_mul_unop, smul_eq_mul_unop, mul_inv_rev, ← mul_assoc,
       mem_normalizer_iff'.mp b.prop, mul_assoc, mul_inv_cancel_left]⟩

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

@@ -3,12 +3,12 @@ Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Thomas Browning
 -/
-import Mathbin.Algebra.Hom.GroupAction
-import Mathbin.Data.Fintype.BigOperators
-import Mathbin.Dynamics.PeriodicPts
-import Mathbin.GroupTheory.GroupAction.ConjAct
-import Mathbin.GroupTheory.Commutator
-import Mathbin.GroupTheory.Coset
+import Algebra.Hom.GroupAction
+import Data.Fintype.BigOperators
+import Dynamics.PeriodicPts
+import GroupTheory.GroupAction.ConjAct
+import GroupTheory.Commutator
+import GroupTheory.Coset
 
 #align_import group_theory.group_action.quotient from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"
 

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

@@ -46,7 +46,7 @@ variable (β) [Monoid β] [MulAction β α] (H : Subgroup α)
 #print MulAction.QuotientAction /-
 /-- A typeclass for when a `mul_action β α` descends to the quotient `α ⧸ H`. -/
 class QuotientAction : Prop where
-  inv_mul_mem : ∀ (b : β) {a a' : α}, a⁻¹ * a' ∈ H → (b • a)⁻¹ * b • a' ∈ H
+  inv_hMul_mem : ∀ (b : β) {a a' : α}, a⁻¹ * a' ∈ H → (b • a)⁻¹ * b • a' ∈ H
 #align mul_action.quotient_action MulAction.QuotientAction
 -/
 
@@ -54,7 +54,7 @@ class QuotientAction : Prop where
 /-- A typeclass for when an `add_action β α` descends to the quotient `α ⧸ H`. -/
 class AddAction.QuotientAction {α : Type _} (β : Type _) [AddGroup α] [AddMonoid β] [AddAction β α]
     (H : AddSubgroup α) : Prop where
-  inv_mul_mem : ∀ (b : β) {a a' : α}, -a + a' ∈ H → -(b +ᵥ a) + (b +ᵥ a') ∈ H
+  inv_hMul_mem : ∀ (b : β) {a a' : α}, -a + a' ∈ H → -(b +ᵥ a) + (b +ᵥ a') ∈ H
 #align add_action.quotient_action AddAction.QuotientAction
 -/
 
@@ -94,9 +94,9 @@ instance quotient [QuotientAction β H] : MulAction β (α ⧸ H)
     where
   smul b :=
     Quotient.map' ((· • ·) b) fun a a' h =>
-      leftRel_apply.mpr <| QuotientAction.inv_mul_mem b <| leftRel_apply.mp h
+      leftRel_apply.mpr <| QuotientAction.inv_hMul_mem b <| leftRel_apply.mp h
   one_smul q := Quotient.inductionOn' q fun a => congr_arg Quotient.mk'' (one_smul β a)
-  mul_smul b b' q := Quotient.inductionOn' q fun a => congr_arg Quotient.mk'' (mul_smul b b' a)
+  hMul_smul b b' q := Quotient.inductionOn' q fun a => congr_arg Quotient.mk'' (hMul_smul b b' a)
 #align mul_action.quotient MulAction.quotient
 #align add_action.quotient AddAction.quotient
 -/
@@ -204,7 +204,7 @@ theorem ofQuotientStabilizer_mem_orbit (g) : ofQuotientStabilizer α x g ∈ orb
 @[to_additive]
 theorem ofQuotientStabilizer_smul (g : α) (g' : α ⧸ MulAction.stabilizer α x) :
     ofQuotientStabilizer α x (g • g') = g • ofQuotientStabilizer α x g' :=
-  Quotient.inductionOn' g' fun _ => mul_smul _ _ _
+  Quotient.inductionOn' g' fun _ => hMul_smul _ _ _
 #align mul_action.of_quotient_stabilizer_smul MulAction.ofQuotientStabilizer_smul
 #align add_action.of_quotient_stabilizer_vadd AddAction.ofQuotientStabilizer_vadd
 -/

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

@@ -10,7 +10,7 @@ import Mathbin.GroupTheory.GroupAction.ConjAct
 import Mathbin.GroupTheory.Commutator
 import Mathbin.GroupTheory.Coset
 
-#align_import group_theory.group_action.quotient from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
+#align_import group_theory.group_action.quotient from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"
 
 /-!
 # Properties of group actions involving quotient groups
@@ -421,7 +421,7 @@ open QuotientGroup
 #print Subgroup.quotientCentralizerEmbedding /-
 /-- Cosets of the centralizer of an element embed into the set of commutators. -/
 noncomputable def quotientCentralizerEmbedding (g : G) :
-    G ⧸ centralizer (zpowers (g : G)) ↪ commutatorSet G :=
+    G ⧸ centralizer (zpowers (g : G) : Set G) ↪ commutatorSet G :=
   ((MulAction.orbitEquivQuotientStabilizer (ConjAct G) g).trans
             (quotientEquivOfEq (ConjAct.stabilizer_eq_centralizer g))).symm.toEmbedding.trans
     ⟨fun x =>

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

@@ -2,11 +2,6 @@
 Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Thomas Browning
-
-! This file was ported from Lean 3 source module group_theory.group_action.quotient
-! leanprover-community/mathlib commit 34ee86e6a59d911a8e4f89b68793ee7577ae79c7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Hom.GroupAction
 import Mathbin.Data.Fintype.BigOperators
@@ -15,6 +10,8 @@ import Mathbin.GroupTheory.GroupAction.ConjAct
 import Mathbin.GroupTheory.Commutator
 import Mathbin.GroupTheory.Coset
 
+#align_import group_theory.group_action.quotient from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
+
 /-!
 # Properties of group actions involving quotient groups
 

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

@@ -71,6 +71,7 @@ instance left_quotientAction : QuotientAction α H :=
 #align add_action.left_quotient_action AddAction.left_quotientAction
 -/
 
+#print MulAction.right_quotientAction /-
 @[to_additive]
 instance right_quotientAction : QuotientAction H.normalizer.opposite H :=
   ⟨fun b c _ _ => by
@@ -78,6 +79,7 @@ instance right_quotientAction : QuotientAction H.normalizer.opposite H :=
       mem_normalizer_iff'.mp b.prop, mul_assoc, mul_inv_cancel_left]⟩
 #align mul_action.right_quotient_action MulAction.right_quotientAction
 #align add_action.right_quotient_action AddAction.right_quotientAction
+-/
 
 #print MulAction.right_quotientAction' /-
 @[to_additive]
@@ -137,20 +139,24 @@ theorem Quotient.coe_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) : 
 #align add_action.quotient.coe_vadd_out' AddAction.Quotient.coe_vadd_out'
 -/
 
+#print QuotientGroup.out'_conj_pow_minimalPeriod_mem /-
 theorem QuotientGroup.out'_conj_pow_minimalPeriod_mem (a : α) (q : α ⧸ H) :
     q.out'⁻¹ * a ^ Function.minimalPeriod ((· • ·) a) q * q.out' ∈ H := by
   rw [mul_assoc, ← QuotientGroup.eq', QuotientGroup.out_eq', ← smul_eq_mul, quotient.mk_smul_out',
     eq_comm, pow_smul_eq_iff_minimal_period_dvd]
 #align quotient_group.out'_conj_pow_minimal_period_mem QuotientGroup.out'_conj_pow_minimalPeriod_mem
+-/
 
 end QuotientAction
 
 open QuotientGroup
 
+#print MulActionHom.toQuotient /-
 /-- The canonical map to the left cosets. -/
 def MulActionHom.toQuotient (H : Subgroup α) : α →[α] α ⧸ H :=
   ⟨coe, Quotient.smul_coe H⟩
 #align mul_action_hom.to_quotient MulActionHom.toQuotient
+-/
 
 #print MulActionHom.toQuotient_apply /-
 @[simp]
@@ -159,11 +165,13 @@ theorem MulActionHom.toQuotient_apply (H : Subgroup α) (g : α) : MulActionHom.
 #align mul_action_hom.to_quotient_apply MulActionHom.toQuotient_apply
 -/
 
+#print MulAction.mulLeftCosetsCompSubtypeVal /-
 @[to_additive]
 instance mulLeftCosetsCompSubtypeVal (H I : Subgroup α) : MulAction I (α ⧸ H) :=
   MulAction.compHom (α ⧸ H) (Subgroup.subtype I)
 #align mul_action.mul_left_cosets_comp_subtype_val MulAction.mulLeftCosetsCompSubtypeVal
 #align add_action.add_left_cosets_comp_subtype_val AddAction.addLeftCosetsCompSubtypeVal
+-/
 
 variable (α) {β} [MulAction α β] (x : β)
 
@@ -227,6 +235,7 @@ noncomputable def orbitEquivQuotientStabilizer (b : β) : orbit α b ≃ α ⧸
 #align add_action.orbit_equiv_quotient_stabilizer AddAction.orbitEquivQuotientStabilizer
 -/
 
+#print MulAction.orbitProdStabilizerEquivGroup /-
 /-- Orbit-stabilizer theorem. -/
 @[to_additive "Orbit-stabilizer theorem."]
 noncomputable def orbitProdStabilizerEquivGroup (b : β) : orbit α b × stabilizer α b ≃ α :=
@@ -234,7 +243,9 @@ noncomputable def orbitProdStabilizerEquivGroup (b : β) : orbit α b × stabili
     Subgroup.groupEquivQuotientProdSubgroup.symm
 #align mul_action.orbit_prod_stabilizer_equiv_group MulAction.orbitProdStabilizerEquivGroup
 #align add_action.orbit_sum_stabilizer_equiv_add_group AddAction.orbitSumStabilizerEquivAddGroup
+-/
 
+#print MulAction.card_orbit_mul_card_stabilizer_eq_card_group /-
 /-- Orbit-stabilizer theorem. -/
 @[to_additive "Orbit-stabilizer theorem."]
 theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fintype <| orbit α b]
@@ -243,23 +254,27 @@ theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fint
   rw [← Fintype.card_prod, Fintype.card_congr (orbit_prod_stabilizer_equiv_group α b)]
 #align mul_action.card_orbit_mul_card_stabilizer_eq_card_group MulAction.card_orbit_mul_card_stabilizer_eq_card_group
 #align add_action.card_orbit_add_card_stabilizer_eq_card_add_group AddAction.card_orbit_add_card_stabilizer_eq_card_addGroup
+-/
 
+#print MulAction.orbitEquivQuotientStabilizer_symm_apply /-
 @[simp, to_additive]
 theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :
     ((orbitEquivQuotientStabilizer α b).symm a : β) = a • b :=
   rfl
 #align mul_action.orbit_equiv_quotient_stabilizer_symm_apply MulAction.orbitEquivQuotientStabilizer_symm_apply
 #align add_action.orbit_equiv_quotient_stabilizer_symm_apply AddAction.orbitEquivQuotientStabilizer_symm_apply
+-/
 
+#print MulAction.stabilizer_quotient /-
 @[simp, to_additive]
 theorem stabilizer_quotient {G} [Group G] (H : Subgroup G) :
     MulAction.stabilizer G ((1 : G) : G ⧸ H) = H := by ext; simp [QuotientGroup.eq]
 #align mul_action.stabilizer_quotient MulAction.stabilizer_quotient
 #align add_action.stabilizer_quotient AddAction.stabilizer_quotient
+-/
 
 variable (β)
 
--- mathport name: exprΩ
 local notation "Ω" => Quotient <| orbitRel α β
 
 #print MulAction.selfEquivSigmaOrbitsQuotientStabilizer' /-
@@ -282,6 +297,7 @@ noncomputable def selfEquivSigmaOrbitsQuotientStabilizer' {φ : Ω → β}
 #align add_action.self_equiv_sigma_orbits_quotient_stabilizer' AddAction.selfEquivSigmaOrbitsQuotientStabilizer'
 -/
 
+#print MulAction.card_eq_sum_card_group_div_card_stabilizer' /-
 /-- **Class formula** for a finite group acting on a finite type. See
 `mul_action.card_eq_sum_card_group_div_card_stabilizer` for a specialized version using
 `quotient.out'`. -/
@@ -303,6 +319,7 @@ theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [F
     Fintype.card_congr (self_equiv_sigma_orbits_quotient_stabilizer' α β hφ)]
 #align mul_action.card_eq_sum_card_group_div_card_stabilizer' MulAction.card_eq_sum_card_group_div_card_stabilizer'
 #align add_action.card_eq_sum_card_add_group_sub_card_stabilizer' AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer'
+-/
 
 #print MulAction.selfEquivSigmaOrbitsQuotientStabilizer /-
 /-- **Class formula**. This is a special case of
@@ -315,6 +332,7 @@ noncomputable def selfEquivSigmaOrbitsQuotientStabilizer : β ≃ Σ ω : Ω, α
 #align add_action.self_equiv_sigma_orbits_quotient_stabilizer AddAction.selfEquivSigmaOrbitsQuotientStabilizer
 -/
 
+#print MulAction.card_eq_sum_card_group_div_card_stabilizer /-
 /-- **Class formula** for a finite group acting on a finite type. -/
 @[to_additive "**Class formula** for a finite group acting on a finite type."]
 theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fintype Ω]
@@ -323,6 +341,7 @@ theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fi
   card_eq_sum_card_group_div_card_stabilizer' α β Quotient.out_eq'
 #align mul_action.card_eq_sum_card_group_div_card_stabilizer MulAction.card_eq_sum_card_group_div_card_stabilizer
 #align add_action.card_eq_sum_card_add_group_sub_card_stabilizer AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer
+-/
 
 #print MulAction.sigmaFixedByEquivOrbitsProdGroup /-
 /-- **Burnside's lemma** : a (noncomputable) bijection between the disjoint union of all
@@ -423,6 +442,7 @@ theorem quotientCentralizerEmbedding_apply (g : G) (x : G) :
 #align subgroup.quotient_centralizer_embedding_apply Subgroup.quotientCentralizerEmbedding_apply
 -/
 
+#print Subgroup.quotientCenterEmbedding /-
 /-- If `G` is generated by `S`, then the quotient by the center embeds into `S`-indexed sequences
 of commutators. -/
 noncomputable def quotientCenterEmbedding {S : Set G} (hS : closure S = ⊤) :
@@ -431,11 +451,14 @@ noncomputable def quotientCenterEmbedding {S : Set G} (hS : closure S = ⊤) :
     ((quotientiInfEmbedding _).trans
       (Function.Embedding.piCongrRight fun g => quotientCentralizerEmbedding g))
 #align subgroup.quotient_center_embedding Subgroup.quotientCenterEmbedding
+-/
 
+#print Subgroup.quotientCenterEmbedding_apply /-
 theorem quotientCenterEmbedding_apply {S : Set G} (hS : closure S = ⊤) (g : G) (s : S) :
     quotientCenterEmbedding hS g s = ⟨⁅g, s⁆, g, s, rfl⟩ :=
   rfl
 #align subgroup.quotient_center_embedding_apply Subgroup.quotientCenterEmbedding_apply
+-/
 
 end Subgroup
 

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

@@ -359,7 +359,7 @@ elements fixed by each `g ∈ G` is the number of orbits. -/
 @[to_additive
       "**Burnside's lemma** : given a finite additive group `G` acting on a set `X`,\nthe average number of elements fixed by each `g ∈ G` is the number of orbits. "]
 theorem sum_card_fixedBy_eq_card_orbits_mul_card_group [Fintype α] [∀ a, Fintype <| fixedBy α β a]
-    [Fintype Ω] : (∑ a : α, Fintype.card (fixedBy α β a)) = Fintype.card Ω * Fintype.card α := by
+    [Fintype Ω] : ∑ a : α, Fintype.card (fixedBy α β a) = Fintype.card Ω * Fintype.card α := by
   rw [← Fintype.card_prod, ← Fintype.card_sigma,
     Fintype.card_congr (sigma_fixed_by_equiv_orbits_prod_group α β)]
 #align mul_action.sum_card_fixed_by_eq_card_orbits_mul_card_group MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group

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

@@ -175,7 +175,6 @@ def ofQuotientStabilizer (g : α ⧸ MulAction.stabilizer α x) : β :=
     calc
       g1 • x = g1 • (g1⁻¹ * g2) • x := congr_arg _ (leftRel_apply.mp H).symm
       _ = g2 • x := by rw [smul_smul, mul_inv_cancel_left]
-      
 #align mul_action.of_quotient_stabilizer MulAction.ofQuotientStabilizer
 #align add_action.of_quotient_stabilizer AddAction.ofQuotientStabilizer
 -/
@@ -279,7 +278,6 @@ noncomputable def selfEquivSigmaOrbitsQuotientStabilizer' {φ : Ω → β}
       Equiv.sigmaCongrRight fun ω =>
         (Equiv.Set.ofEq <| orbitRel.Quotient.orbit_eq_orbit_out _ hφ).trans <|
           orbitEquivQuotientStabilizer α (φ ω)
-    
 #align mul_action.self_equiv_sigma_orbits_quotient_stabilizer' MulAction.selfEquivSigmaOrbitsQuotientStabilizer'
 #align add_action.self_equiv_sigma_orbits_quotient_stabilizer' AddAction.selfEquivSigmaOrbitsQuotientStabilizer'
 -/
@@ -351,7 +349,6 @@ noncomputable def sigmaFixedByEquivOrbitsProdGroup : (Σ a : α, fixedBy α β a
       (Equiv.sigmaCongrRight fun ω => Equiv.sigmaEquivProd _ _)
     _ ≃ Σ ω : Ω, α := (Equiv.sigmaCongrRight fun ω => orbitProdStabilizerEquivGroup α ω.out')
     _ ≃ Ω × α := Equiv.sigmaEquivProd Ω α
-    
 #align mul_action.sigma_fixed_by_equiv_orbits_prod_group MulAction.sigmaFixedByEquivOrbitsProdGroup
 #align add_action.sigma_fixed_by_equiv_orbits_sum_add_group AddAction.sigmaFixedByEquivOrbitsSumAddGroup
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -293,17 +293,16 @@ theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [F
     [∀ b : β, Fintype <| stabilizer α b] {φ : Ω → β} (hφ : LeftInverse Quotient.mk'' φ) :
     Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) := by
   classical
-    have :
-      ∀ ω : Ω,
-        Fintype.card α / Fintype.card ↥(stabilizer α (φ ω)) =
-          Fintype.card (α ⧸ stabilizer α (φ ω)) :=
-      by
-      intro ω
-      rw [Fintype.card_congr (@Subgroup.groupEquivQuotientProdSubgroup α _ (stabilizer α <| φ ω)),
-        Fintype.card_prod, Nat.mul_div_cancel]
-      exact fintype.card_pos_iff.mpr (by infer_instance)
-    simp_rw [this, ← Fintype.card_sigma,
-      Fintype.card_congr (self_equiv_sigma_orbits_quotient_stabilizer' α β hφ)]
+  have :
+    ∀ ω : Ω,
+      Fintype.card α / Fintype.card ↥(stabilizer α (φ ω)) = Fintype.card (α ⧸ stabilizer α (φ ω)) :=
+    by
+    intro ω
+    rw [Fintype.card_congr (@Subgroup.groupEquivQuotientProdSubgroup α _ (stabilizer α <| φ ω)),
+      Fintype.card_prod, Nat.mul_div_cancel]
+    exact fintype.card_pos_iff.mpr (by infer_instance)
+  simp_rw [this, ← Fintype.card_sigma,
+    Fintype.card_congr (self_equiv_sigma_orbits_quotient_stabilizer' α β hφ)]
 #align mul_action.card_eq_sum_card_group_div_card_stabilizer' MulAction.card_eq_sum_card_group_div_card_stabilizer'
 #align add_action.card_eq_sum_card_add_group_sub_card_stabilizer' AddAction.card_eq_sum_card_addGroup_sub_card_stabilizer'
 

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

@@ -56,7 +56,7 @@ class QuotientAction : Prop where
 #print AddAction.QuotientAction /-
 /-- A typeclass for when an `add_action β α` descends to the quotient `α ⧸ H`. -/
 class AddAction.QuotientAction {α : Type _} (β : Type _) [AddGroup α] [AddMonoid β] [AddAction β α]
-  (H : AddSubgroup α) : Prop where
+    (H : AddSubgroup α) : Prop where
   inv_mul_mem : ∀ (b : β) {a a' : α}, -a + a' ∈ H → -(b +ᵥ a) + (b +ᵥ a') ∈ H
 #align add_action.quotient_action AddAction.QuotientAction
 -/
@@ -272,10 +272,10 @@ provide `mul_action.self_equiv_sigma_orbits_quotient_stabilizer` as a special ca
 @[to_additive
       "**Class formula** : given `G` an additive group acting on `X` and `φ` a function\nmapping each orbit of `X` under this action (that is, each element of the quotient of `X` by the\nrelation `orbit_rel G X`) to an element in this orbit, this gives a (noncomputable) bijection\nbetween `X` and the disjoint union of `G/Stab(φ(ω))` over all orbits `ω`. In most cases you'll want\n`φ` to be `quotient.out'`, so we provide `add_action.self_equiv_sigma_orbits_quotient_stabilizer`\nas a special case. "]
 noncomputable def selfEquivSigmaOrbitsQuotientStabilizer' {φ : Ω → β}
-    (hφ : LeftInverse Quotient.mk'' φ) : β ≃ Σω : Ω, α ⧸ stabilizer α (φ ω) :=
+    (hφ : LeftInverse Quotient.mk'' φ) : β ≃ Σ ω : Ω, α ⧸ stabilizer α (φ ω) :=
   calc
-    β ≃ Σω : Ω, orbitRel.Quotient.orbit ω := selfEquivSigmaOrbits' α β
-    _ ≃ Σω : Ω, α ⧸ stabilizer α (φ ω) :=
+    β ≃ Σ ω : Ω, orbitRel.Quotient.orbit ω := selfEquivSigmaOrbits' α β
+    _ ≃ Σ ω : Ω, α ⧸ stabilizer α (φ ω) :=
       Equiv.sigmaCongrRight fun ω =>
         (Equiv.Set.ofEq <| orbitRel.Quotient.orbit_eq_orbit_out _ hφ).trans <|
           orbitEquivQuotientStabilizer α (φ ω)
@@ -312,7 +312,7 @@ theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [F
 `mul_action.self_equiv_sigma_orbits_quotient_stabilizer'` with `φ = quotient.out'`. -/
 @[to_additive
       "**Class formula**. This is a special case of\n`add_action.self_equiv_sigma_orbits_quotient_stabilizer'` with `φ = quotient.out'`. "]
-noncomputable def selfEquivSigmaOrbitsQuotientStabilizer : β ≃ Σω : Ω, α ⧸ stabilizer α ω.out' :=
+noncomputable def selfEquivSigmaOrbitsQuotientStabilizer : β ≃ Σ ω : Ω, α ⧸ stabilizer α ω.out' :=
   selfEquivSigmaOrbitsQuotientStabilizer' α β Quotient.out_eq'
 #align mul_action.self_equiv_sigma_orbits_quotient_stabilizer MulAction.selfEquivSigmaOrbitsQuotientStabilizer
 #align add_action.self_equiv_sigma_orbits_quotient_stabilizer AddAction.selfEquivSigmaOrbitsQuotientStabilizer
@@ -333,24 +333,24 @@ theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fi
 `X/G`denotes the quotient of `X` by the relation `orbit_rel G X`. -/
 @[to_additive
       "**Burnside's lemma** : a (noncomputable) bijection between the disjoint union of all\n`{x ∈ X | g • x = x}` for `g ∈ G` and the product `G × X/G`, where `G` is an additive group acting\non `X` and `X/G`denotes the quotient of `X` by the relation `orbit_rel G X`. "]
-noncomputable def sigmaFixedByEquivOrbitsProdGroup : (Σa : α, fixedBy α β a) ≃ Ω × α :=
+noncomputable def sigmaFixedByEquivOrbitsProdGroup : (Σ a : α, fixedBy α β a) ≃ Ω × α :=
   calc
-    (Σa : α, fixedBy α β a) ≃ { ab : α × β // ab.1 • ab.2 = ab.2 } :=
+    (Σ a : α, fixedBy α β a) ≃ { ab : α × β // ab.1 • ab.2 = ab.2 } :=
       (Equiv.subtypeProdEquivSigmaSubtype _).symm
     _ ≃ { ba : β × α // ba.2 • ba.1 = ba.1 } :=
       ((Equiv.prodComm α β).subtypeEquiv fun ab => Iff.rfl)
-    _ ≃ Σb : β, stabilizer α b :=
+    _ ≃ Σ b : β, stabilizer α b :=
       (Equiv.subtypeProdEquivSigmaSubtype fun (b : β) a => a ∈ stabilizer α b)
-    _ ≃ Σωb : Σω : Ω, orbit α ω.out', stabilizer α (ωb.2 : β) :=
+    _ ≃ Σ ωb : Σ ω : Ω, orbit α ω.out', stabilizer α (ωb.2 : β) :=
       (selfEquivSigmaOrbits α β).sigmaCongrLeft'
-    _ ≃ Σω : Ω, Σb : orbit α ω.out', stabilizer α (b : β) :=
+    _ ≃ Σ ω : Ω, Σ b : orbit α ω.out', stabilizer α (b : β) :=
       (Equiv.sigmaAssoc fun (ω : Ω) (b : orbit α ω.out') => stabilizer α (b : β))
-    _ ≃ Σω : Ω, Σb : orbit α ω.out', stabilizer α ω.out' :=
+    _ ≃ Σ ω : Ω, Σ b : orbit α ω.out', stabilizer α ω.out' :=
       (Equiv.sigmaCongrRight fun ω =>
         Equiv.sigmaCongrRight fun ⟨b, hb⟩ => (stabilizerEquivStabilizerOfOrbitRel hb).toEquiv)
-    _ ≃ Σω : Ω, orbit α ω.out' × stabilizer α ω.out' :=
+    _ ≃ Σ ω : Ω, orbit α ω.out' × stabilizer α ω.out' :=
       (Equiv.sigmaCongrRight fun ω => Equiv.sigmaEquivProd _ _)
-    _ ≃ Σω : Ω, α := (Equiv.sigmaCongrRight fun ω => orbitProdStabilizerEquivGroup α ω.out')
+    _ ≃ Σ ω : Ω, α := (Equiv.sigmaCongrRight fun ω => orbitProdStabilizerEquivGroup α ω.out')
     _ ≃ Ω × α := Equiv.sigmaEquivProd Ω α
     
 #align mul_action.sigma_fixed_by_equiv_orbits_prod_group MulAction.sigmaFixedByEquivOrbitsProdGroup

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

@@ -34,7 +34,7 @@ variable {α : Type u} {β : Type v} {γ : Type w}
 
 open Function
 
-open BigOperators
+open scoped BigOperators
 
 namespace MulAction
 

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

@@ -71,12 +71,6 @@ instance left_quotientAction : QuotientAction α H :=
 #align add_action.left_quotient_action AddAction.left_quotientAction
 -/
 
-/- warning: mul_action.right_quotient_action -> MulAction.right_quotientAction is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) _inst_1 (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) (Subgroup.toGroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))))) (Subgroup.mulAction.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (Subtype.{succ u1} (MulOpposite.{u1} α) (fun (x : MulOpposite.{u1} α) => Membership.mem.{u1, u1} (MulOpposite.{u1} α) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (SetLike.instMembership.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (MulOpposite.{u1} α) (Subgroup.instSetLikeSubgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) _inst_1 (Submonoid.toMonoid.{u1} (MulOpposite.{u1} α) (DivInvMonoid.toMonoid.{u1} (MulOpposite.{u1} α) (Group.toDivInvMonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.toSubmonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) (Subgroup.instMulActionSubtypeMemSubgroupInstMembershipInstSetLikeSubgroupToMonoidToMonoidToDivInvMonoidToSubmonoid.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (_x : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
-Case conversion may be inaccurate. Consider using '#align mul_action.right_quotient_action MulAction.right_quotientActionₓ'. -/
 @[to_additive]
 instance right_quotientAction : QuotientAction H.normalizer.opposite H :=
   ⟨fun b c _ _ => by
@@ -143,12 +137,6 @@ theorem Quotient.coe_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) : 
 #align add_action.quotient.coe_vadd_out' AddAction.Quotient.coe_vadd_out'
 -/
 
-/- warning: quotient_group.out'_conj_pow_minimal_period_mem -> QuotientGroup.out'_conj_pow_minimalPeriod_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) (a : α) (q : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H), Membership.Mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) a (Function.minimalPeriod.{u1} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (SMul.smul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (MulAction.toHasSmul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (MulAction.quotient.{u1, u1} α α _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H (MulAction.left_quotientAction.{u1} α _inst_1 H))) a) q))) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) H
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) (a : α) (q : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H), Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) a (Function.minimalPeriod.{u1} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) ((fun (x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.853 : α) (x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.855 : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) => HSMul.hSMul.{u1, u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (instHSMul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (MulAction.toSMul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (MulAction.quotient.{u1, u1} α α _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H (MulAction.left_quotientAction.{u1} α _inst_1 H)))) x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.853 x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.855) a) q))) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) H
-Case conversion may be inaccurate. Consider using '#align quotient_group.out'_conj_pow_minimal_period_mem QuotientGroup.out'_conj_pow_minimalPeriod_memₓ'. -/
 theorem QuotientGroup.out'_conj_pow_minimalPeriod_mem (a : α) (q : α ⧸ H) :
     q.out'⁻¹ * a ^ Function.minimalPeriod ((· • ·) a) q * q.out' ∈ H := by
   rw [mul_assoc, ← QuotientGroup.eq', QuotientGroup.out_eq', ← smul_eq_mul, quotient.mk_smul_out',
@@ -159,12 +147,6 @@ end QuotientAction
 
 open QuotientGroup
 
-/- warning: mul_action_hom.to_quotient -> MulActionHom.toQuotient is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulActionHom.{u1, u1, u1} α α (Mul.toSMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (MulAction.toHasSmul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (MulAction.quotient.{u1, u1} α α _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H (MulAction.left_quotientAction.{u1} α _inst_1 H)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulActionHom.{u1, u1, u1} α α (MulAction.toSMul.{u1, u1} α α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (MulAction.toSMul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (MulAction.quotient.{u1, u1} α α _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H (MulAction.left_quotientAction.{u1} α _inst_1 H)))
-Case conversion may be inaccurate. Consider using '#align mul_action_hom.to_quotient MulActionHom.toQuotientₓ'. -/
 /-- The canonical map to the left cosets. -/
 def MulActionHom.toQuotient (H : Subgroup α) : α →[α] α ⧸ H :=
   ⟨coe, Quotient.smul_coe H⟩
@@ -177,12 +159,6 @@ theorem MulActionHom.toQuotient_apply (H : Subgroup α) (g : α) : MulActionHom.
 #align mul_action_hom.to_quotient_apply MulActionHom.toQuotient_apply
 -/
 
-/- warning: mul_action.mul_left_cosets_comp_subtype_val -> MulAction.mulLeftCosetsCompSubtypeVal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) (I : Subgroup.{u1} α _inst_1), MulAction.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) I) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) I) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) I) (Subgroup.toGroup.{u1} α _inst_1 I)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) (I : Subgroup.{u1} α _inst_1), MulAction.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) x I)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (Submonoid.toMonoid.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Subgroup.toSubmonoid.{u1} α _inst_1 I))
-Case conversion may be inaccurate. Consider using '#align mul_action.mul_left_cosets_comp_subtype_val MulAction.mulLeftCosetsCompSubtypeValₓ'. -/
 @[to_additive]
 instance mulLeftCosetsCompSubtypeVal (H I : Subgroup α) : MulAction I (α ⧸ H) :=
   MulAction.compHom (α ⧸ H) (Subgroup.subtype I)
@@ -252,12 +228,6 @@ noncomputable def orbitEquivQuotientStabilizer (b : β) : orbit α b ≃ α ⧸
 #align add_action.orbit_equiv_quotient_stabilizer AddAction.orbitEquivQuotientStabilizer
 -/
 
-/- warning: mul_action.orbit_prod_stabilizer_equiv_group -> MulAction.orbitProdStabilizerEquivGroup is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β), Equiv.{max (succ u2) (succ u1), succ u1} (Prod.{u2, u1} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b))) α
-but is expected to have type
-  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β), Equiv.{max (succ u1) (succ u2), succ u1} (Prod.{u2, u1} (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) x (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)))) α
-Case conversion may be inaccurate. Consider using '#align mul_action.orbit_prod_stabilizer_equiv_group MulAction.orbitProdStabilizerEquivGroupₓ'. -/
 /-- Orbit-stabilizer theorem. -/
 @[to_additive "Orbit-stabilizer theorem."]
 noncomputable def orbitProdStabilizerEquivGroup (b : β) : orbit α b × stabilizer α b ≃ α :=
@@ -266,12 +236,6 @@ noncomputable def orbitProdStabilizerEquivGroup (b : β) : orbit α b × stabili
 #align mul_action.orbit_prod_stabilizer_equiv_group MulAction.orbitProdStabilizerEquivGroup
 #align add_action.orbit_sum_stabilizer_equiv_add_group AddAction.orbitSumStabilizerEquivAddGroup
 
-/- warning: mul_action.card_orbit_mul_card_stabilizer_eq_card_group -> MulAction.card_orbit_mul_card_stabilizer_eq_card_group is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) [_inst_3 : Fintype.{u1} α] [_inst_4 : Fintype.{u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))] [_inst_5 : Fintype.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b))], Eq.{1} Nat (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat Nat.hasMul) (Fintype.card.{u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) _inst_4) (Fintype.card.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) _inst_5)) (Fintype.card.{u1} α _inst_3)
-but is expected to have type
-  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) [_inst_3 : Fintype.{u1} α] [_inst_4 : Fintype.{u2} (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))] [_inst_5 : Fintype.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) x (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)))], Eq.{1} Nat (HMul.hMul.{0, 0, 0} Nat Nat Nat (instHMul.{0} Nat instMulNat) (Fintype.card.{u2} (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) _inst_4) (Fintype.card.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) x (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b))) _inst_5)) (Fintype.card.{u1} α _inst_3)
-Case conversion may be inaccurate. Consider using '#align mul_action.card_orbit_mul_card_stabilizer_eq_card_group MulAction.card_orbit_mul_card_stabilizer_eq_card_groupₓ'. -/
 /-- Orbit-stabilizer theorem. -/
 @[to_additive "Orbit-stabilizer theorem."]
 theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fintype <| orbit α b]
@@ -281,12 +245,6 @@ theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fint
 #align mul_action.card_orbit_mul_card_stabilizer_eq_card_group MulAction.card_orbit_mul_card_stabilizer_eq_card_group
 #align add_action.card_orbit_add_card_stabilizer_eq_card_add_group AddAction.card_orbit_add_card_stabilizer_eq_card_addGroup
 
-/- warning: mul_action.orbit_equiv_quotient_stabilizer_symm_apply -> MulAction.orbitEquivQuotientStabilizer_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) (a : α), Eq.{succ u2} β ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)))))) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (fun (_x : Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) => (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) -> (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.hasCoeToFun.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.symm.{succ u2, succ u1} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (MulAction.orbitEquivQuotientStabilizer.{u1, u2} α β _inst_1 _inst_2 b)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (HasLiftT.mk.{succ u1, succ u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (CoeTCₓ.coe.{succ u1, succ u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (QuotientGroup.HasQuotient.Quotient.hasCoeT.{u1} α _inst_1 (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)))) a))) (SMul.smul.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2) a b)
-but is expected to have type
-  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) (a : α), Eq.{succ u2} β (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (fun (_x : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.symm.{succ u2, succ u1} (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (MulAction.orbitEquivQuotientStabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (QuotientGroup.mk.{u1} α _inst_1 (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b) a))) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) a b)
-Case conversion may be inaccurate. Consider using '#align mul_action.orbit_equiv_quotient_stabilizer_symm_apply MulAction.orbitEquivQuotientStabilizer_symm_applyₓ'. -/
 @[simp, to_additive]
 theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :
     ((orbitEquivQuotientStabilizer α b).symm a : β) = a • b :=
@@ -294,12 +252,6 @@ theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :
 #align mul_action.orbit_equiv_quotient_stabilizer_symm_apply MulAction.orbitEquivQuotientStabilizer_symm_apply
 #align add_action.orbit_equiv_quotient_stabilizer_symm_apply AddAction.orbitEquivQuotientStabilizer_symm_apply
 
-/- warning: mul_action.stabilizer_quotient -> MulAction.stabilizer_quotient is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (H : Subgroup.{u1} G _inst_3), Eq.{succ u1} (Subgroup.{u1} G _inst_3) (MulAction.stabilizer.{u1, u1} G (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_3) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_3) H) _inst_3 (MulAction.quotient.{u1, u1} G G _inst_3 (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)) (Monoid.toMulAction.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) H (MulAction.left_quotientAction.{u1} G _inst_3 H)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) G (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_3) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_3) H) (HasLiftT.mk.{succ u1, succ u1} G (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_3) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_3) H) (CoeTCₓ.coe.{succ u1, succ u1} G (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_3) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_3) H) (QuotientGroup.HasQuotient.Quotient.hasCoeT.{u1} G _inst_3 H))) (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 _inst_3))))))))) H
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (H : Subgroup.{u1} G _inst_3), Eq.{succ u1} (Subgroup.{u1} G _inst_3) (MulAction.stabilizer.{u1, u1} G (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_3) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_3) H) _inst_3 (MulAction.quotient.{u1, u1} G G _inst_3 (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)) (Monoid.toMulAction.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) H (MulAction.left_quotientAction.{u1} G _inst_3 H)) (QuotientGroup.mk.{u1} G _inst_3 H (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_3)))))))) H
-Case conversion may be inaccurate. Consider using '#align mul_action.stabilizer_quotient MulAction.stabilizer_quotientₓ'. -/
 @[simp, to_additive]
 theorem stabilizer_quotient {G} [Group G] (H : Subgroup G) :
     MulAction.stabilizer G ((1 : G) : G ⧸ H) = H := by ext; simp [QuotientGroup.eq]
@@ -332,12 +284,6 @@ noncomputable def selfEquivSigmaOrbitsQuotientStabilizer' {φ : Ω → β}
 #align add_action.self_equiv_sigma_orbits_quotient_stabilizer' AddAction.selfEquivSigmaOrbitsQuotientStabilizer'
 -/
 
-/- warning: mul_action.card_eq_sum_card_group_div_card_stabilizer' -> MulAction.card_eq_sum_card_group_div_card_stabilizer' is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) (β : Type.{u2}) [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : Fintype.{u1} α] [_inst_4 : Fintype.{u2} β] [_inst_5 : Fintype.{u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2))] [_inst_6 : forall (b : β), Fintype.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b))] {φ : (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) -> β}, (Function.LeftInverse.{succ u2, succ u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) β (Quotient.mk''.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) φ) -> (Eq.{1} Nat (Fintype.card.{u2} β _inst_4) (Finset.sum.{0, u2} Nat (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) Nat.addCommMonoid (Finset.univ.{u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) _inst_5) (fun (ω : Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) => HDiv.hDiv.{0, 0, 0} Nat Nat Nat (instHDiv.{0} Nat Nat.hasDiv) (Fintype.card.{u1} α _inst_3) (Fintype.card.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 (φ ω))) (_inst_6 (φ ω))))))
-but is expected to have type
-  forall (α : Type.{u1}) (β : Type.{u2}) [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : Fintype.{u1} α] [_inst_4 : Fintype.{u2} β] [_inst_5 : Fintype.{u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2))] [_inst_6 : forall (b : β), Fintype.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) x (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)))] {φ : (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) -> β}, (Function.LeftInverse.{succ u2, succ u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) β (Quotient.mk''.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) φ) -> (Eq.{1} Nat (Fintype.card.{u2} β _inst_4) (Finset.sum.{0, u2} Nat (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) Nat.addCommMonoid (Finset.univ.{u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) _inst_5) (fun (ω : Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) => HDiv.hDiv.{0, 0, 0} Nat Nat Nat (instHDiv.{0} Nat Nat.instDivNat) (Fintype.card.{u1} α _inst_3) (Fintype.card.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) x (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 (φ ω)))) (_inst_6 (φ ω))))))
-Case conversion may be inaccurate. Consider using '#align mul_action.card_eq_sum_card_group_div_card_stabilizer' MulAction.card_eq_sum_card_group_div_card_stabilizer'ₓ'. -/
 /-- **Class formula** for a finite group acting on a finite type. See
 `mul_action.card_eq_sum_card_group_div_card_stabilizer` for a specialized version using
 `quotient.out'`. -/
@@ -372,12 +318,6 @@ noncomputable def selfEquivSigmaOrbitsQuotientStabilizer : β ≃ Σω : Ω, α
 #align add_action.self_equiv_sigma_orbits_quotient_stabilizer AddAction.selfEquivSigmaOrbitsQuotientStabilizer
 -/
 
-/- warning: mul_action.card_eq_sum_card_group_div_card_stabilizer -> MulAction.card_eq_sum_card_group_div_card_stabilizer is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) (β : Type.{u2}) [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : Fintype.{u1} α] [_inst_4 : Fintype.{u2} β] [_inst_5 : Fintype.{u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2))] [_inst_6 : forall (b : β), Fintype.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b))], Eq.{1} Nat (Fintype.card.{u2} β _inst_4) (Finset.sum.{0, u2} Nat (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) Nat.addCommMonoid (Finset.univ.{u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) _inst_5) (fun (ω : Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) => HDiv.hDiv.{0, 0, 0} Nat Nat Nat (instHDiv.{0} Nat Nat.hasDiv) (Fintype.card.{u1} α _inst_3) (Fintype.card.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} α _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 (Quotient.out'.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2) ω))) (_inst_6 (Quotient.out'.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2) ω)))))
-but is expected to have type
-  forall (α : Type.{u1}) (β : Type.{u2}) [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : Fintype.{u1} α] [_inst_4 : Fintype.{u2} β] [_inst_5 : Fintype.{u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2))] [_inst_6 : forall (b : β), Fintype.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) x (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)))], Eq.{1} Nat (Fintype.card.{u2} β _inst_4) (Finset.sum.{0, u2} Nat (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) Nat.addCommMonoid (Finset.univ.{u2} (Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) _inst_5) (fun (ω : Quotient.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2)) => HDiv.hDiv.{0, 0, 0} Nat Nat Nat (instHDiv.{0} Nat Nat.instDivNat) (Fintype.card.{u1} α _inst_3) (Fintype.card.{u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) x (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 (Quotient.out'.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2) ω)))) (_inst_6 (Quotient.out'.{succ u2} β (MulAction.orbitRel.{u1, u2} α β _inst_1 _inst_2) ω)))))
-Case conversion may be inaccurate. Consider using '#align mul_action.card_eq_sum_card_group_div_card_stabilizer MulAction.card_eq_sum_card_group_div_card_stabilizerₓ'. -/
 /-- **Class formula** for a finite group acting on a finite type. -/
 @[to_additive "**Class formula** for a finite group acting on a finite type."]
 theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fintype Ω]
@@ -487,12 +427,6 @@ theorem quotientCentralizerEmbedding_apply (g : G) (x : G) :
 #align subgroup.quotient_centralizer_embedding_apply Subgroup.quotientCentralizerEmbedding_apply
 -/
 
-/- warning: subgroup.quotient_center_embedding -> Subgroup.quotientCenterEmbedding is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {S : Set.{u1} G}, (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasTop.{u1} G _inst_1))) -> (Function.Embedding.{succ u1, succ u1} (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) (commutatorSet.{u1} G _inst_1))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {S : Set.{u1} G}, (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instTopSubgroup.{u1} G _inst_1))) -> (Function.Embedding.{succ u1, succ u1} (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((Set.Elem.{u1} G S) -> (Set.Elem.{u1} G (commutatorSet.{u1} G _inst_1))))
-Case conversion may be inaccurate. Consider using '#align subgroup.quotient_center_embedding Subgroup.quotientCenterEmbeddingₓ'. -/
 /-- If `G` is generated by `S`, then the quotient by the center embeds into `S`-indexed sequences
 of commutators. -/
 noncomputable def quotientCenterEmbedding {S : Set G} (hS : closure S = ⊤) :
@@ -502,9 +436,6 @@ noncomputable def quotientCenterEmbedding {S : Set G} (hS : closure S = ⊤) :
       (Function.Embedding.piCongrRight fun g => quotientCentralizerEmbedding g))
 #align subgroup.quotient_center_embedding Subgroup.quotientCenterEmbedding
 
-/- warning: subgroup.quotient_center_embedding_apply -> Subgroup.quotientCenterEmbedding_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align subgroup.quotient_center_embedding_apply Subgroup.quotientCenterEmbedding_applyₓ'. -/
 theorem quotientCenterEmbedding_apply {S : Set G} (hS : closure S = ⊤) (g : G) (s : S) :
     quotientCenterEmbedding hS g s = ⟨⁅g, s⁆, g, s, rfl⟩ :=
   rfl

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

@@ -234,9 +234,7 @@ theorem ofQuotientStabilizer_smul (g : α) (g' : α ⧸ MulAction.stabilizer α
 theorem injective_ofQuotientStabilizer : Function.Injective (ofQuotientStabilizer α x) :=
   fun y₁ y₂ =>
   Quotient.inductionOn₂' y₁ y₂ fun g₁ g₂ (H : g₁ • x = g₂ • x) =>
-    Quotient.sound' <| by
-      rw [left_rel_apply]
-      show (g₁⁻¹ * g₂) • x = x
+    Quotient.sound' <| by rw [left_rel_apply]; show (g₁⁻¹ * g₂) • x = x;
       rw [mul_smul, ← H, inv_smul_smul]
 #align mul_action.injective_of_quotient_stabilizer MulAction.injective_ofQuotientStabilizer
 #align add_action.injective_of_quotient_stabilizer AddAction.injective_ofQuotientStabilizer
@@ -304,10 +302,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align mul_action.stabilizer_quotient MulAction.stabilizer_quotientₓ'. -/
 @[simp, to_additive]
 theorem stabilizer_quotient {G} [Group G] (H : Subgroup G) :
-    MulAction.stabilizer G ((1 : G) : G ⧸ H) = H :=
-  by
-  ext
-  simp [QuotientGroup.eq]
+    MulAction.stabilizer G ((1 : G) : G ⧸ H) = H := by ext; simp [QuotientGroup.eq]
 #align mul_action.stabilizer_quotient MulAction.stabilizer_quotient
 #align add_action.stabilizer_quotient AddAction.stabilizer_quotient
 

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

@@ -508,10 +508,7 @@ noncomputable def quotientCenterEmbedding {S : Set G} (hS : closure S = ⊤) :
 #align subgroup.quotient_center_embedding Subgroup.quotientCenterEmbedding
 
 /- warning: subgroup.quotient_center_embedding_apply -> Subgroup.quotientCenterEmbedding_apply is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {S : Set.{u1} G} (hS : Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasTop.{u1} G _inst_1))) (g : G) (s : coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) (commutatorSet.{u1} G _inst_1)) (coeFn.{succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) (commutatorSet.{u1} G _inst_1)))) (fun (_x : Function.Embedding.{succ u1, succ u1} (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) (commutatorSet.{u1} G _inst_1)))) => (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) (commutatorSet.{u1} G _inst_1))) (Function.Embedding.hasCoeToFun.{succ u1, succ u1} (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) (commutatorSet.{u1} G _inst_1)))) (Subgroup.quotientCenterEmbedding.{u1} G _inst_1 S hS) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) G (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) (HasLiftT.mk.{succ u1, succ u1} G (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} G (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) (QuotientGroup.HasQuotient.Quotient.hasCoeT.{u1} G _inst_1 (Subgroup.center.{u1} G _inst_1)))) g) s) (Subtype.mk.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x (commutatorSet.{u1} G _inst_1)) (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x S))))) s)) (Exists.intro.{succ u1} G (fun (g₁ : G) => Exists.{succ u1} G (fun (g₂ : G) => Eq.{succ u1} G (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g₁ g₂) (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x S))))) s)))) g (Exists.intro.{succ u1} G (fun (g₂ : G) => Eq.{succ u1} G (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g g₂) (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x S))))) s))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x S))))) s) (rfl.{succ u1} G (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x S))))) s))))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {S : Set.{u1} G} (hS : Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instTopSubgroup.{u1} G _inst_1))) (g : G) (s : Set.Elem.{u1} G S), Eq.{succ u1} (Set.Elem.{u1} G (commutatorSet.{u1} G _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((Set.Elem.{u1} G S) -> (Set.Elem.{u1} G (commutatorSet.{u1} G _inst_1)))) (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) (fun (_x : HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) => (Set.Elem.{u1} G S) -> (Set.Elem.{u1} G (commutatorSet.{u1} G _inst_1))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((Set.Elem.{u1} G S) -> (Set.Elem.{u1} G (commutatorSet.{u1} G _inst_1)))) (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((Set.Elem.{u1} G S) -> (Set.Elem.{u1} G (commutatorSet.{u1} G _inst_1))) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (HasQuotient.Quotient.{u1, u1} G (Subgroup.{u1} G _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1)) ((Set.Elem.{u1} G S) -> (Set.Elem.{u1} G (commutatorSet.{u1} G _inst_1))))) (Subgroup.quotientCenterEmbedding.{u1} G _inst_1 S hS) (QuotientGroup.mk.{u1} G _inst_1 (Subgroup.center.{u1} G _inst_1) g) s) (Subtype.mk.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (commutatorSet.{u1} G _inst_1)) (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x S) s)) (Exists.intro.{succ u1} G (fun (g₁ : G) => Exists.{succ u1} G (fun (g₂ : G) => Eq.{succ u1} G (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g₁ g₂) (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x S) s)))) g (Exists.intro.{succ u1} G (fun (g₂ : G) => Eq.{succ u1} G (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g g₂) (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x S) s))) (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x S) s) (rfl.{succ u1} G (Bracket.bracket.{u1, u1} G G (commutatorElement.{u1} G _inst_1) g (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x S) s))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align subgroup.quotient_center_embedding_apply Subgroup.quotientCenterEmbedding_applyₓ'. -/
 theorem quotientCenterEmbedding_apply {S : Set G} (hS : closure S = ⊤) (g : G) (s : S) :
     quotientCenterEmbedding hS g s = ⟨⁅g, s⁆, g, s, rfl⟩ :=

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

@@ -75,7 +75,7 @@ instance left_quotientAction : QuotientAction α H :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) _inst_1 (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) (Subgroup.toGroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))))) (Subgroup.mulAction.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (Subtype.{succ u1} (MulOpposite.{u1} α) (fun (x : MulOpposite.{u1} α) => Membership.mem.{u1, u1} (MulOpposite.{u1} α) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (SetLike.instMembership.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (MulOpposite.{u1} α) (Subgroup.instSetLikeSubgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) _inst_1 (Submonoid.toMonoid.{u1} (MulOpposite.{u1} α) (DivInvMonoid.toMonoid.{u1} (MulOpposite.{u1} α) (Group.toDivInvMonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.toSubmonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) (Subgroup.instMulActionSubtypeMemSubgroupInstMembershipInstSetLikeSubgroupToMonoidToMonoidToDivInvMonoidToSubmonoid.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (_x : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (Subtype.{succ u1} (MulOpposite.{u1} α) (fun (x : MulOpposite.{u1} α) => Membership.mem.{u1, u1} (MulOpposite.{u1} α) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (SetLike.instMembership.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (MulOpposite.{u1} α) (Subgroup.instSetLikeSubgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) _inst_1 (Submonoid.toMonoid.{u1} (MulOpposite.{u1} α) (DivInvMonoid.toMonoid.{u1} (MulOpposite.{u1} α) (Group.toDivInvMonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.toSubmonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) (Subgroup.instMulActionSubtypeMemSubgroupInstMembershipInstSetLikeSubgroupToMonoidToMonoidToDivInvMonoidToSubmonoid.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (_x : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
 Case conversion may be inaccurate. Consider using '#align mul_action.right_quotient_action MulAction.right_quotientActionₓ'. -/
 @[to_additive]
 instance right_quotientAction : QuotientAction H.normalizer.opposite H :=
@@ -287,7 +287,7 @@ theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fint
 lean 3 declaration is
   forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) (a : α), Eq.{succ u2} β ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)))))) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (fun (_x : Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) => (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) -> (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.hasCoeToFun.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.symm.{succ u2, succ u1} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (MulAction.orbitEquivQuotientStabilizer.{u1, u2} α β _inst_1 _inst_2 b)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (HasLiftT.mk.{succ u1, succ u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (CoeTCₓ.coe.{succ u1, succ u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (QuotientGroup.HasQuotient.Quotient.hasCoeT.{u1} α _inst_1 (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)))) a))) (SMul.smul.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2) a b)
 but is expected to have type
-  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) (a : α), Eq.{succ u2} β (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (fun (_x : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.symm.{succ u2, succ u1} (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (MulAction.orbitEquivQuotientStabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (QuotientGroup.mk.{u1} α _inst_1 (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b) a))) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) a b)
+  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) (a : α), Eq.{succ u2} β (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (fun (_x : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.symm.{succ u2, succ u1} (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (MulAction.orbitEquivQuotientStabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (QuotientGroup.mk.{u1} α _inst_1 (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b) a))) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) a b)
 Case conversion may be inaccurate. Consider using '#align mul_action.orbit_equiv_quotient_stabilizer_symm_apply MulAction.orbitEquivQuotientStabilizer_symm_applyₓ'. -/
 @[simp, to_additive]
 theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :

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

@@ -503,7 +503,7 @@ of commutators. -/
 noncomputable def quotientCenterEmbedding {S : Set G} (hS : closure S = ⊤) :
     G ⧸ center G ↪ S → commutatorSet G :=
   (quotientEquivOfEq (center_eq_infi' S hS)).toEmbedding.trans
-    ((quotientInfᵢEmbedding _).trans
+    ((quotientiInfEmbedding _).trans
       (Function.Embedding.piCongrRight fun g => quotientCentralizerEmbedding g))
 #align subgroup.quotient_center_embedding Subgroup.quotientCenterEmbedding
 

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

@@ -75,7 +75,7 @@ instance left_quotientAction : QuotientAction α H :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) _inst_1 (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) (Subgroup.toGroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))))) (Subgroup.mulAction.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (Subtype.{succ u1} (MulOpposite.{u1} α) (fun (x : MulOpposite.{u1} α) => Membership.mem.{u1, u1} (MulOpposite.{u1} α) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (SetLike.instMembership.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (MulOpposite.{u1} α) (Subgroup.instSetLikeSubgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) _inst_1 (Submonoid.toMonoid.{u1} (MulOpposite.{u1} α) (DivInvMonoid.toMonoid.{u1} (MulOpposite.{u1} α) (Group.toDivInvMonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.toSubmonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) (Subgroup.instMulActionSubtypeMemSubgroupInstMembershipInstSetLikeSubgroupToMonoidToMonoidToDivInvMonoidToSubmonoid.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (_x : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (Subtype.{succ u1} (MulOpposite.{u1} α) (fun (x : MulOpposite.{u1} α) => Membership.mem.{u1, u1} (MulOpposite.{u1} α) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (SetLike.instMembership.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (MulOpposite.{u1} α) (Subgroup.instSetLikeSubgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) _inst_1 (Submonoid.toMonoid.{u1} (MulOpposite.{u1} α) (DivInvMonoid.toMonoid.{u1} (MulOpposite.{u1} α) (Group.toDivInvMonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.toSubmonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) (Subgroup.instMulActionSubtypeMemSubgroupInstMembershipInstSetLikeSubgroupToMonoidToMonoidToDivInvMonoidToSubmonoid.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (_x : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
 Case conversion may be inaccurate. Consider using '#align mul_action.right_quotient_action MulAction.right_quotientActionₓ'. -/
 @[to_additive]
 instance right_quotientAction : QuotientAction H.normalizer.opposite H :=
@@ -85,12 +85,7 @@ instance right_quotientAction : QuotientAction H.normalizer.opposite H :=
 #align mul_action.right_quotient_action MulAction.right_quotientAction
 #align add_action.right_quotient_action AddAction.right_quotientAction
 
-/- warning: mul_action.right_quotient_action' -> MulAction.right_quotientAction' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) [hH : Subgroup.Normal.{u1} α _inst_1 H], MulAction.QuotientAction.{u1, u1} α (MulOpposite.{u1} α) _inst_1 (MulOpposite.monoid.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) [hH : Subgroup.Normal.{u1} α _inst_1 H], MulAction.QuotientAction.{u1, u1} α (MulOpposite.{u1} α) _inst_1 (MulOpposite.instMonoidMulOpposite.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H
-Case conversion may be inaccurate. Consider using '#align mul_action.right_quotient_action' MulAction.right_quotientAction'ₓ'. -/
+#print MulAction.right_quotientAction' /-
 @[to_additive]
 instance right_quotientAction' [hH : H.Normal] : QuotientAction αᵐᵒᵖ H :=
   ⟨fun _ _ _ _ => by
@@ -98,6 +93,7 @@ instance right_quotientAction' [hH : H.Normal] : QuotientAction αᵐᵒᵖ H :=
       mul_inv_cancel_right]⟩
 #align mul_action.right_quotient_action' MulAction.right_quotientAction'
 #align add_action.right_quotient_action' AddAction.right_quotientAction'
+-/
 
 #print MulAction.quotient /-
 @[to_additive]

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

@@ -75,7 +75,7 @@ instance left_quotientAction : QuotientAction α H :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) _inst_1 (DivInvMonoid.toMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) (Group.toDivInvMonoid.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1)) (MulOpposite.{u1} α) (Subgroup.setLike.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) (Subgroup.toGroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))))) (Subgroup.mulAction.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (fun (_x : Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) => (Subgroup.{u1} α _inst_1) -> (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.group.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (Subtype.{succ u1} (MulOpposite.{u1} α) (fun (x : MulOpposite.{u1} α) => Membership.mem.{u1, u1} (MulOpposite.{u1} α) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (SetLike.instMembership.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (MulOpposite.{u1} α) (Subgroup.instSetLikeSubgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) _inst_1 (Submonoid.toMonoid.{u1} (MulOpposite.{u1} α) (DivInvMonoid.toMonoid.{u1} (MulOpposite.{u1} α) (Group.toDivInvMonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.toSubmonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) (Subgroup.instMulActionSubtypeMemSubgroupInstMembershipInstSetLikeSubgroupToMonoidToMonoidToDivInvMonoidToSubmonoid.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (_x : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1), MulAction.QuotientAction.{u1, u1} α (Subtype.{succ u1} (MulOpposite.{u1} α) (fun (x : MulOpposite.{u1} α) => Membership.mem.{u1, u1} (MulOpposite.{u1} α) ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (SetLike.instMembership.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) (Subgroup.normalizer.{u1} α _inst_1 H)) (MulOpposite.{u1} α) (Subgroup.instSetLikeSubgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) _inst_1 (Submonoid.toMonoid.{u1} (MulOpposite.{u1} α) (DivInvMonoid.toMonoid.{u1} (MulOpposite.{u1} α) (Group.toDivInvMonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.toSubmonoid.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (a : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H)))) (Subgroup.instMulActionSubtypeMemSubgroupInstMembershipInstSetLikeSubgroupToMonoidToMonoidToDivInvMonoidToSubmonoid.{u1, u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1) α (Monoid.toOppositeMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.{u1} α _inst_1) (fun (_x : Subgroup.{u1} α _inst_1) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subgroup.{u1} α _inst_1) => Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subgroup.{u1} α _inst_1) (Subgroup.{u1} (MulOpposite.{u1} α) (MulOpposite.instGroupMulOpposite.{u1} α _inst_1))) (Subgroup.opposite.{u1} α _inst_1) (Subgroup.normalizer.{u1} α _inst_1 H))) H
 Case conversion may be inaccurate. Consider using '#align mul_action.right_quotient_action MulAction.right_quotientActionₓ'. -/
 @[to_additive]
 instance right_quotientAction : QuotientAction H.normalizer.opposite H :=
@@ -151,7 +151,7 @@ theorem Quotient.coe_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) : 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) (a : α) (q : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H), Membership.Mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.setLike.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) a (Function.minimalPeriod.{u1} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (SMul.smul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (MulAction.toHasSmul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) H) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (MulAction.quotient.{u1, u1} α α _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H (MulAction.left_quotientAction.{u1} α _inst_1 H))) a) q))) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) H
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) (a : α) (q : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H), Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) a (Function.minimalPeriod.{u1} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) ((fun (x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.852 : α) (x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.854 : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) => HSMul.hSMul.{u1, u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (instHSMul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (MulAction.toSMul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (MulAction.quotient.{u1, u1} α α _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H (MulAction.left_quotientAction.{u1} α _inst_1 H)))) x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.852 x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.854) a) q))) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) H
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] (H : Subgroup.{u1} α _inst_1) (a : α) (q : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H), Membership.mem.{u1, u1} α (Subgroup.{u1} α _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} α _inst_1) α (Subgroup.instSetLikeSubgroup.{u1} α _inst_1)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) (HPow.hPow.{u1, 0, u1} α Nat α (instHPow.{u1, 0} α Nat (Monoid.Pow.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))) a (Function.minimalPeriod.{u1} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) ((fun (x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.853 : α) (x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.855 : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) => HSMul.hSMul.{u1, u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (instHSMul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (MulAction.toSMul.{u1, u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) H) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (MulAction.quotient.{u1, u1} α α _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (Monoid.toMulAction.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) H (MulAction.left_quotientAction.{u1} α _inst_1 H)))) x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.853 x._@.Mathlib.GroupTheory.GroupAction.Quotient._hyg.855) a) q))) (Quotient.out'.{succ u1} α (QuotientGroup.leftRel.{u1} α _inst_1 H) q)) H
 Case conversion may be inaccurate. Consider using '#align quotient_group.out'_conj_pow_minimal_period_mem QuotientGroup.out'_conj_pow_minimalPeriod_memₓ'. -/
 theorem QuotientGroup.out'_conj_pow_minimalPeriod_mem (a : α) (q : α ⧸ H) :
     q.out'⁻¹ * a ^ Function.minimalPeriod ((· • ·) a) q * q.out' ∈ H := by
@@ -291,7 +291,7 @@ theorem card_orbit_mul_card_stabilizer_eq_card_group (b : β) [Fintype α] [Fint
 lean 3 declaration is
   forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) (a : α), Eq.{succ u2} β ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) β (coeSubtype.{succ u2} β (fun (x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) x (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)))))) (coeFn.{max 1 (max (succ u1) (succ u2)) (succ u2) (succ u1), max (succ u1) (succ u2)} (Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (fun (_x : Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) => (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) -> (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.hasCoeToFun.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.symm.{succ u2, succ u1} (coeSort.{succ u2, succ (succ u2)} (Set.{u2} β) Type.{u2} (Set.hasCoeToSort.{u2} β) (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (MulAction.orbitEquivQuotientStabilizer.{u1, u2} α β _inst_1 _inst_2 b)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (HasLiftT.mk.{succ u1, succ u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (CoeTCₓ.coe.{succ u1, succ u1} α (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.Subgroup.hasQuotient.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (QuotientGroup.HasQuotient.Quotient.hasCoeT.{u1} α _inst_1 (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)))) a))) (SMul.smul.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2) a b)
 but is expected to have type
-  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) (a : α), Eq.{succ u2} β (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (fun (_x : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.symm.{succ u2, succ u1} (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (MulAction.orbitEquivQuotientStabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (QuotientGroup.mk.{u1} α _inst_1 (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b) a))) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) a b)
+  forall (α : Type.{u1}) {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] (b : β) (a : α), Eq.{succ u2} β (Subtype.val.{succ u2} β (fun (x : β) => Membership.mem.{u2, u2} β (Set.{u2} β) (Set.instMembershipSet.{u2} β) x (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (Equiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (fun (_x : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) => Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u2} (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b))) (Equiv.symm.{succ u2, succ u1} (Set.Elem.{u2} β (MulAction.orbit.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2 b)) (HasQuotient.Quotient.{u1, u1} α (Subgroup.{u1} α _inst_1) (QuotientGroup.instHasQuotientSubgroup.{u1} α _inst_1) (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (MulAction.orbitEquivQuotientStabilizer.{u1, u2} α β _inst_1 _inst_2 b)) (QuotientGroup.mk.{u1} α _inst_1 (MulAction.stabilizer.{u1, u2} α β _inst_1 _inst_2 b) a))) (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) a b)
 Case conversion may be inaccurate. Consider using '#align mul_action.orbit_equiv_quotient_stabilizer_symm_apply MulAction.orbitEquivQuotientStabilizer_symm_applyₓ'. -/
 @[simp, to_additive]
 theorem orbitEquivQuotientStabilizer_symm_apply (b : β) (a : α) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -406,19 +406,20 @@ noncomputable def sigmaFixedByEquivOrbitsProdGroup : (Σa : α, fixedBy α β a)
   calc
     (Σa : α, fixedBy α β a) ≃ { ab : α × β // ab.1 • ab.2 = ab.2 } :=
       (Equiv.subtypeProdEquivSigmaSubtype _).symm
-    _ ≃ { ba : β × α // ba.2 • ba.1 = ba.1 } := (Equiv.prodComm α β).subtypeEquiv fun ab => Iff.rfl
+    _ ≃ { ba : β × α // ba.2 • ba.1 = ba.1 } :=
+      ((Equiv.prodComm α β).subtypeEquiv fun ab => Iff.rfl)
     _ ≃ Σb : β, stabilizer α b :=
-      Equiv.subtypeProdEquivSigmaSubtype fun (b : β) a => a ∈ stabilizer α b
+      (Equiv.subtypeProdEquivSigmaSubtype fun (b : β) a => a ∈ stabilizer α b)
     _ ≃ Σωb : Σω : Ω, orbit α ω.out', stabilizer α (ωb.2 : β) :=
       (selfEquivSigmaOrbits α β).sigmaCongrLeft'
     _ ≃ Σω : Ω, Σb : orbit α ω.out', stabilizer α (b : β) :=
-      Equiv.sigmaAssoc fun (ω : Ω) (b : orbit α ω.out') => stabilizer α (b : β)
+      (Equiv.sigmaAssoc fun (ω : Ω) (b : orbit α ω.out') => stabilizer α (b : β))
     _ ≃ Σω : Ω, Σb : orbit α ω.out', stabilizer α ω.out' :=
-      Equiv.sigmaCongrRight fun ω =>
-        Equiv.sigmaCongrRight fun ⟨b, hb⟩ => (stabilizerEquivStabilizerOfOrbitRel hb).toEquiv
+      (Equiv.sigmaCongrRight fun ω =>
+        Equiv.sigmaCongrRight fun ⟨b, hb⟩ => (stabilizerEquivStabilizerOfOrbitRel hb).toEquiv)
     _ ≃ Σω : Ω, orbit α ω.out' × stabilizer α ω.out' :=
-      Equiv.sigmaCongrRight fun ω => Equiv.sigmaEquivProd _ _
-    _ ≃ Σω : Ω, α := Equiv.sigmaCongrRight fun ω => orbitProdStabilizerEquivGroup α ω.out'
+      (Equiv.sigmaCongrRight fun ω => Equiv.sigmaEquivProd _ _)
+    _ ≃ Σω : Ω, α := (Equiv.sigmaCongrRight fun ω => orbitProdStabilizerEquivGroup α ω.out')
     _ ≃ Ω × α := Equiv.sigmaEquivProd Ω α
     
 #align mul_action.sigma_fixed_by_equiv_orbits_prod_group MulAction.sigmaFixedByEquivOrbitsProdGroup

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

@@ -350,9 +350,9 @@ instance isPretransitive_quotient (G) [Group G] (H : Subgroup G) : IsPretransiti
 
 end MulAction
 
-set_option autoImplicit true in
-theorem ConjClasses.card_carrier [Group G] [Fintype G] (g : G) [Fintype (ConjClasses.mk g).carrier]
-    [Fintype <| MulAction.stabilizer (ConjAct G) g] : Fintype.card (ConjClasses.mk g).carrier =
+theorem ConjClasses.card_carrier {G : Type*} [Group G] [Fintype G] (g : G)
+    [Fintype (ConjClasses.mk g).carrier] [Fintype <| MulAction.stabilizer (ConjAct G) g] :
+    Fintype.card (ConjClasses.mk g).carrier =
       Fintype.card G / Fintype.card (MulAction.stabilizer (ConjAct G) g) := by
   classical
   rw [Fintype.card_congr <| ConjAct.toConjAct (G := G) |>.toEquiv]

Quoting [@digama0](https://github.com/digama0):

These were actually never meant to go in the file, they are basically debugging information and only useful on significantly broken mathport files. You can safely remove all of them.

@@ -233,7 +233,6 @@ theorem stabilizer_quotient {G} [Group G] (H : Subgroup G) :
 
 variable (β)
 
--- mathport name: exprΩ
 local notation "Ω" => Quotient <| orbitRel α β
 
 /-- **Class formula** : given `G` a group acting on `X` and `φ` a function mapping each orbit of `X`

These lemmas can easily go to Logic.Basic

@@ -427,7 +427,7 @@ theorem card_comm_eq_card_conjClasses_mul_card (G : Type*) [Group G] :
   rw [card_congr (Equiv.subtypeProdEquivSigmaSubtype Commute), card_sigma,
     sum_equiv ConjAct.toConjAct.toEquiv (fun a ↦ card { b // Commute a b })
       (fun g ↦ card (MulAction.fixedBy G g))
-      fun g ↦ card_congr' <| congr_arg _ <| funext fun h ↦ mul_inv_eq_iff_eq_mul.symm.to_eq,
+      fun g ↦ card_congr' <| congr_arg _ <| funext fun h ↦ mul_inv_eq_iff_eq_mul.symm.eq,
     MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group]
   congr 1; apply card_congr'; congr; ext;
   exact (Setoid.comm' _).trans isConj_iff.symm

I used the regex \(\(· (.) ·\) (.)\), replacing with ($2 $1 ·).

@@ -83,7 +83,7 @@ instance right_quotientAction' [hH : H.Normal] : QuotientAction αᵐᵒᵖ H :=
 @[to_additive]
 instance quotient [QuotientAction β H] : MulAction β (α ⧸ H) where
   smul b :=
-    Quotient.map' ((· • ·) b) fun _ _ h =>
+    Quotient.map' (b • ·) fun _ _ h =>
       leftRel_apply.mpr <| QuotientAction.inv_mul_mem b <| leftRel_apply.mp h
   one_smul q := Quotient.inductionOn' q fun a => congr_arg Quotient.mk'' (one_smul β a)
   mul_smul b b' q := Quotient.inductionOn' q fun a => congr_arg Quotient.mk'' (mul_smul b b' a)
@@ -120,7 +120,7 @@ theorem Quotient.coe_smul_out' [QuotientAction β H] (b : β) (q : α ⧸ H) : 
 #align add_action.quotient.coe_vadd_out' AddAction.Quotient.coe_vadd_out'
 
 theorem _root_.QuotientGroup.out'_conj_pow_minimalPeriod_mem (a : α) (q : α ⧸ H) :
-    q.out'⁻¹ * a ^ Function.minimalPeriod ((· • ·) a) q * q.out' ∈ H := by
+    q.out'⁻¹ * a ^ Function.minimalPeriod (a • ·) q * q.out' ∈ H := by
   rw [mul_assoc, ← QuotientGroup.eq', QuotientGroup.out_eq', ← smul_eq_mul, Quotient.mk_smul_out',
     eq_comm, pow_smul_eq_iff_minimalPeriod_dvd]
 #align quotient_group.out'_conj_pow_minimal_period_mem QuotientGroup.out'_conj_pow_minimalPeriod_mem

@@ -189,7 +189,7 @@ theorem injective_ofQuotientStabilizer : Function.Injective (ofQuotientStabilize
 #align mul_action.injective_of_quotient_stabilizer MulAction.injective_ofQuotientStabilizer
 #align add_action.injective_of_quotient_stabilizer AddAction.injective_ofQuotientStabilizer
 
-/-- Orbit-stabilizer theorem. -/
+/-- **Orbit-stabilizer theorem**. -/
 @[to_additive "Orbit-stabilizer theorem."]
 noncomputable def orbitEquivQuotientStabilizer (b : β) : orbit α b ≃ α ⧸ stabilizer α b :=
   Equiv.symm <|

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

@@ -357,7 +357,7 @@ theorem ConjClasses.card_carrier [Group G] [Fintype G] (g : G) [Fintype (ConjCla
       Fintype.card G / Fintype.card (MulAction.stabilizer (ConjAct G) g) := by
   classical
   rw [Fintype.card_congr <| ConjAct.toConjAct (G := G) |>.toEquiv]
-  rw [←MulAction.card_orbit_mul_card_stabilizer_eq_card_group (ConjAct G) g, Nat.mul_div_cancel]
+  rw [← MulAction.card_orbit_mul_card_stabilizer_eq_card_group (ConjAct G) g, Nat.mul_div_cancel]
   simp_rw [ConjAct.orbit_eq_carrier_conjClasses]
   exact Fintype.card_pos_iff.mpr inferInstance
 

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
• leanprover/lean4#2790
• leanprover/lean4#2783
• leanprover/lean4#2825
• leanprover/lean4#2722

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>

@@ -101,7 +101,7 @@ theorem Quotient.smul_mk [QuotientAction β H] (b : β) (a : α) :
 
 @[to_additive (attr := simp)]
 theorem Quotient.smul_coe [QuotientAction β H] (b : β) (a : α) :
-    b • (a : α ⧸ H) = (b • a : α ⧸ H) :=
+    b • (a : α ⧸ H) = (↑(b • a) : α ⧸ H) :=
   rfl
 #align mul_action.quotient.smul_coe MulAction.Quotient.smul_coe
 #align add_action.quotient.vadd_coe AddAction.Quotient.vadd_coe

I believe the file defining a type of morphisms belongs alongside the file defining the structure this morphism works on. So I would like to reorganize the files in the Mathlib.Algebra.Hom folder so that e.g. Mathlib.Algebra.Hom.Ring becomes Mathlib.Algebra.Ring.Hom and Mathlib.Algebra.Hom.NonUnitalAlg becomes Mathlib.Algebra.Algebra.NonUnitalHom.

While fixing the imports I went ahead and sorted them for good luck.

The full list of changes is: renamed: Mathlib/Algebra/Hom/NonUnitalAlg.lean -> Mathlib/Algebra/Algebra/NonUnitalHom.lean renamed: Mathlib/Algebra/Hom/Aut.lean -> Mathlib/Algebra/Group/Aut.lean renamed: Mathlib/Algebra/Hom/Commute.lean -> Mathlib/Algebra/Group/Commute/Hom.lean renamed: Mathlib/Algebra/Hom/Embedding.lean -> Mathlib/Algebra/Group/Embedding.lean renamed: Mathlib/Algebra/Hom/Equiv/Basic.lean -> Mathlib/Algebra/Group/Equiv/Basic.lean renamed: Mathlib/Algebra/Hom/Equiv/TypeTags.lean -> Mathlib/Algebra/Group/Equiv/TypeTags.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/Basic.lean -> Mathlib/Algebra/Group/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/GroupWithZero.lean -> Mathlib/Algebra/GroupWithZero/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Freiman.lean -> Mathlib/Algebra/Group/Freiman.lean renamed: Mathlib/Algebra/Hom/Group/Basic.lean -> Mathlib/Algebra/Group/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Group/Defs.lean -> Mathlib/Algebra/Group/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/GroupAction.lean -> Mathlib/GroupTheory/GroupAction/Hom.lean renamed: Mathlib/Algebra/Hom/GroupInstances.lean -> Mathlib/Algebra/Group/Hom/Instances.lean renamed: Mathlib/Algebra/Hom/Iterate.lean -> Mathlib/Algebra/GroupPower/IterateHom.lean renamed: Mathlib/Algebra/Hom/Centroid.lean -> Mathlib/Algebra/Ring/CentroidHom.lean renamed: Mathlib/Algebra/Hom/Ring/Basic.lean -> Mathlib/Algebra/Ring/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Ring/Defs.lean -> Mathlib/Algebra/Ring/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/Units.lean -> Mathlib/Algebra/Group/Units/Hom.lean

Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Reorganizing.20.60Mathlib.2EAlgebra.2EHom.60

@@ -4,12 +4,12 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Thomas Browning
 -/
 import Mathlib.Algebra.Group.ConjFinite
-import Mathlib.Algebra.Hom.GroupAction
 import Mathlib.Data.Fintype.BigOperators
 import Mathlib.Dynamics.PeriodicPts
-import Mathlib.GroupTheory.GroupAction.ConjAct
 import Mathlib.GroupTheory.Commutator
 import Mathlib.GroupTheory.Coset
+import Mathlib.GroupTheory.GroupAction.ConjAct
+import Mathlib.GroupTheory.GroupAction.Hom
 
 #align_import group_theory.group_action.quotient from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"
 

• Re-organise the namespace and section structure of GroupTheory/GroupAction/Basic.lean.
• Remove the namespaces MulAction.Stabilizer and AddAction.Stabilizer, renaming MulAction.Stabilizer.submonoid to MulAction.stabilizerSubmonoid.
• Make variables for the monoid/group/set implicit when an element or subset is used in the statement.

@@ -307,9 +307,9 @@ theorem card_eq_sum_card_group_div_card_stabilizer [Fintype α] [Fintype β] [Fi
       "**Burnside's lemma** : a (noncomputable) bijection between the disjoint union of all
       `{x ∈ X | g • x = x}` for `g ∈ G` and the product `G × X/G`, where `G` is an additive group
       acting on `X` and `X/G`denotes the quotient of `X` by the relation `orbitRel G X`. "]
-noncomputable def sigmaFixedByEquivOrbitsProdGroup : (Σa : α, fixedBy α β a) ≃ Ω × α :=
+noncomputable def sigmaFixedByEquivOrbitsProdGroup : (Σa : α, fixedBy β a) ≃ Ω × α :=
   calc
-    (Σa : α, fixedBy α β a) ≃ { ab : α × β // ab.1 • ab.2 = ab.2 } :=
+    (Σa : α, fixedBy β a) ≃ { ab : α × β // ab.1 • ab.2 = ab.2 } :=
       (Equiv.subtypeProdEquivSigmaSubtype _).symm
     _ ≃ { ba : β × α // ba.2 • ba.1 = ba.1 } := (Equiv.prodComm α β).subtypeEquiv fun _ => Iff.rfl
     _ ≃ Σb : β, stabilizer α b :=
@@ -333,8 +333,8 @@ elements fixed by each `g ∈ G` is the number of orbits. -/
 @[to_additive
       "**Burnside's lemma** : given a finite additive group `G` acting on a set `X`,
       the average number of elements fixed by each `g ∈ G` is the number of orbits. "]
-theorem sum_card_fixedBy_eq_card_orbits_mul_card_group [Fintype α] [∀ a, Fintype <| fixedBy α β a]
-    [Fintype Ω] : (∑ a : α, Fintype.card (fixedBy α β a)) = Fintype.card Ω * Fintype.card α := by
+theorem sum_card_fixedBy_eq_card_orbits_mul_card_group [Fintype α] [∀ a : α, Fintype <| fixedBy β a]
+    [Fintype Ω] : (∑ a : α, Fintype.card (fixedBy β a)) = Fintype.card Ω * Fintype.card α := by
   rw [← Fintype.card_prod, ← Fintype.card_sigma,
     Fintype.card_congr (sigmaFixedByEquivOrbitsProdGroup α β)]
 #align mul_action.sum_card_fixed_by_eq_card_orbits_mul_card_group MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group
@@ -426,7 +426,7 @@ theorem card_comm_eq_card_conjClasses_mul_card (G : Type*) [Group G] :
   -- Porting note: Changed `calc` proof into a `rw` proof.
   rw [card_congr (Equiv.subtypeProdEquivSigmaSubtype Commute), card_sigma,
     sum_equiv ConjAct.toConjAct.toEquiv (fun a ↦ card { b // Commute a b })
-      (fun g ↦ card (MulAction.fixedBy (ConjAct G) G g))
+      (fun g ↦ card (MulAction.fixedBy G g))
       fun g ↦ card_congr' <| congr_arg _ <| funext fun h ↦ mul_inv_eq_iff_eq_mul.symm.to_eq,
     MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group]
   congr 1; apply card_congr'; congr; ext;

We have turned to Type* instead of Type _, but many of them remained in mathlib because the straight replacement did not work. In general, having Type _ before the colon is a code smell, though, as it hides which types should be in the same universe and which shouldn't, and is not very robust.

This PR replaces most of the remaining Type _ before the colon (except those in category theory) by Type* or Type u. This has uncovered a few bugs (where declarations were not as polymorphic as they should be).

I had to increase heartbeats at two places when replacing Type _ by Type*, but I think it's worth it as it's really more robust.

@@ -49,7 +49,7 @@ class QuotientAction : Prop where
 #align mul_action.quotient_action MulAction.QuotientAction
 
 /-- A typeclass for when an `AddAction β α` descends to the quotient `α ⧸ H`. -/
-class _root_.AddAction.QuotientAction {α : Type*} (β : Type _) [AddGroup α] [AddMonoid β]
+class _root_.AddAction.QuotientAction {α : Type u} (β : Type v) [AddGroup α] [AddMonoid β]
   [AddAction β α] (H : AddSubgroup α) : Prop where
   /-- The action fulfils a normality condition on summands that lie in `H`.
     This ensures that the action descends to an action on the quotient `α ⧸ H`. -/

We already have API for the multiplicative opposite of subgroups.

This tidies the API for subgroups by introducing separate .op and .unop definitions (as dot notation on .opposite worked in Lean 3 but not Lean 4), and adds the same API for submonoids.

@@ -65,7 +65,7 @@ instance left_quotientAction : QuotientAction α H :=
 #align add_action.left_quotient_action AddAction.left_quotientAction
 
 @[to_additive]
-instance right_quotientAction : QuotientAction (opposite (normalizer H)) H :=
+instance right_quotientAction : QuotientAction (normalizer H).op H :=
   ⟨fun b c _ _ => by
     rwa [smul_def, smul_def, smul_eq_mul_unop, smul_eq_mul_unop, mul_inv_rev, ← mul_assoc,
       mem_normalizer_iff'.mp b.prop, mul_assoc, mul_inv_cancel_left]⟩

This makes it easier to refactor the order or inheritance structure of morphisms without having to change all of the anonymous constructors.

This is far from exhaustive.

@@ -130,8 +130,8 @@ end QuotientAction
 open QuotientGroup
 
 /-- The canonical map to the left cosets. -/
-def _root_.MulActionHom.toQuotient (H : Subgroup α) : α →[α] α ⧸ H :=
-  ⟨(↑), Quotient.smul_coe H⟩
+def _root_.MulActionHom.toQuotient (H : Subgroup α) : α →[α] α ⧸ H where
+  toFun := (↑); map_smul' := Quotient.smul_coe H
 #align mul_action_hom.to_quotient MulActionHom.toQuotient
 
 @[simp]

This PR protects Function.Commute, so that it no longer clashes with Commute in the root namespace, as suggested by @j-loreaux in #6290.

@@ -418,14 +418,14 @@ section conjClasses
 open Fintype
 
 theorem card_comm_eq_card_conjClasses_mul_card (G : Type*) [Group G] :
-    Nat.card { p : G × G // _root_.Commute p.1 p.2 } = Nat.card (ConjClasses G) * Nat.card G := by
+    Nat.card { p : G × G // Commute p.1 p.2 } = Nat.card (ConjClasses G) * Nat.card G := by
   classical
   rcases fintypeOrInfinite G; swap
   · rw [mul_comm, Nat.card_eq_zero_of_infinite, Nat.card_eq_zero_of_infinite, zero_mul]
   simp only [Nat.card_eq_fintype_card]
   -- Porting note: Changed `calc` proof into a `rw` proof.
-  rw [card_congr (Equiv.subtypeProdEquivSigmaSubtype _root_.Commute), card_sigma,
-    sum_equiv ConjAct.toConjAct.toEquiv (fun a ↦ card { b // _root_.Commute a b })
+  rw [card_congr (Equiv.subtypeProdEquivSigmaSubtype Commute), card_sigma,
+    sum_equiv ConjAct.toConjAct.toEquiv (fun a ↦ card { b // Commute a b })
       (fun g ↦ card (MulAction.fixedBy (ConjAct G) G g))
       fun g ↦ card_congr' <| congr_arg _ <| funext fun h ↦ mul_inv_eq_iff_eq_mul.symm.to_eq,
     MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group]

Autoimplicits are highly controversial and also defeat the performance-improving work in #6474.

The intent of this PR is to make autoImplicit opt-in on a per-file basis, by disabling it in the lakefile and enabling it again with set_option autoImplicit true in the few files that rely on it.

That also keeps this PR small, as opposed to attempting to "fix" files to not need it any more.

I claim that many of the uses of autoImplicit in these files are accidental; situations such as:

• Assuming variables are in scope, but pasting the lemma in the wrong section
• Pasting in a lemma from a scratch file without checking to see if the variable names are consistent with the rest of the file
• Making a copy-paste error between lemmas and forgetting to add an explicit arguments.

Having set_option autoImplicit false as the default prevents these types of mistake being made in the 90% of files where autoImplicits are not used at all, and causes them to be caught by CI during review.

I think there were various points during the port where we encouraged porters to delete the universes u v lines; I think having autoparams for universe variables only would cover a lot of the cases we actually use them, while avoiding any real shortcomings.

A Zulip poll (after combining overlapping votes accordingly) was in favor of this change with 5:5:18 as the no:dontcare:yes vote ratio.

While this PR was being reviewed, a handful of files gained some more likely-accidental autoImplicits. In these places, set_option autoImplicit true has been placed locally within a section, rather than at the top of the file.

@@ -351,6 +351,7 @@ instance isPretransitive_quotient (G) [Group G] (H : Subgroup G) : IsPretransiti
 
 end MulAction
 
+set_option autoImplicit true in
 theorem ConjClasses.card_carrier [Group G] [Fintype G] (g : G) [Fintype (ConjClasses.mk g).carrier]
     [Fintype <| MulAction.stabilizer (ConjAct G) g] : Fintype.card (ConjClasses.mk g).carrier =
       Fintype.card G / Fintype.card (MulAction.stabilizer (ConjAct G) g) := by

This is mostly mathported work of Johan's towards Wedderburn's Little theorem.

Co-authored-by: Eric Rodriguez <37984851+ericrbg@users.noreply.github.com>

@@ -351,6 +351,15 @@ instance isPretransitive_quotient (G) [Group G] (H : Subgroup G) : IsPretransiti
 
 end MulAction
 
+theorem ConjClasses.card_carrier [Group G] [Fintype G] (g : G) [Fintype (ConjClasses.mk g).carrier]
+    [Fintype <| MulAction.stabilizer (ConjAct G) g] : Fintype.card (ConjClasses.mk g).carrier =
+      Fintype.card G / Fintype.card (MulAction.stabilizer (ConjAct G) g) := by
+  classical
+  rw [Fintype.card_congr <| ConjAct.toConjAct (G := G) |>.toEquiv]
+  rw [←MulAction.card_orbit_mul_card_stabilizer_eq_card_group (ConjAct G) g, Nat.mul_div_cancel]
+  simp_rw [ConjAct.orbit_eq_carrier_conjClasses]
+  exact Fintype.card_pos_iff.mpr inferInstance
+
 namespace Subgroup
 
 variable {G : Type*} [Group G] (H : Subgroup G)

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

This has nice performance benefits.

@@ -49,7 +49,7 @@ class QuotientAction : Prop where
 #align mul_action.quotient_action MulAction.QuotientAction
 
 /-- A typeclass for when an `AddAction β α` descends to the quotient `α ⧸ H`. -/
-class _root_.AddAction.QuotientAction {α : Type _} (β : Type _) [AddGroup α] [AddMonoid β]
+class _root_.AddAction.QuotientAction {α : Type*} (β : Type _) [AddGroup α] [AddMonoid β]
   [AddAction β α] (H : AddSubgroup α) : Prop where
   /-- The action fulfils a normality condition on summands that lie in `H`.
     This ensures that the action descends to an action on the quotient `α ⧸ H`. -/
@@ -353,7 +353,7 @@ end MulAction
 
 namespace Subgroup
 
-variable {G : Type _} [Group G] (H : Subgroup G)
+variable {G : Type*} [Group G] (H : Subgroup G)
 
 theorem normalCore_eq_ker : H.normalCore = (MulAction.toPermHom G (G ⧸ H)).ker := by
   apply le_antisymm
@@ -407,7 +407,7 @@ section conjClasses
 
 open Fintype
 
-theorem card_comm_eq_card_conjClasses_mul_card (G : Type _) [Group G] :
+theorem card_comm_eq_card_conjClasses_mul_card (G : Type*) [Group G] :
     Nat.card { p : G × G // _root_.Commute p.1 p.2 } = Nat.card (ConjClasses G) * Nat.card G := by
   classical
   rcases fintypeOrInfinite G; swap

This PR moves a formula for the number of conjugacy classes earlier. The proof uses Burnside's theorem, so it cannot be moved any earlier than GroupTheory/GroupAction/Quotient.

@@ -3,6 +3,7 @@ Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Thomas Browning
 -/
+import Mathlib.Algebra.Group.ConjFinite
 import Mathlib.Algebra.Hom.GroupAction
 import Mathlib.Data.Fintype.BigOperators
 import Mathlib.Dynamics.PeriodicPts
@@ -401,3 +402,25 @@ theorem quotientCenterEmbedding_apply {S : Set G} (hS : closure S = ⊤) (g : G)
 #align subgroup.quotient_center_embedding_apply Subgroup.quotientCenterEmbedding_apply
 
 end Subgroup
+
+section conjClasses
+
+open Fintype
+
+theorem card_comm_eq_card_conjClasses_mul_card (G : Type _) [Group G] :
+    Nat.card { p : G × G // _root_.Commute p.1 p.2 } = Nat.card (ConjClasses G) * Nat.card G := by
+  classical
+  rcases fintypeOrInfinite G; swap
+  · rw [mul_comm, Nat.card_eq_zero_of_infinite, Nat.card_eq_zero_of_infinite, zero_mul]
+  simp only [Nat.card_eq_fintype_card]
+  -- Porting note: Changed `calc` proof into a `rw` proof.
+  rw [card_congr (Equiv.subtypeProdEquivSigmaSubtype _root_.Commute), card_sigma,
+    sum_equiv ConjAct.toConjAct.toEquiv (fun a ↦ card { b // _root_.Commute a b })
+      (fun g ↦ card (MulAction.fixedBy (ConjAct G) G g))
+      fun g ↦ card_congr' <| congr_arg _ <| funext fun h ↦ mul_inv_eq_iff_eq_mul.symm.to_eq,
+    MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group]
+  congr 1; apply card_congr'; congr; ext;
+  exact (Setoid.comm' _).trans isConj_iff.symm
+#align card_comm_eq_card_conj_classes_mul_card card_comm_eq_card_conjClasses_mul_card
+
+end conjClasses

@@ -10,7 +10,7 @@ import Mathlib.GroupTheory.GroupAction.ConjAct
 import Mathlib.GroupTheory.Commutator
 import Mathlib.GroupTheory.Coset
 
-#align_import group_theory.group_action.quotient from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+#align_import group_theory.group_action.quotient from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"
 
 /-!
 # Properties of group actions involving quotient groups

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2018 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Thomas Browning
-
-! This file was ported from Lean 3 source module group_theory.group_action.quotient
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Hom.GroupAction
 import Mathlib.Data.Fintype.BigOperators
@@ -15,6 +10,8 @@ import Mathlib.GroupTheory.GroupAction.ConjAct
 import Mathlib.GroupTheory.Commutator
 import Mathlib.GroupTheory.Coset
 
+#align_import group_theory.group_action.quotient from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Properties of group actions involving quotient groups
 

As discussed on Zulip

Renames

• supₛ → sSup
• infₛ → sInf
• supᵢ → iSup
• infᵢ → iInf
• bsupₛ → bsSup
• binfₛ → bsInf
• bsupᵢ → biSup
• binfᵢ → biInf
• csupₛ → csSup
• cinfₛ → csInf
• csupᵢ → ciSup
• cinfᵢ → ciInf
• unionₛ → sUnion
• interₛ → sInter
• unionᵢ → iUnion
• interᵢ → iInter
• bunionₛ → bsUnion
• binterₛ → bsInter
• bunionᵢ → biUnion
• binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -394,7 +394,7 @@ of commutators. -/
 noncomputable def quotientCenterEmbedding {S : Set G} (hS : closure S = ⊤) :
     G ⧸ center G ↪ S → commutatorSet G :=
   (quotientEquivOfEq (center_eq_infi' S hS)).toEmbedding.trans
-    ((quotientInfᵢEmbedding _).trans
+    ((quotientiInfEmbedding _).trans
       (Function.Embedding.piCongrRight fun g => quotientCentralizerEmbedding (g : G)))
 #align subgroup.quotient_center_embedding Subgroup.quotientCenterEmbedding
 

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

@@ -272,11 +272,8 @@ theorem card_eq_sum_card_group_div_card_stabilizer' [Fintype α] [Fintype β] [F
     [∀ b : β, Fintype <| stabilizer α b] {φ : Ω → β} (hφ : LeftInverse Quotient.mk'' φ) :
     Fintype.card β = ∑ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) := by
   classical
-    have :
-      ∀ ω : Ω,
-        Fintype.card α / Fintype.card (stabilizer α (φ ω)) =
-          Fintype.card (α ⧸ stabilizer α (φ ω)) :=
-      by
+    have : ∀ ω : Ω, Fintype.card α / Fintype.card (stabilizer α (φ ω)) =
+        Fintype.card (α ⧸ stabilizer α (φ ω)) := by
       intro ω
       rw [Fintype.card_congr (@Subgroup.groupEquivQuotientProdSubgroup α _ (stabilizer α <| φ ω)),
         Fintype.card_prod, Nat.mul_div_cancel]

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

@@ -158,7 +158,6 @@ def ofQuotientStabilizer (g : α ⧸ MulAction.stabilizer α x) : β :=
     calc
       g1 • x = g1 • (g1⁻¹ * g2) • x := congr_arg _ (leftRel_apply.mp H).symm
       _ = g2 • x := by rw [smul_smul, mul_inv_cancel_left]
-
 #align mul_action.of_quotient_stabilizer MulAction.ofQuotientStabilizer
 #align add_action.of_quotient_stabilizer AddAction.ofQuotientStabilizer
 

@@ -75,16 +75,15 @@ instance right_quotientAction : QuotientAction (opposite (normalizer H)) H :=
 #align add_action.right_quotient_action AddAction.right_quotientAction
 
 @[to_additive]
-instance right_quotient_action' [hH : H.Normal] : QuotientAction αᵐᵒᵖ H :=
+instance right_quotientAction' [hH : H.Normal] : QuotientAction αᵐᵒᵖ H :=
   ⟨fun _ _ _ _ => by
     rwa [smul_eq_mul_unop, smul_eq_mul_unop, mul_inv_rev, mul_assoc, hH.mem_comm_iff, mul_assoc,
       mul_inv_cancel_right]⟩
-#align mul_action.right_quotient_action' MulAction.right_quotient_action'
-#align add_action.right_quotient_action' AddAction.right_quotient_action'
+#align mul_action.right_quotient_action' MulAction.right_quotientAction'
+#align add_action.right_quotient_action' AddAction.right_quotientAction'
 
 @[to_additive]
-instance quotient [QuotientAction β H] : MulAction β (α ⧸ H)
-    where
+instance quotient [QuotientAction β H] : MulAction β (α ⧸ H) where
   smul b :=
     Quotient.map' ((· • ·) b) fun _ _ h =>
       leftRel_apply.mpr <| QuotientAction.inv_mul_mem b <| leftRel_apply.mp h
@@ -348,8 +347,8 @@ theorem sum_card_fixedBy_eq_card_orbits_mul_card_group [Fintype α] [∀ a, Fint
 #align add_action.sum_card_fixed_by_eq_card_orbits_add_card_add_group AddAction.sum_card_fixedBy_eq_card_orbits_add_card_addGroup
 
 @[to_additive]
-instance isPretransitive_quotient (G) [Group G] (H : Subgroup G) : IsPretransitive G (G ⧸ H)
-    where exists_smul_eq := by
+instance isPretransitive_quotient (G) [Group G] (H : Subgroup G) : IsPretransitive G (G ⧸ H) where
+  exists_smul_eq := by
     { rintro ⟨x⟩ ⟨y⟩
       refine' ⟨y * x⁻¹, QuotientGroup.eq.mpr _⟩
       simp only [smul_eq_mul, H.one_mem, mul_left_inv, inv_mul_cancel_right]}

Co-authored-by: Johan Commelin <johan@commelin.net>