group_theory.perm.cycle.basic ⟷ Mathlib.GroupTheory.Perm.Cycle.Factors

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

@@ -6,7 +6,7 @@ Authors: Chris Hughes, Yaël Dillies
 import Algebra.Module.BigOperators
 import Data.Finset.NoncommProd
 import Data.Fintype.Perm
-import Data.Int.Modeq
+import Data.Int.ModEq
 import GroupTheory.Perm.List
 import GroupTheory.Perm.Sign
 import Logic.Equiv.Fintype
@@ -212,14 +212,14 @@ theorem sameCycle_zpow_right {n : ℤ} : SameCycle f x ((f ^ n) y) ↔ SameCycle
 #print Equiv.Perm.sameCycle_pow_left /-
 @[simp]
 theorem sameCycle_pow_left {n : ℕ} : SameCycle f ((f ^ n) x) y ↔ SameCycle f x y := by
-  rw [← zpow_coe_nat, same_cycle_zpow_left]
+  rw [← zpow_natCast, same_cycle_zpow_left]
 #align equiv.perm.same_cycle_pow_left Equiv.Perm.sameCycle_pow_left
 -/
 
 #print Equiv.Perm.sameCycle_pow_right /-
 @[simp]
 theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y := by
-  rw [← zpow_coe_nat, same_cycle_zpow_right]
+  rw [← zpow_natCast, same_cycle_zpow_right]
 #align equiv.perm.same_cycle_pow_right Equiv.Perm.sameCycle_pow_right
 -/
 
@@ -297,7 +297,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
   use(k % orderOf f).natAbs
   have h₀ := int.coe_nat_pos.mpr (orderOf_pos f)
   have h₁ := Int.emod_nonneg k h₀.ne'
-  rw [← zpow_coe_nat, Int.natAbs_of_nonneg h₁, ← zpow_mod_orderOf]
+  rw [← zpow_natCast, Int.natAbs_of_nonneg h₁, ← zpow_mod_orderOf]
   refine' ⟨_, rfl⟩
   rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
   exact Int.emod_lt_of_pos _ h₀
@@ -323,14 +323,14 @@ instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f
           (Int.ofNat_lt.1 <|
             by
             rw [Int.natAbs_of_nonneg
-                (Int.emod_nonneg _ <| Int.coe_nat_ne_zero.2 (orderOf_pos _).ne')]
-            · refine' (Int.emod_lt _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _).trans_le _
+                (Int.emod_nonneg _ <| Int.natCast_ne_zero.2 (orderOf_pos _).ne')]
+            · refine' (Int.emod_lt _ <| Int.natCast_ne_zero_iff_pos.2 <| orderOf_pos _).trans_le _
               simp [orderOf_le_card_univ]
             infer_instance),
         by
-        rw [← zpow_coe_nat,
+        rw [← zpow_natCast,
           Int.natAbs_of_nonneg
-            (Int.emod_nonneg _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _),
+            (Int.emod_nonneg _ <| Int.natCast_ne_zero_iff_pos.2 <| orderOf_pos _),
           ← zpow_mod_orderOf, hi]
         infer_instance⟩⟩
 
@@ -444,7 +444,7 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
     ⟨(n % orderOf f).toNat,
       by
       have := n.mod_nonneg (int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
-      rwa [← zpow_coe_nat, Int.toNat_of_nonneg this, ← zpow_mod_orderOf]⟩
+      rwa [← zpow_natCast, Int.toNat_of_nonneg this, ← zpow_mod_orderOf]⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 -/
 
@@ -557,7 +557,7 @@ theorem isCycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
         exact this.1
       let ⟨i, hi⟩ :=
         is_cycle_swap_mul_aux₁ n hb'
-          (f.Injective <| by rw [apply_inv_self]; rwa [pow_succ, mul_apply] at h)
+          (f.Injective <| by rw [apply_inv_self]; rwa [pow_succ', mul_apply] at h)
       ⟨i + 1, by
         rw [add_comm, zpow_add, mul_apply, hi, zpow_one, mul_apply, apply_inv_self,
           swap_apply_of_ne_of_ne (ne_and_ne_of_swap_mul_apply_ne_self hb).2 (Ne.symm hfbx)]⟩
@@ -583,15 +583,15 @@ theorem isCycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
       let ⟨i, hi⟩ :=
         isCycle_swap_mul_aux₁ n hb
           (show (f⁻¹ ^ n) (f⁻¹ x) = f⁻¹ b by
-            rw [← zpow_coe_nat, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc, ← inv_pow,
-              pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_coe_nat, ← pow_succ', ←
-              pow_succ])
+            rw [← zpow_natCast, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc, ← inv_pow,
+              pow_succ, mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_natCast, ← pow_succ, ←
+              pow_succ'])
       have h : (swap x (f⁻¹ x) * f⁻¹) (f x) = f⁻¹ x := by
         rw [mul_apply, inv_apply_self, swap_apply_left]
       ⟨-i, by
-        rw [← add_sub_cancel i 1, neg_sub, sub_eq_add_neg, zpow_add, zpow_one, zpow_neg, ← inv_zpow,
-          mul_inv_rev, swap_inv, mul_swap_eq_swap_mul, inv_apply_self, swap_comm _ x, zpow_add,
-          zpow_one, mul_apply, mul_apply (_ ^ i), h, hi, mul_apply, apply_inv_self,
+        rw [← add_sub_cancel_right i 1, neg_sub, sub_eq_add_neg, zpow_add, zpow_one, zpow_neg, ←
+          inv_zpow, mul_inv_rev, swap_inv, mul_swap_eq_swap_mul, inv_apply_self, swap_comm _ x,
+          zpow_add, zpow_one, mul_apply, mul_apply (_ ^ i), h, hi, mul_apply, apply_inv_self,
           swap_apply_of_ne_of_ne this.2 (Ne.symm hfbx')]⟩
 #align equiv.perm.is_cycle_swap_mul_aux₂ Equiv.Perm.isCycle_swap_mul_aux₂
 -/
@@ -853,7 +853,7 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
     · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
       simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
     · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
-      simp only [zpow_one, zpow_coe_nat] at h
+      simp only [zpow_one, zpow_natCast] at h
       rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa
       contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
@@ -1037,10 +1037,10 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
 #print Equiv.Perm.IsCycleOn.zpow_apply_eq /-
 theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
     ∀ {n : ℤ}, (f ^ n) a = a ↔ (s.card : ℤ) ∣ n
-  | Int.ofNat n => (hf.pow_apply_eq ha).trans Int.coe_nat_dvd.symm
+  | Int.ofNat n => (hf.pow_apply_eq ha).trans Int.natCast_dvd_natCast.symm
   | Int.negSucc n => by
     rw [zpow_negSucc, ← inv_pow]
-    exact (hf.inv.pow_apply_eq ha).trans (dvd_neg.trans Int.coe_nat_dvd).symm
+    exact (hf.inv.pow_apply_eq ha).trans (dvd_neg.trans Int.natCast_dvd_natCast).symm
 #align equiv.perm.is_cycle_on.zpow_apply_eq Equiv.Perm.IsCycleOn.zpow_apply_eq
 -/
 
@@ -1076,10 +1076,10 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
   obtain ⟨n, rfl⟩ := hf.2 ha hb
   obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.Dvd
   refine' ⟨n.nat_mod s.card, Int.natMod_lt (nonempty.card_pos ⟨a, ha⟩).ne', _⟩
-  rw [← zpow_coe_nat, Int.natMod,
+  rw [← zpow_natCast, Int.natMod,
     Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2 (nonempty.card_pos ⟨a, ha⟩).ne'),
     sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
-  simp only [zpow_coe_nat, coe_mul, EmbeddingLike.apply_eq_iff_eq]
+  simp only [zpow_natCast, coe_mul, EmbeddingLike.apply_eq_iff_eq]
   exact is_fixed_pt.perm_zpow (hf.pow_card_apply ha) _
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
 -/
@@ -1177,7 +1177,7 @@ theorem cycleOf_pow_apply_self (f : Perm α) (x : α) : ∀ n : ℕ, (cycleOf f
   | 0 => rfl
   | n + 1 =>
     by
-    rw [pow_succ, mul_apply, cycle_of_apply, cycle_of_pow_apply_self, if_pos, pow_succ, mul_apply]
+    rw [pow_succ', mul_apply, cycle_of_apply, cycle_of_pow_apply_self, if_pos, pow_succ', mul_apply]
     exact ⟨n, rfl⟩
 #align equiv.perm.cycle_of_pow_apply_self Equiv.Perm.cycleOf_pow_apply_self
 -/
@@ -1942,7 +1942,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
     induction' n with n ih
     · exact subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _))
     · convert H.mul_mem (H.mul_mem h3 ih) (H.inv_mem h3)
-      simp_rw [mul_swap_eq_swap_mul, mul_inv_cancel_right, pow_succ]; rfl
+      simp_rw [mul_swap_eq_swap_mul, mul_inv_cancel_right, pow_succ']; rfl
   have step2 : ∀ n : ℕ, swap x ((σ ^ n) x) ∈ H :=
     by
     intro n
@@ -1950,7 +1950,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
     · convert H.one_mem
       exact swap_self x
     · by_cases h5 : x = (σ ^ n) x
-      · rw [pow_succ, mul_apply, ← h5]; exact h4
+      · rw [pow_succ', mul_apply, ← h5]; exact h4
       by_cases h6 : x = (σ ^ (n + 1)) x
       · rw [← h6, swap_self]; exact H.one_mem
       rw [swap_comm, ← swap_mul_swap_mul_swap h5 h6]
@@ -2060,7 +2060,7 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
   apply (congr rfl (congr rfl (congr rfl (hσ.zpowers_equiv_support_symm_apply (n + 1))))).trans _
   simp only [Ne.def, is_cycle.zpowers_equiv_support_apply, Subtype.coe_mk,
     zpowersEquivZPowers_apply]
-  rw [pow_succ, perm.mul_apply]
+  rw [pow_succ', perm.mul_apply]
 #align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
 -/
 
@@ -2185,7 +2185,7 @@ theorem Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn {a | a ∈
   rw [Set.mem_setOf, ← index_of_lt_length] at ha hb
   rw [← index_of_nth_le ha, ← index_of_nth_le hb]
   refine' ⟨l.index_of b - l.index_of a, _⟩
-  simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_coe_nat,
+  simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_natCast,
     Equiv.Perm.coe_mul, form_perm_pow_apply_nth_le _ h]
   rw [add_comm]
 #align list.nodup.is_cycle_on_form_perm List.Nodup.isCycleOn_formPerm

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

@@ -415,7 +415,7 @@ protected theorem IsCycle.extendDomain {p : β → Prop} [DecidablePred p] (f :
   have h : b = f (f.symm ⟨b, of_not_not <| hb ∘ extend_domain_apply_not_subtype _ _⟩) := by
     rw [apply_symm_apply, Subtype.coe_mk]
   rw [h] at hb ⊢
-  simp only [extend_domain_apply_image, subtype.coe_injective.ne_iff, f.injective.ne_iff] at hb 
+  simp only [extend_domain_apply_image, subtype.coe_injective.ne_iff, f.injective.ne_iff] at hb
   exact (ha' hb).extendDomain
 #align equiv.perm.is_cycle.extend_domain Equiv.Perm.IsCycle.extendDomain
 -/
@@ -425,7 +425,7 @@ theorem isCycle_iff_sameCycle (hx : f x ≠ x) : IsCycle f ↔ ∀ {y}, SameCycl
   ⟨fun hf y =>
     ⟨fun ⟨i, hi⟩ hy =>
       hx <| by
-        rw [← zpow_apply_eq_self_of_apply_eq_self hy i, (f ^ i).Injective.eq_iff] at hi 
+        rw [← zpow_apply_eq_self_of_apply_eq_self hy i, (f ^ i).Injective.eq_iff] at hi
         rw [hi, hy],
       hf.exists_zpow_eq hx⟩,
     fun h => ⟨x, hx, fun y hy => h.2 hy⟩⟩
@@ -477,11 +477,11 @@ theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by
   classical
   have : IsOfFinOrder f := isOfFinOrder_of_finite f
-  rw [isOfFinOrder_iff_pow_eq_one] at this 
+  rw [isOfFinOrder_iff_pow_eq_one] at this
   obtain ⟨x, hx, hx'⟩ := hf
   obtain ⟨_ | _ | k, hk, hk'⟩ := this
   · exact absurd hk (lt_asymm hk)
-  · rw [pow_one] at hk' 
+  · rw [pow_one] at hk'
     simpa [hk'] using hx
   · exact ⟨k + 2, by simp, hk'⟩
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
@@ -506,7 +506,7 @@ noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ)
           rw [Subtype.coe_mk, Subtype.coe_mk, zpow_apply_comm σ m i, zpow_apply_comm σ n i]
           exact congr_arg _ (subtype.ext_iff.mp h)
       · rintro ⟨y, hy⟩
-        rw [Finset.mem_coe, mem_support] at hy 
+        rw [Finset.mem_coe, mem_support] at hy
         obtain ⟨n, rfl⟩ := (Classical.choose_spec hσ).2 hy
         exact ⟨⟨σ ^ n, n, rfl⟩, rfl⟩)
 #align equiv.perm.is_cycle.zpowers_equiv_support Equiv.Perm.IsCycle.zpowersEquivSupport
@@ -557,7 +557,7 @@ theorem isCycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
         exact this.1
       let ⟨i, hi⟩ :=
         is_cycle_swap_mul_aux₁ n hb'
-          (f.Injective <| by rw [apply_inv_self]; rwa [pow_succ, mul_apply] at h )
+          (f.Injective <| by rw [apply_inv_self]; rwa [pow_succ, mul_apply] at h)
       ⟨i + 1, by
         rw [add_comm, zpow_add, mul_apply, hi, zpow_one, mul_apply, apply_inv_self,
           swap_apply_of_ne_of_ne (ne_and_ne_of_swap_mul_apply_ne_self hb).2 (Ne.symm hfbx)]⟩
@@ -609,10 +609,10 @@ theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type _} [DecidableEq α] {f
         rw [swap_apply_of_ne_of_ne hyx hfyx]
         refine' by_contradiction fun hy => _
         cases' hz.2 hy with j hj
-        rw [← sub_add_cancel j i, zpow_add, mul_apply, hi] at hj 
+        rw [← sub_add_cancel j i, zpow_add, mul_apply, hi] at hj
         cases' zpow_apply_eq_of_apply_apply_eq_self hffx (j - i) with hji hji
-        · rw [← hj, hji] at hyx ; cc
-        · rw [← hj, hji] at hfyx ; cc
+        · rw [← hj, hji] at hyx; cc
+        · rw [← hj, hji] at hfyx; cc
 #align equiv.perm.is_cycle.eq_swap_of_apply_apply_eq_self Equiv.Perm.IsCycle.eq_swap_of_apply_apply_eq_self
 -/
 
@@ -684,7 +684,7 @@ theorem IsCycle.of_zpow {n : ℤ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f
     IsCycle f := by
   cases n
   · exact h1.of_pow h2
-  · simp only [le_eq_subset, zpow_negSucc, perm.support_inv] at h1 h2 
+  · simp only [le_eq_subset, zpow_negSucc, perm.support_inv] at h1 h2
     simpa using h1.inv.of_pow h2
 #align equiv.perm.is_cycle.of_zpow Equiv.Perm.IsCycle.of_zpow
 -/
@@ -732,7 +732,7 @@ theorem IsCycle.eq_on_support_inter_nonempty_congr (hf : IsCycle f) (hg : IsCycl
     intro y hy
     obtain ⟨k, rfl⟩ := hf.exists_pow_eq (mem_support.mp hx') (mem_support.mp hy)
     rwa [pow_eq_on_of_mem_support h _ _ (mem_inter_of_mem hx' hx''), pow_apply_mem_support]
-  rw [(inter_eq_left_iff_subset _ _).mpr this] at h 
+  rw [(inter_eq_left_iff_subset _ _).mpr this] at h
   exact hf.support_congr hg this h
 #align equiv.perm.is_cycle.eq_on_support_inter_nonempty_congr Equiv.Perm.IsCycle.eq_on_support_inter_nonempty_congr
 -/
@@ -781,7 +781,7 @@ theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
       refine' h.ne_one _
       simp [pow_mul, pow_orderOf_eq_one]
     have : orderOf (f ^ n) = orderOf f := by rw [h.order_of, hr, hf.order_of]
-    rw [orderOf_pow, Nat.div_eq_self] at this 
+    rw [orderOf_pow, Nat.div_eq_self] at this
     cases this
     · exact absurd this (orderOf_pos _).ne'
     · rwa [Nat.coprime_iff_gcd_eq_one, Nat.gcd_comm]
@@ -806,9 +806,9 @@ theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : 
     exact ⟨x, hx, by simp [h]⟩
   · rintro ⟨x, hx, hx'⟩
     by_cases h : support (f ^ n) = support f
-    · rw [← mem_support, ← h, mem_support] at hx 
+    · rw [← mem_support, ← h, mem_support] at hx
       contradiction
-    · rw [hf.support_pow_eq_iff, Classical.not_not] at h 
+    · rw [hf.support_pow_eq_iff, Classical.not_not] at h
       obtain ⟨k, rfl⟩ := h
       rw [pow_mul, pow_orderOf_eq_one, one_pow]
 #align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iff
@@ -846,15 +846,15 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
     wlog hab : a ≤ b generalizing a b
     · exact (this hx'.symm (le_of_not_le hab)).symm
     suffices f ^ (b - a) = 1 by
-      rw [pow_sub _ hab, mul_inv_eq_one] at this 
+      rw [pow_sub _ hab, mul_inv_eq_one] at this
       rw [this]
     rw [hf.pow_eq_one_iff]
     by_cases hfa : (f ^ a) x ∈ f.support
     · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
       simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
     · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
-      simp only [zpow_one, zpow_coe_nat] at h 
-      rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa 
+      simp only [zpow_one, zpow_coe_nat] at h
+      rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa
       contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
 -/
@@ -870,7 +870,7 @@ theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf
     exact Nat.not_dvd_of_pos_of_lt hn hn'
   obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
   have hf'' := hf
-  rw [← hm] at hf'' 
+  rw [← hm] at hf''
   refine' hf''.of_pow _
   rw [hm]
   exact support_pow_le f n
@@ -936,7 +936,7 @@ alias ⟨is_cycle_on.of_inv, is_cycle_on.inv⟩ := is_cycle_on_inv
 #print Equiv.Perm.IsCycleOn.conj /-
 theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Perm α) '' s) :=
   ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy => by
-    rw [← preimage_inv] at hx hy ; convert (h.2 hx hy).conj <;> rw [apply_inv_self]⟩
+    rw [← preimage_inv] at hx hy; convert (h.2 hx hy).conj <;> rw [apply_inv_self]⟩
 #align equiv.perm.is_cycle_on.conj Equiv.Perm.IsCycleOn.conj
 -/
 
@@ -944,7 +944,7 @@ theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Pe
 theorem isCycleOn_swap [DecidableEq α] (hab : a ≠ b) : (swap a b).IsCycleOn {a, b} :=
   ⟨bijOn_swap (by simp) (by simp), fun x hx y hy =>
     by
-    rw [Set.mem_insert_iff, Set.mem_singleton_iff] at hx hy 
+    rw [Set.mem_insert_iff, Set.mem_singleton_iff] at hx hy
     obtain rfl | rfl := hx <;> obtain rfl | rfl := hy
     · exact ⟨0, by rw [zpow_zero, coe_one, id.def]⟩
     · exact ⟨1, by rw [zpow_one, swap_apply_left]⟩
@@ -1021,12 +1021,12 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
     (f ^ n) a = a ↔ s.card ∣ n :=
   by
   obtain rfl | hs := Finset.eq_singleton_or_nontrivial ha
-  · rw [coe_singleton, is_cycle_on_singleton] at hf 
+  · rw [coe_singleton, is_cycle_on_singleton] at hf
     simpa using is_fixed_pt.iterate hf n
   classical
   have h : ∀ x ∈ s.attach, ¬f ↑x = ↑x := fun x hx => hf.apply_ne hs x.Prop
   have := (hf.is_cycle_subtype_perm hs).orderOf
-  simp only [filter_true_of_mem h, support_subtype_perm, card_attach] at this 
+  simp only [filter_true_of_mem h, support_subtype_perm, card_attach] at this
   rw [← this, orderOf_dvd_iff_pow_eq_one,
     (hf.is_cycle_subtype_perm hs).pow_eq_one_iff'
       (ne_of_apply_ne (coe : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).Prop)]
@@ -1314,7 +1314,7 @@ theorem isCycle_cycleOf (f : Perm α) (hx : f x ≠ x) : IsCycle (cycleOf f x) :
       if hxy : SameCycle f x y then
         let ⟨i, hi⟩ := hxy
         ⟨i, by rw [cycle_of_zpow_apply_self, hi]⟩
-      else by rw [cycle_of_apply_of_not_same_cycle hxy] at h ; exact (h rfl).elim⟩
+      else by rw [cycle_of_apply_of_not_same_cycle hxy] at h; exact (h rfl).elim⟩
 #align equiv.perm.is_cycle_cycle_of Equiv.Perm.isCycle_cycleOf
 -/
 
@@ -1324,7 +1324,7 @@ theorem two_le_card_support_cycleOf_iff : 2 ≤ card (cycleOf f x).support ↔ f
   by
   refine' ⟨fun h => _, fun h => by simpa using (is_cycle_cycle_of _ h).two_le_card_support⟩
   contrapose! h
-  rw [← cycle_of_eq_one_iff] at h 
+  rw [← cycle_of_eq_one_iff] at h
   simp [h]
 #align equiv.perm.two_le_card_support_cycle_of_iff Equiv.Perm.two_le_card_support_cycleOf_iff
 -/
@@ -1380,8 +1380,8 @@ theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.sup
 theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ support f :=
   by
   intro y hy
-  rw [mem_support, cycle_of_apply] at hy 
-  split_ifs at hy 
+  rw [mem_support, cycle_of_apply] at hy
+  split_ifs at hy
   · exact mem_support.mpr hy
   · exact absurd rfl hy
 #align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_le
@@ -1441,7 +1441,7 @@ theorem isCycle_cycleOf_iff (f : Perm α) : IsCycle (cycleOf f x) ↔ f x ≠ x
 #print Equiv.Perm.isCycleOn_support_cycleOf /-
 theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleOf x).support :=
   ⟨f.BijOn <| by simp [mem_support_cycle_of_iff], fun a ha b hb => by
-    rw [mem_coe, mem_support_cycle_of_iff] at ha hb ; exact ha.1.symm.trans hb.1⟩
+    rw [mem_coe, mem_support_cycle_of_iff] at ha hb; exact ha.1.symm.trans hb.1⟩
 #align equiv.perm.is_cycle_on_support_cycle_of Equiv.Perm.isCycleOn_support_cycleOf
 -/
 
@@ -1449,7 +1449,7 @@ theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleO
 theorem SameCycle.exists_pow_eq_of_mem_support (h : SameCycle f x y) (hx : x ∈ f.support) :
     ∃ (i : ℕ) (hi' : i < (f.cycleOf x).support.card), (f ^ i) x = y :=
   by
-  rw [mem_support] at hx 
+  rw [mem_support] at hx
   refine' (f.is_cycle_on_support_cycle_of _).exists_pow_eq _ _ <;>
     rwa [mem_support_cycle_of_iff' hx]
 #align equiv.perm.same_cycle.exists_pow_eq_of_mem_support Equiv.Perm.SameCycle.exists_pow_eq_of_mem_support
@@ -1465,14 +1465,14 @@ theorem SameCycle.exists_pow_eq (f : Perm α) (h : SameCycle f x y) :
     · refine' ⟨(f.cycle_of x).support.card, _, self_le_add_right _ _, _⟩
       · refine' zero_lt_one.trans (one_lt_card_support_of_ne_one _)
         simpa using hx
-      · simp only [perm.coe_one, id.def, pow_zero] at hk' 
+      · simp only [perm.coe_one, id.def, pow_zero] at hk'
         subst hk'
         rw [← (is_cycle_cycle_of _ <| mem_support.1 hx).orderOf, ← cycle_of_pow_apply_self,
           pow_orderOf_eq_one, one_apply]
     · exact ⟨k + 1, by simp, Nat.le_succ_of_le hk.le, hk'⟩
   · refine' ⟨1, zero_lt_one, by simp, _⟩
     obtain ⟨k, rfl⟩ := h
-    rw [not_mem_support] at hx 
+    rw [not_mem_support] at hx
     rw [pow_apply_eq_self_of_apply_eq_self hx, zpow_apply_eq_self_of_apply_eq_self hx]
 #align equiv.perm.same_cycle.exists_pow_eq Equiv.Perm.SameCycle.exists_pow_eq
 -/
@@ -1510,11 +1510,11 @@ def cycleFactorsAux [Fintype α] :
         cycle_factors_aux l ((cycleOf f x)⁻¹ * f) fun y hy =>
           List.mem_of_ne_of_mem
             (fun h : y = x => by
-              rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycle_of_apply_self] at hy ; exact hy rfl)
+              rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycle_of_apply_self] at hy; exact hy rfl)
             (h fun h : f y = y =>
               by
-              rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycle_of_apply] at hy 
-              split_ifs at hy  <;> cc)
+              rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycle_of_apply] at hy
+              split_ifs at hy <;> cc)
       ⟨cycleOf f x::m, by rw [List.prod_cons, hm₁]; simp, fun g hg =>
         ((List.mem_cons _ _ _).1 hg).elim (fun hg => hg.symm ▸ isCycle_cycleOf _ hx) (hm₂ g),
         List.pairwise_cons.2
@@ -1533,7 +1533,7 @@ def cycleFactorsAux [Fintype α] :
                   have hsc : SameCycle f⁻¹ x (f y) := by
                     rwa [same_cycle_inv, same_cycle_apply_right]
                   rw [disjoint_prod_perm hm₃ hgm.symm, List.prod_cons, ← eq_inv_mul_iff_mul_eq] at
-                    hm₁ 
+                    hm₁
                   rwa [hm₁, mul_apply, mul_apply, cycle_of_inv, hsc.cycle_of_apply, inv_apply_self,
                     inv_eq_iff_eq, eq_comm],
             hm₃⟩⟩
@@ -1556,10 +1556,10 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
   · intro h
     have hσl : σ.support ⊆ l.prod.support := by
       intro x hx
-      rw [mem_support] at hx 
+      rw [mem_support] at hx
       rwa [mem_support, ← h _ hx]
     obtain ⟨a, ha, -⟩ := id h3
-    rw [← mem_support] at ha 
+    rw [← mem_support] at ha
     obtain ⟨τ, hτ, hτa⟩ := exists_mem_support_of_mem_support_prod (hσl ha)
     have hτl : ∀ x ∈ τ.support, τ x = l.prod x := eq_on_support_mem_disjoint hτ h2
     have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x :=
@@ -1692,7 +1692,7 @@ theorem mem_cycleFactorsFinset_iff {f p : Perm α} :
   by
   obtain ⟨l, hl, hl'⟩ := f.cycle_factors_finset.exists_list_nodup_eq
   rw [← hl']
-  rw [eq_comm, cycle_factors_finset_eq_list_to_finset hl] at hl' 
+  rw [eq_comm, cycle_factors_finset_eq_list_to_finset hl] at hl'
   simpa [List.mem_toFinset, Ne.def, ← hl'.right.right] using
     mem_list_cycles_iff hl'.left hl'.right.left
 #align equiv.perm.mem_cycle_factors_finset_iff Equiv.Perm.mem_cycleFactorsFinset_iff
@@ -1706,16 +1706,16 @@ theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
   constructor
   · rintro ⟨hc, h⟩
     contrapose! hc
-    rw [not_mem_support, ← cycle_of_eq_one_iff] at hc 
+    rw [not_mem_support, ← cycle_of_eq_one_iff] at hc
     simp [hc]
   · intro hx
     refine' ⟨is_cycle_cycle_of _ (mem_support.mp hx), _⟩
     intro y hy
-    rw [mem_support] at hy 
+    rw [mem_support] at hy
     rw [cycle_of_apply]
     split_ifs with H
     · rfl
-    · rw [cycle_of_apply_of_not_same_cycle H] at hy 
+    · rw [cycle_of_apply_of_not_same_cycle H] at hy
       contradiction
 #align equiv.perm.cycle_of_mem_cycle_factors_finset_iff Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff
 -/
@@ -1723,7 +1723,7 @@ theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
 #print Equiv.Perm.mem_cycleFactorsFinset_support_le /-
 theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactorsFinset f) :
     p.support ≤ f.support := by
-  rw [mem_cycle_factors_finset_iff] at h 
+  rw [mem_cycle_factors_finset_iff] at h
   intro x hx
   rwa [mem_support, ← h.right x hx, ← mem_support]
 #align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_le
@@ -1780,10 +1780,10 @@ theorem cycleFactorsFinset_injective : Function.Injective (@cycleFactorsFinset 
 theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g) :
     Disjoint (cycleFactorsFinset f) (cycleFactorsFinset g) :=
   by
-  rw [disjoint_iff_disjoint_support] at h 
+  rw [disjoint_iff_disjoint_support] at h
   rw [Finset.disjoint_left]
   intro x hx hy
-  simp only [mem_cycle_factors_finset_iff, mem_support] at hx hy 
+  simp only [mem_cycle_factors_finset_iff, mem_support] at hx hy
   obtain ⟨⟨⟨a, ha, -⟩, hf⟩, -, hg⟩ := hx, hy
   refine' h.le_bot (_ : a ∈ f.support ∩ g.support)
   simp [ha, ← hf a ha, ← hg a ha]
@@ -1810,7 +1810,7 @@ theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f
 #print Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset /-
 theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cycleFactorsFinset g) :
     Disjoint (g * f⁻¹) f := by
-  rw [mem_cycle_factors_finset_iff] at h 
+  rw [mem_cycle_factors_finset_iff] at h
   intro x
   by_cases hx : f x = x
   · exact Or.inr hx
@@ -1884,7 +1884,7 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
     rintro (hf | hf)
     · rw [hd.commute.eq, union_comm, union_sdiff_distrib, sdiff_singleton_eq_erase,
         erase_eq_of_not_mem, mul_assoc, disjoint.cycle_factors_finset_mul_eq_union, hσ hf]
-      · rw [mem_cycle_factors_finset_iff] at hf 
+      · rw [mem_cycle_factors_finset_iff] at hf
         intro x
         cases' hd.symm x with hx hx
         · exact Or.inl hx
@@ -1893,12 +1893,12 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
           · rw [← hfx]
             simpa [hx] using hfx.symm
           · rw [mul_apply]
-            rw [← hf.right _ (mem_support.mpr hfx)] at hx 
+            rw [← hf.right _ (mem_support.mpr hfx)] at hx
             contradiction
       · exact fun H => hd.disjoint_cycle_factors_finset.le_bot (mem_inter_of_mem hf H)
     · rw [union_sdiff_distrib, sdiff_singleton_eq_erase, erase_eq_of_not_mem, mul_assoc,
         disjoint.cycle_factors_finset_mul_eq_union, hτ hf]
-      · rw [mem_cycle_factors_finset_iff] at hf 
+      · rw [mem_cycle_factors_finset_iff] at hf
         intro x
         cases' hd x with hx hx
         · exact Or.inl hx
@@ -1907,7 +1907,7 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
           · rw [← hfx]
             simpa [hx] using hfx.symm
           · rw [mul_apply]
-            rw [← hf.right _ (mem_support.mpr hfx)] at hx 
+            rw [← hf.right _ (mem_support.mpr hfx)] at hx
             contradiction
       · exact fun H => hd.disjoint_cycle_factors_finset.le_bot (mem_inter_of_mem H hf)
 #align equiv.perm.cycle_factors_finset_mul_inv_mem_eq_sdiff Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiff
@@ -1958,9 +1958,9 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
   have step3 : ∀ y : α, swap x y ∈ H := by
     intro y
     have hx : x ∈ (⊤ : Finset α) := Finset.mem_univ x
-    rw [← h2, mem_support] at hx 
+    rw [← h2, mem_support] at hx
     have hy : y ∈ (⊤ : Finset α) := Finset.mem_univ y
-    rw [← h2, mem_support] at hy 
+    rw [← h2, mem_support] at hy
     cases' is_cycle.exists_pow_eq h1 hx hy with n hn
     rw [← hn]
     exact step2 n
@@ -1984,10 +1984,10 @@ theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.Coprime n
     (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
     closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ :=
   by
-  rw [← Finset.card_univ, ← h2, ← h1.order_of] at h0 
+  rw [← Finset.card_univ, ← h2, ← h1.order_of] at h0
   cases' exists_pow_eq_self_of_coprime h0 with m hm
   have h2' : (σ ^ n).support = ⊤ := Eq.trans (support_pow_coprime h0) h2
-  have h1' : is_cycle ((σ ^ n) ^ (m : ℤ)) := by rwa [← hm] at h1 
+  have h1' : is_cycle ((σ ^ n) ^ (m : ℤ)) := by rwa [← hm] at h1
   replace h1' : is_cycle (σ ^ n) :=
     h1'.of_pow (le_trans (support_pow_le σ n) (ge_of_eq (congr_arg support hm)))
   rw [eq_top_iff, ← closure_cycle_adjacent_swap h1' h2' x, closure_le, Set.insert_subset_iff]
@@ -2010,7 +2010,7 @@ theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime
     closure_cycle_coprime_swap (Nat.Coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
   cases' h with m hm
   rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.order_of, pow_orderOf_eq_one, one_pow,
-    one_apply] at hi 
+    one_apply] at hi
 #align equiv.perm.closure_prime_cycle_swap Equiv.Perm.closure_prime_cycle_swap
 -/
 
@@ -2076,7 +2076,7 @@ theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
     · simp [mem_support.1 ha]
     · refine' ⟨π⁻¹ b, ⟨_, π.apply_inv_self b⟩⟩
       contrapose! hb
-      rw [mem_support, Classical.not_not] at hb 
+      rw [mem_support, Classical.not_not] at hb
       rw [mem_support, Classical.not_not, perm.mul_apply, perm.mul_apply, hb, perm.apply_inv_self],
     hσ.IsConj hτ⟩
 #align equiv.perm.is_cycle.is_conj_iff Equiv.Perm.IsCycle.isConj_iff
@@ -2123,26 +2123,26 @@ theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (h
   · intro x hx
     simp only [trans_apply, symm_trans_apply, set.of_eq_apply, set.of_eq_symm_apply,
       Equiv.sumCongr_apply]
-    rw [hd1', Set.mem_union] at hx 
+    rw [hd1', Set.mem_union] at hx
     cases' hx with hxσ hxτ
-    · rw [mem_coe, mem_support] at hxσ 
+    · rw [mem_coe, mem_support] at hxσ
       rw [set.union_apply_left hd1''.le_bot _, set.union_apply_left hd1''.le_bot _]
       simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inl, comp_app,
         set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
       · have h := (hd2 (f x)).resolve_left _
-        · rw [mul_apply, mul_apply] at h 
+        · rw [mul_apply, mul_apply] at h
           rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
         · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
       · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, mem_support]
       ·
         rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
           apply_mem_support, mem_support]
-    · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ 
+    · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ
       rw [set.union_apply_right hd1''.le_bot _, set.union_apply_right hd1''.le_bot _]
       simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inr, comp_app,
         set.union_symm_apply_right, Subtype.coe_mk, apply_eq_iff_eq]
       · have h := (hd2 (g (τ x))).resolve_right _
-        · rw [mul_apply, mul_apply] at h 
+        · rw [mul_apply, mul_apply] at h
           rw [inv_apply_self, h, (hd1 (τ x)).resolve_right hxτ]
         · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
       · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
@@ -2182,7 +2182,7 @@ variable [DecidableEq α] {l : List α}
 theorem Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn {a | a ∈ l} :=
   by
   refine' ⟨l.form_perm.bij_on fun _ => form_perm_mem_iff_mem, fun a ha b hb => _⟩
-  rw [Set.mem_setOf, ← index_of_lt_length] at ha hb 
+  rw [Set.mem_setOf, ← index_of_lt_length] at ha hb
   rw [← index_of_nth_le ha, ← index_of_nth_le hb]
   refine' ⟨l.index_of b - l.index_of a, _⟩
   simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_coe_nat,
@@ -2290,8 +2290,8 @@ theorem product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
   simp only [disjoint_left, Function.onFun, mem_map, Function.Embedding.coeFn_mk, exists_prop,
     not_exists, not_and, forall_exists_index, and_imp, Prod.forall, Prod.mk.inj_iff]
   rintro _ _ _ - rfl rfl a ha rfl h
-  rw [hf.pow_apply_eq_pow_apply ha] at h 
-  rw [mem_coe, mem_range] at hm hn 
+  rw [hf.pow_apply_eq_pow_apply ha] at h
+  rw [mem_coe, mem_range] at hm hn
   exact hmn.symm (h.eq_of_lt_of_lt hn hm)
 #align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disjiUnion_perm_aux
 -/

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

@@ -212,14 +212,14 @@ theorem sameCycle_zpow_right {n : ℤ} : SameCycle f x ((f ^ n) y) ↔ SameCycle
 #print Equiv.Perm.sameCycle_pow_left /-
 @[simp]
 theorem sameCycle_pow_left {n : ℕ} : SameCycle f ((f ^ n) x) y ↔ SameCycle f x y := by
-  rw [← zpow_ofNat, same_cycle_zpow_left]
+  rw [← zpow_coe_nat, same_cycle_zpow_left]
 #align equiv.perm.same_cycle_pow_left Equiv.Perm.sameCycle_pow_left
 -/
 
 #print Equiv.Perm.sameCycle_pow_right /-
 @[simp]
 theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y := by
-  rw [← zpow_ofNat, same_cycle_zpow_right]
+  rw [← zpow_coe_nat, same_cycle_zpow_right]
 #align equiv.perm.same_cycle_pow_right Equiv.Perm.sameCycle_pow_right
 -/
 
@@ -297,7 +297,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
   use(k % orderOf f).natAbs
   have h₀ := int.coe_nat_pos.mpr (orderOf_pos f)
   have h₁ := Int.emod_nonneg k h₀.ne'
-  rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_mod_orderOf]
+  rw [← zpow_coe_nat, Int.natAbs_of_nonneg h₁, ← zpow_mod_orderOf]
   refine' ⟨_, rfl⟩
   rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
   exact Int.emod_lt_of_pos _ h₀
@@ -328,7 +328,7 @@ instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f
               simp [orderOf_le_card_univ]
             infer_instance),
         by
-        rw [← zpow_ofNat,
+        rw [← zpow_coe_nat,
           Int.natAbs_of_nonneg
             (Int.emod_nonneg _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _),
           ← zpow_mod_orderOf, hi]
@@ -444,7 +444,7 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
     ⟨(n % orderOf f).toNat,
       by
       have := n.mod_nonneg (int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
-      rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_mod_orderOf]⟩
+      rwa [← zpow_coe_nat, Int.toNat_of_nonneg this, ← zpow_mod_orderOf]⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 -/
 
@@ -583,8 +583,8 @@ theorem isCycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
       let ⟨i, hi⟩ :=
         isCycle_swap_mul_aux₁ n hb
           (show (f⁻¹ ^ n) (f⁻¹ x) = f⁻¹ b by
-            rw [← zpow_ofNat, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc, ← inv_pow,
-              pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_ofNat, ← pow_succ', ←
+            rw [← zpow_coe_nat, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc, ← inv_pow,
+              pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_coe_nat, ← pow_succ', ←
               pow_succ])
       have h : (swap x (f⁻¹ x) * f⁻¹) (f x) = f⁻¹ x := by
         rw [mul_apply, inv_apply_self, swap_apply_left]
@@ -853,7 +853,7 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
     · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
       simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
     · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
-      simp only [zpow_one, zpow_ofNat] at h 
+      simp only [zpow_one, zpow_coe_nat] at h 
       rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa 
       contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
@@ -1076,10 +1076,10 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
   obtain ⟨n, rfl⟩ := hf.2 ha hb
   obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.Dvd
   refine' ⟨n.nat_mod s.card, Int.natMod_lt (nonempty.card_pos ⟨a, ha⟩).ne', _⟩
-  rw [← zpow_ofNat, Int.natMod,
+  rw [← zpow_coe_nat, Int.natMod,
     Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2 (nonempty.card_pos ⟨a, ha⟩).ne'),
     sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
-  simp only [zpow_ofNat, coe_mul, EmbeddingLike.apply_eq_iff_eq]
+  simp only [zpow_coe_nat, coe_mul, EmbeddingLike.apply_eq_iff_eq]
   exact is_fixed_pt.perm_zpow (hf.pow_card_apply ha) _
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
 -/
@@ -2185,7 +2185,7 @@ theorem Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn {a | a ∈
   rw [Set.mem_setOf, ← index_of_lt_length] at ha hb 
   rw [← index_of_nth_le ha, ← index_of_nth_le hb]
   refine' ⟨l.index_of b - l.index_of a, _⟩
-  simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_ofNat,
+  simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_coe_nat,
     Equiv.Perm.coe_mul, form_perm_pow_apply_nth_le _ h]
   rw [add_comm]
 #align list.nodup.is_cycle_on_form_perm List.Nodup.isCycleOn_formPerm

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

@@ -630,7 +630,7 @@ theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCy
 #align equiv.perm.is_cycle.swap_mul Equiv.Perm.IsCycle.swap_mul
 -/
 
-/- ./././Mathport/Syntax/Translate/Command.lean:298:8: warning: using_well_founded used, estimated equivalent -/
+/- ./././Mathport/Syntax/Translate/Command.lean:299:8: warning: using_well_founded used, estimated equivalent -/
 #print Equiv.Perm.IsCycle.sign /-
 theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.support.card
   | f => fun hf =>
@@ -658,8 +658,7 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.su
           rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
           simp only [pow_add, mul_one, neg_neg, one_mul, mul_neg, eq_self_iff_true, pow_one,
             neg_mul_neg]
-termination_by
-  _ x => WellFounded.wrap (measure_wf fun f => f.support.card) x
+termination_by x => WellFounded.wrap (measure_wf fun f => f.support.card) x
 #align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.sign
 -/
 

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

@@ -293,12 +293,25 @@ alias ⟨_, same_cycle.extend_domain⟩ := same_cycle_extend_domain
 #print Equiv.Perm.SameCycle.exists_pow_eq' /-
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
   classical
+  rintro ⟨k, rfl⟩
+  use(k % orderOf f).natAbs
+  have h₀ := int.coe_nat_pos.mpr (orderOf_pos f)
+  have h₁ := Int.emod_nonneg k h₀.ne'
+  rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_mod_orderOf]
+  refine' ⟨_, rfl⟩
+  rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
+  exact Int.emod_lt_of_pos _ h₀
 #align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'
 -/
 
 #print Equiv.Perm.SameCycle.exists_pow_eq'' /-
 theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
-    ∃ (i : ℕ) (hpos : 0 < i) (h : i ≤ orderOf f), (f ^ i) x = y := by classical
+    ∃ (i : ℕ) (hpos : 0 < i) (h : i ≤ orderOf f), (f ^ i) x = y := by
+  classical
+  obtain ⟨_ | i, hi, rfl⟩ := h.exists_pow_eq'
+  · refine' ⟨orderOf f, orderOf_pos f, le_rfl, _⟩
+    rw [pow_orderOf_eq_one, pow_zero]
+  · exact ⟨i.succ, i.zero_lt_succ, hi.le, rfl⟩
 #align equiv.perm.same_cycle.exists_pow_eq'' Equiv.Perm.SameCycle.exists_pow_eq''
 -/
 
@@ -427,7 +440,11 @@ variable [Finite α]
 theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y) :
     ∃ i : ℕ, (f ^ i) x = y := by
   let ⟨n, hn⟩ := hf.exists_zpow_eq hx hy
-  classical
+  classical exact
+    ⟨(n % orderOf f).toNat,
+      by
+      have := n.mod_nonneg (int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
+      rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_mod_orderOf]⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 -/
 
@@ -457,7 +474,16 @@ theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
 -/
 
 theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
-    ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by classical
+    ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by
+  classical
+  have : IsOfFinOrder f := isOfFinOrder_of_finite f
+  rw [isOfFinOrder_iff_pow_eq_one] at this 
+  obtain ⟨x, hx, hx'⟩ := hf
+  obtain ⟨_ | _ | k, hk, hk'⟩ := this
+  · exact absurd hk (lt_asymm hk)
+  · rw [pow_one] at hk' 
+    simpa [hk'] using hx
+  · exact ⟨k + 2, by simp, hk'⟩
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
 
 #print Equiv.Perm.IsCycle.zpowersEquivSupport /-
@@ -744,14 +770,48 @@ theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npo
 
 #print Equiv.Perm.IsCycle.pow_iff /-
 theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
-    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) := by classical
+    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) := by
+  classical
+  cases nonempty_fintype β
+  constructor
+  · intro h
+    have hr : support (f ^ n) = support f :=
+      by
+      rw [hf.support_pow_eq_iff]
+      rintro ⟨k, rfl⟩
+      refine' h.ne_one _
+      simp [pow_mul, pow_orderOf_eq_one]
+    have : orderOf (f ^ n) = orderOf f := by rw [h.order_of, hr, hf.order_of]
+    rw [orderOf_pow, Nat.div_eq_self] at this 
+    cases this
+    · exact absurd this (orderOf_pos _).ne'
+    · rwa [Nat.coprime_iff_gcd_eq_one, Nat.gcd_comm]
+  · intro h
+    obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime h
+    have hf' : is_cycle ((f ^ n) ^ m) := by rwa [hm]
+    refine' hf'.of_pow fun x hx => _
+    rw [hm]
+    exact support_pow_le _ n hx
 #align equiv.perm.is_cycle.pow_iff Equiv.Perm.IsCycle.pow_iff
 -/
 
 #print Equiv.Perm.IsCycle.pow_eq_one_iff /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
-    f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x := by classical
+    f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x := by
+  classical
+  cases nonempty_fintype β
+  constructor
+  · intro h
+    obtain ⟨x, hx, -⟩ := id hf
+    exact ⟨x, hx, by simp [h]⟩
+  · rintro ⟨x, hx, hx'⟩
+    by_cases h : support (f ^ n) = support f
+    · rw [← mem_support, ← h, mem_support] at hx 
+      contradiction
+    · rw [hf.support_pow_eq_iff, Classical.not_not] at h 
+      obtain ⟨k, rfl⟩ := h
+      rw [pow_mul, pow_orderOf_eq_one, one_pow]
 #align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iff
 -/
 
@@ -776,7 +836,27 @@ theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
 #print Equiv.Perm.IsCycle.pow_eq_pow_iff /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b : ℕ} :
-    f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x := by classical
+    f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x := by
+  classical
+  cases nonempty_fintype β
+  constructor
+  · intro h
+    obtain ⟨x, hx, -⟩ := id hf
+    exact ⟨x, hx, by simp [h]⟩
+  · rintro ⟨x, hx, hx'⟩
+    wlog hab : a ≤ b generalizing a b
+    · exact (this hx'.symm (le_of_not_le hab)).symm
+    suffices f ^ (b - a) = 1 by
+      rw [pow_sub _ hab, mul_inv_eq_one] at this 
+      rw [this]
+    rw [hf.pow_eq_one_iff]
+    by_cases hfa : (f ^ a) x ∈ f.support
+    · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
+      simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
+    · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
+      simp only [zpow_one, zpow_ofNat] at h 
+      rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa 
+      contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
 -/
 
@@ -784,6 +864,17 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
 theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf : IsCycle f)
     (hf' : (orderOf f).Prime) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f) : IsCycle (f ^ n) := by
   classical
+  cases nonempty_fintype β
+  have : n.coprime (orderOf f) := by
+    refine' Nat.Coprime.symm _
+    rw [Nat.Prime.coprime_iff_not_dvd hf']
+    exact Nat.not_dvd_of_pos_of_lt hn hn'
+  obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
+  have hf'' := hf
+  rw [← hm] at hf'' 
+  refine' hf''.of_pow _
+  rw [hm]
+  exact support_pow_le f n
 #align equiv.perm.is_cycle.is_cycle_pow_pos_of_lt_prime_order Equiv.Perm.IsCycle.isCycle_pow_pos_of_lt_prime_order
 -/
 
@@ -934,6 +1025,13 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
   · rw [coe_singleton, is_cycle_on_singleton] at hf 
     simpa using is_fixed_pt.iterate hf n
   classical
+  have h : ∀ x ∈ s.attach, ¬f ↑x = ↑x := fun x hx => hf.apply_ne hs x.Prop
+  have := (hf.is_cycle_subtype_perm hs).orderOf
+  simp only [filter_true_of_mem h, support_subtype_perm, card_attach] at this 
+  rw [← this, orderOf_dvd_iff_pow_eq_one,
+    (hf.is_cycle_subtype_perm hs).pow_eq_one_iff'
+      (ne_of_apply_ne (coe : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).Prop)]
+  simp only [Subtype.coe_mk, subtype_perm_pow, subtype_perm_apply]
 #align equiv.perm.is_cycle_on.pow_apply_eq Equiv.Perm.IsCycleOn.pow_apply_eq
 -/
 
@@ -974,7 +1072,16 @@ theorem IsCycleOn.pow_card_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a 
 
 #print Equiv.Perm.IsCycleOn.exists_pow_eq /-
 theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
-    ∃ n < s.card, (f ^ n) a = b := by classical
+    ∃ n < s.card, (f ^ n) a = b := by
+  classical
+  obtain ⟨n, rfl⟩ := hf.2 ha hb
+  obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.Dvd
+  refine' ⟨n.nat_mod s.card, Int.natMod_lt (nonempty.card_pos ⟨a, ha⟩).ne', _⟩
+  rw [← zpow_ofNat, Int.natMod,
+    Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2 (nonempty.card_pos ⟨a, ha⟩).ne'),
+    sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
+  simp only [zpow_ofNat, coe_mul, EmbeddingLike.apply_eq_iff_eq]
+  exact is_fixed_pt.perm_zpow (hf.pow_card_apply ha) _
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
 -/
 
@@ -1443,6 +1550,26 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
     exact ⟨fun hσ => ⟨h1 σ hσ, (this (h1 σ hσ)).mp hσ⟩, fun hσ => (this hσ.1).mpr hσ.2⟩
   intro h3
   classical
+  cases nonempty_fintype α
+  constructor
+  · intro h a ha
+    exact eq_on_support_mem_disjoint h h2 _ (mem_support.mpr ha)
+  · intro h
+    have hσl : σ.support ⊆ l.prod.support := by
+      intro x hx
+      rw [mem_support] at hx 
+      rwa [mem_support, ← h _ hx]
+    obtain ⟨a, ha, -⟩ := id h3
+    rw [← mem_support] at ha 
+    obtain ⟨τ, hτ, hτa⟩ := exists_mem_support_of_mem_support_prod (hσl ha)
+    have hτl : ∀ x ∈ τ.support, τ x = l.prod x := eq_on_support_mem_disjoint hτ h2
+    have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x :=
+      by
+      intro x hx
+      rw [h x (mem_support.mp (mem_of_mem_inter_left hx)), hτl x (mem_of_mem_inter_right hx)]
+    convert hτ
+    refine' h3.eq_on_support_inter_nonempty_congr (h1 _ hτ) key _ ha
+    exact key a (mem_inter_of_mem ha hτa)
 #align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
 -/
 
@@ -1450,7 +1577,16 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
 theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List (Perm α)}
     (h₀ : l₁.Prod = l₂.Prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
     (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
-    (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by classical
+    (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by
+  classical
+  refine'
+    (List.perm_ext_iff_of_nodup (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
+          (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
+      fun σ => _
+  by_cases hσ : σ.is_cycle
+  · obtain ⟨a, ha⟩ := not_forall.mp (mt ext hσ.ne_one)
+    rw [mem_list_cycles_iff h₁l₁ h₂l₁, mem_list_cycles_iff h₁l₂ h₂l₂, h₀]
+  · exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
 #align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cycles
 -/
 
@@ -1717,7 +1853,10 @@ theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (ba
   by
   cases nonempty_fintype β
   suffices ∀ l : List (perm β), (∀ τ : perm β, τ ∈ l → τ.IsCycle) → l.Pairwise Disjoint → P l.Prod
-    by classical
+    by
+    classical
+    let x := σ.trunc_cycle_factors.out
+    exact (congr_arg P x.2.1).mp (this x.1 x.2.2.1 x.2.2.2)
   intro l
   induction' l with σ l ih
   · exact fun _ _ => base_one
@@ -1782,7 +1921,10 @@ variable [Finite β]
 open Subgroup
 
 #print Equiv.Perm.closure_isCycle /-
-theorem closure_isCycle : closure {σ : Perm β | IsCycle σ} = ⊤ := by classical
+theorem closure_isCycle : closure {σ : Perm β | IsCycle σ} = ⊤ := by
+  classical
+  cases nonempty_fintype β
+  exact top_le_iff.mp (le_trans (ge_of_eq closure_is_swap) (closure_mono fun _ => is_swap.is_cycle))
 #align equiv.perm.closure_is_cycle Equiv.Perm.closure_isCycle
 -/
 
@@ -1962,6 +2104,52 @@ end
 theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
     (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
   classical
+  cases nonempty_fintype α
+  obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
+  obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
+  have hd1' := coe_inj.2 hd1.support_mul
+  have hd2' := coe_inj.2 hd2.support_mul
+  rw [coe_union] at *
+  have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
+  have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
+  refine' is_conj_of_support_equiv _ _
+  ·
+    refine'
+        ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
+          ((Equiv.sumCongr (subtype_equiv f fun a => _) (subtype_equiv g fun a => _)).trans
+            ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
+      ·
+        simp only [Set.mem_image, to_embedding_apply, exists_eq_right, support_conj, coe_map,
+          apply_eq_iff_eq]
+  · intro x hx
+    simp only [trans_apply, symm_trans_apply, set.of_eq_apply, set.of_eq_symm_apply,
+      Equiv.sumCongr_apply]
+    rw [hd1', Set.mem_union] at hx 
+    cases' hx with hxσ hxτ
+    · rw [mem_coe, mem_support] at hxσ 
+      rw [set.union_apply_left hd1''.le_bot _, set.union_apply_left hd1''.le_bot _]
+      simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inl, comp_app,
+        set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
+      · have h := (hd2 (f x)).resolve_left _
+        · rw [mul_apply, mul_apply] at h 
+          rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
+        · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
+      · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, mem_support]
+      ·
+        rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
+          apply_mem_support, mem_support]
+    · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ 
+      rw [set.union_apply_right hd1''.le_bot _, set.union_apply_right hd1''.le_bot _]
+      simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inr, comp_app,
+        set.union_symm_apply_right, Subtype.coe_mk, apply_eq_iff_eq]
+      · have h := (hd2 (g (τ x))).resolve_right _
+        · rw [mul_apply, mul_apply] at h 
+          rw [inv_apply_self, h, (hd1 (τ x)).resolve_right hxτ]
+        · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
+      · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
+      ·
+        rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 (τ x)).resolve_right hxτ, mem_coe,
+          mem_support]
 #align equiv.perm.disjoint.is_conj_mul Equiv.Perm.Disjoint.isConj_mul
 -/
 
@@ -2047,7 +2235,24 @@ variable {f : Perm α} {s : Set α}
 
 #print Set.Countable.exists_cycleOn /-
 theorem Countable.exists_cycleOn (hs : s.Countable) :
-    ∃ f : Perm α, f.IsCycleOn s ∧ {x | f x ≠ x} ⊆ s := by classical
+    ∃ f : Perm α, f.IsCycleOn s ∧ {x | f x ≠ x} ⊆ s := by
+  classical
+  obtain hs' | hs' := s.finite_or_infinite
+  · refine'
+      ⟨hs'.to_finset.to_list.form_perm, _, fun x hx => by
+        simpa using List.mem_of_formPerm_apply_ne _ _ hx⟩
+    convert hs'.to_finset.nodup_to_list.is_cycle_on_form_perm
+    simp
+  haveI := hs.to_subtype
+  haveI := hs'.to_subtype
+  obtain ⟨f⟩ : Nonempty (ℤ ≃ s) := inferInstance
+  refine'
+    ⟨(Equiv.addRight 1).extendDomain f, _, fun x hx =>
+      of_not_not fun h => hx <| perm.extend_domain_apply_not_subtype _ _ h⟩
+  convert int.add_right_one_is_cycle.is_cycle_on.extend_domain _
+  rw [image_comp, Equiv.image_eq_preimage]
+  ext
+  simp
 #align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
 -/
 
@@ -2082,6 +2287,13 @@ theorem product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
     simp_rw [Set.Subsingleton, mem_coe, ← card_le_one] at hs ⊢
     rwa [card_range]
   classical
+  rintro m hm n hn hmn
+  simp only [disjoint_left, Function.onFun, mem_map, Function.Embedding.coeFn_mk, exists_prop,
+    not_exists, not_and, forall_exists_index, and_imp, Prod.forall, Prod.mk.inj_iff]
+  rintro _ _ _ - rfl rfl a ha rfl h
+  rw [hf.pow_apply_eq_pow_apply ha] at h 
+  rw [mem_coe, mem_range] at hm hn 
+  exact hmn.symm (h.eq_of_lt_of_lt hn hm)
 #align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disjiUnion_perm_aux
 -/
 

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

@@ -293,25 +293,12 @@ alias ⟨_, same_cycle.extend_domain⟩ := same_cycle_extend_domain
 #print Equiv.Perm.SameCycle.exists_pow_eq' /-
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
   classical
-  rintro ⟨k, rfl⟩
-  use(k % orderOf f).natAbs
-  have h₀ := int.coe_nat_pos.mpr (orderOf_pos f)
-  have h₁ := Int.emod_nonneg k h₀.ne'
-  rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_mod_orderOf]
-  refine' ⟨_, rfl⟩
-  rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
-  exact Int.emod_lt_of_pos _ h₀
 #align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'
 -/
 
 #print Equiv.Perm.SameCycle.exists_pow_eq'' /-
 theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
-    ∃ (i : ℕ) (hpos : 0 < i) (h : i ≤ orderOf f), (f ^ i) x = y := by
-  classical
-  obtain ⟨_ | i, hi, rfl⟩ := h.exists_pow_eq'
-  · refine' ⟨orderOf f, orderOf_pos f, le_rfl, _⟩
-    rw [pow_orderOf_eq_one, pow_zero]
-  · exact ⟨i.succ, i.zero_lt_succ, hi.le, rfl⟩
+    ∃ (i : ℕ) (hpos : 0 < i) (h : i ≤ orderOf f), (f ^ i) x = y := by classical
 #align equiv.perm.same_cycle.exists_pow_eq'' Equiv.Perm.SameCycle.exists_pow_eq''
 -/
 
@@ -440,11 +427,7 @@ variable [Finite α]
 theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y) :
     ∃ i : ℕ, (f ^ i) x = y := by
   let ⟨n, hn⟩ := hf.exists_zpow_eq hx hy
-  classical exact
-    ⟨(n % orderOf f).toNat,
-      by
-      have := n.mod_nonneg (int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
-      rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_mod_orderOf]⟩
+  classical
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 -/
 
@@ -474,16 +457,7 @@ theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
 -/
 
 theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
-    ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by
-  classical
-  have : IsOfFinOrder f := isOfFinOrder_of_finite f
-  rw [isOfFinOrder_iff_pow_eq_one] at this 
-  obtain ⟨x, hx, hx'⟩ := hf
-  obtain ⟨_ | _ | k, hk, hk'⟩ := this
-  · exact absurd hk (lt_asymm hk)
-  · rw [pow_one] at hk' 
-    simpa [hk'] using hx
-  · exact ⟨k + 2, by simp, hk'⟩
+    ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by classical
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
 
 #print Equiv.Perm.IsCycle.zpowersEquivSupport /-
@@ -770,48 +744,14 @@ theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npo
 
 #print Equiv.Perm.IsCycle.pow_iff /-
 theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
-    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) := by
-  classical
-  cases nonempty_fintype β
-  constructor
-  · intro h
-    have hr : support (f ^ n) = support f :=
-      by
-      rw [hf.support_pow_eq_iff]
-      rintro ⟨k, rfl⟩
-      refine' h.ne_one _
-      simp [pow_mul, pow_orderOf_eq_one]
-    have : orderOf (f ^ n) = orderOf f := by rw [h.order_of, hr, hf.order_of]
-    rw [orderOf_pow, Nat.div_eq_self] at this 
-    cases this
-    · exact absurd this (orderOf_pos _).ne'
-    · rwa [Nat.coprime_iff_gcd_eq_one, Nat.gcd_comm]
-  · intro h
-    obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime h
-    have hf' : is_cycle ((f ^ n) ^ m) := by rwa [hm]
-    refine' hf'.of_pow fun x hx => _
-    rw [hm]
-    exact support_pow_le _ n hx
+    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) := by classical
 #align equiv.perm.is_cycle.pow_iff Equiv.Perm.IsCycle.pow_iff
 -/
 
 #print Equiv.Perm.IsCycle.pow_eq_one_iff /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
-    f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x := by
-  classical
-  cases nonempty_fintype β
-  constructor
-  · intro h
-    obtain ⟨x, hx, -⟩ := id hf
-    exact ⟨x, hx, by simp [h]⟩
-  · rintro ⟨x, hx, hx'⟩
-    by_cases h : support (f ^ n) = support f
-    · rw [← mem_support, ← h, mem_support] at hx 
-      contradiction
-    · rw [hf.support_pow_eq_iff, Classical.not_not] at h 
-      obtain ⟨k, rfl⟩ := h
-      rw [pow_mul, pow_orderOf_eq_one, one_pow]
+    f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x := by classical
 #align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iff
 -/
 
@@ -836,27 +776,7 @@ theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
 #print Equiv.Perm.IsCycle.pow_eq_pow_iff /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b : ℕ} :
-    f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x := by
-  classical
-  cases nonempty_fintype β
-  constructor
-  · intro h
-    obtain ⟨x, hx, -⟩ := id hf
-    exact ⟨x, hx, by simp [h]⟩
-  · rintro ⟨x, hx, hx'⟩
-    wlog hab : a ≤ b generalizing a b
-    · exact (this hx'.symm (le_of_not_le hab)).symm
-    suffices f ^ (b - a) = 1 by
-      rw [pow_sub _ hab, mul_inv_eq_one] at this 
-      rw [this]
-    rw [hf.pow_eq_one_iff]
-    by_cases hfa : (f ^ a) x ∈ f.support
-    · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
-      simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
-    · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
-      simp only [zpow_one, zpow_ofNat] at h 
-      rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa 
-      contradiction
+    f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x := by classical
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
 -/
 
@@ -864,17 +784,6 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
 theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf : IsCycle f)
     (hf' : (orderOf f).Prime) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f) : IsCycle (f ^ n) := by
   classical
-  cases nonempty_fintype β
-  have : n.coprime (orderOf f) := by
-    refine' Nat.Coprime.symm _
-    rw [Nat.Prime.coprime_iff_not_dvd hf']
-    exact Nat.not_dvd_of_pos_of_lt hn hn'
-  obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
-  have hf'' := hf
-  rw [← hm] at hf'' 
-  refine' hf''.of_pow _
-  rw [hm]
-  exact support_pow_le f n
 #align equiv.perm.is_cycle.is_cycle_pow_pos_of_lt_prime_order Equiv.Perm.IsCycle.isCycle_pow_pos_of_lt_prime_order
 -/
 
@@ -1025,13 +934,6 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
   · rw [coe_singleton, is_cycle_on_singleton] at hf 
     simpa using is_fixed_pt.iterate hf n
   classical
-  have h : ∀ x ∈ s.attach, ¬f ↑x = ↑x := fun x hx => hf.apply_ne hs x.Prop
-  have := (hf.is_cycle_subtype_perm hs).orderOf
-  simp only [filter_true_of_mem h, support_subtype_perm, card_attach] at this 
-  rw [← this, orderOf_dvd_iff_pow_eq_one,
-    (hf.is_cycle_subtype_perm hs).pow_eq_one_iff'
-      (ne_of_apply_ne (coe : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).Prop)]
-  simp only [Subtype.coe_mk, subtype_perm_pow, subtype_perm_apply]
 #align equiv.perm.is_cycle_on.pow_apply_eq Equiv.Perm.IsCycleOn.pow_apply_eq
 -/
 
@@ -1072,16 +974,7 @@ theorem IsCycleOn.pow_card_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a 
 
 #print Equiv.Perm.IsCycleOn.exists_pow_eq /-
 theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
-    ∃ n < s.card, (f ^ n) a = b := by
-  classical
-  obtain ⟨n, rfl⟩ := hf.2 ha hb
-  obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.Dvd
-  refine' ⟨n.nat_mod s.card, Int.natMod_lt (nonempty.card_pos ⟨a, ha⟩).ne', _⟩
-  rw [← zpow_ofNat, Int.natMod,
-    Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2 (nonempty.card_pos ⟨a, ha⟩).ne'),
-    sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
-  simp only [zpow_ofNat, coe_mul, EmbeddingLike.apply_eq_iff_eq]
-  exact is_fixed_pt.perm_zpow (hf.pow_card_apply ha) _
+    ∃ n < s.card, (f ^ n) a = b := by classical
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
 -/
 
@@ -1550,26 +1443,6 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
     exact ⟨fun hσ => ⟨h1 σ hσ, (this (h1 σ hσ)).mp hσ⟩, fun hσ => (this hσ.1).mpr hσ.2⟩
   intro h3
   classical
-  cases nonempty_fintype α
-  constructor
-  · intro h a ha
-    exact eq_on_support_mem_disjoint h h2 _ (mem_support.mpr ha)
-  · intro h
-    have hσl : σ.support ⊆ l.prod.support := by
-      intro x hx
-      rw [mem_support] at hx 
-      rwa [mem_support, ← h _ hx]
-    obtain ⟨a, ha, -⟩ := id h3
-    rw [← mem_support] at ha 
-    obtain ⟨τ, hτ, hτa⟩ := exists_mem_support_of_mem_support_prod (hσl ha)
-    have hτl : ∀ x ∈ τ.support, τ x = l.prod x := eq_on_support_mem_disjoint hτ h2
-    have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x :=
-      by
-      intro x hx
-      rw [h x (mem_support.mp (mem_of_mem_inter_left hx)), hτl x (mem_of_mem_inter_right hx)]
-    convert hτ
-    refine' h3.eq_on_support_inter_nonempty_congr (h1 _ hτ) key _ ha
-    exact key a (mem_inter_of_mem ha hτa)
 #align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
 -/
 
@@ -1577,16 +1450,7 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
 theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List (Perm α)}
     (h₀ : l₁.Prod = l₂.Prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
     (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
-    (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by
-  classical
-  refine'
-    (List.perm_ext_iff_of_nodup (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
-          (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
-      fun σ => _
-  by_cases hσ : σ.is_cycle
-  · obtain ⟨a, ha⟩ := not_forall.mp (mt ext hσ.ne_one)
-    rw [mem_list_cycles_iff h₁l₁ h₂l₁, mem_list_cycles_iff h₁l₂ h₂l₂, h₀]
-  · exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
+    (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by classical
 #align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cycles
 -/
 
@@ -1853,10 +1717,7 @@ theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (ba
   by
   cases nonempty_fintype β
   suffices ∀ l : List (perm β), (∀ τ : perm β, τ ∈ l → τ.IsCycle) → l.Pairwise Disjoint → P l.Prod
-    by
-    classical
-    let x := σ.trunc_cycle_factors.out
-    exact (congr_arg P x.2.1).mp (this x.1 x.2.2.1 x.2.2.2)
+    by classical
   intro l
   induction' l with σ l ih
   · exact fun _ _ => base_one
@@ -1921,10 +1782,7 @@ variable [Finite β]
 open Subgroup
 
 #print Equiv.Perm.closure_isCycle /-
-theorem closure_isCycle : closure {σ : Perm β | IsCycle σ} = ⊤ := by
-  classical
-  cases nonempty_fintype β
-  exact top_le_iff.mp (le_trans (ge_of_eq closure_is_swap) (closure_mono fun _ => is_swap.is_cycle))
+theorem closure_isCycle : closure {σ : Perm β | IsCycle σ} = ⊤ := by classical
 #align equiv.perm.closure_is_cycle Equiv.Perm.closure_isCycle
 -/
 
@@ -2104,52 +1962,6 @@ end
 theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
     (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
   classical
-  cases nonempty_fintype α
-  obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
-  obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
-  have hd1' := coe_inj.2 hd1.support_mul
-  have hd2' := coe_inj.2 hd2.support_mul
-  rw [coe_union] at *
-  have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
-  have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
-  refine' is_conj_of_support_equiv _ _
-  ·
-    refine'
-        ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
-          ((Equiv.sumCongr (subtype_equiv f fun a => _) (subtype_equiv g fun a => _)).trans
-            ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
-      ·
-        simp only [Set.mem_image, to_embedding_apply, exists_eq_right, support_conj, coe_map,
-          apply_eq_iff_eq]
-  · intro x hx
-    simp only [trans_apply, symm_trans_apply, set.of_eq_apply, set.of_eq_symm_apply,
-      Equiv.sumCongr_apply]
-    rw [hd1', Set.mem_union] at hx 
-    cases' hx with hxσ hxτ
-    · rw [mem_coe, mem_support] at hxσ 
-      rw [set.union_apply_left hd1''.le_bot _, set.union_apply_left hd1''.le_bot _]
-      simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inl, comp_app,
-        set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
-      · have h := (hd2 (f x)).resolve_left _
-        · rw [mul_apply, mul_apply] at h 
-          rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
-        · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
-      · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, mem_support]
-      ·
-        rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
-          apply_mem_support, mem_support]
-    · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ 
-      rw [set.union_apply_right hd1''.le_bot _, set.union_apply_right hd1''.le_bot _]
-      simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inr, comp_app,
-        set.union_symm_apply_right, Subtype.coe_mk, apply_eq_iff_eq]
-      · have h := (hd2 (g (τ x))).resolve_right _
-        · rw [mul_apply, mul_apply] at h 
-          rw [inv_apply_self, h, (hd1 (τ x)).resolve_right hxτ]
-        · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
-      · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
-      ·
-        rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 (τ x)).resolve_right hxτ, mem_coe,
-          mem_support]
 #align equiv.perm.disjoint.is_conj_mul Equiv.Perm.Disjoint.isConj_mul
 -/
 
@@ -2235,24 +2047,7 @@ variable {f : Perm α} {s : Set α}
 
 #print Set.Countable.exists_cycleOn /-
 theorem Countable.exists_cycleOn (hs : s.Countable) :
-    ∃ f : Perm α, f.IsCycleOn s ∧ {x | f x ≠ x} ⊆ s := by
-  classical
-  obtain hs' | hs' := s.finite_or_infinite
-  · refine'
-      ⟨hs'.to_finset.to_list.form_perm, _, fun x hx => by
-        simpa using List.mem_of_formPerm_apply_ne _ _ hx⟩
-    convert hs'.to_finset.nodup_to_list.is_cycle_on_form_perm
-    simp
-  haveI := hs.to_subtype
-  haveI := hs'.to_subtype
-  obtain ⟨f⟩ : Nonempty (ℤ ≃ s) := inferInstance
-  refine'
-    ⟨(Equiv.addRight 1).extendDomain f, _, fun x hx =>
-      of_not_not fun h => hx <| perm.extend_domain_apply_not_subtype _ _ h⟩
-  convert int.add_right_one_is_cycle.is_cycle_on.extend_domain _
-  rw [image_comp, Equiv.image_eq_preimage]
-  ext
-  simp
+    ∃ f : Perm α, f.IsCycleOn s ∧ {x | f x ≠ x} ⊆ s := by classical
 #align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
 -/
 
@@ -2287,13 +2082,6 @@ theorem product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
     simp_rw [Set.Subsingleton, mem_coe, ← card_le_one] at hs ⊢
     rwa [card_range]
   classical
-  rintro m hm n hn hmn
-  simp only [disjoint_left, Function.onFun, mem_map, Function.Embedding.coeFn_mk, exists_prop,
-    not_exists, not_and, forall_exists_index, and_imp, Prod.forall, Prod.mk.inj_iff]
-  rintro _ _ _ - rfl rfl a ha rfl h
-  rw [hf.pow_apply_eq_pow_apply ha] at h 
-  rw [mem_coe, mem_range] at hm hn 
-  exact hmn.symm (h.eq_of_lt_of_lt hn hm)
 #align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disjiUnion_perm_aux
 -/
 

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

@@ -819,7 +819,7 @@ theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : 
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} {x : β}
     (hx : f x ≠ x) : f ^ n = 1 ↔ (f ^ n) x = x :=
-  ⟨fun h => FunLike.congr_fun h x, fun h => hf.pow_eq_one_iff.2 ⟨x, hx, h⟩⟩
+  ⟨fun h => DFunLike.congr_fun h x, fun h => hf.pow_eq_one_iff.2 ⟨x, hx, h⟩⟩
 #align equiv.perm.is_cycle.pow_eq_one_iff' Equiv.Perm.IsCycle.pow_eq_one_iff'
 -/
 

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

@@ -630,6 +630,7 @@ theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCy
 #align equiv.perm.is_cycle.swap_mul Equiv.Perm.IsCycle.swap_mul
 -/
 
+/- ./././Mathport/Syntax/Translate/Command.lean:298:8: warning: using_well_founded used, estimated equivalent -/
 #print Equiv.Perm.IsCycle.sign /-
 theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.support.card
   | f => fun hf =>
@@ -657,7 +658,8 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.su
           rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
           simp only [pow_add, mul_one, neg_neg, one_mul, mul_neg, eq_self_iff_true, pow_one,
             neg_mul_neg]
-termination_by' ⟨_, measure_wf fun f => f.support.card⟩
+termination_by
+  _ x => WellFounded.wrap (measure_wf fun f => f.support.card) x
 #align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.sign
 -/
 

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

@@ -2048,7 +2048,7 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
   refine'
     is_conj_of_support_equiv
       (hσ.zpowers_equiv_support.symm.trans <|
-        (zpowersEquivZpowers <| by rw [hσ.order_of, h, hτ.order_of]).trans hτ.zpowers_equiv_support)
+        (zpowersEquivZPowers <| by rw [hσ.order_of, h, hτ.order_of]).trans hτ.zpowers_equiv_support)
       _
   intro x hx
   simp only [perm.mul_apply, Equiv.trans_apply, Equiv.sumCongr_apply]
@@ -2058,7 +2058,7 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
       (congr rfl (congr rfl (congr rfl (congr rfl (hσ.zpowers_equiv_support_symm_apply n).symm))))
   apply (congr rfl (congr rfl (congr rfl (hσ.zpowers_equiv_support_symm_apply (n + 1))))).trans _
   simp only [Ne.def, is_cycle.zpowers_equiv_support_apply, Subtype.coe_mk,
-    zpowersEquivZpowers_apply]
+    zpowersEquivZPowers_apply]
   rw [pow_succ, perm.mul_apply]
 #align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
 -/

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

@@ -1578,7 +1578,7 @@ theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List
     (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by
   classical
   refine'
-    (List.perm_ext (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
+    (List.perm_ext_iff_of_nodup (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
           (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
       fun σ => _
   by_cases hσ : σ.is_cycle

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

@@ -536,7 +536,7 @@ theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ)
 #print Equiv.Perm.IsCycle.orderOf /-
 protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.support.card :=
   by
-  rw [orderOf_eq_card_zpowers, ← Fintype.card_coe]
+  rw [Fintype.card_zpowers, ← Fintype.card_coe]
   convert Fintype.card_congr (is_cycle.zpowers_equiv_support hf)
 #align equiv.perm.is_cycle.order_of Equiv.Perm.IsCycle.orderOf
 -/

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

@@ -297,7 +297,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
   use(k % orderOf f).natAbs
   have h₀ := int.coe_nat_pos.mpr (orderOf_pos f)
   have h₁ := Int.emod_nonneg k h₀.ne'
-  rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_eq_mod_orderOf]
+  rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_mod_orderOf]
   refine' ⟨_, rfl⟩
   rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
   exact Int.emod_lt_of_pos _ h₀
@@ -331,7 +331,7 @@ instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f
         rw [← zpow_ofNat,
           Int.natAbs_of_nonneg
             (Int.emod_nonneg _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _),
-          ← zpow_eq_mod_orderOf, hi]
+          ← zpow_mod_orderOf, hi]
         infer_instance⟩⟩
 
 end SameCycle
@@ -444,7 +444,7 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
     ⟨(n % orderOf f).toNat,
       by
       have := n.mod_nonneg (int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
-      rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_eq_mod_orderOf]⟩
+      rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_mod_orderOf]⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 -/
 
@@ -473,11 +473,10 @@ theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
 #align equiv.perm.is_cycle.two_le_card_support Equiv.Perm.IsCycle.two_le_card_support
 -/
 
-#print Equiv.Perm.IsCycle.exists_pow_eq_one /-
 theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by
   classical
-  have : IsOfFinOrder f := exists_pow_eq_one f
+  have : IsOfFinOrder f := isOfFinOrder_of_finite f
   rw [isOfFinOrder_iff_pow_eq_one] at this 
   obtain ⟨x, hx, hx'⟩ := hf
   obtain ⟨_ | _ | k, hk, hk'⟩ := this
@@ -486,7 +485,6 @@ theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     simpa [hk'] using hx
   · exact ⟨k + 2, by simp, hk'⟩
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
--/
 
 #print Equiv.Perm.IsCycle.zpowersEquivSupport /-
 /-- The subgroup generated by a cycle is in bijection with its support -/
@@ -1339,11 +1337,11 @@ theorem card_support_cycleOf_pos_iff : 0 < card (cycleOf f x).support ↔ f x 
 #align equiv.perm.card_support_cycle_of_pos_iff Equiv.Perm.card_support_cycleOf_pos_iff
 -/
 
-#print Equiv.Perm.pow_apply_eq_pow_mod_orderOf_cycleOf_apply /-
-theorem pow_apply_eq_pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x : α) :
+#print Equiv.Perm.pow_mod_orderOf_cycleOf_apply /-
+theorem pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x : α) :
     (f ^ n) x = (f ^ (n % orderOf (cycleOf f x))) x := by
-  rw [← cycle_of_pow_apply_self f, ← cycle_of_pow_apply_self f, pow_eq_mod_orderOf]
-#align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_apply_eq_pow_mod_orderOf_cycleOf_apply
+  rw [← cycle_of_pow_apply_self f, ← cycle_of_pow_apply_self f, pow_mod_orderOf]
+#align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_mod_orderOf_cycleOf_apply
 -/
 
 #print Equiv.Perm.cycleOf_mul_of_apply_right_eq_self /-
@@ -1425,7 +1423,7 @@ theorem pow_mod_card_support_cycleOf_self_apply (f : Perm α) (n : ℕ) (x : α)
   · rw [pow_apply_eq_self_of_apply_eq_self hx, pow_apply_eq_self_of_apply_eq_self hx]
   ·
     rw [← cycle_of_pow_apply_self, ← cycle_of_pow_apply_self f, ← (is_cycle_cycle_of f hx).orderOf,
-      ← pow_eq_mod_orderOf]
+      ← pow_mod_orderOf]
 #align equiv.perm.pow_mod_card_support_cycle_of_self_apply Equiv.Perm.pow_mod_card_support_cycleOf_self_apply
 -/
 

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

@@ -1520,7 +1520,7 @@ def cycleFactorsAux [Fintype α] :
         ((List.mem_cons _ _ _).1 hg).elim (fun hg => hg.symm ▸ isCycle_cycleOf _ hx) (hm₂ g),
         List.pairwise_cons.2
           ⟨fun g hg y =>
-            or_iff_not_imp_left.2 fun hfy =>
+            Classical.or_iff_not_imp_left.2 fun hfy =>
               have hxy : SameCycle f x y :=
                 Classical.not_not.1 (mt cycleOf_apply_of_not_sameCycle hfy)
               have hgm : (g::m.eraseₓ g) ~ m :=

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

@@ -2277,8 +2277,8 @@ namespace Finset
 
 variable {f : Perm α} {s : Finset α}
 
-#print Finset.product_self_eq_disj_Union_perm_aux /-
-theorem product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
+#print Finset.product_self_eq_disjiUnion_perm_aux /-
+theorem product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
     (range s.card : Set ℕ).PairwiseDisjoint fun k =>
       s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩ :=
   by
@@ -2294,7 +2294,7 @@ theorem product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
   rw [hf.pow_apply_eq_pow_apply ha] at h 
   rw [mem_coe, mem_range] at hm hn 
   exact hmn.symm (h.eq_of_lt_of_lt hn hm)
-#align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disj_Union_perm_aux
+#align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disjiUnion_perm_aux
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -2309,11 +2309,11 @@ theorem product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
 
 The diagonals are given by the cycle `f`.
 -/
-theorem product_self_eq_disjUnion_perm (hf : f.IsCycleOn s) :
+theorem product_self_eq_disjiUnion_perm (hf : f.IsCycleOn s) :
     s ×ˢ s =
       (range s.card).disjUnionₓ
         (fun k => s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩)
-        (product_self_eq_disj_Union_perm_aux hf) :=
+        (product_self_eq_disjiUnion_perm_aux hf) :=
   by
   ext ⟨a, b⟩
   simp only [mem_product, Equiv.Perm.coe_pow, mem_disj_Union, mem_range, mem_map,
@@ -2323,7 +2323,7 @@ theorem product_self_eq_disjUnion_perm (hf : f.IsCycleOn s) :
     exact ⟨n, hn, a, hx.1, rfl, by rw [f.iterate_eq_pow]⟩
   · rintro ⟨n, -, a, ha, rfl, rfl⟩
     exact ⟨ha, (hf.1.iterate _).MapsTo ha⟩
-#align finset.product_self_eq_disj_Union_perm Finset.product_self_eq_disjUnionₓ_perm
+#align finset.product_self_eq_disj_Union_perm Finset.product_self_eq_disjiUnion_permₓ
 
 end Finset
 

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

@@ -3,13 +3,13 @@ Copyright (c) 2019 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Yaël Dillies
 -/
-import Mathbin.Algebra.Module.BigOperators
-import Mathbin.Data.Finset.NoncommProd
-import Mathbin.Data.Fintype.Perm
-import Mathbin.Data.Int.Modeq
-import Mathbin.GroupTheory.Perm.List
-import Mathbin.GroupTheory.Perm.Sign
-import Mathbin.Logic.Equiv.Fintype
+import Algebra.Module.BigOperators
+import Data.Finset.NoncommProd
+import Data.Fintype.Perm
+import Data.Int.Modeq
+import GroupTheory.Perm.List
+import GroupTheory.Perm.Sign
+import Logic.Equiv.Fintype
 
 #align_import group_theory.perm.cycle.basic from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
 

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

@@ -770,7 +770,7 @@ theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npo
 
 #print Equiv.Perm.IsCycle.pow_iff /-
 theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
-    IsCycle (f ^ n) ↔ n.coprime (orderOf f) := by
+    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) := by
   classical
   cases nonempty_fintype β
   constructor
@@ -866,7 +866,7 @@ theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf
   classical
   cases nonempty_fintype β
   have : n.coprime (orderOf f) := by
-    refine' Nat.coprime.symm _
+    refine' Nat.Coprime.symm _
     rw [Nat.Prime.coprime_iff_not_dvd hf']
     exact Nat.not_dvd_of_pos_of_lt hn hn'
   obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
@@ -1981,7 +1981,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
 -/
 
 #print Equiv.Perm.closure_cycle_coprime_swap /-
-theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n (Fintype.card α))
+theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.Coprime n (Fintype.card α))
     (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
     closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ :=
   by
@@ -2008,7 +2008,7 @@ theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime
       (mem_support.mp ((finset.ext_iff.mp h2 y).mpr (Finset.mem_univ y)))
   rw [h5, ← hi]
   refine'
-    closure_cycle_coprime_swap (Nat.coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
+    closure_cycle_coprime_swap (Nat.Coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
   cases' h with m hm
   rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.order_of, pow_orderOf_eq_one, one_pow,
     one_apply] at hi 

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

@@ -130,7 +130,7 @@ theorem sameCycle_inv : SameCycle f⁻¹ x y ↔ SameCycle f x y :=
 #align equiv.perm.same_cycle_inv Equiv.Perm.sameCycle_inv
 -/
 
-alias same_cycle_inv ↔ same_cycle.of_inv same_cycle.inv
+alias ⟨same_cycle.of_inv, same_cycle.inv⟩ := same_cycle_inv
 #align equiv.perm.same_cycle.of_inv Equiv.Perm.SameCycle.of_inv
 #align equiv.perm.same_cycle.inv Equiv.Perm.SameCycle.inv
 
@@ -223,35 +223,35 @@ theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle
 #align equiv.perm.same_cycle_pow_right Equiv.Perm.sameCycle_pow_right
 -/
 
-alias same_cycle_apply_left ↔ same_cycle.of_apply_left same_cycle.apply_left
+alias ⟨same_cycle.of_apply_left, same_cycle.apply_left⟩ := same_cycle_apply_left
 #align equiv.perm.same_cycle.of_apply_left Equiv.Perm.SameCycle.of_apply_left
 #align equiv.perm.same_cycle.apply_left Equiv.Perm.SameCycle.apply_left
 
-alias same_cycle_apply_right ↔ same_cycle.of_apply_right same_cycle.apply_right
+alias ⟨same_cycle.of_apply_right, same_cycle.apply_right⟩ := same_cycle_apply_right
 #align equiv.perm.same_cycle.of_apply_right Equiv.Perm.SameCycle.of_apply_right
 #align equiv.perm.same_cycle.apply_right Equiv.Perm.SameCycle.apply_right
 
-alias same_cycle_inv_apply_left ↔ same_cycle.of_inv_apply_left same_cycle.inv_apply_left
+alias ⟨same_cycle.of_inv_apply_left, same_cycle.inv_apply_left⟩ := same_cycle_inv_apply_left
 #align equiv.perm.same_cycle.of_inv_apply_left Equiv.Perm.SameCycle.of_inv_apply_left
 #align equiv.perm.same_cycle.inv_apply_left Equiv.Perm.SameCycle.inv_apply_left
 
-alias same_cycle_inv_apply_right ↔ same_cycle.of_inv_apply_right same_cycle.inv_apply_right
+alias ⟨same_cycle.of_inv_apply_right, same_cycle.inv_apply_right⟩ := same_cycle_inv_apply_right
 #align equiv.perm.same_cycle.of_inv_apply_right Equiv.Perm.SameCycle.of_inv_apply_right
 #align equiv.perm.same_cycle.inv_apply_right Equiv.Perm.SameCycle.inv_apply_right
 
-alias same_cycle_pow_left ↔ same_cycle.of_pow_left same_cycle.pow_left
+alias ⟨same_cycle.of_pow_left, same_cycle.pow_left⟩ := same_cycle_pow_left
 #align equiv.perm.same_cycle.of_pow_left Equiv.Perm.SameCycle.of_pow_left
 #align equiv.perm.same_cycle.pow_left Equiv.Perm.SameCycle.pow_left
 
-alias same_cycle_pow_right ↔ same_cycle.of_pow_right same_cycle.pow_right
+alias ⟨same_cycle.of_pow_right, same_cycle.pow_right⟩ := same_cycle_pow_right
 #align equiv.perm.same_cycle.of_pow_right Equiv.Perm.SameCycle.of_pow_right
 #align equiv.perm.same_cycle.pow_right Equiv.Perm.SameCycle.pow_right
 
-alias same_cycle_zpow_left ↔ same_cycle.of_zpow_left same_cycle.zpow_left
+alias ⟨same_cycle.of_zpow_left, same_cycle.zpow_left⟩ := same_cycle_zpow_left
 #align equiv.perm.same_cycle.of_zpow_left Equiv.Perm.SameCycle.of_zpow_left
 #align equiv.perm.same_cycle.zpow_left Equiv.Perm.SameCycle.zpow_left
 
-alias same_cycle_zpow_right ↔ same_cycle.of_zpow_right same_cycle.zpow_right
+alias ⟨same_cycle.of_zpow_right, same_cycle.zpow_right⟩ := same_cycle_zpow_right
 #align equiv.perm.same_cycle.of_zpow_right Equiv.Perm.SameCycle.of_zpow_right
 #align equiv.perm.same_cycle.zpow_right Equiv.Perm.SameCycle.zpow_right
 
@@ -275,7 +275,7 @@ theorem sameCycle_subtypePerm {h} {x y : { x // p x }} :
 #align equiv.perm.same_cycle_subtype_perm Equiv.Perm.sameCycle_subtypePerm
 -/
 
-alias same_cycle_subtype_perm ↔ _ same_cycle.subtype_perm
+alias ⟨_, same_cycle.subtype_perm⟩ := same_cycle_subtype_perm
 #align equiv.perm.same_cycle.subtype_perm Equiv.Perm.SameCycle.subtypePerm
 
 #print Equiv.Perm.sameCycle_extendDomain /-
@@ -287,7 +287,7 @@ theorem sameCycle_extendDomain {p : β → Prop} [DecidablePred p] {f : α ≃ S
 #align equiv.perm.same_cycle_extend_domain Equiv.Perm.sameCycle_extendDomain
 -/
 
-alias same_cycle_extend_domain ↔ _ same_cycle.extend_domain
+alias ⟨_, same_cycle.extend_domain⟩ := same_cycle_extend_domain
 #align equiv.perm.same_cycle.extend_domain Equiv.Perm.SameCycle.extendDomain
 
 #print Equiv.Perm.SameCycle.exists_pow_eq' /-
@@ -908,7 +908,7 @@ theorem isCycleOn_one : (1 : Perm α).IsCycleOn s ↔ s.Subsingleton := by
 #align equiv.perm.is_cycle_on_one Equiv.Perm.isCycleOn_one
 -/
 
-alias is_cycle_on_one ↔ is_cycle_on.subsingleton _root_.set.subsingleton.is_cycle_on_one
+alias ⟨is_cycle_on.subsingleton, _root_.set.subsingleton.is_cycle_on_one⟩ := is_cycle_on_one
 #align equiv.perm.is_cycle_on.subsingleton Equiv.Perm.IsCycleOn.subsingleton
 #align set.subsingleton.is_cycle_on_one Set.Subsingleton.isCycleOn_one
 
@@ -930,7 +930,7 @@ theorem isCycleOn_inv : f⁻¹.IsCycleOn s ↔ f.IsCycleOn s := by simp [is_cycl
 #align equiv.perm.is_cycle_on_inv Equiv.Perm.isCycleOn_inv
 -/
 
-alias is_cycle_on_inv ↔ is_cycle_on.of_inv is_cycle_on.inv
+alias ⟨is_cycle_on.of_inv, is_cycle_on.inv⟩ := is_cycle_on_inv
 #align equiv.perm.is_cycle_on.of_inv Equiv.Perm.IsCycleOn.of_inv
 #align equiv.perm.is_cycle_on.inv Equiv.Perm.IsCycleOn.inv
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -294,7 +294,7 @@ alias same_cycle_extend_domain ↔ _ same_cycle.extend_domain
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
   classical
   rintro ⟨k, rfl⟩
-  use (k % orderOf f).natAbs
+  use(k % orderOf f).natAbs
   have h₀ := int.coe_nat_pos.mpr (orderOf_pos f)
   have h₁ := Int.emod_nonneg k h₀.ne'
   rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_eq_mod_orderOf]

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

@@ -2,11 +2,6 @@
 Copyright (c) 2019 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Yaël Dillies
-
-! This file was ported from Lean 3 source module group_theory.perm.cycle.basic
-! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Module.BigOperators
 import Mathbin.Data.Finset.NoncommProd
@@ -16,6 +11,8 @@ import Mathbin.GroupTheory.Perm.List
 import Mathbin.GroupTheory.Perm.Sign
 import Mathbin.Logic.Equiv.Fintype
 
+#align_import group_theory.perm.cycle.basic from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
+
 /-!
 # Cyclic permutations
 

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

@@ -1994,7 +1994,7 @@ theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n
   have h1' : is_cycle ((σ ^ n) ^ (m : ℤ)) := by rwa [← hm] at h1 
   replace h1' : is_cycle (σ ^ n) :=
     h1'.of_pow (le_trans (support_pow_le σ n) (ge_of_eq (congr_arg support hm)))
-  rw [eq_top_iff, ← closure_cycle_adjacent_swap h1' h2' x, closure_le, Set.insert_subset]
+  rw [eq_top_iff, ← closure_cycle_adjacent_swap h1' h2' x, closure_le, Set.insert_subset_iff]
   exact
     ⟨Subgroup.pow_mem (closure _) (subset_closure (Set.mem_insert σ _)) n,
       set.singleton_subset_iff.mpr (subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _)))⟩

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

@@ -120,23 +120,29 @@ theorem SameCycle.trans : SameCycle f x y → SameCycle f y z → SameCycle f x
 #align equiv.perm.same_cycle.trans Equiv.Perm.SameCycle.trans
 -/
 
+#print Equiv.Perm.sameCycle_one /-
 @[simp]
 theorem sameCycle_one : SameCycle 1 x y ↔ x = y := by simp [same_cycle]
 #align equiv.perm.same_cycle_one Equiv.Perm.sameCycle_one
+-/
 
+#print Equiv.Perm.sameCycle_inv /-
 @[simp]
 theorem sameCycle_inv : SameCycle f⁻¹ x y ↔ SameCycle f x y :=
   (Equiv.neg _).exists_congr_left.trans <| by simp [same_cycle]
 #align equiv.perm.same_cycle_inv Equiv.Perm.sameCycle_inv
+-/
 
 alias same_cycle_inv ↔ same_cycle.of_inv same_cycle.inv
 #align equiv.perm.same_cycle.of_inv Equiv.Perm.SameCycle.of_inv
 #align equiv.perm.same_cycle.inv Equiv.Perm.SameCycle.inv
 
+#print Equiv.Perm.sameCycle_conj /-
 @[simp]
 theorem sameCycle_conj : SameCycle (g * f * g⁻¹) x y ↔ SameCycle f (g⁻¹ x) (g⁻¹ y) :=
   exists_congr fun i => by simp [conj_zpow, eq_inv_iff_eq]
 #align equiv.perm.same_cycle_conj Equiv.Perm.sameCycle_conj
+-/
 
 #print Equiv.Perm.SameCycle.conj /-
 theorem SameCycle.conj : SameCycle f x y → SameCycle (g * f * g⁻¹) (g x) (g y) := by
@@ -287,6 +293,7 @@ theorem sameCycle_extendDomain {p : β → Prop} [DecidablePred p] {f : α ≃ S
 alias same_cycle_extend_domain ↔ _ same_cycle.extend_domain
 #align equiv.perm.same_cycle.extend_domain Equiv.Perm.SameCycle.extendDomain
 
+#print Equiv.Perm.SameCycle.exists_pow_eq' /-
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
   classical
   rintro ⟨k, rfl⟩
@@ -298,6 +305,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
   rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
   exact Int.emod_lt_of_pos _ h₀
 #align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'
+-/
 
 #print Equiv.Perm.SameCycle.exists_pow_eq'' /-
 theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
@@ -348,12 +356,16 @@ def IsCycle (f : Perm α) : Prop :=
 #align equiv.perm.is_cycle Equiv.Perm.IsCycle
 -/
 
+#print Equiv.Perm.IsCycle.ne_one /-
 theorem IsCycle.ne_one (h : IsCycle f) : f ≠ 1 := fun hf => by simpa [hf, is_cycle] using h
 #align equiv.perm.is_cycle.ne_one Equiv.Perm.IsCycle.ne_one
+-/
 
+#print Equiv.Perm.not_isCycle_one /-
 @[simp]
 theorem not_isCycle_one : ¬(1 : Perm α).IsCycle := fun H => H.ne_one rfl
 #align equiv.perm.not_is_cycle_one Equiv.Perm.not_isCycle_one
+-/
 
 #print Equiv.Perm.IsCycle.sameCycle /-
 protected theorem IsCycle.sameCycle (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y) :
@@ -371,16 +383,21 @@ theorem IsCycle.exists_zpow_eq : IsCycle f → f x ≠ x → f y ≠ y → ∃ i
 #align equiv.perm.is_cycle.exists_zpow_eq Equiv.Perm.IsCycle.exists_zpow_eq
 -/
 
+#print Equiv.Perm.IsCycle.inv /-
 theorem IsCycle.inv (hf : IsCycle f) : IsCycle f⁻¹ :=
   hf.imp fun x ⟨hx, h⟩ =>
     ⟨inv_eq_iff_eq.Not.2 hx.symm, fun y hy => (h <| inv_eq_iff_eq.Not.2 hy.symm).inv⟩
 #align equiv.perm.is_cycle.inv Equiv.Perm.IsCycle.inv
+-/
 
+#print Equiv.Perm.isCycle_inv /-
 @[simp]
 theorem isCycle_inv : IsCycle f⁻¹ ↔ IsCycle f :=
   ⟨fun h => by convert h.inv; rw [inv_inv], IsCycle.inv⟩
 #align equiv.perm.is_cycle_inv Equiv.Perm.isCycle_inv
+-/
 
+#print Equiv.Perm.IsCycle.conj /-
 theorem IsCycle.conj : IsCycle f → IsCycle (g * f * g⁻¹) :=
   by
   rintro ⟨x, hx, h⟩
@@ -388,6 +405,7 @@ theorem IsCycle.conj : IsCycle f → IsCycle (g * f * g⁻¹) :=
   rw [← apply_inv_self g y]
   exact (h <| eq_inv_iff_eq.not.2 hy).conj
 #align equiv.perm.is_cycle.conj Equiv.Perm.IsCycle.conj
+-/
 
 #print Equiv.Perm.IsCycle.extendDomain /-
 protected theorem IsCycle.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) :
@@ -458,6 +476,7 @@ theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
 #align equiv.perm.is_cycle.two_le_card_support Equiv.Perm.IsCycle.two_le_card_support
 -/
 
+#print Equiv.Perm.IsCycle.exists_pow_eq_one /-
 theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by
   classical
@@ -470,7 +489,9 @@ theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     simpa [hk'] using hx
   · exact ⟨k + 2, by simp, hk'⟩
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
+-/
 
+#print Equiv.Perm.IsCycle.zpowersEquivSupport /-
 /-- The subgroup generated by a cycle is in bijection with its support -/
 noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ) :
     (↑(Subgroup.zpowers σ) : Set (Perm α)) ≃ (↑σ.support : Set α) :=
@@ -494,6 +515,7 @@ noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ)
         obtain ⟨n, rfl⟩ := (Classical.choose_spec hσ).2 hy
         exact ⟨⟨σ ^ n, n, rfl⟩, rfl⟩)
 #align equiv.perm.is_cycle.zpowers_equiv_support Equiv.Perm.IsCycle.zpowersEquivSupport
+-/
 
 #print Equiv.Perm.IsCycle.zpowersEquivSupport_apply /-
 @[simp]
@@ -505,6 +527,7 @@ theorem IsCycle.zpowersEquivSupport_apply {σ : Perm α} (hσ : IsCycle σ) {n :
 #align equiv.perm.is_cycle.zpowers_equiv_support_apply Equiv.Perm.IsCycle.zpowersEquivSupport_apply
 -/
 
+#print Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply /-
 @[simp]
 theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ) (n : ℕ) :
     hσ.zpowersEquivSupport.symm
@@ -513,6 +536,7 @@ theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ)
       ⟨σ ^ n, n, rfl⟩ :=
   (Equiv.symm_apply_eq _).2 hσ.zpowersEquivSupport_apply
 #align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply
+-/
 
 #print Equiv.Perm.IsCycle.orderOf /-
 protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.support.card :=
@@ -611,6 +635,7 @@ theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCy
 #align equiv.perm.is_cycle.swap_mul Equiv.Perm.IsCycle.swap_mul
 -/
 
+#print Equiv.Perm.IsCycle.sign /-
 theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.support.card
   | f => fun hf =>
     let ⟨x, hx⟩ := hf
@@ -639,6 +664,7 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.su
             neg_mul_neg]
 termination_by' ⟨_, measure_wf fun f => f.support.card⟩
 #align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.sign
+-/
 
 #print Equiv.Perm.IsCycle.of_pow /-
 theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
@@ -772,6 +798,7 @@ theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
 #align equiv.perm.is_cycle.pow_iff Equiv.Perm.IsCycle.pow_iff
 -/
 
+#print Equiv.Perm.IsCycle.pow_eq_one_iff /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x := by
@@ -789,6 +816,7 @@ theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : 
       obtain ⟨k, rfl⟩ := h
       rw [pow_mul, pow_orderOf_eq_one, one_pow]
 #align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iff
+-/
 
 #print Equiv.Perm.IsCycle.pow_eq_one_iff' /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
@@ -798,6 +826,7 @@ theorem IsCycle.pow_eq_one_iff' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
 #align equiv.perm.is_cycle.pow_eq_one_iff' Equiv.Perm.IsCycle.pow_eq_one_iff'
 -/
 
+#print Equiv.Perm.IsCycle.pow_eq_one_iff'' /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     f ^ n = 1 ↔ ∀ x, f x ≠ x → (f ^ n) x = x :=
@@ -805,6 +834,7 @@ theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
     let ⟨x, hx, _⟩ := id hf
     (hf.pow_eq_one_iff' hx).2 (h _ hx)⟩
 #align equiv.perm.is_cycle.pow_eq_one_iff'' Equiv.Perm.IsCycle.pow_eq_one_iff''
+-/
 
 #print Equiv.Perm.IsCycle.pow_eq_pow_iff /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
@@ -874,10 +904,12 @@ theorem isCycleOn_empty : f.IsCycleOn ∅ := by simp [is_cycle_on]
 #align equiv.perm.is_cycle_on_empty Equiv.Perm.isCycleOn_empty
 -/
 
+#print Equiv.Perm.isCycleOn_one /-
 @[simp]
 theorem isCycleOn_one : (1 : Perm α).IsCycleOn s ↔ s.Subsingleton := by
   simp [is_cycle_on, Set.bijOn_id, Set.Subsingleton]
 #align equiv.perm.is_cycle_on_one Equiv.Perm.isCycleOn_one
+-/
 
 alias is_cycle_on_one ↔ is_cycle_on.subsingleton _root_.set.subsingleton.is_cycle_on_one
 #align equiv.perm.is_cycle_on.subsingleton Equiv.Perm.IsCycleOn.subsingleton
@@ -895,9 +927,11 @@ theorem isCycleOn_of_subsingleton [Subsingleton α] (f : Perm α) (s : Set α) :
 #align equiv.perm.is_cycle_on_of_subsingleton Equiv.Perm.isCycleOn_of_subsingleton
 -/
 
+#print Equiv.Perm.isCycleOn_inv /-
 @[simp]
 theorem isCycleOn_inv : f⁻¹.IsCycleOn s ↔ f.IsCycleOn s := by simp [is_cycle_on, Set.bijOn_perm_inv]
 #align equiv.perm.is_cycle_on_inv Equiv.Perm.isCycleOn_inv
+-/
 
 alias is_cycle_on_inv ↔ is_cycle_on.of_inv is_cycle_on.inv
 #align equiv.perm.is_cycle_on.of_inv Equiv.Perm.IsCycleOn.of_inv
@@ -1039,6 +1073,7 @@ theorem IsCycleOn.pow_card_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a 
 #align equiv.perm.is_cycle_on.pow_card_apply Equiv.Perm.IsCycleOn.pow_card_apply
 -/
 
+#print Equiv.Perm.IsCycleOn.exists_pow_eq /-
 theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
     ∃ n < s.card, (f ^ n) a = b := by
   classical
@@ -1051,6 +1086,7 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
   simp only [zpow_ofNat, coe_mul, EmbeddingLike.apply_eq_iff_eq]
   exact is_fixed_pt.perm_zpow (hf.pow_card_apply ha) _
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
+-/
 
 #print Equiv.Perm.IsCycleOn.exists_pow_eq' /-
 theorem IsCycleOn.exists_pow_eq' (hs : s.Finite) (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
@@ -1131,11 +1167,13 @@ theorem cycleOf_apply (f : Perm α) (x y : α) : cycleOf f x y = if SameCycle f
 #align equiv.perm.cycle_of_apply Equiv.Perm.cycleOf_apply
 -/
 
+#print Equiv.Perm.cycleOf_inv /-
 theorem cycleOf_inv (f : Perm α) (x : α) : (cycleOf f x)⁻¹ = cycleOf f⁻¹ x :=
   Equiv.ext fun y => by
     rw [inv_eq_iff_eq, cycle_of_apply, cycle_of_apply]
     split_ifs <;> simp_all [same_cycle_inv, same_cycle_inv_apply_right]
 #align equiv.perm.cycle_of_inv Equiv.Perm.cycleOf_inv
+-/
 
 #print Equiv.Perm.cycleOf_pow_apply_self /-
 @[simp]
@@ -1223,6 +1261,7 @@ theorem IsCycle.cycleOf_eq (hf : IsCycle f) (hx : f x ≠ x) : cycleOf f x = f :
 #align equiv.perm.is_cycle.cycle_of_eq Equiv.Perm.IsCycle.cycleOf_eq
 -/
 
+#print Equiv.Perm.cycleOf_eq_one_iff /-
 @[simp]
 theorem cycleOf_eq_one_iff (f : Perm α) : cycleOf f x = 1 ↔ f x = x :=
   by
@@ -1232,6 +1271,7 @@ theorem cycleOf_eq_one_iff (f : Perm α) : cycleOf f x = 1 ↔ f x = x :=
   · rw [hy, if_t_t]
   · exact if_neg (mt same_cycle.apply_eq_self_iff (by tauto))
 #align equiv.perm.cycle_of_eq_one_iff Equiv.Perm.cycleOf_eq_one_iff
+-/
 
 #print Equiv.Perm.cycleOf_self_apply /-
 @[simp]
@@ -1264,9 +1304,11 @@ protected theorem IsCycle.cycleOf (hf : IsCycle f) : cycleOf f x = if f x = x th
 #align equiv.perm.is_cycle.cycle_of Equiv.Perm.IsCycle.cycleOf
 -/
 
+#print Equiv.Perm.cycleOf_one /-
 theorem cycleOf_one (x : α) : cycleOf 1 x = 1 :=
   (cycleOf_eq_one_iff 1).mpr rfl
 #align equiv.perm.cycle_of_one Equiv.Perm.cycleOf_one
+-/
 
 #print Equiv.Perm.isCycle_cycleOf /-
 theorem isCycle_cycleOf (f : Perm α) (hx : f x ≠ x) : IsCycle (cycleOf f x) :=
@@ -1307,6 +1349,7 @@ theorem pow_apply_eq_pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x :
 #align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_apply_eq_pow_mod_orderOf_cycleOf_apply
 -/
 
+#print Equiv.Perm.cycleOf_mul_of_apply_right_eq_self /-
 theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x = x) :
     (f * g).cycleOf x = f.cycleOf x := by
   ext y
@@ -1320,7 +1363,9 @@ theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x
     refine' ⟨z, _⟩
     simp [h.mul_zpow, zpow_apply_eq_self_of_apply_eq_self hx]
 #align equiv.perm.cycle_of_mul_of_apply_right_eq_self Equiv.Perm.cycleOf_mul_of_apply_right_eq_self
+-/
 
+#print Equiv.Perm.Disjoint.cycleOf_mul_distrib /-
 theorem Disjoint.cycleOf_mul_distrib (h : f.Disjoint g) (x : α) :
     (f * g).cycleOf x = f.cycleOf x * g.cycleOf x :=
   by
@@ -1328,6 +1373,7 @@ theorem Disjoint.cycleOf_mul_distrib (h : f.Disjoint g) (x : α) :
   · simp [h.commute.eq, cycle_of_mul_of_apply_right_eq_self h.symm.commute, hfx]
   · simp [cycle_of_mul_of_apply_right_eq_self h.commute, hgx]
 #align equiv.perm.disjoint.cycle_of_mul_distrib Equiv.Perm.Disjoint.cycleOf_mul_distrib
+-/
 
 #print Equiv.Perm.support_cycleOf_eq_nil_iff /-
 theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.support := by simp
@@ -1530,6 +1576,7 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
 #align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
 -/
 
+#print Equiv.Perm.list_cycles_perm_list_cycles /-
 theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List (Perm α)}
     (h₀ : l₁.Prod = l₂.Prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
     (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
@@ -1544,13 +1591,17 @@ theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List
     rw [mem_list_cycles_iff h₁l₁ h₂l₁, mem_list_cycles_iff h₁l₂ h₂l₂, h₀]
   · exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
 #align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cycles
+-/
 
+#print Equiv.Perm.cycleFactors /-
 /-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`. -/
 def cycleFactors [Fintype α] [LinearOrder α] (f : Perm α) :
     { l : List (Perm α) // l.Prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } :=
   cycleFactorsAux (univ.sort (· ≤ ·)) f fun _ _ => (mem_sort _).2 (mem_univ _)
 #align equiv.perm.cycle_factors Equiv.Perm.cycleFactors
+-/
 
+#print Equiv.Perm.truncCycleFactors /-
 /-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`,
   without a linear order. -/
 def truncCycleFactors [Fintype α] (f : Perm α) :
@@ -1558,6 +1609,7 @@ def truncCycleFactors [Fintype α] (f : Perm α) :
   Quotient.recOnSubsingleton (@univ α _).1 (fun l h => Trunc.mk (cycleFactorsAux l f h))
     (show ∀ x, f x ≠ x → x ∈ (@univ α _).1 from fun _ _ => mem_univ _)
 #align equiv.perm.trunc_cycle_factors Equiv.Perm.truncCycleFactors
+-/
 
 section CycleFactorsFinset
 
@@ -1577,6 +1629,7 @@ def cycleFactorsFinset : Finset (Perm α) :=
 #align equiv.perm.cycle_factors_finset Equiv.Perm.cycleFactorsFinset
 -/
 
+#print Equiv.Perm.cycleFactorsFinset_eq_list_toFinset /-
 theorem cycleFactorsFinset_eq_list_toFinset {σ : Perm α} {l : List (Perm α)} (hn : l.Nodup) :
     σ.cycleFactorsFinset = l.toFinset ↔
       (∀ f : Perm α, f ∈ l → f.IsCycle) ∧ l.Pairwise Disjoint ∧ l.Prod = σ :=
@@ -1600,6 +1653,7 @@ theorem cycleFactorsFinset_eq_list_toFinset {σ : Perm α} {l : List (Perm α)}
     refine' list_cycles_perm_list_cycles _ hc' hc hd' hd
     rw [hp, hp']
 #align equiv.perm.cycle_factors_finset_eq_list_to_finset Equiv.Perm.cycleFactorsFinset_eq_list_toFinset
+-/
 
 #print Equiv.Perm.cycleFactorsFinset_eq_finset /-
 theorem cycleFactorsFinset_eq_finset {σ : Perm α} {s : Finset (Perm α)} :
@@ -1620,10 +1674,13 @@ theorem cycleFactorsFinset_pairwise_disjoint :
 #align equiv.perm.cycle_factors_finset_pairwise_disjoint Equiv.Perm.cycleFactorsFinset_pairwise_disjoint
 -/
 
+#print Equiv.Perm.cycleFactorsFinset_mem_commute /-
 theorem cycleFactorsFinset_mem_commute : (cycleFactorsFinset f : Set (Perm α)).Pairwise Commute :=
   (cycleFactorsFinset_pairwise_disjoint _).mono' fun _ _ => Disjoint.commute
 #align equiv.perm.cycle_factors_finset_mem_commute Equiv.Perm.cycleFactorsFinset_mem_commute
+-/
 
+#print Equiv.Perm.cycleFactorsFinset_noncommProd /-
 /-- The product of cycle factors is equal to the original `f : perm α`. -/
 theorem cycleFactorsFinset_noncommProd
     (comm : (cycleFactorsFinset f : Set (Perm α)).Pairwise Commute :=
@@ -1631,6 +1688,7 @@ theorem cycleFactorsFinset_noncommProd
     f.cycleFactorsFinset.noncommProd id comm = f :=
   (cycleFactorsFinset_eq_finset.mp rfl).2.choose_spec
 #align equiv.perm.cycle_factors_finset_noncomm_prod Equiv.Perm.cycleFactorsFinset_noncommProd
+-/
 
 #print Equiv.Perm.mem_cycleFactorsFinset_iff /-
 theorem mem_cycleFactorsFinset_iff {f p : Perm α} :
@@ -1675,14 +1733,18 @@ theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactor
 #align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_le
 -/
 
+#print Equiv.Perm.cycleFactorsFinset_eq_empty_iff /-
 theorem cycleFactorsFinset_eq_empty_iff {f : Perm α} : cycleFactorsFinset f = ∅ ↔ f = 1 := by
   simpa [cycle_factors_finset_eq_finset] using eq_comm
 #align equiv.perm.cycle_factors_finset_eq_empty_iff Equiv.Perm.cycleFactorsFinset_eq_empty_iff
+-/
 
+#print Equiv.Perm.cycleFactorsFinset_one /-
 @[simp]
 theorem cycleFactorsFinset_one : cycleFactorsFinset (1 : Perm α) = ∅ := by
   simp [cycle_factors_finset_eq_empty_iff]
 #align equiv.perm.cycle_factors_finset_one Equiv.Perm.cycleFactorsFinset_one
+-/
 
 #print Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff /-
 @[simp]
@@ -1718,6 +1780,7 @@ theorem cycleFactorsFinset_injective : Function.Injective (@cycleFactorsFinset 
 #align equiv.perm.cycle_factors_finset_injective Equiv.Perm.cycleFactorsFinset_injective
 -/
 
+#print Equiv.Perm.Disjoint.disjoint_cycleFactorsFinset /-
 theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g) :
     Disjoint (cycleFactorsFinset f) (cycleFactorsFinset g) :=
   by
@@ -1729,7 +1792,9 @@ theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g)
   refine' h.le_bot (_ : a ∈ f.support ∩ g.support)
   simp [ha, ← hf a ha, ← hg a ha]
 #align equiv.perm.disjoint.disjoint_cycle_factors_finset Equiv.Perm.Disjoint.disjoint_cycleFactorsFinset
+-/
 
+#print Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_union /-
 theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f g) :
     cycleFactorsFinset (f * g) = cycleFactorsFinset f ∪ cycleFactorsFinset g :=
   by
@@ -1744,7 +1809,9 @@ theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f
   · rw [noncomm_prod_union_of_disjoint h.disjoint_cycle_factors_finset]
     rw [cycle_factors_finset_noncomm_prod, cycle_factors_finset_noncomm_prod]
 #align equiv.perm.disjoint.cycle_factors_finset_mul_eq_union Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_union
+-/
 
+#print Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset /-
 theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cycleFactorsFinset g) :
     Disjoint (g * f⁻¹) f := by
   rw [mem_cycle_factors_finset_iff] at h 
@@ -1755,6 +1822,7 @@ theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cy
     rw [mul_apply, ← h.right, apply_inv_self]
     rwa [← support_inv, apply_mem_support, support_inv, mem_support]
 #align equiv.perm.disjoint_mul_inv_of_mem_cycle_factors_finset Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset
+-/
 
 #print Equiv.Perm.cycle_is_cycleOf /-
 /-- If c is a cycle, a ∈ c.support and c is a cycle of f, then `c = f.cycle_of a` -/
@@ -1780,6 +1848,7 @@ theorem cycle_is_cycleOf {f c : Equiv.Perm α} {a : α} (ha : a ∈ c.support)
 
 end CycleFactorsFinset
 
+#print Equiv.Perm.cycle_induction_on /-
 @[elab_as_elim]
 theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (base_one : P 1)
     (base_cycles : ∀ σ : Perm β, σ.IsCycle → P σ)
@@ -1801,7 +1870,9 @@ theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (ba
         (h1 _ (List.mem_cons_self _ _)) (base_cycles σ (h1 σ (l.mem_cons_self σ)))
         (ih (fun τ hτ => h1 τ (List.mem_cons_of_mem σ hτ)) h2.of_cons)
 #align equiv.perm.cycle_induction_on Equiv.Perm.cycle_induction_on
+-/
 
+#print Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiff /-
 theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
     (h : f ∈ cycleFactorsFinset g) : cycleFactorsFinset (g * f⁻¹) = cycleFactorsFinset g \ {f} :=
   by
@@ -1844,6 +1915,7 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
             contradiction
       · exact fun H => hd.disjoint_cycle_factors_finset.le_bot (mem_inter_of_mem H hf)
 #align equiv.perm.cycle_factors_finset_mul_inv_mem_eq_sdiff Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiff
+-/
 
 section Generation
 
@@ -1851,14 +1923,17 @@ variable [Finite β]
 
 open Subgroup
 
+#print Equiv.Perm.closure_isCycle /-
 theorem closure_isCycle : closure {σ : Perm β | IsCycle σ} = ⊤ := by
   classical
   cases nonempty_fintype β
   exact top_le_iff.mp (le_trans (ge_of_eq closure_is_swap) (closure_mono fun _ => is_swap.is_cycle))
 #align equiv.perm.closure_is_cycle Equiv.Perm.closure_isCycle
+-/
 
 variable [Fintype α]
 
+#print Equiv.Perm.closure_cycle_adjacent_swap /-
 theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.support = ⊤) (x : α) :
     closure ({σ, swap x (σ x)} : Set (Perm α)) = ⊤ :=
   by
@@ -1906,6 +1981,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
   rw [h6]
   exact step4 y z
 #align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swap
+-/
 
 #print Equiv.Perm.closure_cycle_coprime_swap /-
 theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n (Fintype.card α))
@@ -1925,6 +2001,7 @@ theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n
 #align equiv.perm.closure_cycle_coprime_swap Equiv.Perm.closure_cycle_coprime_swap
 -/
 
+#print Equiv.Perm.closure_prime_cycle_swap /-
 theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime) (h1 : IsCycle σ)
     (h2 : σ.support = Finset.univ) (h3 : IsSwap τ) : closure ({σ, τ} : Set (Perm α)) = ⊤ :=
   by
@@ -1939,6 +2016,7 @@ theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime
   rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.order_of, pow_orderOf_eq_one, one_pow,
     one_apply] at hi 
 #align equiv.perm.closure_prime_cycle_swap Equiv.Perm.closure_prime_cycle_swap
+-/
 
 end Generation
 
@@ -2008,6 +2086,7 @@ theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
 #align equiv.perm.is_cycle.is_conj_iff Equiv.Perm.IsCycle.isConj_iff
 -/
 
+#print Equiv.Perm.support_conj /-
 @[simp]
 theorem support_conj : (σ * τ * σ⁻¹).support = τ.support.map σ.toEmbedding :=
   by
@@ -2015,12 +2094,16 @@ theorem support_conj : (σ * τ * σ⁻¹).support = τ.support.map σ.toEmbeddi
   simp only [mem_map_equiv, perm.coe_mul, comp_app, Ne.def, perm.mem_support, Equiv.eq_symm_apply]
   rfl
 #align equiv.perm.support_conj Equiv.Perm.support_conj
+-/
 
+#print Equiv.Perm.card_support_conj /-
 theorem card_support_conj : (σ * τ * σ⁻¹).support.card = τ.support.card := by simp
 #align equiv.perm.card_support_conj Equiv.Perm.card_support_conj
+-/
 
 end
 
+#print Equiv.Perm.Disjoint.isConj_mul /-
 theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
     (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
   classical
@@ -2071,6 +2154,7 @@ theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (h
         rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 (τ x)).resolve_right hxτ, mem_coe,
           mem_support]
 #align equiv.perm.disjoint.is_conj_mul Equiv.Perm.Disjoint.isConj_mul
+-/
 
 section FixedPoints
 
@@ -2079,12 +2163,14 @@ section FixedPoints
 -/
 
 
+#print Equiv.Perm.fixed_point_card_lt_of_ne_one /-
 theorem fixed_point_card_lt_of_ne_one [Fintype α] {σ : Perm α} (h : σ ≠ 1) :
     (filter (fun x => σ x = x) univ).card < Fintype.card α - 1 :=
   by
   rw [lt_tsub_iff_left, ← lt_tsub_iff_right, ← Finset.card_compl, Finset.compl_filter]
   exact one_lt_card_support_of_ne_one h
 #align equiv.perm.fixed_point_card_lt_of_ne_one Equiv.Perm.fixed_point_card_lt_of_ne_one
+-/
 
 end FixedPoints
 
@@ -2115,13 +2201,17 @@ namespace Int
 
 open Equiv
 
+#print Int.addLeft_one_isCycle /-
 theorem addLeft_one_isCycle : (Equiv.addLeft 1 : Perm ℤ).IsCycle :=
   ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
 #align int.add_left_one_is_cycle Int.addLeft_one_isCycle
+-/
 
+#print Int.addRight_one_isCycle /-
 theorem addRight_one_isCycle : (Equiv.addRight 1 : Perm ℤ).IsCycle :=
   ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
 #align int.add_right_one_is_cycle Int.addRight_one_isCycle
+-/
 
 end Int
 
@@ -2146,6 +2236,7 @@ namespace Set
 
 variable {f : Perm α} {s : Set α}
 
+#print Set.Countable.exists_cycleOn /-
 theorem Countable.exists_cycleOn (hs : s.Countable) :
     ∃ f : Perm α, f.IsCycleOn s ∧ {x | f x ≠ x} ⊆ s := by
   classical
@@ -2166,6 +2257,7 @@ theorem Countable.exists_cycleOn (hs : s.Countable) :
   ext
   simp
 #align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.prod_self_eq_iUnion_perm /-
@@ -2242,15 +2334,19 @@ namespace Finset
 
 variable [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : Perm ι}
 
+#print Finset.sum_smul_sum_eq_sum_perm /-
 theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
     (∑ i in s, f i) • ∑ i in s, g i = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) := by
   simp_rw [sum_smul_sum, product_self_eq_disj_Union_perm hσ, sum_disj_Union, sum_map]; rfl
 #align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_perm
+-/
 
+#print Finset.sum_mul_sum_eq_sum_perm /-
 theorem sum_mul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f g : ι → α) :
     (∑ i in s, f i) * ∑ i in s, g i = ∑ k in range s.card, ∑ i in s, f i * g ((σ ^ k) i) :=
   sum_smul_sum_eq_sum_perm hσ f g
 #align finset.sum_mul_sum_eq_sum_perm Finset.sum_mul_sum_eq_sum_perm
+-/
 
 end Finset
 

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

@@ -2243,12 +2243,12 @@ namespace Finset
 variable [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : Perm ι}
 
 theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
-    ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) := by
+    (∑ i in s, f i) • ∑ i in s, g i = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) := by
   simp_rw [sum_smul_sum, product_self_eq_disj_Union_perm hσ, sum_disj_Union, sum_map]; rfl
 #align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_perm
 
 theorem sum_mul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f g : ι → α) :
-    ((∑ i in s, f i) * ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i * g ((σ ^ k) i) :=
+    (∑ i in s, f i) * ∑ i in s, g i = ∑ k in range s.card, ∑ i in s, f i * g ((σ ^ k) i) :=
   sum_smul_sum_eq_sum_perm hσ f g
 #align finset.sum_mul_sum_eq_sum_perm Finset.sum_mul_sum_eq_sum_perm
 

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

@@ -607,7 +607,6 @@ theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCy
       calc
         (f ^ (i - 1)) (f x) = (f ^ (i - 1) * f ^ (1 : ℤ)) x := by rw [zpow_one, mul_apply]
         _ = y := by rwa [← zpow_add, sub_add_cancel]
-        
     isCycle_swap_mul_aux₂ (i - 1) hy hi⟩
 #align equiv.perm.is_cycle.swap_mul Equiv.Perm.IsCycle.swap_mul
 -/
@@ -638,7 +637,6 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.su
           rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
           simp only [pow_add, mul_one, neg_neg, one_mul, mul_neg, eq_self_iff_true, pow_one,
             neg_mul_neg]
-      
 termination_by' ⟨_, measure_wf fun f => f.support.card⟩
 #align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.sign
 

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

@@ -289,24 +289,24 @@ alias same_cycle_extend_domain ↔ _ same_cycle.extend_domain
 
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
   classical
-    rintro ⟨k, rfl⟩
-    use (k % orderOf f).natAbs
-    have h₀ := int.coe_nat_pos.mpr (orderOf_pos f)
-    have h₁ := Int.emod_nonneg k h₀.ne'
-    rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_eq_mod_orderOf]
-    refine' ⟨_, rfl⟩
-    rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
-    exact Int.emod_lt_of_pos _ h₀
+  rintro ⟨k, rfl⟩
+  use (k % orderOf f).natAbs
+  have h₀ := int.coe_nat_pos.mpr (orderOf_pos f)
+  have h₁ := Int.emod_nonneg k h₀.ne'
+  rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_eq_mod_orderOf]
+  refine' ⟨_, rfl⟩
+  rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
+  exact Int.emod_lt_of_pos _ h₀
 #align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'
 
 #print Equiv.Perm.SameCycle.exists_pow_eq'' /-
 theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
     ∃ (i : ℕ) (hpos : 0 < i) (h : i ≤ orderOf f), (f ^ i) x = y := by
   classical
-    obtain ⟨_ | i, hi, rfl⟩ := h.exists_pow_eq'
-    · refine' ⟨orderOf f, orderOf_pos f, le_rfl, _⟩
-      rw [pow_orderOf_eq_one, pow_zero]
-    · exact ⟨i.succ, i.zero_lt_succ, hi.le, rfl⟩
+  obtain ⟨_ | i, hi, rfl⟩ := h.exists_pow_eq'
+  · refine' ⟨orderOf f, orderOf_pos f, le_rfl, _⟩
+    rw [pow_orderOf_eq_one, pow_zero]
+  · exact ⟨i.succ, i.zero_lt_succ, hi.le, rfl⟩
 #align equiv.perm.same_cycle.exists_pow_eq'' Equiv.Perm.SameCycle.exists_pow_eq''
 -/
 
@@ -426,10 +426,10 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
     ∃ i : ℕ, (f ^ i) x = y := by
   let ⟨n, hn⟩ := hf.exists_zpow_eq hx hy
   classical exact
-      ⟨(n % orderOf f).toNat,
-        by
-        have := n.mod_nonneg (int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
-        rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_eq_mod_orderOf]⟩
+    ⟨(n % orderOf f).toNat,
+      by
+      have := n.mod_nonneg (int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
+      rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_eq_mod_orderOf]⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 -/
 
@@ -440,7 +440,7 @@ variable [DecidableEq α]
 #print Equiv.Perm.isCycle_swap /-
 theorem isCycle_swap (hxy : x ≠ y) : IsCycle (swap x y) :=
   ⟨y, by rwa [swap_apply_right], fun a (ha : ite (a = x) y (ite (a = y) x a) ≠ a) =>
-    if hya : y = a then ⟨0, hya⟩ else ⟨1, by rw [zpow_one, swap_apply_def]; split_ifs  at * <;> cc⟩⟩
+    if hya : y = a then ⟨0, hya⟩ else ⟨1, by rw [zpow_one, swap_apply_def]; split_ifs at * <;> cc⟩⟩
 #align equiv.perm.is_cycle_swap Equiv.Perm.isCycle_swap
 -/
 
@@ -461,14 +461,14 @@ theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
 theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by
   classical
-    have : IsOfFinOrder f := exists_pow_eq_one f
-    rw [isOfFinOrder_iff_pow_eq_one] at this 
-    obtain ⟨x, hx, hx'⟩ := hf
-    obtain ⟨_ | _ | k, hk, hk'⟩ := this
-    · exact absurd hk (lt_asymm hk)
-    · rw [pow_one] at hk' 
-      simpa [hk'] using hx
-    · exact ⟨k + 2, by simp, hk'⟩
+  have : IsOfFinOrder f := exists_pow_eq_one f
+  rw [isOfFinOrder_iff_pow_eq_one] at this 
+  obtain ⟨x, hx, hx'⟩ := hf
+  obtain ⟨_ | _ | k, hk, hk'⟩ := this
+  · exact absurd hk (lt_asymm hk)
+  · rw [pow_one] at hk' 
+    simpa [hk'] using hx
+  · exact ⟨k + 2, by simp, hk'⟩
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
 
 /-- The subgroup generated by a cycle is in bijection with its support -/
@@ -751,26 +751,26 @@ theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npo
 theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     IsCycle (f ^ n) ↔ n.coprime (orderOf f) := by
   classical
-    cases nonempty_fintype β
-    constructor
-    · intro h
-      have hr : support (f ^ n) = support f :=
-        by
-        rw [hf.support_pow_eq_iff]
-        rintro ⟨k, rfl⟩
-        refine' h.ne_one _
-        simp [pow_mul, pow_orderOf_eq_one]
-      have : orderOf (f ^ n) = orderOf f := by rw [h.order_of, hr, hf.order_of]
-      rw [orderOf_pow, Nat.div_eq_self] at this 
-      cases this
-      · exact absurd this (orderOf_pos _).ne'
-      · rwa [Nat.coprime_iff_gcd_eq_one, Nat.gcd_comm]
-    · intro h
-      obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime h
-      have hf' : is_cycle ((f ^ n) ^ m) := by rwa [hm]
-      refine' hf'.of_pow fun x hx => _
-      rw [hm]
-      exact support_pow_le _ n hx
+  cases nonempty_fintype β
+  constructor
+  · intro h
+    have hr : support (f ^ n) = support f :=
+      by
+      rw [hf.support_pow_eq_iff]
+      rintro ⟨k, rfl⟩
+      refine' h.ne_one _
+      simp [pow_mul, pow_orderOf_eq_one]
+    have : orderOf (f ^ n) = orderOf f := by rw [h.order_of, hr, hf.order_of]
+    rw [orderOf_pow, Nat.div_eq_self] at this 
+    cases this
+    · exact absurd this (orderOf_pos _).ne'
+    · rwa [Nat.coprime_iff_gcd_eq_one, Nat.gcd_comm]
+  · intro h
+    obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime h
+    have hf' : is_cycle ((f ^ n) ^ m) := by rwa [hm]
+    refine' hf'.of_pow fun x hx => _
+    rw [hm]
+    exact support_pow_le _ n hx
 #align equiv.perm.is_cycle.pow_iff Equiv.Perm.IsCycle.pow_iff
 -/
 
@@ -778,18 +778,18 @@ theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
 theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x := by
   classical
-    cases nonempty_fintype β
-    constructor
-    · intro h
-      obtain ⟨x, hx, -⟩ := id hf
-      exact ⟨x, hx, by simp [h]⟩
-    · rintro ⟨x, hx, hx'⟩
-      by_cases h : support (f ^ n) = support f
-      · rw [← mem_support, ← h, mem_support] at hx 
-        contradiction
-      · rw [hf.support_pow_eq_iff, Classical.not_not] at h 
-        obtain ⟨k, rfl⟩ := h
-        rw [pow_mul, pow_orderOf_eq_one, one_pow]
+  cases nonempty_fintype β
+  constructor
+  · intro h
+    obtain ⟨x, hx, -⟩ := id hf
+    exact ⟨x, hx, by simp [h]⟩
+  · rintro ⟨x, hx, hx'⟩
+    by_cases h : support (f ^ n) = support f
+    · rw [← mem_support, ← h, mem_support] at hx 
+      contradiction
+    · rw [hf.support_pow_eq_iff, Classical.not_not] at h 
+      obtain ⟨k, rfl⟩ := h
+      rw [pow_mul, pow_orderOf_eq_one, one_pow]
 #align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iff
 
 #print Equiv.Perm.IsCycle.pow_eq_one_iff' /-
@@ -813,25 +813,25 @@ theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
 theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b : ℕ} :
     f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x := by
   classical
-    cases nonempty_fintype β
-    constructor
-    · intro h
-      obtain ⟨x, hx, -⟩ := id hf
-      exact ⟨x, hx, by simp [h]⟩
-    · rintro ⟨x, hx, hx'⟩
-      wlog hab : a ≤ b generalizing a b
-      · exact (this hx'.symm (le_of_not_le hab)).symm
-      suffices f ^ (b - a) = 1 by
-        rw [pow_sub _ hab, mul_inv_eq_one] at this 
-        rw [this]
-      rw [hf.pow_eq_one_iff]
-      by_cases hfa : (f ^ a) x ∈ f.support
-      · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
-        simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
-      · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
-        simp only [zpow_one, zpow_ofNat] at h 
-        rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa 
-        contradiction
+  cases nonempty_fintype β
+  constructor
+  · intro h
+    obtain ⟨x, hx, -⟩ := id hf
+    exact ⟨x, hx, by simp [h]⟩
+  · rintro ⟨x, hx, hx'⟩
+    wlog hab : a ≤ b generalizing a b
+    · exact (this hx'.symm (le_of_not_le hab)).symm
+    suffices f ^ (b - a) = 1 by
+      rw [pow_sub _ hab, mul_inv_eq_one] at this 
+      rw [this]
+    rw [hf.pow_eq_one_iff]
+    by_cases hfa : (f ^ a) x ∈ f.support
+    · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
+      simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
+    · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
+      simp only [zpow_one, zpow_ofNat] at h 
+      rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa 
+      contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
 -/
 
@@ -839,17 +839,17 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
 theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf : IsCycle f)
     (hf' : (orderOf f).Prime) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f) : IsCycle (f ^ n) := by
   classical
-    cases nonempty_fintype β
-    have : n.coprime (orderOf f) := by
-      refine' Nat.coprime.symm _
-      rw [Nat.Prime.coprime_iff_not_dvd hf']
-      exact Nat.not_dvd_of_pos_of_lt hn hn'
-    obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
-    have hf'' := hf
-    rw [← hm] at hf'' 
-    refine' hf''.of_pow _
-    rw [hm]
-    exact support_pow_le f n
+  cases nonempty_fintype β
+  have : n.coprime (orderOf f) := by
+    refine' Nat.coprime.symm _
+    rw [Nat.Prime.coprime_iff_not_dvd hf']
+    exact Nat.not_dvd_of_pos_of_lt hn hn'
+  obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
+  have hf'' := hf
+  rw [← hm] at hf'' 
+  refine' hf''.of_pow _
+  rw [hm]
+  exact support_pow_le f n
 #align equiv.perm.is_cycle.is_cycle_pow_pos_of_lt_prime_order Equiv.Perm.IsCycle.isCycle_pow_pos_of_lt_prime_order
 -/
 
@@ -908,7 +908,7 @@ alias is_cycle_on_inv ↔ is_cycle_on.of_inv is_cycle_on.inv
 #print Equiv.Perm.IsCycleOn.conj /-
 theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Perm α) '' s) :=
   ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy => by
-    rw [← preimage_inv] at hx hy ; convert(h.2 hx hy).conj <;> rw [apply_inv_self]⟩
+    rw [← preimage_inv] at hx hy ; convert (h.2 hx hy).conj <;> rw [apply_inv_self]⟩
 #align equiv.perm.is_cycle_on.conj Equiv.Perm.IsCycleOn.conj
 -/
 
@@ -935,7 +935,7 @@ protected theorem IsCycleOn.apply_ne (hf : f.IsCycleOn s) (hs : s.Nontrivial) (h
 -/
 
 #print Equiv.Perm.IsCycle.isCycleOn /-
-protected theorem IsCycle.isCycleOn (hf : f.IsCycle) : f.IsCycleOn { x | f x ≠ x } :=
+protected theorem IsCycle.isCycleOn (hf : f.IsCycle) : f.IsCycleOn {x | f x ≠ x} :=
   ⟨f.BijOn fun x => f.apply_eq_iff_eq.Not, fun a ha b => hf.SameCycle ha⟩
 #align equiv.perm.is_cycle.is_cycle_on Equiv.Perm.IsCycle.isCycleOn
 -/
@@ -946,7 +946,7 @@ in non-degenerate cases. -/
 theorem isCycle_iff_exists_isCycleOn :
     f.IsCycle ↔ ∃ s : Set α, s.Nontrivial ∧ f.IsCycleOn s ∧ ∀ ⦃x⦄, ¬IsFixedPt f x → x ∈ s :=
   by
-  refine' ⟨fun hf => ⟨{ x | f x ≠ x }, _, hf.IsCycleOn, fun _ => id⟩, _⟩
+  refine' ⟨fun hf => ⟨{x | f x ≠ x}, _, hf.IsCycleOn, fun _ => id⟩, _⟩
   · obtain ⟨a, ha⟩ := hf
     exact ⟨f a, f.injective.ne ha.1, a, ha.1, ha.1⟩
   · rintro ⟨s, hs, hf, hsf⟩
@@ -981,7 +981,7 @@ protected theorem IsCycleOn.subtypePerm (hf : f.IsCycleOn s) :
   obtain hs | hs := s.subsingleton_or_nontrivial
   · haveI := hs.coe_sort
     exact is_cycle_on_of_subsingleton _ _
-  convert(hf.is_cycle_subtype_perm hs).IsCycleOn
+  convert (hf.is_cycle_subtype_perm hs).IsCycleOn
   rw [eq_comm, Set.eq_univ_iff_forall]
   exact fun x => ne_of_apply_ne (coe : s → α) (hf.apply_ne hs x.Prop)
 #align equiv.perm.is_cycle_on.subtype_perm Equiv.Perm.IsCycleOn.subtypePerm
@@ -996,13 +996,13 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
   · rw [coe_singleton, is_cycle_on_singleton] at hf 
     simpa using is_fixed_pt.iterate hf n
   classical
-    have h : ∀ x ∈ s.attach, ¬f ↑x = ↑x := fun x hx => hf.apply_ne hs x.Prop
-    have := (hf.is_cycle_subtype_perm hs).orderOf
-    simp only [filter_true_of_mem h, support_subtype_perm, card_attach] at this 
-    rw [← this, orderOf_dvd_iff_pow_eq_one,
-      (hf.is_cycle_subtype_perm hs).pow_eq_one_iff'
-        (ne_of_apply_ne (coe : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).Prop)]
-    simp only [Subtype.coe_mk, subtype_perm_pow, subtype_perm_apply]
+  have h : ∀ x ∈ s.attach, ¬f ↑x = ↑x := fun x hx => hf.apply_ne hs x.Prop
+  have := (hf.is_cycle_subtype_perm hs).orderOf
+  simp only [filter_true_of_mem h, support_subtype_perm, card_attach] at this 
+  rw [← this, orderOf_dvd_iff_pow_eq_one,
+    (hf.is_cycle_subtype_perm hs).pow_eq_one_iff'
+      (ne_of_apply_ne (coe : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).Prop)]
+  simp only [Subtype.coe_mk, subtype_perm_pow, subtype_perm_apply]
 #align equiv.perm.is_cycle_on.pow_apply_eq Equiv.Perm.IsCycleOn.pow_apply_eq
 -/
 
@@ -1044,14 +1044,14 @@ theorem IsCycleOn.pow_card_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a 
 theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
     ∃ n < s.card, (f ^ n) a = b := by
   classical
-    obtain ⟨n, rfl⟩ := hf.2 ha hb
-    obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.Dvd
-    refine' ⟨n.nat_mod s.card, Int.natMod_lt (nonempty.card_pos ⟨a, ha⟩).ne', _⟩
-    rw [← zpow_ofNat, Int.natMod,
-      Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2 (nonempty.card_pos ⟨a, ha⟩).ne'),
-      sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
-    simp only [zpow_ofNat, coe_mul, EmbeddingLike.apply_eq_iff_eq]
-    exact is_fixed_pt.perm_zpow (hf.pow_card_apply ha) _
+  obtain ⟨n, rfl⟩ := hf.2 ha hb
+  obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.Dvd
+  refine' ⟨n.nat_mod s.card, Int.natMod_lt (nonempty.card_pos ⟨a, ha⟩).ne', _⟩
+  rw [← zpow_ofNat, Int.natMod,
+    Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2 (nonempty.card_pos ⟨a, ha⟩).ne'),
+    sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
+  simp only [zpow_ofNat, coe_mul, EmbeddingLike.apply_eq_iff_eq]
+  exact is_fixed_pt.perm_zpow (hf.pow_card_apply ha) _
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
 
 #print Equiv.Perm.IsCycleOn.exists_pow_eq' /-
@@ -1341,7 +1341,7 @@ theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ su
   by
   intro y hy
   rw [mem_support, cycle_of_apply] at hy 
-  split_ifs  at hy 
+  split_ifs at hy 
   · exact mem_support.mpr hy
   · exact absurd rfl hy
 #align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_le
@@ -1474,7 +1474,7 @@ def cycleFactorsAux [Fintype α] :
             (h fun h : f y = y =>
               by
               rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycle_of_apply] at hy 
-              split_ifs  at hy  <;> cc)
+              split_ifs at hy  <;> cc)
       ⟨cycleOf f x::m, by rw [List.prod_cons, hm₁]; simp, fun g hg =>
         ((List.mem_cons _ _ _).1 hg).elim (fun hg => hg.symm ▸ isCycle_cycleOf _ hx) (hm₂ g),
         List.pairwise_cons.2
@@ -1509,26 +1509,26 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
     exact ⟨fun hσ => ⟨h1 σ hσ, (this (h1 σ hσ)).mp hσ⟩, fun hσ => (this hσ.1).mpr hσ.2⟩
   intro h3
   classical
-    cases nonempty_fintype α
-    constructor
-    · intro h a ha
-      exact eq_on_support_mem_disjoint h h2 _ (mem_support.mpr ha)
-    · intro h
-      have hσl : σ.support ⊆ l.prod.support := by
-        intro x hx
-        rw [mem_support] at hx 
-        rwa [mem_support, ← h _ hx]
-      obtain ⟨a, ha, -⟩ := id h3
-      rw [← mem_support] at ha 
-      obtain ⟨τ, hτ, hτa⟩ := exists_mem_support_of_mem_support_prod (hσl ha)
-      have hτl : ∀ x ∈ τ.support, τ x = l.prod x := eq_on_support_mem_disjoint hτ h2
-      have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x :=
-        by
-        intro x hx
-        rw [h x (mem_support.mp (mem_of_mem_inter_left hx)), hτl x (mem_of_mem_inter_right hx)]
-      convert hτ
-      refine' h3.eq_on_support_inter_nonempty_congr (h1 _ hτ) key _ ha
-      exact key a (mem_inter_of_mem ha hτa)
+  cases nonempty_fintype α
+  constructor
+  · intro h a ha
+    exact eq_on_support_mem_disjoint h h2 _ (mem_support.mpr ha)
+  · intro h
+    have hσl : σ.support ⊆ l.prod.support := by
+      intro x hx
+      rw [mem_support] at hx 
+      rwa [mem_support, ← h _ hx]
+    obtain ⟨a, ha, -⟩ := id h3
+    rw [← mem_support] at ha 
+    obtain ⟨τ, hτ, hτa⟩ := exists_mem_support_of_mem_support_prod (hσl ha)
+    have hτl : ∀ x ∈ τ.support, τ x = l.prod x := eq_on_support_mem_disjoint hτ h2
+    have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x :=
+      by
+      intro x hx
+      rw [h x (mem_support.mp (mem_of_mem_inter_left hx)), hτl x (mem_of_mem_inter_right hx)]
+    convert hτ
+    refine' h3.eq_on_support_inter_nonempty_congr (h1 _ hτ) key _ ha
+    exact key a (mem_inter_of_mem ha hτa)
 #align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
 -/
 
@@ -1537,14 +1537,14 @@ theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List
     (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
     (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by
   classical
-    refine'
-      (List.perm_ext (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
-            (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
-        fun σ => _
-    by_cases hσ : σ.is_cycle
-    · obtain ⟨a, ha⟩ := not_forall.mp (mt ext hσ.ne_one)
-      rw [mem_list_cycles_iff h₁l₁ h₂l₁, mem_list_cycles_iff h₁l₂ h₂l₂, h₀]
-    · exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
+  refine'
+    (List.perm_ext (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
+          (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
+      fun σ => _
+  by_cases hσ : σ.is_cycle
+  · obtain ⟨a, ha⟩ := not_forall.mp (mt ext hσ.ne_one)
+    rw [mem_list_cycles_iff h₁l₁ h₂l₁, mem_list_cycles_iff h₁l₂ h₂l₂, h₀]
+  · exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
 #align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cycles
 
 /-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`. -/
@@ -1791,8 +1791,8 @@ theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (ba
   suffices ∀ l : List (perm β), (∀ τ : perm β, τ ∈ l → τ.IsCycle) → l.Pairwise Disjoint → P l.Prod
     by
     classical
-      let x := σ.trunc_cycle_factors.out
-      exact (congr_arg P x.2.1).mp (this x.1 x.2.2.1 x.2.2.2)
+    let x := σ.trunc_cycle_factors.out
+    exact (congr_arg P x.2.1).mp (this x.1 x.2.2.1 x.2.2.2)
   intro l
   induction' l with σ l ih
   · exact fun _ _ => base_one
@@ -1853,11 +1853,10 @@ variable [Finite β]
 
 open Subgroup
 
-theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤ := by
+theorem closure_isCycle : closure {σ : Perm β | IsCycle σ} = ⊤ := by
   classical
-    cases nonempty_fintype β
-    exact
-      top_le_iff.mp (le_trans (ge_of_eq closure_is_swap) (closure_mono fun _ => is_swap.is_cycle))
+  cases nonempty_fintype β
+  exact top_le_iff.mp (le_trans (ge_of_eq closure_is_swap) (closure_mono fun _ => is_swap.is_cycle))
 #align equiv.perm.closure_is_cycle Equiv.Perm.closure_isCycle
 
 variable [Fintype α]
@@ -2027,52 +2026,52 @@ end
 theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
     (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
   classical
-    cases nonempty_fintype α
-    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
-    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
-    have hd1' := coe_inj.2 hd1.support_mul
-    have hd2' := coe_inj.2 hd2.support_mul
-    rw [coe_union] at *
-    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
-    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
-    refine' is_conj_of_support_equiv _ _
-    ·
-      refine'
-          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
-            ((Equiv.sumCongr (subtype_equiv f fun a => _) (subtype_equiv g fun a => _)).trans
-              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
-        ·
-          simp only [Set.mem_image, to_embedding_apply, exists_eq_right, support_conj, coe_map,
-            apply_eq_iff_eq]
-    · intro x hx
-      simp only [trans_apply, symm_trans_apply, set.of_eq_apply, set.of_eq_symm_apply,
-        Equiv.sumCongr_apply]
-      rw [hd1', Set.mem_union] at hx 
-      cases' hx with hxσ hxτ
-      · rw [mem_coe, mem_support] at hxσ 
-        rw [set.union_apply_left hd1''.le_bot _, set.union_apply_left hd1''.le_bot _]
-        simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inl, comp_app,
-          set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
-        · have h := (hd2 (f x)).resolve_left _
-          · rw [mul_apply, mul_apply] at h 
-            rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
-          · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
-        · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, mem_support]
-        ·
-          rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
-            apply_mem_support, mem_support]
-      · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ 
-        rw [set.union_apply_right hd1''.le_bot _, set.union_apply_right hd1''.le_bot _]
-        simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inr, comp_app,
-          set.union_symm_apply_right, Subtype.coe_mk, apply_eq_iff_eq]
-        · have h := (hd2 (g (τ x))).resolve_right _
-          · rw [mul_apply, mul_apply] at h 
-            rw [inv_apply_self, h, (hd1 (τ x)).resolve_right hxτ]
-          · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
-        · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
-        ·
-          rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 (τ x)).resolve_right hxτ,
-            mem_coe, mem_support]
+  cases nonempty_fintype α
+  obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
+  obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
+  have hd1' := coe_inj.2 hd1.support_mul
+  have hd2' := coe_inj.2 hd2.support_mul
+  rw [coe_union] at *
+  have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
+  have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
+  refine' is_conj_of_support_equiv _ _
+  ·
+    refine'
+        ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
+          ((Equiv.sumCongr (subtype_equiv f fun a => _) (subtype_equiv g fun a => _)).trans
+            ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
+      ·
+        simp only [Set.mem_image, to_embedding_apply, exists_eq_right, support_conj, coe_map,
+          apply_eq_iff_eq]
+  · intro x hx
+    simp only [trans_apply, symm_trans_apply, set.of_eq_apply, set.of_eq_symm_apply,
+      Equiv.sumCongr_apply]
+    rw [hd1', Set.mem_union] at hx 
+    cases' hx with hxσ hxτ
+    · rw [mem_coe, mem_support] at hxσ 
+      rw [set.union_apply_left hd1''.le_bot _, set.union_apply_left hd1''.le_bot _]
+      simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inl, comp_app,
+        set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
+      · have h := (hd2 (f x)).resolve_left _
+        · rw [mul_apply, mul_apply] at h 
+          rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
+        · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
+      · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, mem_support]
+      ·
+        rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
+          apply_mem_support, mem_support]
+    · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ 
+      rw [set.union_apply_right hd1''.le_bot _, set.union_apply_right hd1''.le_bot _]
+      simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inr, comp_app,
+        set.union_symm_apply_right, Subtype.coe_mk, apply_eq_iff_eq]
+      · have h := (hd2 (g (τ x))).resolve_right _
+        · rw [mul_apply, mul_apply] at h 
+          rw [inv_apply_self, h, (hd1 (τ x)).resolve_right hxτ]
+        · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
+      · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
+      ·
+        rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 (τ x)).resolve_right hxτ, mem_coe,
+          mem_support]
 #align equiv.perm.disjoint.is_conj_mul Equiv.Perm.Disjoint.isConj_mul
 
 section FixedPoints
@@ -2100,7 +2099,7 @@ namespace List
 variable [DecidableEq α] {l : List α}
 
 #print List.Nodup.isCycleOn_formPerm /-
-theorem Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn { a | a ∈ l } :=
+theorem Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn {a | a ∈ l} :=
   by
   refine' ⟨l.form_perm.bij_on fun _ => form_perm_mem_iff_mem, fun a ha b hb => _⟩
   rw [Set.mem_setOf, ← index_of_lt_length] at ha hb 
@@ -2150,24 +2149,24 @@ namespace Set
 variable {f : Perm α} {s : Set α}
 
 theorem Countable.exists_cycleOn (hs : s.Countable) :
-    ∃ f : Perm α, f.IsCycleOn s ∧ { x | f x ≠ x } ⊆ s := by
+    ∃ f : Perm α, f.IsCycleOn s ∧ {x | f x ≠ x} ⊆ s := by
   classical
-    obtain hs' | hs' := s.finite_or_infinite
-    · refine'
-        ⟨hs'.to_finset.to_list.form_perm, _, fun x hx => by
-          simpa using List.mem_of_formPerm_apply_ne _ _ hx⟩
-      convert hs'.to_finset.nodup_to_list.is_cycle_on_form_perm
-      simp
-    haveI := hs.to_subtype
-    haveI := hs'.to_subtype
-    obtain ⟨f⟩ : Nonempty (ℤ ≃ s) := inferInstance
-    refine'
-      ⟨(Equiv.addRight 1).extendDomain f, _, fun x hx =>
-        of_not_not fun h => hx <| perm.extend_domain_apply_not_subtype _ _ h⟩
-    convert int.add_right_one_is_cycle.is_cycle_on.extend_domain _
-    rw [image_comp, Equiv.image_eq_preimage]
-    ext
+  obtain hs' | hs' := s.finite_or_infinite
+  · refine'
+      ⟨hs'.to_finset.to_list.form_perm, _, fun x hx => by
+        simpa using List.mem_of_formPerm_apply_ne _ _ hx⟩
+    convert hs'.to_finset.nodup_to_list.is_cycle_on_form_perm
     simp
+  haveI := hs.to_subtype
+  haveI := hs'.to_subtype
+  obtain ⟨f⟩ : Nonempty (ℤ ≃ s) := inferInstance
+  refine'
+    ⟨(Equiv.addRight 1).extendDomain f, _, fun x hx =>
+      of_not_not fun h => hx <| perm.extend_domain_apply_not_subtype _ _ h⟩
+  convert int.add_right_one_is_cycle.is_cycle_on.extend_domain _
+  rw [image_comp, Equiv.image_eq_preimage]
+  ext
+  simp
 #align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -2201,13 +2200,13 @@ theorem product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
     simp_rw [Set.Subsingleton, mem_coe, ← card_le_one] at hs ⊢
     rwa [card_range]
   classical
-    rintro m hm n hn hmn
-    simp only [disjoint_left, Function.onFun, mem_map, Function.Embedding.coeFn_mk, exists_prop,
-      not_exists, not_and, forall_exists_index, and_imp, Prod.forall, Prod.mk.inj_iff]
-    rintro _ _ _ - rfl rfl a ha rfl h
-    rw [hf.pow_apply_eq_pow_apply ha] at h 
-    rw [mem_coe, mem_range] at hm hn 
-    exact hmn.symm (h.eq_of_lt_of_lt hn hm)
+  rintro m hm n hn hmn
+  simp only [disjoint_left, Function.onFun, mem_map, Function.Embedding.coeFn_mk, exists_prop,
+    not_exists, not_and, forall_exists_index, and_imp, Prod.forall, Prod.mk.inj_iff]
+  rintro _ _ _ - rfl rfl a ha rfl h
+  rw [hf.pow_apply_eq_pow_apply ha] at h 
+  rw [mem_coe, mem_range] at hm hn 
+  exact hmn.symm (h.eq_of_lt_of_lt hn hm)
 #align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disj_Union_perm_aux
 -/
 

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

@@ -301,7 +301,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
 
 #print Equiv.Perm.SameCycle.exists_pow_eq'' /-
 theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
-    ∃ (i : ℕ)(hpos : 0 < i)(h : i ≤ orderOf f), (f ^ i) x = y := by
+    ∃ (i : ℕ) (hpos : 0 < i) (h : i ≤ orderOf f), (f ^ i) x = y := by
   classical
     obtain ⟨_ | i, hi, rfl⟩ := h.exists_pow_eq'
     · refine' ⟨orderOf f, orderOf_pos f, le_rfl, _⟩
@@ -399,8 +399,8 @@ protected theorem IsCycle.extendDomain {p : β → Prop} [DecidablePred p] (f :
     exact subtype.coe_injective.ne (f.injective.ne ha)
   have h : b = f (f.symm ⟨b, of_not_not <| hb ∘ extend_domain_apply_not_subtype _ _⟩) := by
     rw [apply_symm_apply, Subtype.coe_mk]
-  rw [h] at hb⊢
-  simp only [extend_domain_apply_image, subtype.coe_injective.ne_iff, f.injective.ne_iff] at hb
+  rw [h] at hb ⊢
+  simp only [extend_domain_apply_image, subtype.coe_injective.ne_iff, f.injective.ne_iff] at hb 
   exact (ha' hb).extendDomain
 #align equiv.perm.is_cycle.extend_domain Equiv.Perm.IsCycle.extendDomain
 -/
@@ -410,7 +410,7 @@ theorem isCycle_iff_sameCycle (hx : f x ≠ x) : IsCycle f ↔ ∀ {y}, SameCycl
   ⟨fun hf y =>
     ⟨fun ⟨i, hi⟩ hy =>
       hx <| by
-        rw [← zpow_apply_eq_self_of_apply_eq_self hy i, (f ^ i).Injective.eq_iff] at hi
+        rw [← zpow_apply_eq_self_of_apply_eq_self hy i, (f ^ i).Injective.eq_iff] at hi 
         rw [hi, hy],
       hf.exists_zpow_eq hx⟩,
     fun h => ⟨x, hx, fun y hy => h.2 hy⟩⟩
@@ -459,14 +459,14 @@ theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
 -/
 
 theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
-    ∃ (k : ℕ)(hk : 1 < k), f ^ k = 1 := by
+    ∃ (k : ℕ) (hk : 1 < k), f ^ k = 1 := by
   classical
     have : IsOfFinOrder f := exists_pow_eq_one f
-    rw [isOfFinOrder_iff_pow_eq_one] at this
+    rw [isOfFinOrder_iff_pow_eq_one] at this 
     obtain ⟨x, hx, hx'⟩ := hf
     obtain ⟨_ | _ | k, hk, hk'⟩ := this
     · exact absurd hk (lt_asymm hk)
-    · rw [pow_one] at hk'
+    · rw [pow_one] at hk' 
       simpa [hk'] using hx
     · exact ⟨k + 2, by simp, hk'⟩
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
@@ -490,7 +490,7 @@ noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ)
           rw [Subtype.coe_mk, Subtype.coe_mk, zpow_apply_comm σ m i, zpow_apply_comm σ n i]
           exact congr_arg _ (subtype.ext_iff.mp h)
       · rintro ⟨y, hy⟩
-        rw [Finset.mem_coe, mem_support] at hy
+        rw [Finset.mem_coe, mem_support] at hy 
         obtain ⟨n, rfl⟩ := (Classical.choose_spec hσ).2 hy
         exact ⟨⟨σ ^ n, n, rfl⟩, rfl⟩)
 #align equiv.perm.is_cycle.zpowers_equiv_support Equiv.Perm.IsCycle.zpowersEquivSupport
@@ -538,7 +538,7 @@ theorem isCycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
         exact this.1
       let ⟨i, hi⟩ :=
         is_cycle_swap_mul_aux₁ n hb'
-          (f.Injective <| by rw [apply_inv_self]; rwa [pow_succ, mul_apply] at h)
+          (f.Injective <| by rw [apply_inv_self]; rwa [pow_succ, mul_apply] at h )
       ⟨i + 1, by
         rw [add_comm, zpow_add, mul_apply, hi, zpow_one, mul_apply, apply_inv_self,
           swap_apply_of_ne_of_ne (ne_and_ne_of_swap_mul_apply_ne_self hb).2 (Ne.symm hfbx)]⟩
@@ -558,8 +558,8 @@ theorem isCycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
         by
         rw [mul_apply, swap_apply_def]
         split_ifs <;>
-            simp only [inv_eq_iff_eq, perm.mul_apply, zpow_negSucc, Ne.def, perm.apply_inv_self] at
-              * <;>
+            simp only [inv_eq_iff_eq, perm.mul_apply, zpow_negSucc, Ne.def,
+              perm.apply_inv_self] at * <;>
           cc
       let ⟨i, hi⟩ :=
         isCycle_swap_mul_aux₁ n hb
@@ -590,10 +590,10 @@ theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type _} [DecidableEq α] {f
         rw [swap_apply_of_ne_of_ne hyx hfyx]
         refine' by_contradiction fun hy => _
         cases' hz.2 hy with j hj
-        rw [← sub_add_cancel j i, zpow_add, mul_apply, hi] at hj
+        rw [← sub_add_cancel j i, zpow_add, mul_apply, hi] at hj 
         cases' zpow_apply_eq_of_apply_apply_eq_self hffx (j - i) with hji hji
-        · rw [← hj, hji] at hyx; cc
-        · rw [← hj, hji] at hfyx; cc
+        · rw [← hj, hji] at hyx ; cc
+        · rw [← hj, hji] at hfyx ; cc
 #align equiv.perm.is_cycle.eq_swap_of_apply_apply_eq_self Equiv.Perm.IsCycle.eq_swap_of_apply_apply_eq_self
 -/
 
@@ -638,8 +638,8 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.su
           rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
           simp only [pow_add, mul_one, neg_neg, one_mul, mul_neg, eq_self_iff_true, pow_one,
             neg_mul_neg]
-      termination_by'
-  ⟨_, measure_wf fun f => f.support.card⟩
+      
+termination_by' ⟨_, measure_wf fun f => f.support.card⟩
 #align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.sign
 
 #print Equiv.Perm.IsCycle.of_pow /-
@@ -664,7 +664,7 @@ theorem IsCycle.of_zpow {n : ℤ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f
     IsCycle f := by
   cases n
   · exact h1.of_pow h2
-  · simp only [le_eq_subset, zpow_negSucc, perm.support_inv] at h1 h2
+  · simp only [le_eq_subset, zpow_negSucc, perm.support_inv] at h1 h2 
     simpa using h1.inv.of_pow h2
 #align equiv.perm.is_cycle.of_zpow Equiv.Perm.IsCycle.of_zpow
 -/
@@ -712,7 +712,7 @@ theorem IsCycle.eq_on_support_inter_nonempty_congr (hf : IsCycle f) (hg : IsCycl
     intro y hy
     obtain ⟨k, rfl⟩ := hf.exists_pow_eq (mem_support.mp hx') (mem_support.mp hy)
     rwa [pow_eq_on_of_mem_support h _ _ (mem_inter_of_mem hx' hx''), pow_apply_mem_support]
-  rw [(inter_eq_left_iff_subset _ _).mpr this] at h
+  rw [(inter_eq_left_iff_subset _ _).mpr this] at h 
   exact hf.support_congr hg this h
 #align equiv.perm.is_cycle.eq_on_support_inter_nonempty_congr Equiv.Perm.IsCycle.eq_on_support_inter_nonempty_congr
 -/
@@ -761,7 +761,7 @@ theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
         refine' h.ne_one _
         simp [pow_mul, pow_orderOf_eq_one]
       have : orderOf (f ^ n) = orderOf f := by rw [h.order_of, hr, hf.order_of]
-      rw [orderOf_pow, Nat.div_eq_self] at this
+      rw [orderOf_pow, Nat.div_eq_self] at this 
       cases this
       · exact absurd this (orderOf_pos _).ne'
       · rwa [Nat.coprime_iff_gcd_eq_one, Nat.gcd_comm]
@@ -785,9 +785,9 @@ theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : 
       exact ⟨x, hx, by simp [h]⟩
     · rintro ⟨x, hx, hx'⟩
       by_cases h : support (f ^ n) = support f
-      · rw [← mem_support, ← h, mem_support] at hx
+      · rw [← mem_support, ← h, mem_support] at hx 
         contradiction
-      · rw [hf.support_pow_eq_iff, Classical.not_not] at h
+      · rw [hf.support_pow_eq_iff, Classical.not_not] at h 
         obtain ⟨k, rfl⟩ := h
         rw [pow_mul, pow_orderOf_eq_one, one_pow]
 #align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iff
@@ -822,15 +822,15 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
       wlog hab : a ≤ b generalizing a b
       · exact (this hx'.symm (le_of_not_le hab)).symm
       suffices f ^ (b - a) = 1 by
-        rw [pow_sub _ hab, mul_inv_eq_one] at this
+        rw [pow_sub _ hab, mul_inv_eq_one] at this 
         rw [this]
       rw [hf.pow_eq_one_iff]
       by_cases hfa : (f ^ a) x ∈ f.support
       · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
         simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
       · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
-        simp only [zpow_one, zpow_ofNat] at h
-        rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa
+        simp only [zpow_one, zpow_ofNat] at h 
+        rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa 
         contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
 -/
@@ -846,7 +846,7 @@ theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf
       exact Nat.not_dvd_of_pos_of_lt hn hn'
     obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
     have hf'' := hf
-    rw [← hm] at hf''
+    rw [← hm] at hf'' 
     refine' hf''.of_pow _
     rw [hm]
     exact support_pow_le f n
@@ -908,7 +908,7 @@ alias is_cycle_on_inv ↔ is_cycle_on.of_inv is_cycle_on.inv
 #print Equiv.Perm.IsCycleOn.conj /-
 theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Perm α) '' s) :=
   ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy => by
-    rw [← preimage_inv] at hx hy; convert(h.2 hx hy).conj <;> rw [apply_inv_self]⟩
+    rw [← preimage_inv] at hx hy ; convert(h.2 hx hy).conj <;> rw [apply_inv_self]⟩
 #align equiv.perm.is_cycle_on.conj Equiv.Perm.IsCycleOn.conj
 -/
 
@@ -916,7 +916,7 @@ theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Pe
 theorem isCycleOn_swap [DecidableEq α] (hab : a ≠ b) : (swap a b).IsCycleOn {a, b} :=
   ⟨bijOn_swap (by simp) (by simp), fun x hx y hy =>
     by
-    rw [Set.mem_insert_iff, Set.mem_singleton_iff] at hx hy
+    rw [Set.mem_insert_iff, Set.mem_singleton_iff] at hx hy 
     obtain rfl | rfl := hx <;> obtain rfl | rfl := hy
     · exact ⟨0, by rw [zpow_zero, coe_one, id.def]⟩
     · exact ⟨1, by rw [zpow_one, swap_apply_left]⟩
@@ -993,12 +993,12 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
     (f ^ n) a = a ↔ s.card ∣ n :=
   by
   obtain rfl | hs := Finset.eq_singleton_or_nontrivial ha
-  · rw [coe_singleton, is_cycle_on_singleton] at hf
+  · rw [coe_singleton, is_cycle_on_singleton] at hf 
     simpa using is_fixed_pt.iterate hf n
   classical
     have h : ∀ x ∈ s.attach, ¬f ↑x = ↑x := fun x hx => hf.apply_ne hs x.Prop
     have := (hf.is_cycle_subtype_perm hs).orderOf
-    simp only [filter_true_of_mem h, support_subtype_perm, card_attach] at this
+    simp only [filter_true_of_mem h, support_subtype_perm, card_attach] at this 
     rw [← this, orderOf_dvd_iff_pow_eq_one,
       (hf.is_cycle_subtype_perm hs).pow_eq_one_iff'
         (ne_of_apply_ne (coe : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).Prop)]
@@ -1278,7 +1278,7 @@ theorem isCycle_cycleOf (f : Perm α) (hx : f x ≠ x) : IsCycle (cycleOf f x) :
       if hxy : SameCycle f x y then
         let ⟨i, hi⟩ := hxy
         ⟨i, by rw [cycle_of_zpow_apply_self, hi]⟩
-      else by rw [cycle_of_apply_of_not_same_cycle hxy] at h; exact (h rfl).elim⟩
+      else by rw [cycle_of_apply_of_not_same_cycle hxy] at h ; exact (h rfl).elim⟩
 #align equiv.perm.is_cycle_cycle_of Equiv.Perm.isCycle_cycleOf
 -/
 
@@ -1288,7 +1288,7 @@ theorem two_le_card_support_cycleOf_iff : 2 ≤ card (cycleOf f x).support ↔ f
   by
   refine' ⟨fun h => _, fun h => by simpa using (is_cycle_cycle_of _ h).two_le_card_support⟩
   contrapose! h
-  rw [← cycle_of_eq_one_iff] at h
+  rw [← cycle_of_eq_one_iff] at h 
   simp [h]
 #align equiv.perm.two_le_card_support_cycle_of_iff Equiv.Perm.two_le_card_support_cycleOf_iff
 -/
@@ -1340,8 +1340,8 @@ theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.sup
 theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ support f :=
   by
   intro y hy
-  rw [mem_support, cycle_of_apply] at hy
-  split_ifs  at hy
+  rw [mem_support, cycle_of_apply] at hy 
+  split_ifs  at hy 
   · exact mem_support.mpr hy
   · exact absurd rfl hy
 #align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_le
@@ -1401,15 +1401,15 @@ theorem isCycle_cycleOf_iff (f : Perm α) : IsCycle (cycleOf f x) ↔ f x ≠ x
 #print Equiv.Perm.isCycleOn_support_cycleOf /-
 theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleOf x).support :=
   ⟨f.BijOn <| by simp [mem_support_cycle_of_iff], fun a ha b hb => by
-    rw [mem_coe, mem_support_cycle_of_iff] at ha hb; exact ha.1.symm.trans hb.1⟩
+    rw [mem_coe, mem_support_cycle_of_iff] at ha hb ; exact ha.1.symm.trans hb.1⟩
 #align equiv.perm.is_cycle_on_support_cycle_of Equiv.Perm.isCycleOn_support_cycleOf
 -/
 
 #print Equiv.Perm.SameCycle.exists_pow_eq_of_mem_support /-
 theorem SameCycle.exists_pow_eq_of_mem_support (h : SameCycle f x y) (hx : x ∈ f.support) :
-    ∃ (i : ℕ)(hi' : i < (f.cycleOf x).support.card), (f ^ i) x = y :=
+    ∃ (i : ℕ) (hi' : i < (f.cycleOf x).support.card), (f ^ i) x = y :=
   by
-  rw [mem_support] at hx
+  rw [mem_support] at hx 
   refine' (f.is_cycle_on_support_cycle_of _).exists_pow_eq _ _ <;>
     rwa [mem_support_cycle_of_iff' hx]
 #align equiv.perm.same_cycle.exists_pow_eq_of_mem_support Equiv.Perm.SameCycle.exists_pow_eq_of_mem_support
@@ -1417,7 +1417,7 @@ theorem SameCycle.exists_pow_eq_of_mem_support (h : SameCycle f x y) (hx : x ∈
 
 #print Equiv.Perm.SameCycle.exists_pow_eq /-
 theorem SameCycle.exists_pow_eq (f : Perm α) (h : SameCycle f x y) :
-    ∃ (i : ℕ)(hi : 0 < i)(hi' : i ≤ (f.cycleOf x).support.card + 1), (f ^ i) x = y :=
+    ∃ (i : ℕ) (hi : 0 < i) (hi' : i ≤ (f.cycleOf x).support.card + 1), (f ^ i) x = y :=
   by
   by_cases hx : x ∈ f.support
   · obtain ⟨k, hk, hk'⟩ := h.exists_pow_eq_of_mem_support hx
@@ -1425,14 +1425,14 @@ theorem SameCycle.exists_pow_eq (f : Perm α) (h : SameCycle f x y) :
     · refine' ⟨(f.cycle_of x).support.card, _, self_le_add_right _ _, _⟩
       · refine' zero_lt_one.trans (one_lt_card_support_of_ne_one _)
         simpa using hx
-      · simp only [perm.coe_one, id.def, pow_zero] at hk'
+      · simp only [perm.coe_one, id.def, pow_zero] at hk' 
         subst hk'
         rw [← (is_cycle_cycle_of _ <| mem_support.1 hx).orderOf, ← cycle_of_pow_apply_self,
           pow_orderOf_eq_one, one_apply]
     · exact ⟨k + 1, by simp, Nat.le_succ_of_le hk.le, hk'⟩
   · refine' ⟨1, zero_lt_one, by simp, _⟩
     obtain ⟨k, rfl⟩ := h
-    rw [not_mem_support] at hx
+    rw [not_mem_support] at hx 
     rw [pow_apply_eq_self_of_apply_eq_self hx, zpow_apply_eq_self_of_apply_eq_self hx]
 #align equiv.perm.same_cycle.exists_pow_eq Equiv.Perm.SameCycle.exists_pow_eq
 -/
@@ -1470,11 +1470,11 @@ def cycleFactorsAux [Fintype α] :
         cycle_factors_aux l ((cycleOf f x)⁻¹ * f) fun y hy =>
           List.mem_of_ne_of_mem
             (fun h : y = x => by
-              rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycle_of_apply_self] at hy; exact hy rfl)
+              rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycle_of_apply_self] at hy ; exact hy rfl)
             (h fun h : f y = y =>
               by
-              rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycle_of_apply] at hy
-              split_ifs  at hy <;> cc)
+              rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycle_of_apply] at hy 
+              split_ifs  at hy  <;> cc)
       ⟨cycleOf f x::m, by rw [List.prod_cons, hm₁]; simp, fun g hg =>
         ((List.mem_cons _ _ _).1 hg).elim (fun hg => hg.symm ▸ isCycle_cycleOf _ hx) (hm₂ g),
         List.pairwise_cons.2
@@ -1493,7 +1493,7 @@ def cycleFactorsAux [Fintype α] :
                   have hsc : SameCycle f⁻¹ x (f y) := by
                     rwa [same_cycle_inv, same_cycle_apply_right]
                   rw [disjoint_prod_perm hm₃ hgm.symm, List.prod_cons, ← eq_inv_mul_iff_mul_eq] at
-                    hm₁
+                    hm₁ 
                   rwa [hm₁, mul_apply, mul_apply, cycle_of_inv, hsc.cycle_of_apply, inv_apply_self,
                     inv_eq_iff_eq, eq_comm],
             hm₃⟩⟩
@@ -1516,10 +1516,10 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
     · intro h
       have hσl : σ.support ⊆ l.prod.support := by
         intro x hx
-        rw [mem_support] at hx
+        rw [mem_support] at hx 
         rwa [mem_support, ← h _ hx]
       obtain ⟨a, ha, -⟩ := id h3
-      rw [← mem_support] at ha
+      rw [← mem_support] at ha 
       obtain ⟨τ, hτ, hτa⟩ := exists_mem_support_of_mem_support_prod (hσl ha)
       have hτl : ∀ x ∈ τ.support, τ x = l.prod x := eq_on_support_mem_disjoint hτ h2
       have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x :=
@@ -1640,7 +1640,7 @@ theorem mem_cycleFactorsFinset_iff {f p : Perm α} :
   by
   obtain ⟨l, hl, hl'⟩ := f.cycle_factors_finset.exists_list_nodup_eq
   rw [← hl']
-  rw [eq_comm, cycle_factors_finset_eq_list_to_finset hl] at hl'
+  rw [eq_comm, cycle_factors_finset_eq_list_to_finset hl] at hl' 
   simpa [List.mem_toFinset, Ne.def, ← hl'.right.right] using
     mem_list_cycles_iff hl'.left hl'.right.left
 #align equiv.perm.mem_cycle_factors_finset_iff Equiv.Perm.mem_cycleFactorsFinset_iff
@@ -1654,16 +1654,16 @@ theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
   constructor
   · rintro ⟨hc, h⟩
     contrapose! hc
-    rw [not_mem_support, ← cycle_of_eq_one_iff] at hc
+    rw [not_mem_support, ← cycle_of_eq_one_iff] at hc 
     simp [hc]
   · intro hx
     refine' ⟨is_cycle_cycle_of _ (mem_support.mp hx), _⟩
     intro y hy
-    rw [mem_support] at hy
+    rw [mem_support] at hy 
     rw [cycle_of_apply]
     split_ifs with H
     · rfl
-    · rw [cycle_of_apply_of_not_same_cycle H] at hy
+    · rw [cycle_of_apply_of_not_same_cycle H] at hy 
       contradiction
 #align equiv.perm.cycle_of_mem_cycle_factors_finset_iff Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff
 -/
@@ -1671,7 +1671,7 @@ theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
 #print Equiv.Perm.mem_cycleFactorsFinset_support_le /-
 theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactorsFinset f) :
     p.support ≤ f.support := by
-  rw [mem_cycle_factors_finset_iff] at h
+  rw [mem_cycle_factors_finset_iff] at h 
   intro x hx
   rwa [mem_support, ← h.right x hx, ← mem_support]
 #align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_le
@@ -1723,10 +1723,10 @@ theorem cycleFactorsFinset_injective : Function.Injective (@cycleFactorsFinset 
 theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g) :
     Disjoint (cycleFactorsFinset f) (cycleFactorsFinset g) :=
   by
-  rw [disjoint_iff_disjoint_support] at h
+  rw [disjoint_iff_disjoint_support] at h 
   rw [Finset.disjoint_left]
   intro x hx hy
-  simp only [mem_cycle_factors_finset_iff, mem_support] at hx hy
+  simp only [mem_cycle_factors_finset_iff, mem_support] at hx hy 
   obtain ⟨⟨⟨a, ha, -⟩, hf⟩, -, hg⟩ := hx, hy
   refine' h.le_bot (_ : a ∈ f.support ∩ g.support)
   simp [ha, ← hf a ha, ← hg a ha]
@@ -1749,7 +1749,7 @@ theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f
 
 theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cycleFactorsFinset g) :
     Disjoint (g * f⁻¹) f := by
-  rw [mem_cycle_factors_finset_iff] at h
+  rw [mem_cycle_factors_finset_iff] at h 
   intro x
   by_cases hx : f x = x
   · exact Or.inr hx
@@ -1811,7 +1811,7 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
   apply cycle_induction_on _ g
   · simp
   · intro σ hσ f hf
-    simp only [cycle_factors_finset_eq_singleton_self_iff.mpr hσ, mem_singleton] at hf⊢
+    simp only [cycle_factors_finset_eq_singleton_self_iff.mpr hσ, mem_singleton] at hf ⊢
     simp [hf]
   · intro σ τ hd hc hσ hτ f
     simp_rw [hd.cycle_factors_finset_mul_eq_union, mem_union]
@@ -1819,7 +1819,7 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
     rintro (hf | hf)
     · rw [hd.commute.eq, union_comm, union_sdiff_distrib, sdiff_singleton_eq_erase,
         erase_eq_of_not_mem, mul_assoc, disjoint.cycle_factors_finset_mul_eq_union, hσ hf]
-      · rw [mem_cycle_factors_finset_iff] at hf
+      · rw [mem_cycle_factors_finset_iff] at hf 
         intro x
         cases' hd.symm x with hx hx
         · exact Or.inl hx
@@ -1828,12 +1828,12 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
           · rw [← hfx]
             simpa [hx] using hfx.symm
           · rw [mul_apply]
-            rw [← hf.right _ (mem_support.mpr hfx)] at hx
+            rw [← hf.right _ (mem_support.mpr hfx)] at hx 
             contradiction
       · exact fun H => hd.disjoint_cycle_factors_finset.le_bot (mem_inter_of_mem hf H)
     · rw [union_sdiff_distrib, sdiff_singleton_eq_erase, erase_eq_of_not_mem, mul_assoc,
         disjoint.cycle_factors_finset_mul_eq_union, hτ hf]
-      · rw [mem_cycle_factors_finset_iff] at hf
+      · rw [mem_cycle_factors_finset_iff] at hf 
         intro x
         cases' hd x with hx hx
         · exact Or.inl hx
@@ -1842,7 +1842,7 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
           · rw [← hfx]
             simpa [hx] using hfx.symm
           · rw [mul_apply]
-            rw [← hf.right _ (mem_support.mpr hfx)] at hx
+            rw [← hf.right _ (mem_support.mpr hfx)] at hx 
             contradiction
       · exact fun H => hd.disjoint_cycle_factors_finset.le_bot (mem_inter_of_mem H hf)
 #align equiv.perm.cycle_factors_finset_mul_inv_mem_eq_sdiff Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiff
@@ -1890,9 +1890,9 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
   have step3 : ∀ y : α, swap x y ∈ H := by
     intro y
     have hx : x ∈ (⊤ : Finset α) := Finset.mem_univ x
-    rw [← h2, mem_support] at hx
+    rw [← h2, mem_support] at hx 
     have hy : y ∈ (⊤ : Finset α) := Finset.mem_univ y
-    rw [← h2, mem_support] at hy
+    rw [← h2, mem_support] at hy 
     cases' is_cycle.exists_pow_eq h1 hx hy with n hn
     rw [← hn]
     exact step2 n
@@ -1915,10 +1915,10 @@ theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n
     (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
     closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ :=
   by
-  rw [← Finset.card_univ, ← h2, ← h1.order_of] at h0
+  rw [← Finset.card_univ, ← h2, ← h1.order_of] at h0 
   cases' exists_pow_eq_self_of_coprime h0 with m hm
   have h2' : (σ ^ n).support = ⊤ := Eq.trans (support_pow_coprime h0) h2
-  have h1' : is_cycle ((σ ^ n) ^ (m : ℤ)) := by rwa [← hm] at h1
+  have h1' : is_cycle ((σ ^ n) ^ (m : ℤ)) := by rwa [← hm] at h1 
   replace h1' : is_cycle (σ ^ n) :=
     h1'.of_pow (le_trans (support_pow_le σ n) (ge_of_eq (congr_arg support hm)))
   rw [eq_top_iff, ← closure_cycle_adjacent_swap h1' h2' x, closure_le, Set.insert_subset]
@@ -1940,7 +1940,7 @@ theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime
     closure_cycle_coprime_swap (Nat.coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
   cases' h with m hm
   rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.order_of, pow_orderOf_eq_one, one_pow,
-    one_apply] at hi
+    one_apply] at hi 
 #align equiv.perm.closure_prime_cycle_swap Equiv.Perm.closure_prime_cycle_swap
 
 end Generation
@@ -2005,7 +2005,7 @@ theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
     · simp [mem_support.1 ha]
     · refine' ⟨π⁻¹ b, ⟨_, π.apply_inv_self b⟩⟩
       contrapose! hb
-      rw [mem_support, Classical.not_not] at hb
+      rw [mem_support, Classical.not_not] at hb 
       rw [mem_support, Classical.not_not, perm.mul_apply, perm.mul_apply, hb, perm.apply_inv_self],
     hσ.IsConj hτ⟩
 #align equiv.perm.is_cycle.is_conj_iff Equiv.Perm.IsCycle.isConj_iff
@@ -2047,26 +2047,26 @@ theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (h
     · intro x hx
       simp only [trans_apply, symm_trans_apply, set.of_eq_apply, set.of_eq_symm_apply,
         Equiv.sumCongr_apply]
-      rw [hd1', Set.mem_union] at hx
+      rw [hd1', Set.mem_union] at hx 
       cases' hx with hxσ hxτ
-      · rw [mem_coe, mem_support] at hxσ
+      · rw [mem_coe, mem_support] at hxσ 
         rw [set.union_apply_left hd1''.le_bot _, set.union_apply_left hd1''.le_bot _]
         simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inl, comp_app,
           set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
         · have h := (hd2 (f x)).resolve_left _
-          · rw [mul_apply, mul_apply] at h
+          · rw [mul_apply, mul_apply] at h 
             rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
           · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
         · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, mem_support]
         ·
           rwa [Subtype.coe_mk, Subtype.coe_mk, perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
             apply_mem_support, mem_support]
-      · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ
+      · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ 
         rw [set.union_apply_right hd1''.le_bot _, set.union_apply_right hd1''.le_bot _]
         simp only [subtype_equiv_apply, perm.coe_mul, Sum.map_inr, comp_app,
           set.union_symm_apply_right, Subtype.coe_mk, apply_eq_iff_eq]
         · have h := (hd2 (g (τ x))).resolve_right _
-          · rw [mul_apply, mul_apply] at h
+          · rw [mul_apply, mul_apply] at h 
             rw [inv_apply_self, h, (hd1 (τ x)).resolve_right hxτ]
           · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
         · rwa [Subtype.coe_mk, Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
@@ -2103,7 +2103,7 @@ variable [DecidableEq α] {l : List α}
 theorem Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn { a | a ∈ l } :=
   by
   refine' ⟨l.form_perm.bij_on fun _ => form_perm_mem_iff_mem, fun a ha b hb => _⟩
-  rw [Set.mem_setOf, ← index_of_lt_length] at ha hb
+  rw [Set.mem_setOf, ← index_of_lt_length] at ha hb 
   rw [← index_of_nth_le ha, ← index_of_nth_le hb]
   refine' ⟨l.index_of b - l.index_of a, _⟩
   simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_ofNat,
@@ -2198,15 +2198,15 @@ theorem product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
   by
   obtain hs | hs := (s : Set α).subsingleton_or_nontrivial
   · refine' Set.Subsingleton.pairwise _ _
-    simp_rw [Set.Subsingleton, mem_coe, ← card_le_one] at hs⊢
+    simp_rw [Set.Subsingleton, mem_coe, ← card_le_one] at hs ⊢
     rwa [card_range]
   classical
     rintro m hm n hn hmn
     simp only [disjoint_left, Function.onFun, mem_map, Function.Embedding.coeFn_mk, exists_prop,
       not_exists, not_and, forall_exists_index, and_imp, Prod.forall, Prod.mk.inj_iff]
     rintro _ _ _ - rfl rfl a ha rfl h
-    rw [hf.pow_apply_eq_pow_apply ha] at h
-    rw [mem_coe, mem_range] at hm hn
+    rw [hf.pow_apply_eq_pow_apply ha] at h 
+    rw [mem_coe, mem_range] at hm hn 
     exact hmn.symm (h.eq_of_lt_of_lt hn hm)
 #align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disj_Union_perm_aux
 -/

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

@@ -62,7 +62,7 @@ The following two definitions require that `β` is a `fintype`:
 
 open Equiv Function Finset
 
-open BigOperators
+open scoped BigOperators
 
 variable {ι α β : Type _}
 
@@ -1336,6 +1336,7 @@ theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.sup
 #align equiv.perm.support_cycle_of_eq_nil_iff Equiv.Perm.support_cycleOf_eq_nil_iff
 -/
 
+#print Equiv.Perm.support_cycleOf_le /-
 theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ support f :=
   by
   intro y hy
@@ -1344,6 +1345,7 @@ theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ su
   · exact mem_support.mpr hy
   · exact absurd rfl hy
 #align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_le
+-/
 
 #print Equiv.Perm.mem_support_cycleOf_iff /-
 theorem mem_support_cycleOf_iff : y ∈ support (f.cycleOf x) ↔ SameCycle f x y ∧ x ∈ support f :=
@@ -1666,12 +1668,14 @@ theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
 #align equiv.perm.cycle_of_mem_cycle_factors_finset_iff Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff
 -/
 
+#print Equiv.Perm.mem_cycleFactorsFinset_support_le /-
 theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactorsFinset f) :
     p.support ≤ f.support := by
   rw [mem_cycle_factors_finset_iff] at h
   intro x hx
   rwa [mem_support, ← h.right x hx, ← mem_support]
 #align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_le
+-/
 
 theorem cycleFactorsFinset_eq_empty_iff {f : Perm α} : cycleFactorsFinset f = ∅ ↔ f = 1 := by
   simpa [cycle_factors_finset_eq_finset] using eq_comm

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

@@ -120,49 +120,19 @@ theorem SameCycle.trans : SameCycle f x y → SameCycle f y z → SameCycle f x
 #align equiv.perm.same_cycle.trans Equiv.Perm.SameCycle.trans
 -/
 
-/- warning: equiv.perm.same_cycle_one -> Equiv.Perm.sameCycle_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) x y) (Eq.{succ u1} α x y)
-but is expected to have type
-  forall {α : Type.{u1}} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) x y) (Eq.{succ u1} α x y)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle_one Equiv.Perm.sameCycle_oneₓ'. -/
 @[simp]
 theorem sameCycle_one : SameCycle 1 x y ↔ x = y := by simp [same_cycle]
 #align equiv.perm.same_cycle_one Equiv.Perm.sameCycle_one
 
-/- warning: equiv.perm.same_cycle_inv -> Equiv.Perm.sameCycle_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) x y) (Equiv.Perm.SameCycle.{u1} α f x y)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) x y) (Equiv.Perm.SameCycle.{u1} α f x y)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle_inv Equiv.Perm.sameCycle_invₓ'. -/
 @[simp]
 theorem sameCycle_inv : SameCycle f⁻¹ x y ↔ SameCycle f x y :=
   (Equiv.neg _).exists_congr_left.trans <| by simp [same_cycle]
 #align equiv.perm.same_cycle_inv Equiv.Perm.sameCycle_inv
 
-/- warning: equiv.perm.same_cycle.of_inv -> Equiv.Perm.SameCycle.of_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) x y) -> (Equiv.Perm.SameCycle.{u1} α f x y)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) x y) -> (Equiv.Perm.SameCycle.{u1} α f x y)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle.of_inv Equiv.Perm.SameCycle.of_invₓ'. -/
-/- warning: equiv.perm.same_cycle.inv -> Equiv.Perm.SameCycle.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, (Equiv.Perm.SameCycle.{u1} α f x y) -> (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) x y)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, (Equiv.Perm.SameCycle.{u1} α f x y) -> (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) x y)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle.inv Equiv.Perm.SameCycle.invₓ'. -/
 alias same_cycle_inv ↔ same_cycle.of_inv same_cycle.inv
 #align equiv.perm.same_cycle.of_inv Equiv.Perm.SameCycle.of_inv
 #align equiv.perm.same_cycle.inv Equiv.Perm.SameCycle.inv
 
-/- warning: equiv.perm.same_cycle_conj -> Equiv.Perm.sameCycle_conj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g)) x y) (Equiv.Perm.SameCycle.{u1} α f (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g) x) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g) y))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g)) x y) (Equiv.Perm.SameCycle.{u1} α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g) y))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle_conj Equiv.Perm.sameCycle_conjₓ'. -/
 @[simp]
 theorem sameCycle_conj : SameCycle (g * f * g⁻¹) x y ↔ SameCycle f (g⁻¹ x) (g⁻¹ y) :=
   exists_congr fun i => by simp [conj_zpow, eq_inv_iff_eq]
@@ -317,12 +287,6 @@ theorem sameCycle_extendDomain {p : β → Prop} [DecidablePred p] {f : α ≃ S
 alias same_cycle_extend_domain ↔ _ same_cycle.extend_domain
 #align equiv.perm.same_cycle.extend_domain Equiv.Perm.SameCycle.extendDomain
 
-/- warning: equiv.perm.same_cycle.exists_pow_eq' -> Equiv.Perm.SameCycle.exists_pow_eq' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α} [_inst_1 : Finite.{succ u1} α], (Equiv.Perm.SameCycle.{u1} α f x y) -> (Exists.{1} Nat (fun (i : Nat) => Exists.{0} (LT.lt.{0} Nat Nat.hasLt i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (fun (H : LT.lt.{0} Nat Nat.hasLt i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f i) x) y)))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α} [_inst_1 : Finite.{succ u1} α], (Equiv.Perm.SameCycle.{u1} α f x y) -> (Exists.{1} Nat (fun (i : Nat) => And (LT.lt.{0} Nat instLTNat i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f i) x) y)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'ₓ'. -/
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
   classical
     rintro ⟨k, rfl⟩
@@ -384,21 +348,9 @@ def IsCycle (f : Perm α) : Prop :=
 #align equiv.perm.is_cycle Equiv.Perm.IsCycle
 -/
 
-/- warning: equiv.perm.is_cycle.ne_one -> Equiv.Perm.IsCycle.ne_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Ne.{succ u1} (Equiv.Perm.{succ u1} α) f (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Ne.{succ u1} (Equiv.Perm.{succ u1} α) f (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.ne_one Equiv.Perm.IsCycle.ne_oneₓ'. -/
 theorem IsCycle.ne_one (h : IsCycle f) : f ≠ 1 := fun hf => by simpa [hf, is_cycle] using h
 #align equiv.perm.is_cycle.ne_one Equiv.Perm.IsCycle.ne_one
 
-/- warning: equiv.perm.not_is_cycle_one -> Equiv.Perm.not_isCycle_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Not (Equiv.Perm.IsCycle.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))))
-but is expected to have type
-  forall {α : Type.{u1}}, Not (Equiv.Perm.IsCycle.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.not_is_cycle_one Equiv.Perm.not_isCycle_oneₓ'. -/
 @[simp]
 theorem not_isCycle_one : ¬(1 : Perm α).IsCycle := fun H => H.ne_one rfl
 #align equiv.perm.not_is_cycle_one Equiv.Perm.not_isCycle_one
@@ -419,34 +371,16 @@ theorem IsCycle.exists_zpow_eq : IsCycle f → f x ≠ x → f y ≠ y → ∃ i
 #align equiv.perm.is_cycle.exists_zpow_eq Equiv.Perm.IsCycle.exists_zpow_eq
 -/
 
-/- warning: equiv.perm.is_cycle.inv -> Equiv.Perm.IsCycle.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Equiv.Perm.IsCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Equiv.Perm.IsCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.inv Equiv.Perm.IsCycle.invₓ'. -/
 theorem IsCycle.inv (hf : IsCycle f) : IsCycle f⁻¹ :=
   hf.imp fun x ⟨hx, h⟩ =>
     ⟨inv_eq_iff_eq.Not.2 hx.symm, fun y hy => (h <| inv_eq_iff_eq.Not.2 hy.symm).inv⟩
 #align equiv.perm.is_cycle.inv Equiv.Perm.IsCycle.inv
 
-/- warning: equiv.perm.is_cycle_inv -> Equiv.Perm.isCycle_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, Iff (Equiv.Perm.IsCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (Equiv.Perm.IsCycle.{u1} α f)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, Iff (Equiv.Perm.IsCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f)) (Equiv.Perm.IsCycle.{u1} α f)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_inv Equiv.Perm.isCycle_invₓ'. -/
 @[simp]
 theorem isCycle_inv : IsCycle f⁻¹ ↔ IsCycle f :=
   ⟨fun h => by convert h.inv; rw [inv_inv], IsCycle.inv⟩
 #align equiv.perm.is_cycle_inv Equiv.Perm.isCycle_inv
 
-/- warning: equiv.perm.is_cycle.conj -> Equiv.Perm.IsCycle.conj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Equiv.Perm.IsCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g)))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Equiv.Perm.IsCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.conj Equiv.Perm.IsCycle.conjₓ'. -/
 theorem IsCycle.conj : IsCycle f → IsCycle (g * f * g⁻¹) :=
   by
   rintro ⟨x, hx, h⟩
@@ -524,12 +458,6 @@ theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
 #align equiv.perm.is_cycle.two_le_card_support Equiv.Perm.IsCycle.two_le_card_support
 -/
 
-/- warning: equiv.perm.is_cycle.exists_pow_eq_one -> Equiv.Perm.IsCycle.exists_pow_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (Exists.{1} Nat (fun (k : Nat) => Exists.{0} (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) k) (fun (hk : LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) k) => Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f k) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))))))
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (Exists.{1} Nat (fun (k : Nat) => Exists.{0} (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) k) (fun (hk : LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) k) => Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f k) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_oneₓ'. -/
 theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     ∃ (k : ℕ)(hk : 1 < k), f ^ k = 1 := by
   classical
@@ -543,12 +471,6 @@ theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     · exact ⟨k + 2, by simp, hk'⟩
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
 
-/- warning: equiv.perm.is_cycle.zpowers_equiv_support -> Equiv.Perm.IsCycle.zpowersEquivSupport is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Equiv.{succ u1, succ u1} (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.zpowers_equiv_support Equiv.Perm.IsCycle.zpowersEquivSupportₓ'. -/
 /-- The subgroup generated by a cycle is in bijection with its support -/
 noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ) :
     (↑(Subgroup.zpowers σ) : Set (Perm α)) ≃ (↑σ.support : Set α) :=
@@ -583,9 +505,6 @@ theorem IsCycle.zpowersEquivSupport_apply {σ : Perm α} (hσ : IsCycle σ) {n :
 #align equiv.perm.is_cycle.zpowers_equiv_support_apply Equiv.Perm.IsCycle.zpowersEquivSupport_apply
 -/
 
-/- warning: equiv.perm.is_cycle.zpowers_equiv_support_symm_apply -> Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_applyₓ'. -/
 @[simp]
 theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ) (n : ℕ) :
     hσ.zpowersEquivSupport.symm
@@ -693,12 +612,6 @@ theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCy
 #align equiv.perm.is_cycle.swap_mul Equiv.Perm.IsCycle.swap_mul
 -/
 
-/- warning: equiv.perm.is_cycle.sign -> Equiv.Perm.IsCycle.sign is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} α) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2) f) (Neg.neg.{0} (Units.{0} Int Int.monoid) (Units.hasNeg.{0} Int Int.monoid (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring)))) (HPow.hPow.{0, 0, 0} (Units.{0} Int Int.monoid) Nat (Units.{0} Int Int.monoid) (instHPow.{0, 0} (Units.{0} Int Int.monoid) Nat (Monoid.Pow.{0} (Units.{0} Int Int.monoid) (DivInvMonoid.toMonoid.{0} (Units.{0} Int Int.monoid) (Group.toDivInvMonoid.{0} (Units.{0} Int Int.monoid) (Units.group.{0} Int Int.monoid))))) (Neg.neg.{0} (Units.{0} Int Int.monoid) (Units.hasNeg.{0} Int Int.monoid (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring)))) (OfNat.ofNat.{0} (Units.{0} Int Int.monoid) 1 (OfNat.mk.{0} (Units.{0} Int Int.monoid) 1 (One.one.{0} (Units.{0} Int Int.monoid) (MulOneClass.toHasOne.{0} (Units.{0} Int Int.monoid) (Units.mulOneClass.{0} Int Int.monoid)))))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.Perm.{succ u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toMul.{0} (Units.{0} Int Int.instMonoidInt) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (MonoidHomClass.toMulHomClass.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2) f) (Neg.neg.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (HPow.hPow.{0, 0, 0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) Nat ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (instHPow.{0, 0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) Nat (Monoid.Pow.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivInvMonoid.toMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Group.toDivInvMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instGroupUnits.{0} Int Int.instMonoidInt))))) (Neg.neg.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (OfNat.ofNat.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) 1 (One.toOfNat1.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (InvOneClass.toOne.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivInvOneMonoid.toInvOneClass.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivisionMonoid.toDivInvOneMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivisionCommMonoid.toDivisionMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (CommGroup.toDivisionCommMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instCommGroupUnitsToMonoid.{0} Int Int.instCommMonoidInt))))))))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.signₓ'. -/
 theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.support.card
   | f => fun hf =>
     let ⟨x, hx⟩ := hf
@@ -861,12 +774,6 @@ theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
 #align equiv.perm.is_cycle.pow_iff Equiv.Perm.IsCycle.pow_iff
 -/
 
-/- warning: equiv.perm.is_cycle.pow_eq_one_iff -> Equiv.Perm.IsCycle.pow_eq_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))) (Exists.{succ u1} β (fun (x : β) => And (Ne.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) f x) x) (Eq.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x))))
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) (Exists.{succ u1} β (fun (x : β) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) f x) x) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iffₓ'. -/
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x := by
@@ -893,12 +800,6 @@ theorem IsCycle.pow_eq_one_iff' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
 #align equiv.perm.is_cycle.pow_eq_one_iff' Equiv.Perm.IsCycle.pow_eq_one_iff'
 -/
 
-/- warning: equiv.perm.is_cycle.pow_eq_one_iff'' -> Equiv.Perm.IsCycle.pow_eq_one_iff'' is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))) (forall (x : β), (Ne.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) f x) x) -> (Eq.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x)))
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) (forall (x : β), (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) f x) x) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.pow_eq_one_iff'' Equiv.Perm.IsCycle.pow_eq_one_iff''ₓ'. -/
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     f ^ n = 1 ↔ ∀ x, f x ≠ x → (f ^ n) x = x :=
@@ -975,29 +876,11 @@ theorem isCycleOn_empty : f.IsCycleOn ∅ := by simp [is_cycle_on]
 #align equiv.perm.is_cycle_on_empty Equiv.Perm.isCycleOn_empty
 -/
 
-/- warning: equiv.perm.is_cycle_on_one -> Equiv.Perm.isCycleOn_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) s) (Set.Subsingleton.{u1} α s)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) s) (Set.Subsingleton.{u1} α s)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on_one Equiv.Perm.isCycleOn_oneₓ'. -/
 @[simp]
 theorem isCycleOn_one : (1 : Perm α).IsCycleOn s ↔ s.Subsingleton := by
   simp [is_cycle_on, Set.bijOn_id, Set.Subsingleton]
 #align equiv.perm.is_cycle_on_one Equiv.Perm.isCycleOn_one
 
-/- warning: equiv.perm.is_cycle_on.subsingleton -> Equiv.Perm.IsCycleOn.subsingleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) s) -> (Set.Subsingleton.{u1} α s)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) s) -> (Set.Subsingleton.{u1} α s)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.subsingleton Equiv.Perm.IsCycleOn.subsingletonₓ'. -/
-/- warning: set.subsingleton.is_cycle_on_one -> Set.Subsingleton.isCycleOn_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) s)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) s)
-Case conversion may be inaccurate. Consider using '#align set.subsingleton.is_cycle_on_one Set.Subsingleton.isCycleOn_oneₓ'. -/
 alias is_cycle_on_one ↔ is_cycle_on.subsingleton _root_.set.subsingleton.is_cycle_on_one
 #align equiv.perm.is_cycle_on.subsingleton Equiv.Perm.IsCycleOn.subsingleton
 #align set.subsingleton.is_cycle_on_one Set.Subsingleton.isCycleOn_one
@@ -1014,28 +897,10 @@ theorem isCycleOn_of_subsingleton [Subsingleton α] (f : Perm α) (s : Set α) :
 #align equiv.perm.is_cycle_on_of_subsingleton Equiv.Perm.isCycleOn_of_subsingleton
 -/
 
-/- warning: equiv.perm.is_cycle_on_inv -> Equiv.Perm.isCycleOn_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, Iff (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) s) (Equiv.Perm.IsCycleOn.{u1} α f s)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, Iff (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) s) (Equiv.Perm.IsCycleOn.{u1} α f s)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on_inv Equiv.Perm.isCycleOn_invₓ'. -/
 @[simp]
 theorem isCycleOn_inv : f⁻¹.IsCycleOn s ↔ f.IsCycleOn s := by simp [is_cycle_on, Set.bijOn_perm_inv]
 #align equiv.perm.is_cycle_on_inv Equiv.Perm.isCycleOn_inv
 
-/- warning: equiv.perm.is_cycle_on.of_inv -> Equiv.Perm.IsCycleOn.of_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) s) -> (Equiv.Perm.IsCycleOn.{u1} α f s)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) s) -> (Equiv.Perm.IsCycleOn.{u1} α f s)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.of_inv Equiv.Perm.IsCycleOn.of_invₓ'. -/
-/- warning: equiv.perm.is_cycle_on.inv -> Equiv.Perm.IsCycleOn.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f s) -> (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) s)
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f s) -> (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) s)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.inv Equiv.Perm.IsCycleOn.invₓ'. -/
 alias is_cycle_on_inv ↔ is_cycle_on.of_inv is_cycle_on.inv
 #align equiv.perm.is_cycle_on.of_inv Equiv.Perm.IsCycleOn.of_inv
 #align equiv.perm.is_cycle_on.inv Equiv.Perm.IsCycleOn.inv
@@ -1176,12 +1041,6 @@ theorem IsCycleOn.pow_card_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a 
 #align equiv.perm.is_cycle_on.pow_card_apply Equiv.Perm.IsCycleOn.pow_card_apply
 -/
 
-/- warning: equiv.perm.is_cycle_on.exists_pow_eq -> Equiv.Perm.IsCycleOn.exists_pow_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {a : α} {b : α} {s : Finset.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) b s) -> (Exists.{1} Nat (fun (n : Nat) => Exists.{0} (LT.lt.{0} Nat Nat.hasLt n (Finset.card.{u1} α s)) (fun (H : LT.lt.{0} Nat Nat.hasLt n (Finset.card.{u1} α s)) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f n) a) b)))
-but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {a : α} {b : α} {s : Finset.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f (Finset.toSet.{u1} α s)) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) b s) -> (Exists.{1} Nat (fun (n : Nat) => And (LT.lt.{0} Nat instLTNat n (Finset.card.{u1} α s)) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f n) a) b)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eqₓ'. -/
 theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
     ∃ n < s.card, (f ^ n) a = b := by
   classical
@@ -1274,12 +1133,6 @@ theorem cycleOf_apply (f : Perm α) (x y : α) : cycleOf f x y = if SameCycle f
 #align equiv.perm.cycle_of_apply Equiv.Perm.cycleOf_apply
 -/
 
-/- warning: equiv.perm.cycle_of_inv -> Equiv.Perm.cycleOf_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) x)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) x)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_inv Equiv.Perm.cycleOf_invₓ'. -/
 theorem cycleOf_inv (f : Perm α) (x : α) : (cycleOf f x)⁻¹ = cycleOf f⁻¹ x :=
   Equiv.ext fun y => by
     rw [inv_eq_iff_eq, cycle_of_apply, cycle_of_apply]
@@ -1372,12 +1225,6 @@ theorem IsCycle.cycleOf_eq (hf : IsCycle f) (hx : f x ≠ x) : cycleOf f x = f :
 #align equiv.perm.is_cycle.cycle_of_eq Equiv.Perm.IsCycle.cycleOf_eq
 -/
 
-/- warning: equiv.perm.cycle_of_eq_one_iff -> Equiv.Perm.cycleOf_eq_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {x : α} (f : Equiv.Perm.{succ u1} α), Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))) (Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) f x) x)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {x : α} (f : Equiv.Perm.{succ u1} α), Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) f x) x)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_eq_one_iff Equiv.Perm.cycleOf_eq_one_iffₓ'. -/
 @[simp]
 theorem cycleOf_eq_one_iff (f : Perm α) : cycleOf f x = 1 ↔ f x = x :=
   by
@@ -1419,12 +1266,6 @@ protected theorem IsCycle.cycleOf (hf : IsCycle f) : cycleOf f x = if f x = x th
 #align equiv.perm.is_cycle.cycle_of Equiv.Perm.IsCycle.cycleOf
 -/
 
-/- warning: equiv.perm.cycle_of_one -> Equiv.Perm.cycleOf_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_one Equiv.Perm.cycleOf_oneₓ'. -/
 theorem cycleOf_one (x : α) : cycleOf 1 x = 1 :=
   (cycleOf_eq_one_iff 1).mpr rfl
 #align equiv.perm.cycle_of_one Equiv.Perm.cycleOf_one
@@ -1468,12 +1309,6 @@ theorem pow_apply_eq_pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x :
 #align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_apply_eq_pow_mod_orderOf_cycleOf_apply
 -/
 
-/- warning: equiv.perm.cycle_of_mul_of_apply_right_eq_self -> Equiv.Perm.cycleOf_mul_of_apply_right_eq_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f g) -> (forall (x : α), (Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) g x) x) -> (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f g) -> (forall (x : α), (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) g x) x) -> (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_mul_of_apply_right_eq_self Equiv.Perm.cycleOf_mul_of_apply_right_eq_selfₓ'. -/
 theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x = x) :
     (f * g).cycleOf x = f.cycleOf x := by
   ext y
@@ -1488,12 +1323,6 @@ theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x
     simp [h.mul_zpow, zpow_apply_eq_self_of_apply_eq_self hx]
 #align equiv.perm.cycle_of_mul_of_apply_right_eq_self Equiv.Perm.cycleOf_mul_of_apply_right_eq_self
 
-/- warning: equiv.perm.disjoint.cycle_of_mul_distrib -> Equiv.Perm.Disjoint.cycleOf_mul_distrib is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (forall (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (forall (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g x)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint.cycle_of_mul_distrib Equiv.Perm.Disjoint.cycleOf_mul_distribₓ'. -/
 theorem Disjoint.cycleOf_mul_distrib (h : f.Disjoint g) (x : α) :
     (f * g).cycleOf x = f.cycleOf x * g.cycleOf x :=
   by
@@ -1507,12 +1336,6 @@ theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.sup
 #align equiv.perm.support_cycle_of_eq_nil_iff Equiv.Perm.support_cycleOf_eq_nil_iff
 -/
 
-/- warning: equiv.perm.support_cycle_of_le -> Equiv.Perm.support_cycleOf_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (x : α), LE.le.{u1} (Finset.{u1} α) (Preorder.toHasLe.{u1} (Finset.{u1} α) (PartialOrder.toPreorder.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (x : α), LE.le.{u1} (Finset.{u1} α) (Preorder.toLE.{u1} (Finset.{u1} α) (PartialOrder.toPreorder.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_leₓ'. -/
 theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ support f :=
   by
   intro y hy
@@ -1707,12 +1530,6 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
 #align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
 -/
 
-/- warning: equiv.perm.list_cycles_perm_list_cycles -> Equiv.Perm.list_cycles_perm_list_cycles is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_2 : Finite.{succ u1} α] {l₁ : List.{u1} (Equiv.Perm.{succ u1} α)} {l₂ : List.{u1} (Equiv.Perm.{succ u1} α)}, (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l₁) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l₂)) -> (forall (σ : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) σ l₁) -> (Equiv.Perm.IsCycle.{u1} α σ)) -> (forall (σ : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) σ l₂) -> (Equiv.Perm.IsCycle.{u1} α σ)) -> (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l₁) -> (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l₂) -> (List.Perm.{u1} (Equiv.Perm.{succ u1} α) l₁ l₂)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_2 : Finite.{succ u1} α] {l₁ : List.{u1} (Equiv.Perm.{succ u1} α)} {l₂ : List.{u1} (Equiv.Perm.{succ u1} α)}, (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l₁) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l₂)) -> (forall (σ : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) σ l₁) -> (Equiv.Perm.IsCycle.{u1} α σ)) -> (forall (σ : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) σ l₂) -> (Equiv.Perm.IsCycle.{u1} α σ)) -> (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l₁) -> (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l₂) -> (List.Perm.{u1} (Equiv.Perm.{succ u1} α) l₁ l₂)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cyclesₓ'. -/
 theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List (Perm α)}
     (h₀ : l₁.Prod = l₂.Prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
     (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
@@ -1728,24 +1545,12 @@ theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List
     · exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
 #align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cycles
 
-/- warning: equiv.perm.cycle_factors -> Equiv.Perm.cycleFactors is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] [_inst_3 : LinearOrder.{u1} α] (f : Equiv.Perm.{succ u1} α), Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] [_inst_3 : LinearOrder.{u1} α] (f : Equiv.Perm.{succ u1} α), Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors Equiv.Perm.cycleFactorsₓ'. -/
 /-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`. -/
 def cycleFactors [Fintype α] [LinearOrder α] (f : Perm α) :
     { l : List (Perm α) // l.Prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } :=
   cycleFactorsAux (univ.sort (· ≤ ·)) f fun _ _ => (mem_sort _).2 (mem_univ _)
 #align equiv.perm.cycle_factors Equiv.Perm.cycleFactors
 
-/- warning: equiv.perm.trunc_cycle_factors -> Equiv.Perm.truncCycleFactors is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α), Trunc.{succ u1} (Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α), Trunc.{succ u1} (Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.trunc_cycle_factors Equiv.Perm.truncCycleFactorsₓ'. -/
 /-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`,
   without a linear order. -/
 def truncCycleFactors [Fintype α] (f : Perm α) :
@@ -1772,12 +1577,6 @@ def cycleFactorsFinset : Finset (Perm α) :=
 #align equiv.perm.cycle_factors_finset Equiv.Perm.cycleFactorsFinset
 -/
 
-/- warning: equiv.perm.cycle_factors_finset_eq_list_to_finset -> Equiv.Perm.cycleFactorsFinset_eq_list_toFinset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {l : List.{u1} (Equiv.Perm.{succ u1} α)}, (List.Nodup.{u1} (Equiv.Perm.{succ u1} α) l) -> (Iff (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ) (List.toFinset.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b) l)) (And (forall (f : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) f l) -> (Equiv.Perm.IsCycle.{u1} α f)) (And (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l) (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) σ))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {l : List.{u1} (Equiv.Perm.{succ u1} α)}, (List.Nodup.{u1} (Equiv.Perm.{succ u1} α) l) -> (Iff (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ) (List.toFinset.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b) l)) (And (forall (f : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) f l) -> (Equiv.Perm.IsCycle.{u1} α f)) (And (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l) (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) σ))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_eq_list_to_finset Equiv.Perm.cycleFactorsFinset_eq_list_toFinsetₓ'. -/
 theorem cycleFactorsFinset_eq_list_toFinset {σ : Perm α} {l : List (Perm α)} (hn : l.Nodup) :
     σ.cycleFactorsFinset = l.toFinset ↔
       (∀ f : Perm α, f ∈ l → f.IsCycle) ∧ l.Pairwise Disjoint ∧ l.Prod = σ :=
@@ -1821,22 +1620,10 @@ theorem cycleFactorsFinset_pairwise_disjoint :
 #align equiv.perm.cycle_factors_finset_pairwise_disjoint Equiv.Perm.cycleFactorsFinset_pairwise_disjoint
 -/
 
-/- warning: equiv.perm.cycle_factors_finset_mem_commute -> Equiv.Perm.cycleFactorsFinset_mem_commute is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α), Set.Pairwise.{u1} (Equiv.Perm.{succ u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Finset.Set.hasCoeT.{u1} (Equiv.Perm.{succ u1} α)))) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α), Set.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Finset.toSet.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_mem_commute Equiv.Perm.cycleFactorsFinset_mem_commuteₓ'. -/
 theorem cycleFactorsFinset_mem_commute : (cycleFactorsFinset f : Set (Perm α)).Pairwise Commute :=
   (cycleFactorsFinset_pairwise_disjoint _).mono' fun _ _ => Disjoint.commute
 #align equiv.perm.cycle_factors_finset_mem_commute Equiv.Perm.cycleFactorsFinset_mem_commute
 
-/- warning: equiv.perm.cycle_factors_finset_noncomm_prod -> Equiv.Perm.cycleFactorsFinset_noncommProd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (comm : optParam.{0} (Set.Pairwise.{u1} (Equiv.Perm.{succ u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Finset.Set.hasCoeT.{u1} (Equiv.Perm.{succ u1} α)))) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) (Equiv.Perm.cycleFactorsFinset_mem_commute.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Finset.noncommProd.{u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (id.{succ u1} (Equiv.Perm.{succ u1} α)) comm) f
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (comm : optParam.{0} (Set.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Finset.toSet.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) (Equiv.Perm.cycleFactorsFinset_mem_commute.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Finset.noncommProd.{u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (id.{succ u1} (Equiv.Perm.{succ u1} α)) comm) f
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_noncomm_prod Equiv.Perm.cycleFactorsFinset_noncommProdₓ'. -/
 /-- The product of cycle factors is equal to the original `f : perm α`. -/
 theorem cycleFactorsFinset_noncommProd
     (comm : (cycleFactorsFinset f : Set (Perm α)).Pairwise Commute :=
@@ -1879,12 +1666,6 @@ theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
 #align equiv.perm.cycle_of_mem_cycle_factors_finset_iff Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff
 -/
 
-/- warning: equiv.perm.mem_cycle_factors_finset_support_le -> Equiv.Perm.mem_cycleFactorsFinset_support_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {p : Equiv.Perm.{succ u1} α} {f : Equiv.Perm.{succ u1} α}, (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasMem.{u1} (Equiv.Perm.{succ u1} α)) p (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) -> (LE.le.{u1} (Finset.{u1} α) (Preorder.toHasLe.{u1} (Finset.{u1} α) (PartialOrder.toPreorder.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 p) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {p : Equiv.Perm.{succ u1} α} {f : Equiv.Perm.{succ u1} α}, (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instMembershipFinset.{u1} (Equiv.Perm.{succ u1} α)) p (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) -> (LE.le.{u1} (Finset.{u1} α) (Preorder.toLE.{u1} (Finset.{u1} α) (PartialOrder.toPreorder.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 p) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_leₓ'. -/
 theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactorsFinset f) :
     p.support ≤ f.support := by
   rw [mem_cycle_factors_finset_iff] at h
@@ -1892,22 +1673,10 @@ theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactor
   rwa [mem_support, ← h.right x hx, ← mem_support]
 #align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_le
 
-/- warning: equiv.perm.cycle_factors_finset_eq_empty_iff -> Equiv.Perm.cycleFactorsFinset_eq_empty_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, Iff (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasEmptyc.{u1} (Equiv.Perm.{succ u1} α)))) (Eq.{succ u1} (Equiv.Perm.{succ u1} α) f (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, Iff (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instEmptyCollectionFinset.{u1} (Equiv.Perm.{succ u1} α)))) (Eq.{succ u1} (Equiv.Perm.{succ u1} α) f (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_eq_empty_iff Equiv.Perm.cycleFactorsFinset_eq_empty_iffₓ'. -/
 theorem cycleFactorsFinset_eq_empty_iff {f : Perm α} : cycleFactorsFinset f = ∅ ↔ f = 1 := by
   simpa [cycle_factors_finset_eq_finset] using eq_comm
 #align equiv.perm.cycle_factors_finset_eq_empty_iff Equiv.Perm.cycleFactorsFinset_eq_empty_iff
 
-/- warning: equiv.perm.cycle_factors_finset_one -> Equiv.Perm.cycleFactorsFinset_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α], Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))) (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasEmptyc.{u1} (Equiv.Perm.{succ u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α], Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instEmptyCollectionFinset.{u1} (Equiv.Perm.{succ u1} α)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_one Equiv.Perm.cycleFactorsFinset_oneₓ'. -/
 @[simp]
 theorem cycleFactorsFinset_one : cycleFactorsFinset (1 : Perm α) = ∅ := by
   simp [cycle_factors_finset_eq_empty_iff]
@@ -1947,12 +1716,6 @@ theorem cycleFactorsFinset_injective : Function.Injective (@cycleFactorsFinset 
 #align equiv.perm.cycle_factors_finset_injective Equiv.Perm.cycleFactorsFinset_injective
 -/
 
-/- warning: equiv.perm.disjoint.disjoint_cycle_factors_finset -> Equiv.Perm.Disjoint.disjoint_cycleFactorsFinset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (Disjoint.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.partialOrder.{u1} (Equiv.Perm.{succ u1} α)) (Finset.orderBot.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (Disjoint.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.partialOrder.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instOrderBotFinsetToLEToPreorderPartialOrder.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint.disjoint_cycle_factors_finset Equiv.Perm.Disjoint.disjoint_cycleFactorsFinsetₓ'. -/
 theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g) :
     Disjoint (cycleFactorsFinset f) (cycleFactorsFinset g) :=
   by
@@ -1965,12 +1728,6 @@ theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g)
   simp [ha, ← hf a ha, ← hg a ha]
 #align equiv.perm.disjoint.disjoint_cycle_factors_finset Equiv.Perm.Disjoint.disjoint_cycleFactorsFinset
 
-/- warning: equiv.perm.disjoint.cycle_factors_finset_mul_eq_union -> Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g)) (Union.union.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasUnion.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g)) (Union.union.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instUnionFinset.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint.cycle_factors_finset_mul_eq_union Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_unionₓ'. -/
 theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f g) :
     cycleFactorsFinset (f * g) = cycleFactorsFinset f ∪ cycleFactorsFinset g :=
   by
@@ -1986,12 +1743,6 @@ theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f
     rw [cycle_factors_finset_noncomm_prod, cycle_factors_finset_noncomm_prod]
 #align equiv.perm.disjoint.cycle_factors_finset_mul_eq_union Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_union
 
-/- warning: equiv.perm.disjoint_mul_inv_of_mem_cycle_factors_finset -> Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasMem.{u1} (Equiv.Perm.{succ u1} α)) f (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)) -> (Equiv.Perm.Disjoint.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instMembershipFinset.{u1} (Equiv.Perm.{succ u1} α)) f (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)) -> (Equiv.Perm.Disjoint.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f)) f)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint_mul_inv_of_mem_cycle_factors_finset Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinsetₓ'. -/
 theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cycleFactorsFinset g) :
     Disjoint (g * f⁻¹) f := by
   rw [mem_cycle_factors_finset_iff] at h
@@ -2027,12 +1778,6 @@ theorem cycle_is_cycleOf {f c : Equiv.Perm α} {a : α} (ha : a ∈ c.support)
 
 end CycleFactorsFinset
 
-/- warning: equiv.perm.cycle_induction_on -> Equiv.Perm.cycle_induction_on is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_2 : Finite.{succ u1} β] (P : (Equiv.Perm.{succ u1} β) -> Prop) (σ : Equiv.Perm.{succ u1} β), (P (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))) -> (forall (σ : Equiv.Perm.{succ u1} β), (Equiv.Perm.IsCycle.{u1} β σ) -> (P σ)) -> (forall (σ : Equiv.Perm.{succ u1} β) (τ : Equiv.Perm.{succ u1} β), (Equiv.Perm.Disjoint.{u1} β σ τ) -> (Equiv.Perm.IsCycle.{u1} β σ) -> (P σ) -> (P τ) -> (P (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.{succ u1} β) (Equiv.Perm.{succ u1} β) (instHMul.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))) σ τ))) -> (P σ)
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_2 : Finite.{succ u1} β] (P : (Equiv.Perm.{succ u1} β) -> Prop) (σ : Equiv.Perm.{succ u1} β), (P (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) -> (forall (σ : Equiv.Perm.{succ u1} β), (Equiv.Perm.IsCycle.{u1} β σ) -> (P σ)) -> (forall (σ : Equiv.Perm.{succ u1} β) (τ : Equiv.Perm.{succ u1} β), (Equiv.Perm.Disjoint.{u1} β σ τ) -> (Equiv.Perm.IsCycle.{u1} β σ) -> (P σ) -> (P τ) -> (P (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.{succ u1} β) (Equiv.Perm.{succ u1} β) (instHMul.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))) σ τ))) -> (P σ)
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_induction_on Equiv.Perm.cycle_induction_onₓ'. -/
 @[elab_as_elim]
 theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (base_one : P 1)
     (base_cycles : ∀ σ : Perm β, σ.IsCycle → P σ)
@@ -2055,12 +1800,6 @@ theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (ba
         (ih (fun τ hτ => h1 τ (List.mem_cons_of_mem σ hτ)) h2.of_cons)
 #align equiv.perm.cycle_induction_on Equiv.Perm.cycle_induction_on
 
-/- warning: equiv.perm.cycle_factors_finset_mul_inv_mem_eq_sdiff -> Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasMem.{u1} (Equiv.Perm.{succ u1} α)) f (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)) -> (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f))) (SDiff.sdiff.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasSdiff.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g) (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasSingleton.{u1} (Equiv.Perm.{succ u1} α)) f)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instMembershipFinset.{u1} (Equiv.Perm.{succ u1} α)) f (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)) -> (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f))) (SDiff.sdiff.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instSDiffFinset.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g) (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instSingletonFinset.{u1} (Equiv.Perm.{succ u1} α)) f)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_mul_inv_mem_eq_sdiff Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiffₓ'. -/
 theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
     (h : f ∈ cycleFactorsFinset g) : cycleFactorsFinset (g * f⁻¹) = cycleFactorsFinset g \ {f} :=
   by
@@ -2110,12 +1849,6 @@ variable [Finite β]
 
 open Subgroup
 
-/- warning: equiv.perm.closure_is_cycle -> Equiv.Perm.closure_isCycle is a dubious translation:
-lean 3 declaration is
-  forall {β : Type.{u1}} [_inst_2 : Finite.{succ u1} β], Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β) (setOf.{u1} (Equiv.Perm.{succ u1} β) (fun (σ : Equiv.Perm.{succ u1} β) => Equiv.Perm.IsCycle.{u1} β σ))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)) (Subgroup.hasTop.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))
-but is expected to have type
-  forall {β : Type.{u1}} [_inst_2 : Finite.{succ u1} β], Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β) (setOf.{u1} (Equiv.Perm.{succ u1} β) (fun (σ : Equiv.Perm.{succ u1} β) => Equiv.Perm.IsCycle.{u1} β σ))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)) (Subgroup.instTopSubgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.closure_is_cycle Equiv.Perm.closure_isCycleₓ'. -/
 theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤ := by
   classical
     cases nonempty_fintype β
@@ -2125,12 +1858,6 @@ theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤ := by
 
 variable [Fintype α]
 
-/- warning: equiv.perm.closure_cycle_adjacent_swap -> Equiv.Perm.closure_cycle_adjacent_swap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Top.top.{u1} (Finset.{u1} α) (BooleanAlgebra.toHasTop.{u1} (Finset.{u1} α) (Finset.booleanAlgebra.{u1} α _inst_3 (fun (a : α) (b : α) => _inst_1 a b))))) -> (forall (x : α), Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasInsert.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasSingleton.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x))))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.hasTop.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Top.top.{u1} (Finset.{u1} α) (BooleanAlgebra.toTop.{u1} (Finset.{u1} α) (Finset.booleanAlgebra.{u1} α _inst_3 (fun (a : α) (b : α) => _inst_1 a b))))) -> (forall (x : α), Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instInsertSet.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instSingletonSet.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x))))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.instTopSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swapₓ'. -/
 theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.support = ⊤) (x : α) :
     closure ({σ, swap x (σ x)} : Set (Perm α)) = ⊤ :=
   by
@@ -2197,12 +1924,6 @@ theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n
 #align equiv.perm.closure_cycle_coprime_swap Equiv.Perm.closure_cycle_coprime_swap
 -/
 
-/- warning: equiv.perm.closure_prime_cycle_swap -> Equiv.Perm.closure_prime_cycle_swap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, (Nat.Prime (Fintype.card.{u1} α _inst_3)) -> (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Finset.univ.{u1} α _inst_3)) -> (Equiv.Perm.IsSwap.{u1} α (fun (a : α) (b : α) => _inst_1 a b) τ) -> (Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasInsert.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasSingleton.{u1} (Equiv.Perm.{succ u1} α)) τ))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.hasTop.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, (Nat.Prime (Fintype.card.{u1} α _inst_3)) -> (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Finset.univ.{u1} α _inst_3)) -> (Equiv.Perm.IsSwap.{u1} α (fun (a : α) (b : α) => _inst_1 a b) τ) -> (Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instInsertSet.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instSingletonSet.{u1} (Equiv.Perm.{succ u1} α)) τ))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.instTopSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.closure_prime_cycle_swap Equiv.Perm.closure_prime_cycle_swapₓ'. -/
 theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime) (h1 : IsCycle σ)
     (h2 : σ.support = Finset.univ) (h3 : IsSwap τ) : closure ({σ, τ} : Set (Perm α)) = ⊤ :=
   by
@@ -2286,12 +2007,6 @@ theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
 #align equiv.perm.is_cycle.is_conj_iff Equiv.Perm.IsCycle.isConj_iff
 -/
 
-/- warning: equiv.perm.support_conj -> Equiv.Perm.support_conj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) σ))) (Finset.map.{u1, u1} α α (Equiv.toEmbedding.{succ u1, succ u1} α α σ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 τ))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ))) (Finset.map.{u1, u1} α α (Equiv.toEmbedding.{succ u1, succ u1} α α σ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 τ))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.support_conj Equiv.Perm.support_conjₓ'. -/
 @[simp]
 theorem support_conj : (σ * τ * σ⁻¹).support = τ.support.map σ.toEmbedding :=
   by
@@ -2300,23 +2015,11 @@ theorem support_conj : (σ * τ * σ⁻¹).support = τ.support.map σ.toEmbeddi
   rfl
 #align equiv.perm.support_conj Equiv.Perm.support_conj
 
-/- warning: equiv.perm.card_support_conj -> Equiv.Perm.card_support_conj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, Eq.{1} Nat (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) σ)))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 τ))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, Eq.{1} Nat (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ)))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 τ))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.card_support_conj Equiv.Perm.card_support_conjₓ'. -/
 theorem card_support_conj : (σ * τ * σ⁻¹).support.card = τ.support.card := by simp
 #align equiv.perm.card_support_conj Equiv.Perm.card_support_conj
 
 end
 
-/- warning: equiv.perm.disjoint.is_conj_mul -> Equiv.Perm.Disjoint.isConj_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_2 : Finite.{succ u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α} {π : Equiv.Perm.{succ u1} α} {ρ : Equiv.Perm.{succ u1} α}, (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) σ π) -> (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) τ ρ) -> (Equiv.Perm.Disjoint.{u1} α σ τ) -> (Equiv.Perm.Disjoint.{u1} α π ρ) -> (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) π ρ))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_2 : Finite.{succ u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α} {π : Equiv.Perm.{succ u1} α} {ρ : Equiv.Perm.{succ u1} α}, (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) σ π) -> (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) τ ρ) -> (Equiv.Perm.Disjoint.{u1} α σ τ) -> (Equiv.Perm.Disjoint.{u1} α π ρ) -> (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) π ρ))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint.is_conj_mul Equiv.Perm.Disjoint.isConj_mulₓ'. -/
 theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
     (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
   classical
@@ -2375,12 +2078,6 @@ section FixedPoints
 -/
 
 
-/- warning: equiv.perm.fixed_point_card_lt_of_ne_one -> Equiv.Perm.fixed_point_card_lt_of_ne_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Ne.{succ u1} (Equiv.Perm.{succ u1} α) σ (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))) -> (LT.lt.{0} Nat Nat.hasLt (Finset.card.{u1} α (Finset.filter.{u1} α (fun (x : α) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (fun (a : α) => _inst_1 (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ a) a) (Finset.univ.{u1} α _inst_2))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) (Fintype.card.{u1} α _inst_2) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Ne.{succ u1} (Equiv.Perm.{succ u1} α) σ (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) -> (LT.lt.{0} Nat instLTNat (Finset.card.{u1} α (Finset.filter.{u1} α (fun (x : α) => Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (fun (a : α) => _inst_1 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ a) a) (Finset.univ.{u1} α _inst_2))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) (Fintype.card.{u1} α _inst_2) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))
-Case conversion may be inaccurate. Consider using '#align equiv.perm.fixed_point_card_lt_of_ne_one Equiv.Perm.fixed_point_card_lt_of_ne_oneₓ'. -/
 theorem fixed_point_card_lt_of_ne_one [Fintype α] {σ : Perm α} (h : σ ≠ 1) :
     (filter (fun x => σ x = x) univ).card < Fintype.card α - 1 :=
   by
@@ -2417,22 +2114,10 @@ namespace Int
 
 open Equiv
 
-/- warning: int.add_left_one_is_cycle -> Int.addLeft_one_isCycle is a dubious translation:
-lean 3 declaration is
-  Equiv.Perm.IsCycle.{0} Int (Equiv.addLeft.{0} Int Int.addGroup (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))
-but is expected to have type
-  Equiv.Perm.IsCycle.{0} Int (Equiv.addLeft.{0} Int Int.instAddGroupInt (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))
-Case conversion may be inaccurate. Consider using '#align int.add_left_one_is_cycle Int.addLeft_one_isCycleₓ'. -/
 theorem addLeft_one_isCycle : (Equiv.addLeft 1 : Perm ℤ).IsCycle :=
   ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
 #align int.add_left_one_is_cycle Int.addLeft_one_isCycle
 
-/- warning: int.add_right_one_is_cycle -> Int.addRight_one_isCycle is a dubious translation:
-lean 3 declaration is
-  Equiv.Perm.IsCycle.{0} Int (Equiv.addRight.{0} Int Int.addGroup (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))
-but is expected to have type
-  Equiv.Perm.IsCycle.{0} Int (Equiv.addRight.{0} Int Int.instAddGroupInt (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))
-Case conversion may be inaccurate. Consider using '#align int.add_right_one_is_cycle Int.addRight_one_isCycleₓ'. -/
 theorem addRight_one_isCycle : (Equiv.addRight 1 : Perm ℤ).IsCycle :=
   ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
 #align int.add_right_one_is_cycle Int.addRight_one_isCycle
@@ -2460,12 +2145,6 @@ namespace Set
 
 variable {f : Perm α} {s : Set α}
 
-/- warning: set.countable.exists_cycle_on -> Set.Countable.exists_cycleOn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Countable.{u1} α s) -> (Exists.{succ u1} (Equiv.Perm.{succ u1} α) (fun (f : Equiv.Perm.{succ u1} α) => And (Equiv.Perm.IsCycleOn.{u1} α f s) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (setOf.{u1} α (fun (x : α) => Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) f x) x)) s)))
-but is expected to have type
-  forall {α : Type.{u1}} [s : DecidableEq.{succ u1} α] {hs : Set.{u1} α}, (Set.Countable.{u1} α hs) -> (Exists.{succ u1} (Equiv.Perm.{succ u1} α) (fun (f : Equiv.Perm.{succ u1} α) => And (Equiv.Perm.IsCycleOn.{u1} α f hs) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (setOf.{u1} α (fun (x : α) => Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) f x) x)) hs)))
-Case conversion may be inaccurate. Consider using '#align set.countable.exists_cycle_on Set.Countable.exists_cycleOnₓ'. -/
 theorem Countable.exists_cycleOn (hs : s.Countable) :
     ∃ f : Perm α, f.IsCycleOn s ∧ { x | f x ≠ x } ⊆ s := by
   classical
@@ -2562,23 +2241,11 @@ namespace Finset
 
 variable [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : Perm ι}
 
-/- warning: finset.sum_smul_sum_eq_sum_perm -> Finset.sum_smul_sum_eq_sum_perm is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Semiring.{u2} α] [_inst_2 : AddCommMonoid.{u3} β] [_inst_3 : Module.{u2, u3} α β _inst_1 _inst_2] {s : Finset.{u1} ι} {σ : Equiv.Perm.{succ u1} ι}, (Equiv.Perm.IsCycleOn.{u1} ι σ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} ι) (Set.{u1} ι) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (Finset.Set.hasCoeT.{u1} ι))) s)) -> (forall (f : ι -> α) (g : ι -> β), Eq.{succ u3} β (SMul.smul.{u2, u3} α β (SMulZeroClass.toHasSmul.{u2, u3} α β (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (SMulWithZero.toSmulZeroClass.{u2, u3} α β (MulZeroClass.toHasZero.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α (MonoidWithZero.toMulZeroOneClass.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1)))) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (MulActionWithZero.toSMulWithZero.{u2, u3} α β (Semiring.toMonoidWithZero.{u2} α _inst_1) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (Module.toMulActionWithZero.{u2, u3} α β _inst_1 _inst_2 _inst_3)))) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u3, u1} β ι _inst_2 s (fun (i : ι) => g i))) (Finset.sum.{u3, 0} β Nat _inst_2 (Finset.range (Finset.card.{u1} ι s)) (fun (k : Nat) => Finset.sum.{u3, u1} β ι _inst_2 s (fun (i : ι) => SMul.smul.{u2, u3} α β (SMulZeroClass.toHasSmul.{u2, u3} α β (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (SMulWithZero.toSmulZeroClass.{u2, u3} α β (MulZeroClass.toHasZero.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α (MonoidWithZero.toMulZeroOneClass.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1)))) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (MulActionWithZero.toSMulWithZero.{u2, u3} α β (Semiring.toMonoidWithZero.{u2} α _inst_1) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (Module.toMulActionWithZero.{u2, u3} α β _inst_1 _inst_2 _inst_3)))) (f i) (g (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} ι) Nat (Equiv.Perm.{succ u1} ι) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} ι) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} ι) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Equiv.Perm.permGroup.{u1} ι))))) σ k) i))))))
-but is expected to have type
-  forall {ι : Type.{u3}} {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semiring.{u1} α] [_inst_2 : AddCommMonoid.{u2} β] [_inst_3 : Module.{u1, u2} α β _inst_1 _inst_2] {s : Finset.{u3} ι} {σ : Equiv.Perm.{succ u3} ι}, (Equiv.Perm.IsCycleOn.{u3} ι σ (Finset.toSet.{u3} ι s)) -> (forall (f : ι -> α) (g : ι -> β), Eq.{succ u2} β (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (Finset.sum.{u1, u3} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => g i))) (Finset.sum.{u2, 0} β Nat _inst_2 (Finset.range (Finset.card.{u3} ι s)) (fun (k : Nat) => Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (f i) (g (FunLike.coe.{succ u3, succ u3, succ u3} (Equiv.Perm.{succ u3} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u3, succ u3} ι ι) (HPow.hPow.{u3, 0, u3} (Equiv.Perm.{succ u3} ι) Nat (Equiv.Perm.{succ u3} ι) (instHPow.{u3, 0} (Equiv.Perm.{succ u3} ι) Nat (Monoid.Pow.{u3} (Equiv.Perm.{succ u3} ι) (DivInvMonoid.toMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Group.toDivInvMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Equiv.Perm.permGroup.{u3} ι))))) σ k) i))))))
-Case conversion may be inaccurate. Consider using '#align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_permₓ'. -/
 theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
     ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) := by
   simp_rw [sum_smul_sum, product_self_eq_disj_Union_perm hσ, sum_disj_Union, sum_map]; rfl
 #align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_perm
 
-/- warning: finset.sum_mul_sum_eq_sum_perm -> Finset.sum_mul_sum_eq_sum_perm is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Semiring.{u2} α] {s : Finset.{u1} ι} {σ : Equiv.Perm.{succ u1} ι}, (Equiv.Perm.IsCycleOn.{u1} ι σ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} ι) (Set.{u1} ι) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (Finset.Set.hasCoeT.{u1} ι))) s)) -> (forall (f : ι -> α) (g : ι -> α), Eq.{succ u2} α (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))))) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => g i))) (Finset.sum.{u2, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) (Finset.range (Finset.card.{u1} ι s)) (fun (k : Nat) => Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))))) (f i) (g (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} ι) Nat (Equiv.Perm.{succ u1} ι) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} ι) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} ι) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Equiv.Perm.permGroup.{u1} ι))))) σ k) i))))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Semiring.{u1} α] {s : Finset.{u2} ι} {σ : Equiv.Perm.{succ u2} ι}, (Equiv.Perm.IsCycleOn.{u2} ι σ (Finset.toSet.{u2} ι s)) -> (forall (f : ι -> α) (g : ι -> α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => g i))) (Finset.sum.{u1, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) (Finset.range (Finset.card.{u2} ι s)) (fun (k : Nat) => Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (f i) (g (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} ι ι) (HPow.hPow.{u2, 0, u2} (Equiv.Perm.{succ u2} ι) Nat (Equiv.Perm.{succ u2} ι) (instHPow.{u2, 0} (Equiv.Perm.{succ u2} ι) Nat (Monoid.Pow.{u2} (Equiv.Perm.{succ u2} ι) (DivInvMonoid.toMonoid.{u2} (Equiv.Perm.{succ u2} ι) (Group.toDivInvMonoid.{u2} (Equiv.Perm.{succ u2} ι) (Equiv.Perm.permGroup.{u2} ι))))) σ k) i))))))
-Case conversion may be inaccurate. Consider using '#align finset.sum_mul_sum_eq_sum_perm Finset.sum_mul_sum_eq_sum_permₓ'. -/
 theorem sum_mul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f g : ι → α) :
     ((∑ i in s, f i) * ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i * g ((σ ^ k) i) :=
   sum_smul_sum_eq_sum_perm hσ f g

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

@@ -438,9 +438,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_inv Equiv.Perm.isCycle_invₓ'. -/
 @[simp]
 theorem isCycle_inv : IsCycle f⁻¹ ↔ IsCycle f :=
-  ⟨fun h => by
-    convert h.inv
-    rw [inv_inv], IsCycle.inv⟩
+  ⟨fun h => by convert h.inv; rw [inv_inv], IsCycle.inv⟩
 #align equiv.perm.is_cycle_inv Equiv.Perm.isCycle_inv
 
 /- warning: equiv.perm.is_cycle.conj -> Equiv.Perm.IsCycle.conj is a dubious translation:
@@ -508,18 +506,12 @@ variable [DecidableEq α]
 #print Equiv.Perm.isCycle_swap /-
 theorem isCycle_swap (hxy : x ≠ y) : IsCycle (swap x y) :=
   ⟨y, by rwa [swap_apply_right], fun a (ha : ite (a = x) y (ite (a = y) x a) ≠ a) =>
-    if hya : y = a then ⟨0, hya⟩
-    else
-      ⟨1, by
-        rw [zpow_one, swap_apply_def]
-        split_ifs  at * <;> cc⟩⟩
+    if hya : y = a then ⟨0, hya⟩ else ⟨1, by rw [zpow_one, swap_apply_def]; split_ifs  at * <;> cc⟩⟩
 #align equiv.perm.is_cycle_swap Equiv.Perm.isCycle_swap
 -/
 
 #print Equiv.Perm.IsSwap.isCycle /-
-protected theorem IsSwap.isCycle : IsSwap f → IsCycle f :=
-  by
-  rintro ⟨x, y, hxy, rfl⟩
+protected theorem IsSwap.isCycle : IsSwap f → IsCycle f := by rintro ⟨x, y, hxy, rfl⟩;
   exact is_cycle_swap hxy
 #align equiv.perm.is_swap.is_cycle Equiv.Perm.IsSwap.isCycle
 -/
@@ -627,9 +619,7 @@ theorem isCycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
         exact this.1
       let ⟨i, hi⟩ :=
         is_cycle_swap_mul_aux₁ n hb'
-          (f.Injective <| by
-            rw [apply_inv_self]
-            rwa [pow_succ, mul_apply] at h)
+          (f.Injective <| by rw [apply_inv_self]; rwa [pow_succ, mul_apply] at h)
       ⟨i + 1, by
         rw [add_comm, zpow_add, mul_apply, hi, zpow_one, mul_apply, apply_inv_self,
           swap_apply_of_ne_of_ne (ne_and_ne_of_swap_mul_apply_ne_self hb).2 (Ne.symm hfbx)]⟩
@@ -683,10 +673,8 @@ theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type _} [DecidableEq α] {f
         cases' hz.2 hy with j hj
         rw [← sub_add_cancel j i, zpow_add, mul_apply, hi] at hj
         cases' zpow_apply_eq_of_apply_apply_eq_self hffx (j - i) with hji hji
-        · rw [← hj, hji] at hyx
-          cc
-        · rw [← hj, hji] at hfyx
-          cc
+        · rw [← hj, hji] at hyx; cc
+        · rw [← hj, hji] at hfyx; cc
 #align equiv.perm.is_cycle.eq_swap_of_apply_apply_eq_self Equiv.Perm.IsCycle.eq_swap_of_apply_apply_eq_self
 -/
 
@@ -1054,10 +1042,8 @@ alias is_cycle_on_inv ↔ is_cycle_on.of_inv is_cycle_on.inv
 
 #print Equiv.Perm.IsCycleOn.conj /-
 theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Perm α) '' s) :=
-  ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy =>
-    by
-    rw [← preimage_inv] at hx hy
-    convert(h.2 hx hy).conj <;> rw [apply_inv_self]⟩
+  ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy => by
+    rw [← preimage_inv] at hx hy; convert(h.2 hx hy).conj <;> rw [apply_inv_self]⟩
 #align equiv.perm.is_cycle_on.conj Equiv.Perm.IsCycleOn.conj
 -/
 
@@ -1106,9 +1092,7 @@ theorem isCycle_iff_exists_isCycleOn :
 
 #print Equiv.Perm.IsCycleOn.apply_mem_iff /-
 theorem IsCycleOn.apply_mem_iff (hf : f.IsCycleOn s) : f x ∈ s ↔ x ∈ s :=
-  ⟨fun hx => by
-    convert hf.1.perm_inv.1 hx
-    rw [inv_apply_self], fun hx => hf.1.MapsTo hx⟩
+  ⟨fun hx => by convert hf.1.perm_inv.1 hx; rw [inv_apply_self], fun hx => hf.1.MapsTo hx⟩
 #align equiv.perm.is_cycle_on.apply_mem_iff Equiv.Perm.IsCycleOn.apply_mem_iff
 -/
 
@@ -1213,10 +1197,8 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
 
 #print Equiv.Perm.IsCycleOn.exists_pow_eq' /-
 theorem IsCycleOn.exists_pow_eq' (hs : s.Finite) (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
-    ∃ n : ℕ, (f ^ n) a = b := by
-  lift s to Finset α using id hs
-  obtain ⟨n, -, hn⟩ := hf.exists_pow_eq ha hb
-  exact ⟨n, hn⟩
+    ∃ n : ℕ, (f ^ n) a = b := by lift s to Finset α using id hs;
+  obtain ⟨n, -, hn⟩ := hf.exists_pow_eq ha hb; exact ⟨n, hn⟩
 #align equiv.perm.is_cycle_on.exists_pow_eq' Equiv.Perm.IsCycleOn.exists_pow_eq'
 -/
 
@@ -1251,9 +1233,7 @@ theorem IsCycleOn.of_zpow {n : ℤ} (hf : (f ^ n).IsCycleOn s) (h : Set.BijOn f
 #print Equiv.Perm.IsCycleOn.extendDomain /-
 theorem IsCycleOn.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
     (h : g.IsCycleOn s) : (g.extendDomain f).IsCycleOn (coe ∘ f '' s) :=
-  ⟨h.1.extendDomain, by
-    rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩
-    exact (h.2 ha hb).extendDomain⟩
+  ⟨h.1.extendDomain, by rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩; exact (h.2 ha hb).extendDomain⟩
 #align equiv.perm.is_cycle_on.extend_domain Equiv.Perm.IsCycleOn.extendDomain
 -/
 
@@ -1289,10 +1269,8 @@ theorem cycleOf_apply (f : Perm α) (x y : α) : cycleOf f x y = if SameCycle f
   by
   dsimp only [cycle_of]
   split_ifs
-  · apply of_subtype_apply_of_mem
-    exact h
-  · apply of_subtype_apply_of_not_mem
-    exact h
+  · apply of_subtype_apply_of_mem; exact h
+  · apply of_subtype_apply_of_not_mem; exact h
 #align equiv.perm.cycle_of_apply Equiv.Perm.cycleOf_apply
 -/
 
@@ -1459,9 +1437,7 @@ theorem isCycle_cycleOf (f : Perm α) (hx : f x ≠ x) : IsCycle (cycleOf f x) :
       if hxy : SameCycle f x y then
         let ⟨i, hi⟩ := hxy
         ⟨i, by rw [cycle_of_zpow_apply_self, hi]⟩
-      else by
-        rw [cycle_of_apply_of_not_same_cycle hxy] at h
-        exact (h rfl).elim⟩
+      else by rw [cycle_of_apply_of_not_same_cycle hxy] at h; exact (h rfl).elim⟩
 #align equiv.perm.is_cycle_cycle_of Equiv.Perm.isCycle_cycleOf
 -/
 
@@ -1599,10 +1575,8 @@ theorem isCycle_cycleOf_iff (f : Perm α) : IsCycle (cycleOf f x) ↔ f x ≠ x
 
 #print Equiv.Perm.isCycleOn_support_cycleOf /-
 theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleOf x).support :=
-  ⟨f.BijOn <| by simp [mem_support_cycle_of_iff], fun a ha b hb =>
-    by
-    rw [mem_coe, mem_support_cycle_of_iff] at ha hb
-    exact ha.1.symm.trans hb.1⟩
+  ⟨f.BijOn <| by simp [mem_support_cycle_of_iff], fun a ha b hb => by
+    rw [mem_coe, mem_support_cycle_of_iff] at ha hb; exact ha.1.symm.trans hb.1⟩
 #align equiv.perm.is_cycle_on_support_cycle_of Equiv.Perm.isCycleOn_support_cycleOf
 -/
 
@@ -1662,8 +1636,7 @@ def cycleFactorsAux [Fintype α] :
       by
       simp only [imp_false, List.Pairwise.nil, List.not_mem_nil, forall_const, and_true_iff,
         forall_prop_of_false, Classical.not_not, not_false_iff, List.prod_nil] at *
-      ext
-      simp [*]⟩
+      ext; simp [*]⟩
   | x::l, f, h =>
     if hx : f x = x then
       cycle_factors_aux l f fun y hy => List.mem_of_ne_of_mem (fun h => hy (by rwa [h])) (h hy)
@@ -1671,17 +1644,13 @@ def cycleFactorsAux [Fintype α] :
       let ⟨m, hm₁, hm₂, hm₃⟩ :=
         cycle_factors_aux l ((cycleOf f x)⁻¹ * f) fun y hy =>
           List.mem_of_ne_of_mem
-            (fun h : y = x =>
-              by
-              rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycle_of_apply_self] at hy
-              exact hy rfl)
+            (fun h : y = x => by
+              rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycle_of_apply_self] at hy; exact hy rfl)
             (h fun h : f y = y =>
               by
               rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycle_of_apply] at hy
               split_ifs  at hy <;> cc)
-      ⟨cycleOf f x::m, by
-        rw [List.prod_cons, hm₁]
-        simp, fun g hg =>
+      ⟨cycleOf f x::m, by rw [List.prod_cons, hm₁]; simp, fun g hg =>
         ((List.mem_cons _ _ _).1 hg).elim (fun hg => hg.symm ▸ isCycle_cycleOf _ hx) (hm₂ g),
         List.pairwise_cons.2
           ⟨fun g hg y =>
@@ -2174,8 +2143,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
     induction' n with n ih
     · exact subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _))
     · convert H.mul_mem (H.mul_mem h3 ih) (H.inv_mem h3)
-      simp_rw [mul_swap_eq_swap_mul, mul_inv_cancel_right, pow_succ]
-      rfl
+      simp_rw [mul_swap_eq_swap_mul, mul_inv_cancel_right, pow_succ]; rfl
   have step2 : ∀ n : ℕ, swap x ((σ ^ n) x) ∈ H :=
     by
     intro n
@@ -2183,11 +2151,9 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
     · convert H.one_mem
       exact swap_self x
     · by_cases h5 : x = (σ ^ n) x
-      · rw [pow_succ, mul_apply, ← h5]
-        exact h4
+      · rw [pow_succ, mul_apply, ← h5]; exact h4
       by_cases h6 : x = (σ ^ (n + 1)) x
-      · rw [← h6, swap_self]
-        exact H.one_mem
+      · rw [← h6, swap_self]; exact H.one_mem
       rw [swap_comm, ← swap_mul_swap_mul_swap h5 h6]
       exact H.mul_mem (H.mul_mem (step1 n) ih) (step1 n)
   have step3 : ∀ y : α, swap x y ∈ H := by
@@ -2202,11 +2168,9 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
   have step4 : ∀ y z : α, swap y z ∈ H := by
     intro y z
     by_cases h5 : z = x
-    · rw [h5, swap_comm]
-      exact step3 y
+    · rw [h5, swap_comm]; exact step3 y
     by_cases h6 : z = y
-    · rw [h6, swap_self]
-      exact H.one_mem
+    · rw [h6, swap_self]; exact H.one_mem
     rw [← swap_mul_swap_mul_swap h5 h6, swap_comm z x]
     exact H.mul_mem (H.mul_mem (step3 y) (step3 z)) (step3 y)
   rw [eq_top_iff, ← closure_is_swap, closure_le]
@@ -2605,10 +2569,8 @@ but is expected to have type
   forall {ι : Type.{u3}} {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semiring.{u1} α] [_inst_2 : AddCommMonoid.{u2} β] [_inst_3 : Module.{u1, u2} α β _inst_1 _inst_2] {s : Finset.{u3} ι} {σ : Equiv.Perm.{succ u3} ι}, (Equiv.Perm.IsCycleOn.{u3} ι σ (Finset.toSet.{u3} ι s)) -> (forall (f : ι -> α) (g : ι -> β), Eq.{succ u2} β (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (Finset.sum.{u1, u3} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => g i))) (Finset.sum.{u2, 0} β Nat _inst_2 (Finset.range (Finset.card.{u3} ι s)) (fun (k : Nat) => Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (f i) (g (FunLike.coe.{succ u3, succ u3, succ u3} (Equiv.Perm.{succ u3} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u3, succ u3} ι ι) (HPow.hPow.{u3, 0, u3} (Equiv.Perm.{succ u3} ι) Nat (Equiv.Perm.{succ u3} ι) (instHPow.{u3, 0} (Equiv.Perm.{succ u3} ι) Nat (Monoid.Pow.{u3} (Equiv.Perm.{succ u3} ι) (DivInvMonoid.toMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Group.toDivInvMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Equiv.Perm.permGroup.{u3} ι))))) σ k) i))))))
 Case conversion may be inaccurate. Consider using '#align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_permₓ'. -/
 theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
-    ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) :=
-  by
-  simp_rw [sum_smul_sum, product_self_eq_disj_Union_perm hσ, sum_disj_Union, sum_map]
-  rfl
+    ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) := by
+  simp_rw [sum_smul_sum, product_self_eq_disj_Union_perm hσ, sum_disj_Union, sum_map]; rfl
 #align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_perm
 
 /- warning: finset.sum_mul_sum_eq_sum_perm -> Finset.sum_mul_sum_eq_sum_perm is a dubious translation:

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

@@ -592,10 +592,7 @@ theorem IsCycle.zpowersEquivSupport_apply {σ : Perm α} (hσ : IsCycle σ) {n :
 -/
 
 /- warning: equiv.perm.is_cycle.zpowers_equiv_support_symm_apply -> Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (fun (_x : Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) => (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasMem.{u1} (Equiv.Perm.{succ u1} α)) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) σ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) (Nat.cast.{0} Int instNatCastInt n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) σ (Nat.cast.{0} Int instNatCastInt n)))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_applyₓ'. -/
 @[simp]
 theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ) (n : ℕ) :

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

@@ -161,7 +161,7 @@ alias same_cycle_inv ↔ same_cycle.of_inv same_cycle.inv
 lean 3 declaration is
   forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g)) x y) (Equiv.Perm.SameCycle.{u1} α f (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g) x) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g) y))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g)) x y) (Equiv.Perm.SameCycle.{u1} α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g) y))
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g)) x y) (Equiv.Perm.SameCycle.{u1} α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g) y))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle_conj Equiv.Perm.sameCycle_conjₓ'. -/
 @[simp]
 theorem sameCycle_conj : SameCycle (g * f * g⁻¹) x y ↔ SameCycle f (g⁻¹ x) (g⁻¹ y) :=
@@ -321,7 +321,7 @@ alias same_cycle_extend_domain ↔ _ same_cycle.extend_domain
 lean 3 declaration is
   forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α} [_inst_1 : Finite.{succ u1} α], (Equiv.Perm.SameCycle.{u1} α f x y) -> (Exists.{1} Nat (fun (i : Nat) => Exists.{0} (LT.lt.{0} Nat Nat.hasLt i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (fun (H : LT.lt.{0} Nat Nat.hasLt i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f i) x) y)))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α} [_inst_1 : Finite.{succ u1} α], (Equiv.Perm.SameCycle.{u1} α f x y) -> (Exists.{1} Nat (fun (i : Nat) => And (LT.lt.{0} Nat instLTNat i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f i) x) y)))
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α} [_inst_1 : Finite.{succ u1} α], (Equiv.Perm.SameCycle.{u1} α f x y) -> (Exists.{1} Nat (fun (i : Nat) => And (LT.lt.{0} Nat instLTNat i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f i) x) y)))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'ₓ'. -/
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
   classical
@@ -595,7 +595,7 @@ theorem IsCycle.zpowersEquivSupport_apply {σ : Perm α} (hσ : IsCycle σ) {n :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (fun (_x : Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) => (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasMem.{u1} (Equiv.Perm.{succ u1} α)) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) σ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) (Nat.cast.{0} Int instNatCastInt n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) σ (Nat.cast.{0} Int instNatCastInt n)))))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) (Nat.cast.{0} Int instNatCastInt n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) σ (Nat.cast.{0} Int instNatCastInt n)))))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_applyₓ'. -/
 @[simp]
 theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ) (n : ℕ) :
@@ -712,7 +712,7 @@ theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCy
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} α) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2) f) (Neg.neg.{0} (Units.{0} Int Int.monoid) (Units.hasNeg.{0} Int Int.monoid (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring)))) (HPow.hPow.{0, 0, 0} (Units.{0} Int Int.monoid) Nat (Units.{0} Int Int.monoid) (instHPow.{0, 0} (Units.{0} Int Int.monoid) Nat (Monoid.Pow.{0} (Units.{0} Int Int.monoid) (DivInvMonoid.toMonoid.{0} (Units.{0} Int Int.monoid) (Group.toDivInvMonoid.{0} (Units.{0} Int Int.monoid) (Units.group.{0} Int Int.monoid))))) (Neg.neg.{0} (Units.{0} Int Int.monoid) (Units.hasNeg.{0} Int Int.monoid (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring)))) (OfNat.ofNat.{0} (Units.{0} Int Int.monoid) 1 (OfNat.mk.{0} (Units.{0} Int Int.monoid) 1 (One.one.{0} (Units.{0} Int Int.monoid) (MulOneClass.toHasOne.{0} (Units.{0} Int Int.monoid) (Units.mulOneClass.{0} Int Int.monoid)))))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.Perm.{succ u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toMul.{0} (Units.{0} Int Int.instMonoidInt) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (MonoidHomClass.toMulHomClass.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2) f) (Neg.neg.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (HPow.hPow.{0, 0, 0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) Nat ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (instHPow.{0, 0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) Nat (Monoid.Pow.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivInvMonoid.toMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Group.toDivInvMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instGroupUnits.{0} Int Int.instMonoidInt))))) (Neg.neg.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (OfNat.ofNat.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) 1 (One.toOfNat1.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (InvOneClass.toOne.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivInvOneMonoid.toInvOneClass.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivisionMonoid.toDivInvOneMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivisionCommMonoid.toDivisionMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (CommGroup.toDivisionCommMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instCommGroupUnitsToMonoid.{0} Int Int.instCommMonoidInt))))))))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)))))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.Perm.{succ u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toMul.{0} (Units.{0} Int Int.instMonoidInt) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (MonoidHomClass.toMulHomClass.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2) f) (Neg.neg.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (HPow.hPow.{0, 0, 0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) Nat ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (instHPow.{0, 0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) Nat (Monoid.Pow.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivInvMonoid.toMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Group.toDivInvMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instGroupUnits.{0} Int Int.instMonoidInt))))) (Neg.neg.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (OfNat.ofNat.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) 1 (One.toOfNat1.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (InvOneClass.toOne.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivInvOneMonoid.toInvOneClass.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivisionMonoid.toDivInvOneMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivisionCommMonoid.toDivisionMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (CommGroup.toDivisionCommMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instCommGroupUnitsToMonoid.{0} Int Int.instCommMonoidInt))))))))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)))))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.signₓ'. -/
 theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.support.card
   | f => fun hf =>
@@ -880,7 +880,7 @@ theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
 lean 3 declaration is
   forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))) (Exists.{succ u1} β (fun (x : β) => And (Ne.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) f x) x) (Eq.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x))))
 but is expected to have type
-  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) (Exists.{succ u1} β (fun (x : β) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) f x) x) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x))))
+  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) (Exists.{succ u1} β (fun (x : β) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) f x) x) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x))))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iffₓ'. -/
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
@@ -912,7 +912,7 @@ theorem IsCycle.pow_eq_one_iff' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
 lean 3 declaration is
   forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))) (forall (x : β), (Ne.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) f x) x) -> (Eq.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x)))
 but is expected to have type
-  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) (forall (x : β), (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) f x) x) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x)))
+  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) (forall (x : β), (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) f x) x) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x)))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.pow_eq_one_iff'' Equiv.Perm.IsCycle.pow_eq_one_iff''ₓ'. -/
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
@@ -1199,7 +1199,7 @@ theorem IsCycleOn.pow_card_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a 
 lean 3 declaration is
   forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {a : α} {b : α} {s : Finset.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) b s) -> (Exists.{1} Nat (fun (n : Nat) => Exists.{0} (LT.lt.{0} Nat Nat.hasLt n (Finset.card.{u1} α s)) (fun (H : LT.lt.{0} Nat Nat.hasLt n (Finset.card.{u1} α s)) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f n) a) b)))
 but is expected to have type
-  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {a : α} {b : α} {s : Finset.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f (Finset.toSet.{u1} α s)) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) b s) -> (Exists.{1} Nat (fun (n : Nat) => And (LT.lt.{0} Nat instLTNat n (Finset.card.{u1} α s)) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f n) a) b)))
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {a : α} {b : α} {s : Finset.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f (Finset.toSet.{u1} α s)) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) b s) -> (Exists.{1} Nat (fun (n : Nat) => And (LT.lt.{0} Nat instLTNat n (Finset.card.{u1} α s)) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f n) a) b)))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eqₓ'. -/
 theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
     ∃ n < s.card, (f ^ n) a = b := by
@@ -1401,7 +1401,7 @@ theorem IsCycle.cycleOf_eq (hf : IsCycle f) (hx : f x ≠ x) : cycleOf f x = f :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {x : α} (f : Equiv.Perm.{succ u1} α), Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))) (Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) f x) x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {x : α} (f : Equiv.Perm.{succ u1} α), Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) f x) x)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {x : α} (f : Equiv.Perm.{succ u1} α), Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) f x) x)
 Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_eq_one_iff Equiv.Perm.cycleOf_eq_one_iffₓ'. -/
 @[simp]
 theorem cycleOf_eq_one_iff (f : Perm α) : cycleOf f x = 1 ↔ f x = x :=
@@ -1499,7 +1499,7 @@ theorem pow_apply_eq_pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f g) -> (forall (x : α), (Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) g x) x) -> (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f g) -> (forall (x : α), (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) g x) x) -> (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f g) -> (forall (x : α), (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) g x) x) -> (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_mul_of_apply_right_eq_self Equiv.Perm.cycleOf_mul_of_apply_right_eq_selfₓ'. -/
 theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x = x) :
     (f * g).cycleOf x = f.cycleOf x := by
@@ -2163,7 +2163,7 @@ variable [Fintype α]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Top.top.{u1} (Finset.{u1} α) (BooleanAlgebra.toHasTop.{u1} (Finset.{u1} α) (Finset.booleanAlgebra.{u1} α _inst_3 (fun (a : α) (b : α) => _inst_1 a b))))) -> (forall (x : α), Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasInsert.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasSingleton.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x))))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.hasTop.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Top.top.{u1} (Finset.{u1} α) (BooleanAlgebra.toTop.{u1} (Finset.{u1} α) (Finset.booleanAlgebra.{u1} α _inst_3 (fun (a : α) (b : α) => _inst_1 a b))))) -> (forall (x : α), Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instInsertSet.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instSingletonSet.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x))))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.instTopSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Top.top.{u1} (Finset.{u1} α) (BooleanAlgebra.toTop.{u1} (Finset.{u1} α) (Finset.booleanAlgebra.{u1} α _inst_3 (fun (a : α) (b : α) => _inst_1 a b))))) -> (forall (x : α), Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instInsertSet.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instSingletonSet.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x))))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.instTopSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swapₓ'. -/
 theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.support = ⊤) (x : α) :
     closure ({σ, swap x (σ x)} : Set (Perm α)) = ⊤ :=
@@ -2418,7 +2418,7 @@ section FixedPoints
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Ne.{succ u1} (Equiv.Perm.{succ u1} α) σ (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))) -> (LT.lt.{0} Nat Nat.hasLt (Finset.card.{u1} α (Finset.filter.{u1} α (fun (x : α) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (fun (a : α) => _inst_1 (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ a) a) (Finset.univ.{u1} α _inst_2))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) (Fintype.card.{u1} α _inst_2) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Ne.{succ u1} (Equiv.Perm.{succ u1} α) σ (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) -> (LT.lt.{0} Nat instLTNat (Finset.card.{u1} α (Finset.filter.{u1} α (fun (x : α) => Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (fun (a : α) => _inst_1 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ a) a) (Finset.univ.{u1} α _inst_2))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) (Fintype.card.{u1} α _inst_2) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Ne.{succ u1} (Equiv.Perm.{succ u1} α) σ (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) -> (LT.lt.{0} Nat instLTNat (Finset.card.{u1} α (Finset.filter.{u1} α (fun (x : α) => Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (fun (a : α) => _inst_1 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ a) a) (Finset.univ.{u1} α _inst_2))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) (Fintype.card.{u1} α _inst_2) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.fixed_point_card_lt_of_ne_one Equiv.Perm.fixed_point_card_lt_of_ne_oneₓ'. -/
 theorem fixed_point_card_lt_of_ne_one [Fintype α] {σ : Perm α} (h : σ ≠ 1) :
     (filter (fun x => σ x = x) univ).card < Fintype.card α - 1 :=
@@ -2503,7 +2503,7 @@ variable {f : Perm α} {s : Set α}
 lean 3 declaration is
   forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Countable.{u1} α s) -> (Exists.{succ u1} (Equiv.Perm.{succ u1} α) (fun (f : Equiv.Perm.{succ u1} α) => And (Equiv.Perm.IsCycleOn.{u1} α f s) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (setOf.{u1} α (fun (x : α) => Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) f x) x)) s)))
 but is expected to have type
-  forall {α : Type.{u1}} [s : DecidableEq.{succ u1} α] {hs : Set.{u1} α}, (Set.Countable.{u1} α hs) -> (Exists.{succ u1} (Equiv.Perm.{succ u1} α) (fun (f : Equiv.Perm.{succ u1} α) => And (Equiv.Perm.IsCycleOn.{u1} α f hs) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (setOf.{u1} α (fun (x : α) => Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) f x) x)) hs)))
+  forall {α : Type.{u1}} [s : DecidableEq.{succ u1} α] {hs : Set.{u1} α}, (Set.Countable.{u1} α hs) -> (Exists.{succ u1} (Equiv.Perm.{succ u1} α) (fun (f : Equiv.Perm.{succ u1} α) => And (Equiv.Perm.IsCycleOn.{u1} α f hs) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (setOf.{u1} α (fun (x : α) => Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) f x) x)) hs)))
 Case conversion may be inaccurate. Consider using '#align set.countable.exists_cycle_on Set.Countable.exists_cycleOnₓ'. -/
 theorem Countable.exists_cycleOn (hs : s.Countable) :
     ∃ f : Perm α, f.IsCycleOn s ∧ { x | f x ≠ x } ⊆ s := by
@@ -2605,7 +2605,7 @@ variable [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : P
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Semiring.{u2} α] [_inst_2 : AddCommMonoid.{u3} β] [_inst_3 : Module.{u2, u3} α β _inst_1 _inst_2] {s : Finset.{u1} ι} {σ : Equiv.Perm.{succ u1} ι}, (Equiv.Perm.IsCycleOn.{u1} ι σ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} ι) (Set.{u1} ι) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (Finset.Set.hasCoeT.{u1} ι))) s)) -> (forall (f : ι -> α) (g : ι -> β), Eq.{succ u3} β (SMul.smul.{u2, u3} α β (SMulZeroClass.toHasSmul.{u2, u3} α β (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (SMulWithZero.toSmulZeroClass.{u2, u3} α β (MulZeroClass.toHasZero.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α (MonoidWithZero.toMulZeroOneClass.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1)))) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (MulActionWithZero.toSMulWithZero.{u2, u3} α β (Semiring.toMonoidWithZero.{u2} α _inst_1) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (Module.toMulActionWithZero.{u2, u3} α β _inst_1 _inst_2 _inst_3)))) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u3, u1} β ι _inst_2 s (fun (i : ι) => g i))) (Finset.sum.{u3, 0} β Nat _inst_2 (Finset.range (Finset.card.{u1} ι s)) (fun (k : Nat) => Finset.sum.{u3, u1} β ι _inst_2 s (fun (i : ι) => SMul.smul.{u2, u3} α β (SMulZeroClass.toHasSmul.{u2, u3} α β (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (SMulWithZero.toSmulZeroClass.{u2, u3} α β (MulZeroClass.toHasZero.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α (MonoidWithZero.toMulZeroOneClass.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1)))) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (MulActionWithZero.toSMulWithZero.{u2, u3} α β (Semiring.toMonoidWithZero.{u2} α _inst_1) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (Module.toMulActionWithZero.{u2, u3} α β _inst_1 _inst_2 _inst_3)))) (f i) (g (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} ι) Nat (Equiv.Perm.{succ u1} ι) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} ι) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} ι) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Equiv.Perm.permGroup.{u1} ι))))) σ k) i))))))
 but is expected to have type
-  forall {ι : Type.{u3}} {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semiring.{u1} α] [_inst_2 : AddCommMonoid.{u2} β] [_inst_3 : Module.{u1, u2} α β _inst_1 _inst_2] {s : Finset.{u3} ι} {σ : Equiv.Perm.{succ u3} ι}, (Equiv.Perm.IsCycleOn.{u3} ι σ (Finset.toSet.{u3} ι s)) -> (forall (f : ι -> α) (g : ι -> β), Eq.{succ u2} β (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (Finset.sum.{u1, u3} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => g i))) (Finset.sum.{u2, 0} β Nat _inst_2 (Finset.range (Finset.card.{u3} ι s)) (fun (k : Nat) => Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (f i) (g (FunLike.coe.{succ u3, succ u3, succ u3} (Equiv.Perm.{succ u3} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u3, succ u3} ι ι) (HPow.hPow.{u3, 0, u3} (Equiv.Perm.{succ u3} ι) Nat (Equiv.Perm.{succ u3} ι) (instHPow.{u3, 0} (Equiv.Perm.{succ u3} ι) Nat (Monoid.Pow.{u3} (Equiv.Perm.{succ u3} ι) (DivInvMonoid.toMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Group.toDivInvMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Equiv.Perm.permGroup.{u3} ι))))) σ k) i))))))
+  forall {ι : Type.{u3}} {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semiring.{u1} α] [_inst_2 : AddCommMonoid.{u2} β] [_inst_3 : Module.{u1, u2} α β _inst_1 _inst_2] {s : Finset.{u3} ι} {σ : Equiv.Perm.{succ u3} ι}, (Equiv.Perm.IsCycleOn.{u3} ι σ (Finset.toSet.{u3} ι s)) -> (forall (f : ι -> α) (g : ι -> β), Eq.{succ u2} β (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (Finset.sum.{u1, u3} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => g i))) (Finset.sum.{u2, 0} β Nat _inst_2 (Finset.range (Finset.card.{u3} ι s)) (fun (k : Nat) => Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (f i) (g (FunLike.coe.{succ u3, succ u3, succ u3} (Equiv.Perm.{succ u3} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u3, succ u3} ι ι) (HPow.hPow.{u3, 0, u3} (Equiv.Perm.{succ u3} ι) Nat (Equiv.Perm.{succ u3} ι) (instHPow.{u3, 0} (Equiv.Perm.{succ u3} ι) Nat (Monoid.Pow.{u3} (Equiv.Perm.{succ u3} ι) (DivInvMonoid.toMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Group.toDivInvMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Equiv.Perm.permGroup.{u3} ι))))) σ k) i))))))
 Case conversion may be inaccurate. Consider using '#align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_permₓ'. -/
 theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
     ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) :=
@@ -2618,7 +2618,7 @@ theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Semiring.{u2} α] {s : Finset.{u1} ι} {σ : Equiv.Perm.{succ u1} ι}, (Equiv.Perm.IsCycleOn.{u1} ι σ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} ι) (Set.{u1} ι) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (Finset.Set.hasCoeT.{u1} ι))) s)) -> (forall (f : ι -> α) (g : ι -> α), Eq.{succ u2} α (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))))) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => g i))) (Finset.sum.{u2, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) (Finset.range (Finset.card.{u1} ι s)) (fun (k : Nat) => Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))))) (f i) (g (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} ι) Nat (Equiv.Perm.{succ u1} ι) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} ι) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} ι) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Equiv.Perm.permGroup.{u1} ι))))) σ k) i))))))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Semiring.{u1} α] {s : Finset.{u2} ι} {σ : Equiv.Perm.{succ u2} ι}, (Equiv.Perm.IsCycleOn.{u2} ι σ (Finset.toSet.{u2} ι s)) -> (forall (f : ι -> α) (g : ι -> α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => g i))) (Finset.sum.{u1, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) (Finset.range (Finset.card.{u2} ι s)) (fun (k : Nat) => Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (f i) (g (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} ι ι) (HPow.hPow.{u2, 0, u2} (Equiv.Perm.{succ u2} ι) Nat (Equiv.Perm.{succ u2} ι) (instHPow.{u2, 0} (Equiv.Perm.{succ u2} ι) Nat (Monoid.Pow.{u2} (Equiv.Perm.{succ u2} ι) (DivInvMonoid.toMonoid.{u2} (Equiv.Perm.{succ u2} ι) (Group.toDivInvMonoid.{u2} (Equiv.Perm.{succ u2} ι) (Equiv.Perm.permGroup.{u2} ι))))) σ k) i))))))
+  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Semiring.{u1} α] {s : Finset.{u2} ι} {σ : Equiv.Perm.{succ u2} ι}, (Equiv.Perm.IsCycleOn.{u2} ι σ (Finset.toSet.{u2} ι s)) -> (forall (f : ι -> α) (g : ι -> α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => g i))) (Finset.sum.{u1, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) (Finset.range (Finset.card.{u2} ι s)) (fun (k : Nat) => Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (f i) (g (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} ι ι) (HPow.hPow.{u2, 0, u2} (Equiv.Perm.{succ u2} ι) Nat (Equiv.Perm.{succ u2} ι) (instHPow.{u2, 0} (Equiv.Perm.{succ u2} ι) Nat (Monoid.Pow.{u2} (Equiv.Perm.{succ u2} ι) (DivInvMonoid.toMonoid.{u2} (Equiv.Perm.{succ u2} ι) (Group.toDivInvMonoid.{u2} (Equiv.Perm.{succ u2} ι) (Equiv.Perm.permGroup.{u2} ι))))) σ k) i))))))
 Case conversion may be inaccurate. Consider using '#align finset.sum_mul_sum_eq_sum_perm Finset.sum_mul_sum_eq_sum_permₓ'. -/
 theorem sum_mul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f g : ι → α) :
     ((∑ i in s, f i) * ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i * g ((σ ^ k) i) :=

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

@@ -1534,7 +1534,12 @@ theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.sup
 #align equiv.perm.support_cycle_of_eq_nil_iff Equiv.Perm.support_cycleOf_eq_nil_iff
 -/
 
-#print Equiv.Perm.support_cycleOf_le /-
+/- warning: equiv.perm.support_cycle_of_le -> Equiv.Perm.support_cycleOf_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (x : α), LE.le.{u1} (Finset.{u1} α) (Preorder.toHasLe.{u1} (Finset.{u1} α) (PartialOrder.toPreorder.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (x : α), LE.le.{u1} (Finset.{u1} α) (Preorder.toLE.{u1} (Finset.{u1} α) (PartialOrder.toPreorder.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_leₓ'. -/
 theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ support f :=
   by
   intro y hy
@@ -1543,7 +1548,6 @@ theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ su
   · exact mem_support.mpr hy
   · exact absurd rfl hy
 #align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_le
--/
 
 #print Equiv.Perm.mem_support_cycleOf_iff /-
 theorem mem_support_cycleOf_iff : y ∈ support (f.cycleOf x) ↔ SameCycle f x y ∧ x ∈ support f :=
@@ -1909,14 +1913,18 @@ theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
 #align equiv.perm.cycle_of_mem_cycle_factors_finset_iff Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff
 -/
 
-#print Equiv.Perm.mem_cycleFactorsFinset_support_le /-
+/- warning: equiv.perm.mem_cycle_factors_finset_support_le -> Equiv.Perm.mem_cycleFactorsFinset_support_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {p : Equiv.Perm.{succ u1} α} {f : Equiv.Perm.{succ u1} α}, (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasMem.{u1} (Equiv.Perm.{succ u1} α)) p (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) -> (LE.le.{u1} (Finset.{u1} α) (Preorder.toHasLe.{u1} (Finset.{u1} α) (PartialOrder.toPreorder.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 p) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {p : Equiv.Perm.{succ u1} α} {f : Equiv.Perm.{succ u1} α}, (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instMembershipFinset.{u1} (Equiv.Perm.{succ u1} α)) p (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) -> (LE.le.{u1} (Finset.{u1} α) (Preorder.toLE.{u1} (Finset.{u1} α) (PartialOrder.toPreorder.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 p) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_leₓ'. -/
 theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactorsFinset f) :
     p.support ≤ f.support := by
   rw [mem_cycle_factors_finset_iff] at h
   intro x hx
   rwa [mem_support, ← h.right x hx, ← mem_support]
 #align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_le
--/
 
 /- warning: equiv.perm.cycle_factors_finset_eq_empty_iff -> Equiv.Perm.cycleFactorsFinset_eq_empty_iff is a dubious translation:
 lean 3 declaration is

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

@@ -2519,8 +2519,8 @@ theorem Countable.exists_cycleOn (hs : s.Countable) :
 #align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print Set.prod_self_eq_unionᵢ_perm /-
-theorem prod_self_eq_unionᵢ_perm (hf : f.IsCycleOn s) :
+#print Set.prod_self_eq_iUnion_perm /-
+theorem prod_self_eq_iUnion_perm (hf : f.IsCycleOn s) :
     s ×ˢ s = ⋃ n : ℤ, (fun a => (a, (f ^ n) a)) '' s :=
   by
   ext ⟨a, b⟩
@@ -2530,7 +2530,7 @@ theorem prod_self_eq_unionᵢ_perm (hf : f.IsCycleOn s) :
     exact ⟨_, _, hx.1, rfl⟩
   · rintro ⟨n, a, ha, ⟨⟩⟩
     exact ⟨ha, (hf.1.perm_zpow _).MapsTo ha⟩
-#align set.prod_self_eq_Union_perm Set.prod_self_eq_unionᵢ_perm
+#align set.prod_self_eq_Union_perm Set.prod_self_eq_iUnion_perm
 -/
 
 end Set

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

@@ -595,7 +595,7 @@ theorem IsCycle.zpowersEquivSupport_apply {σ : Perm α} (hσ : IsCycle σ) {n :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (fun (_x : Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) => (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasMem.{u1} (Equiv.Perm.{succ u1} α)) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) σ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) (Nat.cast.{0} Int instNatCastInt n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) σ (Nat.cast.{0} Int instNatCastInt n)))))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) (Nat.cast.{0} Int instNatCastInt n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) σ (Nat.cast.{0} Int instNatCastInt n)))))
 Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_applyₓ'. -/
 @[simp]
 theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ) (n : ℕ) :

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Yaël Dillies
 
 ! This file was ported from Lean 3 source module group_theory.perm.cycle.basic
-! leanprover-community/mathlib commit 932872382355f00112641d305ba0619305dc8642
+! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -1166,7 +1166,7 @@ theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
   | Int.ofNat n => (hf.pow_apply_eq ha).trans Int.coe_nat_dvd.symm
   | Int.negSucc n => by
     rw [zpow_negSucc, ← inv_pow]
-    exact (hf.inv.pow_apply_eq ha).trans ((dvd_neg _ _).trans Int.coe_nat_dvd).symm
+    exact (hf.inv.pow_apply_eq ha).trans (dvd_neg.trans Int.coe_nat_dvd).symm
 #align equiv.perm.is_cycle_on.zpow_apply_eq Equiv.Perm.IsCycleOn.zpow_apply_eq
 -/
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/1f4705ccdfe1e557fc54a0ce081a05e33d2e6240

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Yaël Dillies
 
 ! This file was ported from Lean 3 source module group_theory.perm.cycle.basic
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
+! leanprover-community/mathlib commit 932872382355f00112641d305ba0619305dc8642
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -19,6 +19,9 @@ import Mathbin.Logic.Equiv.Fintype
 /-!
 # Cyclic permutations
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file develops the theory of cycles in permutations.
 
 ## Main definitions

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

@@ -72,112 +72,180 @@ section SameCycle
 
 variable {f g : Perm α} {p : α → Prop} {x y z : α}
 
+#print Equiv.Perm.SameCycle /-
 /-- The equivalence relation indicating that two points are in the same cycle of a permutation. -/
 def SameCycle (f : Perm α) (x y : α) : Prop :=
   ∃ i : ℤ, (f ^ i) x = y
 #align equiv.perm.same_cycle Equiv.Perm.SameCycle
+-/
 
+#print Equiv.Perm.SameCycle.refl /-
 @[refl]
 theorem SameCycle.refl (f : Perm α) (x : α) : SameCycle f x x :=
   ⟨0, rfl⟩
 #align equiv.perm.same_cycle.refl Equiv.Perm.SameCycle.refl
+-/
 
+#print Equiv.Perm.SameCycle.rfl /-
 theorem SameCycle.rfl : SameCycle f x x :=
   SameCycle.refl _ _
 #align equiv.perm.same_cycle.rfl Equiv.Perm.SameCycle.rfl
+-/
 
+#print Eq.sameCycle /-
 protected theorem Eq.sameCycle (h : x = y) (f : Perm α) : f.SameCycle x y := by rw [h]
 #align eq.same_cycle Eq.sameCycle
+-/
 
+#print Equiv.Perm.SameCycle.symm /-
 @[symm]
 theorem SameCycle.symm : SameCycle f x y → SameCycle f y x := fun ⟨i, hi⟩ =>
   ⟨-i, by rw [zpow_neg, ← hi, inv_apply_self]⟩
 #align equiv.perm.same_cycle.symm Equiv.Perm.SameCycle.symm
+-/
 
+#print Equiv.Perm.sameCycle_comm /-
 theorem sameCycle_comm : SameCycle f x y ↔ SameCycle f y x :=
   ⟨SameCycle.symm, SameCycle.symm⟩
 #align equiv.perm.same_cycle_comm Equiv.Perm.sameCycle_comm
+-/
 
+#print Equiv.Perm.SameCycle.trans /-
 @[trans]
 theorem SameCycle.trans : SameCycle f x y → SameCycle f y z → SameCycle f x z :=
   fun ⟨i, hi⟩ ⟨j, hj⟩ => ⟨j + i, by rw [zpow_add, mul_apply, hi, hj]⟩
 #align equiv.perm.same_cycle.trans Equiv.Perm.SameCycle.trans
+-/
 
+/- warning: equiv.perm.same_cycle_one -> Equiv.Perm.sameCycle_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) x y) (Eq.{succ u1} α x y)
+but is expected to have type
+  forall {α : Type.{u1}} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) x y) (Eq.{succ u1} α x y)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle_one Equiv.Perm.sameCycle_oneₓ'. -/
 @[simp]
 theorem sameCycle_one : SameCycle 1 x y ↔ x = y := by simp [same_cycle]
 #align equiv.perm.same_cycle_one Equiv.Perm.sameCycle_one
 
+/- warning: equiv.perm.same_cycle_inv -> Equiv.Perm.sameCycle_inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) x y) (Equiv.Perm.SameCycle.{u1} α f x y)
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) x y) (Equiv.Perm.SameCycle.{u1} α f x y)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle_inv Equiv.Perm.sameCycle_invₓ'. -/
 @[simp]
 theorem sameCycle_inv : SameCycle f⁻¹ x y ↔ SameCycle f x y :=
   (Equiv.neg _).exists_congr_left.trans <| by simp [same_cycle]
 #align equiv.perm.same_cycle_inv Equiv.Perm.sameCycle_inv
 
+/- warning: equiv.perm.same_cycle.of_inv -> Equiv.Perm.SameCycle.of_inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) x y) -> (Equiv.Perm.SameCycle.{u1} α f x y)
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) x y) -> (Equiv.Perm.SameCycle.{u1} α f x y)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle.of_inv Equiv.Perm.SameCycle.of_invₓ'. -/
+/- warning: equiv.perm.same_cycle.inv -> Equiv.Perm.SameCycle.inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, (Equiv.Perm.SameCycle.{u1} α f x y) -> (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) x y)
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α}, (Equiv.Perm.SameCycle.{u1} α f x y) -> (Equiv.Perm.SameCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) x y)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle.inv Equiv.Perm.SameCycle.invₓ'. -/
 alias same_cycle_inv ↔ same_cycle.of_inv same_cycle.inv
 #align equiv.perm.same_cycle.of_inv Equiv.Perm.SameCycle.of_inv
 #align equiv.perm.same_cycle.inv Equiv.Perm.SameCycle.inv
 
+/- warning: equiv.perm.same_cycle_conj -> Equiv.Perm.sameCycle_conj is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g)) x y) (Equiv.Perm.SameCycle.{u1} α f (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g) x) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g) y))
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α} {x : α} {y : α}, Iff (Equiv.Perm.SameCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g)) x y) (Equiv.Perm.SameCycle.{u1} α f (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g) y))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle_conj Equiv.Perm.sameCycle_conjₓ'. -/
 @[simp]
 theorem sameCycle_conj : SameCycle (g * f * g⁻¹) x y ↔ SameCycle f (g⁻¹ x) (g⁻¹ y) :=
   exists_congr fun i => by simp [conj_zpow, eq_inv_iff_eq]
 #align equiv.perm.same_cycle_conj Equiv.Perm.sameCycle_conj
 
+#print Equiv.Perm.SameCycle.conj /-
 theorem SameCycle.conj : SameCycle f x y → SameCycle (g * f * g⁻¹) (g x) (g y) := by
   simp [same_cycle_conj]
 #align equiv.perm.same_cycle.conj Equiv.Perm.SameCycle.conj
+-/
 
+#print Equiv.Perm.SameCycle.apply_eq_self_iff /-
 theorem SameCycle.apply_eq_self_iff : SameCycle f x y → (f x = x ↔ f y = y) := fun ⟨i, hi⟩ => by
   rw [← hi, ← mul_apply, ← zpow_one_add, add_comm, zpow_add_one, mul_apply,
     (f ^ i).Injective.eq_iff]
 #align equiv.perm.same_cycle.apply_eq_self_iff Equiv.Perm.SameCycle.apply_eq_self_iff
+-/
 
+#print Equiv.Perm.SameCycle.eq_of_left /-
 theorem SameCycle.eq_of_left (h : SameCycle f x y) (hx : IsFixedPt f x) : x = y :=
   let ⟨n, hn⟩ := h
   (hx.perm_zpow _).Eq.symm.trans hn
 #align equiv.perm.same_cycle.eq_of_left Equiv.Perm.SameCycle.eq_of_left
+-/
 
+#print Equiv.Perm.SameCycle.eq_of_right /-
 theorem SameCycle.eq_of_right (h : SameCycle f x y) (hy : IsFixedPt f y) : x = y :=
   h.eq_of_left <| h.apply_eq_self_iff.2 hy
 #align equiv.perm.same_cycle.eq_of_right Equiv.Perm.SameCycle.eq_of_right
+-/
 
+#print Equiv.Perm.sameCycle_apply_left /-
 @[simp]
 theorem sameCycle_apply_left : SameCycle f (f x) y ↔ SameCycle f x y :=
   (Equiv.addRight 1).exists_congr_left.trans <| by simp [zpow_sub, same_cycle]
 #align equiv.perm.same_cycle_apply_left Equiv.Perm.sameCycle_apply_left
+-/
 
+#print Equiv.Perm.sameCycle_apply_right /-
 @[simp]
 theorem sameCycle_apply_right : SameCycle f x (f y) ↔ SameCycle f x y := by
   rw [same_cycle_comm, same_cycle_apply_left, same_cycle_comm]
 #align equiv.perm.same_cycle_apply_right Equiv.Perm.sameCycle_apply_right
+-/
 
+#print Equiv.Perm.sameCycle_inv_apply_left /-
 @[simp]
 theorem sameCycle_inv_apply_left : SameCycle f (f⁻¹ x) y ↔ SameCycle f x y := by
   rw [← same_cycle_apply_left, apply_inv_self]
 #align equiv.perm.same_cycle_inv_apply_left Equiv.Perm.sameCycle_inv_apply_left
+-/
 
+#print Equiv.Perm.sameCycle_inv_apply_right /-
 @[simp]
 theorem sameCycle_inv_apply_right : SameCycle f x (f⁻¹ y) ↔ SameCycle f x y := by
   rw [← same_cycle_apply_right, apply_inv_self]
 #align equiv.perm.same_cycle_inv_apply_right Equiv.Perm.sameCycle_inv_apply_right
+-/
 
+#print Equiv.Perm.sameCycle_zpow_left /-
 @[simp]
 theorem sameCycle_zpow_left {n : ℤ} : SameCycle f ((f ^ n) x) y ↔ SameCycle f x y :=
   (Equiv.addRight (n : ℤ)).exists_congr_left.trans <| by simp [same_cycle, zpow_add]
 #align equiv.perm.same_cycle_zpow_left Equiv.Perm.sameCycle_zpow_left
+-/
 
+#print Equiv.Perm.sameCycle_zpow_right /-
 @[simp]
 theorem sameCycle_zpow_right {n : ℤ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y := by
   rw [same_cycle_comm, same_cycle_zpow_left, same_cycle_comm]
 #align equiv.perm.same_cycle_zpow_right Equiv.Perm.sameCycle_zpow_right
+-/
 
+#print Equiv.Perm.sameCycle_pow_left /-
 @[simp]
 theorem sameCycle_pow_left {n : ℕ} : SameCycle f ((f ^ n) x) y ↔ SameCycle f x y := by
   rw [← zpow_ofNat, same_cycle_zpow_left]
 #align equiv.perm.same_cycle_pow_left Equiv.Perm.sameCycle_pow_left
+-/
 
+#print Equiv.Perm.sameCycle_pow_right /-
 @[simp]
 theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y := by
   rw [← zpow_ofNat, same_cycle_zpow_right]
 #align equiv.perm.same_cycle_pow_right Equiv.Perm.sameCycle_pow_right
+-/
 
 alias same_cycle_apply_left ↔ same_cycle.of_apply_left same_cycle.apply_left
 #align equiv.perm.same_cycle.of_apply_left Equiv.Perm.SameCycle.of_apply_left
@@ -211,33 +279,47 @@ alias same_cycle_zpow_right ↔ same_cycle.of_zpow_right same_cycle.zpow_right
 #align equiv.perm.same_cycle.of_zpow_right Equiv.Perm.SameCycle.of_zpow_right
 #align equiv.perm.same_cycle.zpow_right Equiv.Perm.SameCycle.zpow_right
 
+#print Equiv.Perm.SameCycle.of_pow /-
 theorem SameCycle.of_pow {n : ℕ} : SameCycle (f ^ n) x y → SameCycle f x y := fun ⟨m, h⟩ =>
   ⟨n * m, by simp [zpow_mul, h]⟩
 #align equiv.perm.same_cycle.of_pow Equiv.Perm.SameCycle.of_pow
+-/
 
+#print Equiv.Perm.SameCycle.of_zpow /-
 theorem SameCycle.of_zpow {n : ℤ} : SameCycle (f ^ n) x y → SameCycle f x y := fun ⟨m, h⟩ =>
   ⟨n * m, by simp [zpow_mul, h]⟩
 #align equiv.perm.same_cycle.of_zpow Equiv.Perm.SameCycle.of_zpow
+-/
 
+#print Equiv.Perm.sameCycle_subtypePerm /-
 @[simp]
 theorem sameCycle_subtypePerm {h} {x y : { x // p x }} :
     (f.subtypePerm h).SameCycle x y ↔ f.SameCycle x y :=
   exists_congr fun n => by simp [Subtype.ext_iff]
 #align equiv.perm.same_cycle_subtype_perm Equiv.Perm.sameCycle_subtypePerm
+-/
 
 alias same_cycle_subtype_perm ↔ _ same_cycle.subtype_perm
 #align equiv.perm.same_cycle.subtype_perm Equiv.Perm.SameCycle.subtypePerm
 
+#print Equiv.Perm.sameCycle_extendDomain /-
 @[simp]
 theorem sameCycle_extendDomain {p : β → Prop} [DecidablePred p] {f : α ≃ Subtype p} :
     SameCycle (g.extendDomain f) (f x) (f y) ↔ g.SameCycle x y :=
   exists_congr fun n => by
     rw [← extend_domain_zpow, extend_domain_apply_image, Subtype.coe_inj, f.injective.eq_iff]
 #align equiv.perm.same_cycle_extend_domain Equiv.Perm.sameCycle_extendDomain
+-/
 
 alias same_cycle_extend_domain ↔ _ same_cycle.extend_domain
 #align equiv.perm.same_cycle.extend_domain Equiv.Perm.SameCycle.extendDomain
 
+/- warning: equiv.perm.same_cycle.exists_pow_eq' -> Equiv.Perm.SameCycle.exists_pow_eq' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α} [_inst_1 : Finite.{succ u1} α], (Equiv.Perm.SameCycle.{u1} α f x y) -> (Exists.{1} Nat (fun (i : Nat) => Exists.{0} (LT.lt.{0} Nat Nat.hasLt i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (fun (H : LT.lt.{0} Nat Nat.hasLt i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f i) x) y)))
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {x : α} {y : α} [_inst_1 : Finite.{succ u1} α], (Equiv.Perm.SameCycle.{u1} α f x y) -> (Exists.{1} Nat (fun (i : Nat) => And (LT.lt.{0} Nat instLTNat i (orderOf.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f i) x) y)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'ₓ'. -/
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
   classical
     rintro ⟨k, rfl⟩
@@ -250,6 +332,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
     exact Int.emod_lt_of_pos _ h₀
 #align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'
 
+#print Equiv.Perm.SameCycle.exists_pow_eq'' /-
 theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
     ∃ (i : ℕ)(hpos : 0 < i)(h : i ≤ orderOf f), (f ^ i) x = y := by
   classical
@@ -258,6 +341,7 @@ theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
       rw [pow_orderOf_eq_one, pow_zero]
     · exact ⟨i.succ, i.zero_lt_succ, hi.le, rfl⟩
 #align equiv.perm.same_cycle.exists_pow_eq'' Equiv.Perm.SameCycle.exists_pow_eq''
+-/
 
 instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f) := fun x y =>
   decidable_of_iff (∃ n ∈ List.range (Fintype.card (Perm α)), (f ^ n) x = y)
@@ -289,19 +373,34 @@ section IsCycle
 
 variable {f g : Perm α} {x y : α}
 
+#print Equiv.Perm.IsCycle /-
 /-- A cycle is a non identity permutation where any two nonfixed points of the permutation are
 related by repeated application of the permutation. -/
 def IsCycle (f : Perm α) : Prop :=
   ∃ x, f x ≠ x ∧ ∀ ⦃y⦄, f y ≠ y → SameCycle f x y
 #align equiv.perm.is_cycle Equiv.Perm.IsCycle
+-/
 
+/- warning: equiv.perm.is_cycle.ne_one -> Equiv.Perm.IsCycle.ne_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Ne.{succ u1} (Equiv.Perm.{succ u1} α) f (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Ne.{succ u1} (Equiv.Perm.{succ u1} α) f (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.ne_one Equiv.Perm.IsCycle.ne_oneₓ'. -/
 theorem IsCycle.ne_one (h : IsCycle f) : f ≠ 1 := fun hf => by simpa [hf, is_cycle] using h
 #align equiv.perm.is_cycle.ne_one Equiv.Perm.IsCycle.ne_one
 
+/- warning: equiv.perm.not_is_cycle_one -> Equiv.Perm.not_isCycle_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}}, Not (Equiv.Perm.IsCycle.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))))
+but is expected to have type
+  forall {α : Type.{u1}}, Not (Equiv.Perm.IsCycle.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.not_is_cycle_one Equiv.Perm.not_isCycle_oneₓ'. -/
 @[simp]
 theorem not_isCycle_one : ¬(1 : Perm α).IsCycle := fun H => H.ne_one rfl
 #align equiv.perm.not_is_cycle_one Equiv.Perm.not_isCycle_one
 
+#print Equiv.Perm.IsCycle.sameCycle /-
 protected theorem IsCycle.sameCycle (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y) :
     SameCycle f x y :=
   let ⟨g, hg⟩ := hf
@@ -309,16 +408,31 @@ protected theorem IsCycle.sameCycle (hf : IsCycle f) (hx : f x ≠ x) (hy : f y
   let ⟨b, hb⟩ := hg.2 hy
   ⟨b - a, by rw [← ha, ← mul_apply, ← zpow_add, sub_add_cancel, hb]⟩
 #align equiv.perm.is_cycle.same_cycle Equiv.Perm.IsCycle.sameCycle
+-/
 
+#print Equiv.Perm.IsCycle.exists_zpow_eq /-
 theorem IsCycle.exists_zpow_eq : IsCycle f → f x ≠ x → f y ≠ y → ∃ i : ℤ, (f ^ i) x = y :=
   IsCycle.sameCycle
 #align equiv.perm.is_cycle.exists_zpow_eq Equiv.Perm.IsCycle.exists_zpow_eq
+-/
 
+/- warning: equiv.perm.is_cycle.inv -> Equiv.Perm.IsCycle.inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Equiv.Perm.IsCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f))
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Equiv.Perm.IsCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.inv Equiv.Perm.IsCycle.invₓ'. -/
 theorem IsCycle.inv (hf : IsCycle f) : IsCycle f⁻¹ :=
   hf.imp fun x ⟨hx, h⟩ =>
     ⟨inv_eq_iff_eq.Not.2 hx.symm, fun y hy => (h <| inv_eq_iff_eq.Not.2 hy.symm).inv⟩
 #align equiv.perm.is_cycle.inv Equiv.Perm.IsCycle.inv
 
+/- warning: equiv.perm.is_cycle_inv -> Equiv.Perm.isCycle_inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, Iff (Equiv.Perm.IsCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) (Equiv.Perm.IsCycle.{u1} α f)
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α}, Iff (Equiv.Perm.IsCycle.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f)) (Equiv.Perm.IsCycle.{u1} α f)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_inv Equiv.Perm.isCycle_invₓ'. -/
 @[simp]
 theorem isCycle_inv : IsCycle f⁻¹ ↔ IsCycle f :=
   ⟨fun h => by
@@ -326,6 +440,12 @@ theorem isCycle_inv : IsCycle f⁻¹ ↔ IsCycle f :=
     rw [inv_inv], IsCycle.inv⟩
 #align equiv.perm.is_cycle_inv Equiv.Perm.isCycle_inv
 
+/- warning: equiv.perm.is_cycle.conj -> Equiv.Perm.IsCycle.conj is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Equiv.Perm.IsCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) g)))
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Equiv.Perm.IsCycle.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g f) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) g)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.conj Equiv.Perm.IsCycle.conjₓ'. -/
 theorem IsCycle.conj : IsCycle f → IsCycle (g * f * g⁻¹) :=
   by
   rintro ⟨x, hx, h⟩
@@ -334,6 +454,7 @@ theorem IsCycle.conj : IsCycle f → IsCycle (g * f * g⁻¹) :=
   exact (h <| eq_inv_iff_eq.not.2 hy).conj
 #align equiv.perm.is_cycle.conj Equiv.Perm.IsCycle.conj
 
+#print Equiv.Perm.IsCycle.extendDomain /-
 protected theorem IsCycle.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p) :
     IsCycle g → IsCycle (g.extendDomain f) :=
   by
@@ -347,7 +468,9 @@ protected theorem IsCycle.extendDomain {p : β → Prop} [DecidablePred p] (f :
   simp only [extend_domain_apply_image, subtype.coe_injective.ne_iff, f.injective.ne_iff] at hb
   exact (ha' hb).extendDomain
 #align equiv.perm.is_cycle.extend_domain Equiv.Perm.IsCycle.extendDomain
+-/
 
+#print Equiv.Perm.isCycle_iff_sameCycle /-
 theorem isCycle_iff_sameCycle (hx : f x ≠ x) : IsCycle f ↔ ∀ {y}, SameCycle f x y ↔ f y ≠ y :=
   ⟨fun hf y =>
     ⟨fun ⟨i, hi⟩ hy =>
@@ -357,11 +480,13 @@ theorem isCycle_iff_sameCycle (hx : f x ≠ x) : IsCycle f ↔ ∀ {y}, SameCycl
       hf.exists_zpow_eq hx⟩,
     fun h => ⟨x, hx, fun y hy => h.2 hy⟩⟩
 #align equiv.perm.is_cycle_iff_same_cycle Equiv.Perm.isCycle_iff_sameCycle
+-/
 
 section Finite
 
 variable [Finite α]
 
+#print Equiv.Perm.IsCycle.exists_pow_eq /-
 theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y) :
     ∃ i : ℕ, (f ^ i) x = y := by
   let ⟨n, hn⟩ := hf.exists_zpow_eq hx hy
@@ -371,11 +496,13 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
         have := n.mod_nonneg (int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
         rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_eq_mod_orderOf]⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
+-/
 
 end Finite
 
 variable [DecidableEq α]
 
+#print Equiv.Perm.isCycle_swap /-
 theorem isCycle_swap (hxy : x ≠ y) : IsCycle (swap x y) :=
   ⟨y, by rwa [swap_apply_right], fun a (ha : ite (a = x) y (ite (a = y) x a) ≠ a) =>
     if hya : y = a then ⟨0, hya⟩
@@ -384,19 +511,30 @@ theorem isCycle_swap (hxy : x ≠ y) : IsCycle (swap x y) :=
         rw [zpow_one, swap_apply_def]
         split_ifs  at * <;> cc⟩⟩
 #align equiv.perm.is_cycle_swap Equiv.Perm.isCycle_swap
+-/
 
+#print Equiv.Perm.IsSwap.isCycle /-
 protected theorem IsSwap.isCycle : IsSwap f → IsCycle f :=
   by
   rintro ⟨x, y, hxy, rfl⟩
   exact is_cycle_swap hxy
 #align equiv.perm.is_swap.is_cycle Equiv.Perm.IsSwap.isCycle
+-/
 
 variable [Fintype α]
 
-theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.Support.card :=
+#print Equiv.Perm.IsCycle.two_le_card_support /-
+theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
   two_le_card_support_of_ne_one h.ne_one
 #align equiv.perm.is_cycle.two_le_card_support Equiv.Perm.IsCycle.two_le_card_support
+-/
 
+/- warning: equiv.perm.is_cycle.exists_pow_eq_one -> Equiv.Perm.IsCycle.exists_pow_eq_one is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (Exists.{1} Nat (fun (k : Nat) => Exists.{0} (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) k) (fun (hk : LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) k) => Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f k) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))))))
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (Exists.{1} Nat (fun (k : Nat) => Exists.{0} (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) k) (fun (hk : LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) k) => Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f k) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_oneₓ'. -/
 theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     ∃ (k : ℕ)(hk : 1 < k), f ^ k = 1 := by
   classical
@@ -410,9 +548,15 @@ theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
     · exact ⟨k + 2, by simp, hk'⟩
 #align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
 
+/- warning: equiv.perm.is_cycle.zpowers_equiv_support -> Equiv.Perm.IsCycle.zpowersEquivSupport is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Equiv.{succ u1, succ u1} (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.zpowers_equiv_support Equiv.Perm.IsCycle.zpowersEquivSupportₓ'. -/
 /-- The subgroup generated by a cycle is in bijection with its support -/
 noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ) :
-    (↑(Subgroup.zpowers σ) : Set (Perm α)) ≃ (↑σ.Support : Set α) :=
+    (↑(Subgroup.zpowers σ) : Set (Perm α)) ≃ (↑σ.support : Set α) :=
   Equiv.ofBijective
     (fun τ =>
       ⟨τ (Classical.choose hσ), by
@@ -434,6 +578,7 @@ noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ)
         exact ⟨⟨σ ^ n, n, rfl⟩, rfl⟩)
 #align equiv.perm.is_cycle.zpowers_equiv_support Equiv.Perm.IsCycle.zpowersEquivSupport
 
+#print Equiv.Perm.IsCycle.zpowersEquivSupport_apply /-
 @[simp]
 theorem IsCycle.zpowersEquivSupport_apply {σ : Perm α} (hσ : IsCycle σ) {n : ℕ} :
     hσ.zpowersEquivSupport ⟨σ ^ n, n, rfl⟩ =
@@ -441,7 +586,14 @@ theorem IsCycle.zpowersEquivSupport_apply {σ : Perm α} (hσ : IsCycle σ) {n :
         pow_apply_mem_support.2 (mem_support.2 (Classical.choose_spec hσ).1)⟩ :=
   rfl
 #align equiv.perm.is_cycle.zpowers_equiv_support_apply Equiv.Perm.IsCycle.zpowersEquivSupport_apply
+-/
 
+/- warning: equiv.perm.is_cycle.zpowers_equiv_support_symm_apply -> Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (fun (_x : Equiv.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) => (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.hasCoeToFun.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} (Equiv.Perm.{succ u1} α)) Type.{u1} (Set.hasCoeToSort.{u1} (Equiv.Perm.{succ u1} α)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasMem.{u1} (Equiv.Perm.{succ u1} α)) x ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.setLike.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) σ ((fun (a : Type) (b : Type) [self : HasLiftT.{1, 1} a b] => self.0) Nat Int (HasLiftT.mk.{1, 1} Nat Int (CoeTCₓ.coe.{1, 1} Nat Int (coeBase.{1, 1} Nat Int Int.hasCoe))) n)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} (hσ : Equiv.Perm.IsCycle.{u1} α σ) (n : Nat), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (fun (_x : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) => Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)))) (Equiv.symm.{succ u1, succ u1} (Subtype.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ))) (Subtype.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ))) (Equiv.Perm.IsCycle.zpowersEquivSupport.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ hσ)) (Subtype.mk.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) x (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Equiv.Perm.pow_apply_mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ n (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Iff.mpr (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ)) (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Equiv.Perm.mem_support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (And.left (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ (Classical.choose.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ) y)) (Classical.choose_spec.{succ u1} α (fun (x : α) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (forall {{y : α}}, (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) y) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ y) y) -> (Equiv.Perm.SameCycle.{u1} α σ x y))) hσ)))))) (Subtype.mk.{succ u1} (Equiv.Perm.{succ u1} α) (fun (x : Equiv.Perm.{succ u1} α) => Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Equiv.Perm.{succ u1} α) (Subgroup.instSetLikeSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) x (Subgroup.zpowers.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) σ)) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) σ y) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ n)) (Nat.cast.{0} Int instNatCastInt n) (rfl.{succ u1} (Equiv.Perm.{succ u1} α) ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : Equiv.Perm.{succ u1} α) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Int (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Int (DivInvMonoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) σ (Nat.cast.{0} Int instNatCastInt n)))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_applyₓ'. -/
 @[simp]
 theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ) (n : ℕ) :
     hσ.zpowersEquivSupport.symm
@@ -451,13 +603,16 @@ theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ)
   (Equiv.symm_apply_eq _).2 hσ.zpowersEquivSupport_apply
 #align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply
 
-protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.Support.card :=
+#print Equiv.Perm.IsCycle.orderOf /-
+protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.support.card :=
   by
   rw [orderOf_eq_card_zpowers, ← Fintype.card_coe]
   convert Fintype.card_congr (is_cycle.zpowers_equiv_support hf)
 #align equiv.perm.is_cycle.order_of Equiv.Perm.IsCycle.orderOf
+-/
 
-theorem is_cycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
+#print Equiv.Perm.isCycle_swap_mul_aux₁ /-
+theorem isCycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
     ∀ (n : ℕ) {b x : α} {f : Perm α} (hb : (swap x (f x) * f) b ≠ b) (h : (f ^ n) (f x) = b),
       ∃ i : ℤ, ((swap x (f x) * f) ^ i) (f x) = b
   | 0 => fun b x f hb h => ⟨0, h⟩
@@ -478,12 +633,14 @@ theorem is_cycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
       ⟨i + 1, by
         rw [add_comm, zpow_add, mul_apply, hi, zpow_one, mul_apply, apply_inv_self,
           swap_apply_of_ne_of_ne (ne_and_ne_of_swap_mul_apply_ne_self hb).2 (Ne.symm hfbx)]⟩
-#align equiv.perm.is_cycle_swap_mul_aux₁ Equiv.Perm.is_cycle_swap_mul_aux₁
+#align equiv.perm.is_cycle_swap_mul_aux₁ Equiv.Perm.isCycle_swap_mul_aux₁
+-/
 
-theorem is_cycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
+#print Equiv.Perm.isCycle_swap_mul_aux₂ /-
+theorem isCycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
     ∀ (n : ℤ) {b x : α} {f : Perm α} (hb : (swap x (f x) * f) b ≠ b) (h : (f ^ n) (f x) = b),
       ∃ i : ℤ, ((swap x (f x) * f) ^ i) (f x) = b
-  | (n : ℕ) => fun b x f => is_cycle_swap_mul_aux₁ n
+  | (n : ℕ) => fun b x f => isCycle_swap_mul_aux₁ n
   | -[n+1] => fun b x f hb h =>
     if hfbx' : f x = b then ⟨0, hfbx'⟩
     else
@@ -496,7 +653,7 @@ theorem is_cycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
               * <;>
           cc
       let ⟨i, hi⟩ :=
-        is_cycle_swap_mul_aux₁ n hb
+        isCycle_swap_mul_aux₁ n hb
           (show (f⁻¹ ^ n) (f⁻¹ x) = f⁻¹ b by
             rw [← zpow_ofNat, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc, ← inv_pow,
               pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_ofNat, ← pow_succ', ←
@@ -508,8 +665,10 @@ theorem is_cycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
           mul_inv_rev, swap_inv, mul_swap_eq_swap_mul, inv_apply_self, swap_comm _ x, zpow_add,
           zpow_one, mul_apply, mul_apply (_ ^ i), h, hi, mul_apply, apply_inv_self,
           swap_apply_of_ne_of_ne this.2 (Ne.symm hfbx')]⟩
-#align equiv.perm.is_cycle_swap_mul_aux₂ Equiv.Perm.is_cycle_swap_mul_aux₂
+#align equiv.perm.is_cycle_swap_mul_aux₂ Equiv.Perm.isCycle_swap_mul_aux₂
+-/
 
+#print Equiv.Perm.IsCycle.eq_swap_of_apply_apply_eq_self /-
 theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type _} [DecidableEq α] {f : Perm α}
     (hf : IsCycle f) {x : α} (hfx : f x ≠ x) (hffx : f (f x) = x) : f = swap x (f x) :=
   Equiv.ext fun y =>
@@ -529,7 +688,9 @@ theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type _} [DecidableEq α] {f
         · rw [← hj, hji] at hfyx
           cc
 #align equiv.perm.is_cycle.eq_swap_of_apply_apply_eq_self Equiv.Perm.IsCycle.eq_swap_of_apply_apply_eq_self
+-/
 
+#print Equiv.Perm.IsCycle.swap_mul /-
 theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCycle f) {x : α}
     (hx : f x ≠ x) (hffx : f (f x) ≠ x) : IsCycle (swap x (f x) * f) :=
   ⟨f x, by simp [swap_apply_def, mul_apply, if_neg hffx, f.injective.eq_iff, if_neg hx, hx],
@@ -540,16 +701,23 @@ theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCy
         (f ^ (i - 1)) (f x) = (f ^ (i - 1) * f ^ (1 : ℤ)) x := by rw [zpow_one, mul_apply]
         _ = y := by rwa [← zpow_add, sub_add_cancel]
         
-    is_cycle_swap_mul_aux₂ (i - 1) hy hi⟩
+    isCycle_swap_mul_aux₂ (i - 1) hy hi⟩
 #align equiv.perm.is_cycle.swap_mul Equiv.Perm.IsCycle.swap_mul
+-/
 
-theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.Support.card
+/- warning: equiv.perm.is_cycle.sign -> Equiv.Perm.IsCycle.sign is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} α) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2) f) (Neg.neg.{0} (Units.{0} Int Int.monoid) (Units.hasNeg.{0} Int Int.monoid (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring)))) (HPow.hPow.{0, 0, 0} (Units.{0} Int Int.monoid) Nat (Units.{0} Int Int.monoid) (instHPow.{0, 0} (Units.{0} Int Int.monoid) Nat (Monoid.Pow.{0} (Units.{0} Int Int.monoid) (DivInvMonoid.toMonoid.{0} (Units.{0} Int Int.monoid) (Group.toDivInvMonoid.{0} (Units.{0} Int Int.monoid) (Units.group.{0} Int Int.monoid))))) (Neg.neg.{0} (Units.{0} Int Int.monoid) (Units.hasNeg.{0} Int Int.monoid (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.ring)))) (OfNat.ofNat.{0} (Units.{0} Int Int.monoid) 1 (OfNat.mk.{0} (Units.{0} Int Int.monoid) 1 (One.one.{0} (Units.{0} Int Int.monoid) (MulOneClass.toHasOne.{0} (Units.{0} Int Int.monoid) (Units.mulOneClass.{0} Int Int.monoid)))))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α f) -> (Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.Perm.{succ u1} α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toMul.{0} (Units.{0} Int Int.instMonoidInt) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (MonoidHomClass.toMulHomClass.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} α) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2) f) (Neg.neg.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (HPow.hPow.{0, 0, 0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) Nat ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (instHPow.{0, 0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) Nat (Monoid.Pow.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivInvMonoid.toMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Group.toDivInvMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instGroupUnits.{0} Int Int.instMonoidInt))))) (Neg.neg.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instNegUnits.{0} Int Int.instMonoidInt (NonUnitalNonAssocRing.toHasDistribNeg.{0} Int (NonAssocRing.toNonUnitalNonAssocRing.{0} Int (Ring.toNonAssocRing.{0} Int Int.instRingInt)))) (OfNat.ofNat.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) 1 (One.toOfNat1.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (InvOneClass.toOne.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivInvOneMonoid.toInvOneClass.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivisionMonoid.toDivInvOneMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (DivisionCommMonoid.toDivisionMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (CommGroup.toDivisionCommMonoid.{0} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} α) => Units.{0} Int Int.instMonoidInt) f) (Units.instCommGroupUnitsToMonoid.{0} Int Int.instCommMonoidInt))))))))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.signₓ'. -/
+theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.support.card
   | f => fun hf =>
     let ⟨x, hx⟩ := hf
     calc
       sign f = sign (swap x (f x) * (swap x (f x) * f)) := by
         rw [← mul_assoc, mul_def, mul_def, swap_swap, trans_refl]
-      _ = -(-1) ^ f.Support.card :=
+      _ = -(-1) ^ f.support.card :=
         if h1 : f (f x) = x then
           by
           have h : swap x (f x) * f = 1 :=
@@ -561,10 +729,10 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.Su
           rfl
         else
           by
-          have h : card (Support (swap x (f x) * f)) + 1 = card (Support f) := by
+          have h : card (support (swap x (f x) * f)) + 1 = card (support f) := by
             rw [← insert_erase (mem_support.2 hx.1), support_swap_mul_eq _ _ h1,
               card_insert_of_not_mem (not_mem_erase _ _), sdiff_singleton_eq_erase]
-          have wf : card (Support (swap x (f x) * f)) < card (Support f) :=
+          have wf : card (support (swap x (f x) * f)) < card (support f) :=
             card_support_swap_mul hx.1
           rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
           simp only [pow_add, mul_one, neg_neg, one_mul, mul_neg, eq_self_iff_true, pow_one,
@@ -573,7 +741,8 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.Su
   ⟨_, measure_wf fun f => f.support.card⟩
 #align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.sign
 
-theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.Support ⊆ (f ^ n).Support) :
+#print Equiv.Perm.IsCycle.of_pow /-
+theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
     IsCycle f :=
   by
   have key : ∀ x : α, (f ^ n) x ≠ x ↔ f x ≠ x :=
@@ -585,26 +754,32 @@ theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.Support ⊆ (f ^
   cases' hx2 ((key y).mpr hy) with i _
   exact ⟨n * i, by rwa [zpow_mul]⟩
 #align equiv.perm.is_cycle.of_pow Equiv.Perm.IsCycle.of_pow
+-/
 
+#print Equiv.Perm.IsCycle.of_zpow /-
 -- The lemma `support_zpow_le` is relevant. It means that `h2` is equivalent to
 -- `σ.support = (σ ^ n).support`, as well as to `σ.support.card ≤ (σ ^ n).support.card`.
-theorem IsCycle.of_zpow {n : ℤ} (h1 : IsCycle (f ^ n)) (h2 : f.Support ⊆ (f ^ n).Support) :
+theorem IsCycle.of_zpow {n : ℤ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
     IsCycle f := by
   cases n
   · exact h1.of_pow h2
   · simp only [le_eq_subset, zpow_negSucc, perm.support_inv] at h1 h2
     simpa using h1.inv.of_pow h2
 #align equiv.perm.is_cycle.of_zpow Equiv.Perm.IsCycle.of_zpow
+-/
 
+#print Equiv.Perm.nodup_of_pairwise_disjoint_cycles /-
 theorem nodup_of_pairwise_disjoint_cycles {l : List (Perm β)} (h1 : ∀ f ∈ l, IsCycle f)
     (h2 : l.Pairwise Disjoint) : l.Nodup :=
   nodup_of_pairwise_disjoint (fun h => (h1 1 h).ne_one rfl) h2
 #align equiv.perm.nodup_of_pairwise_disjoint_cycles Equiv.Perm.nodup_of_pairwise_disjoint_cycles
+-/
 
+#print Equiv.Perm.IsCycle.support_congr /-
 /-- Unlike `support_congr`, which assumes that `∀ (x ∈ g.support), f x = g x)`, here
 we have the weaker assumption that `∀ (x ∈ f.support), f x = g x`. -/
-theorem IsCycle.support_congr (hf : IsCycle f) (hg : IsCycle g) (h : f.Support ⊆ g.Support)
-    (h' : ∀ x ∈ f.Support, f x = g x) : f = g :=
+theorem IsCycle.support_congr (hf : IsCycle f) (hg : IsCycle g) (h : f.support ⊆ g.support)
+    (h' : ∀ x ∈ f.support, f x = g x) : f = g :=
   by
   have : f.support = g.support := by
     refine' le_antisymm h _
@@ -623,11 +798,13 @@ theorem IsCycle.support_congr (hf : IsCycle f) (hg : IsCycle g) (h : f.Support 
   refine' support_congr h _
   simpa [← this] using h'
 #align equiv.perm.is_cycle.support_congr Equiv.Perm.IsCycle.support_congr
+-/
 
+#print Equiv.Perm.IsCycle.eq_on_support_inter_nonempty_congr /-
 /-- If two cyclic permutations agree on all terms in their intersection,
 and that intersection is not empty, then the two cyclic permutations must be equal. -/
 theorem IsCycle.eq_on_support_inter_nonempty_congr (hf : IsCycle f) (hg : IsCycle g)
-    (h : ∀ x ∈ f.Support ∩ g.Support, f x = g x) (hx : f x = g x) (hx' : x ∈ f.Support) : f = g :=
+    (h : ∀ x ∈ f.support ∩ g.support, f x = g x) (hx : f x = g x) (hx' : x ∈ f.support) : f = g :=
   by
   have hx'' : x ∈ g.support := by rwa [mem_support, ← hx, ← mem_support]
   have : f.support ⊆ g.support := by
@@ -637,9 +814,11 @@ theorem IsCycle.eq_on_support_inter_nonempty_congr (hf : IsCycle f) (hg : IsCycl
   rw [(inter_eq_left_iff_subset _ _).mpr this] at h
   exact hf.support_congr hg this h
 #align equiv.perm.is_cycle.eq_on_support_inter_nonempty_congr Equiv.Perm.IsCycle.eq_on_support_inter_nonempty_congr
+-/
 
+#print Equiv.Perm.IsCycle.support_pow_eq_iff /-
 theorem IsCycle.support_pow_eq_iff (hf : IsCycle f) {n : ℕ} :
-    Support (f ^ n) = Support f ↔ ¬orderOf f ∣ n :=
+    support (f ^ n) = support f ↔ ¬orderOf f ∣ n :=
   by
   rw [orderOf_dvd_iff_pow_eq_one]
   constructor
@@ -658,12 +837,16 @@ theorem IsCycle.support_pow_eq_iff (hf : IsCycle f) {n : ℕ} :
       rw [← mul_apply, (Commute.pow_pow_self _ _ _).Eq, mul_apply]
       simpa using H
 #align equiv.perm.is_cycle.support_pow_eq_iff Equiv.Perm.IsCycle.support_pow_eq_iff
+-/
 
+#print Equiv.Perm.IsCycle.support_pow_of_pos_of_lt_orderOf /-
 theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npos : 0 < n)
-    (hn : n < orderOf f) : (f ^ n).Support = f.Support :=
+    (hn : n < orderOf f) : (f ^ n).support = f.support :=
   hf.support_pow_eq_iff.2 <| Nat.not_dvd_of_pos_of_lt npos hn
 #align equiv.perm.is_cycle.support_pow_of_pos_of_lt_order_of Equiv.Perm.IsCycle.support_pow_of_pos_of_lt_orderOf
+-/
 
+#print Equiv.Perm.IsCycle.pow_iff /-
 theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     IsCycle (f ^ n) ↔ n.coprime (orderOf f) := by
   classical
@@ -688,7 +871,14 @@ theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
       rw [hm]
       exact support_pow_le _ n hx
 #align equiv.perm.is_cycle.pow_iff Equiv.Perm.IsCycle.pow_iff
+-/
 
+/- warning: equiv.perm.is_cycle.pow_eq_one_iff -> Equiv.Perm.IsCycle.pow_eq_one_iff is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))) (Exists.{succ u1} β (fun (x : β) => And (Ne.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) f x) x) (Eq.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x))))
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) (Exists.{succ u1} β (fun (x : β) => And (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) f x) x) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iffₓ'. -/
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     f ^ n = 1 ↔ ∃ x, f x ≠ x ∧ (f ^ n) x = x := by
@@ -707,12 +897,20 @@ theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : 
         rw [pow_mul, pow_orderOf_eq_one, one_pow]
 #align equiv.perm.is_cycle.pow_eq_one_iff Equiv.Perm.IsCycle.pow_eq_one_iff
 
+#print Equiv.Perm.IsCycle.pow_eq_one_iff' /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} {x : β}
     (hx : f x ≠ x) : f ^ n = 1 ↔ (f ^ n) x = x :=
   ⟨fun h => FunLike.congr_fun h x, fun h => hf.pow_eq_one_iff.2 ⟨x, hx, h⟩⟩
 #align equiv.perm.is_cycle.pow_eq_one_iff' Equiv.Perm.IsCycle.pow_eq_one_iff'
+-/
 
+/- warning: equiv.perm.is_cycle.pow_eq_one_iff'' -> Equiv.Perm.IsCycle.pow_eq_one_iff'' is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))) (forall (x : β), (Ne.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) f x) x) -> (Eq.{succ u1} β (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} β) (fun (_x : Equiv.{succ u1, succ u1} β β) => β -> β) (Equiv.hasCoeToFun.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x)))
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_3 : Finite.{succ u1} β] {f : Equiv.Perm.{succ u1} β}, (Equiv.Perm.IsCycle.{u1} β f) -> (forall {n : Nat}, Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) (forall (x : β), (Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) f x) x) -> (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} β) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β β) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} β) Nat (Equiv.Perm.{succ u1} β) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} β) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))) f n) x) x)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle.pow_eq_one_iff'' Equiv.Perm.IsCycle.pow_eq_one_iff''ₓ'. -/
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     f ^ n = 1 ↔ ∀ x, f x ≠ x → (f ^ n) x = x :=
@@ -721,6 +919,7 @@ theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
     (hf.pow_eq_one_iff' hx).2 (h _ hx)⟩
 #align equiv.perm.is_cycle.pow_eq_one_iff'' Equiv.Perm.IsCycle.pow_eq_one_iff''
 
+#print Equiv.Perm.IsCycle.pow_eq_pow_iff /-
 -- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
 theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b : ℕ} :
     f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x := by
@@ -745,7 +944,9 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
         rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).Injective] at hfa
         contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
+-/
 
+#print Equiv.Perm.IsCycle.isCycle_pow_pos_of_lt_prime_order /-
 theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf : IsCycle f)
     (hf' : (orderOf f).Prime) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f) : IsCycle (f ^ n) := by
   classical
@@ -761,6 +962,7 @@ theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf
     rw [hm]
     exact support_pow_le f n
 #align equiv.perm.is_cycle.is_cycle_pow_pos_of_lt_prime_order Equiv.Perm.IsCycle.isCycle_pow_pos_of_lt_prime_order
+-/
 
 end IsCycle
 
@@ -771,48 +973,95 @@ section IsCycleOn
 
 variable {f g : Perm α} {s t : Set α} {a b x y : α}
 
+#print Equiv.Perm.IsCycleOn /-
 /-- A permutation is a cycle on `s` when any two points of `s` are related by repeated application
 of the permutation. Note that this means the identity is a cycle of subsingleton sets. -/
 def IsCycleOn (f : Perm α) (s : Set α) : Prop :=
   Set.BijOn f s s ∧ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄, y ∈ s → f.SameCycle x y
 #align equiv.perm.is_cycle_on Equiv.Perm.IsCycleOn
+-/
 
+#print Equiv.Perm.isCycleOn_empty /-
 @[simp]
 theorem isCycleOn_empty : f.IsCycleOn ∅ := by simp [is_cycle_on]
 #align equiv.perm.is_cycle_on_empty Equiv.Perm.isCycleOn_empty
+-/
 
+/- warning: equiv.perm.is_cycle_on_one -> Equiv.Perm.isCycleOn_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) s) (Set.Subsingleton.{u1} α s)
+but is expected to have type
+  forall {α : Type.{u1}} {s : Set.{u1} α}, Iff (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) s) (Set.Subsingleton.{u1} α s)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on_one Equiv.Perm.isCycleOn_oneₓ'. -/
 @[simp]
 theorem isCycleOn_one : (1 : Perm α).IsCycleOn s ↔ s.Subsingleton := by
   simp [is_cycle_on, Set.bijOn_id, Set.Subsingleton]
 #align equiv.perm.is_cycle_on_one Equiv.Perm.isCycleOn_one
 
+/- warning: equiv.perm.is_cycle_on.subsingleton -> Equiv.Perm.IsCycleOn.subsingleton is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) s) -> (Set.Subsingleton.{u1} α s)
+but is expected to have type
+  forall {α : Type.{u1}} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) s) -> (Set.Subsingleton.{u1} α s)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.subsingleton Equiv.Perm.IsCycleOn.subsingletonₓ'. -/
+/- warning: set.subsingleton.is_cycle_on_one -> Set.Subsingleton.isCycleOn_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) s)
+but is expected to have type
+  forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Equiv.Perm.IsCycleOn.{u1} α (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) s)
+Case conversion may be inaccurate. Consider using '#align set.subsingleton.is_cycle_on_one Set.Subsingleton.isCycleOn_oneₓ'. -/
 alias is_cycle_on_one ↔ is_cycle_on.subsingleton _root_.set.subsingleton.is_cycle_on_one
 #align equiv.perm.is_cycle_on.subsingleton Equiv.Perm.IsCycleOn.subsingleton
 #align set.subsingleton.is_cycle_on_one Set.Subsingleton.isCycleOn_one
 
+#print Equiv.Perm.isCycleOn_singleton /-
 @[simp]
 theorem isCycleOn_singleton : f.IsCycleOn {a} ↔ f a = a := by simp [is_cycle_on, same_cycle.rfl]
 #align equiv.perm.is_cycle_on_singleton Equiv.Perm.isCycleOn_singleton
+-/
 
+#print Equiv.Perm.isCycleOn_of_subsingleton /-
 theorem isCycleOn_of_subsingleton [Subsingleton α] (f : Perm α) (s : Set α) : f.IsCycleOn s :=
   ⟨s.bijOn_of_subsingleton _, fun x _ y _ => (Subsingleton.elim x y).SameCycle _⟩
 #align equiv.perm.is_cycle_on_of_subsingleton Equiv.Perm.isCycleOn_of_subsingleton
+-/
 
+/- warning: equiv.perm.is_cycle_on_inv -> Equiv.Perm.isCycleOn_inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, Iff (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) s) (Equiv.Perm.IsCycleOn.{u1} α f s)
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, Iff (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) s) (Equiv.Perm.IsCycleOn.{u1} α f s)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on_inv Equiv.Perm.isCycleOn_invₓ'. -/
 @[simp]
 theorem isCycleOn_inv : f⁻¹.IsCycleOn s ↔ f.IsCycleOn s := by simp [is_cycle_on, Set.bijOn_perm_inv]
 #align equiv.perm.is_cycle_on_inv Equiv.Perm.isCycleOn_inv
 
+/- warning: equiv.perm.is_cycle_on.of_inv -> Equiv.Perm.IsCycleOn.of_inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) s) -> (Equiv.Perm.IsCycleOn.{u1} α f s)
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) s) -> (Equiv.Perm.IsCycleOn.{u1} α f s)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.of_inv Equiv.Perm.IsCycleOn.of_invₓ'. -/
+/- warning: equiv.perm.is_cycle_on.inv -> Equiv.Perm.IsCycleOn.inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f s) -> (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) s)
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {s : Set.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f s) -> (Equiv.Perm.IsCycleOn.{u1} α (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) s)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.inv Equiv.Perm.IsCycleOn.invₓ'. -/
 alias is_cycle_on_inv ↔ is_cycle_on.of_inv is_cycle_on.inv
 #align equiv.perm.is_cycle_on.of_inv Equiv.Perm.IsCycleOn.of_inv
 #align equiv.perm.is_cycle_on.inv Equiv.Perm.IsCycleOn.inv
 
+#print Equiv.Perm.IsCycleOn.conj /-
 theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Perm α) '' s) :=
   ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy =>
     by
     rw [← preimage_inv] at hx hy
     convert(h.2 hx hy).conj <;> rw [apply_inv_self]⟩
 #align equiv.perm.is_cycle_on.conj Equiv.Perm.IsCycleOn.conj
+-/
 
+#print Equiv.Perm.isCycleOn_swap /-
 theorem isCycleOn_swap [DecidableEq α] (hab : a ≠ b) : (swap a b).IsCycleOn {a, b} :=
   ⟨bijOn_swap (by simp) (by simp), fun x hx y hy =>
     by
@@ -823,18 +1072,24 @@ theorem isCycleOn_swap [DecidableEq α] (hab : a ≠ b) : (swap a b).IsCycleOn {
     · exact ⟨1, by rw [zpow_one, swap_apply_right]⟩
     · exact ⟨0, by rw [zpow_zero, coe_one, id.def]⟩⟩
 #align equiv.perm.is_cycle_on_swap Equiv.Perm.isCycleOn_swap
+-/
 
+#print Equiv.Perm.IsCycleOn.apply_ne /-
 protected theorem IsCycleOn.apply_ne (hf : f.IsCycleOn s) (hs : s.Nontrivial) (ha : a ∈ s) :
     f a ≠ a := by
   obtain ⟨b, hb, hba⟩ := hs.exists_ne a
   obtain ⟨n, rfl⟩ := hf.2 ha hb
   exact fun h => hba (is_fixed_pt.perm_zpow h n)
 #align equiv.perm.is_cycle_on.apply_ne Equiv.Perm.IsCycleOn.apply_ne
+-/
 
+#print Equiv.Perm.IsCycle.isCycleOn /-
 protected theorem IsCycle.isCycleOn (hf : f.IsCycle) : f.IsCycleOn { x | f x ≠ x } :=
   ⟨f.BijOn fun x => f.apply_eq_iff_eq.Not, fun a ha b => hf.SameCycle ha⟩
 #align equiv.perm.is_cycle.is_cycle_on Equiv.Perm.IsCycle.isCycleOn
+-/
 
+#print Equiv.Perm.isCycle_iff_exists_isCycleOn /-
 /-- This lemma demonstrates the relation between `equiv.perm.is_cycle` and `equiv.perm.is_cycle_on`
 in non-degenerate cases. -/
 theorem isCycle_iff_exists_isCycleOn :
@@ -847,13 +1102,17 @@ theorem isCycle_iff_exists_isCycleOn :
     obtain ⟨a, ha⟩ := hs.nonempty
     exact ⟨a, hf.apply_ne hs ha, fun b hb => hf.2 ha <| hsf hb⟩
 #align equiv.perm.is_cycle_iff_exists_is_cycle_on Equiv.Perm.isCycle_iff_exists_isCycleOn
+-/
 
+#print Equiv.Perm.IsCycleOn.apply_mem_iff /-
 theorem IsCycleOn.apply_mem_iff (hf : f.IsCycleOn s) : f x ∈ s ↔ x ∈ s :=
   ⟨fun hx => by
     convert hf.1.perm_inv.1 hx
     rw [inv_apply_self], fun hx => hf.1.MapsTo hx⟩
 #align equiv.perm.is_cycle_on.apply_mem_iff Equiv.Perm.IsCycleOn.apply_mem_iff
+-/
 
+#print Equiv.Perm.IsCycleOn.isCycle_subtypePerm /-
 /-- Note that the identity satisfies `is_cycle_on` for any subsingleton set, but not `is_cycle`. -/
 theorem IsCycleOn.isCycle_subtypePerm (hf : f.IsCycleOn s) (hs : s.Nontrivial) :
     (f.subtypePerm fun _ => hf.apply_mem_iff.symm : Perm s).IsCycle :=
@@ -863,7 +1122,9 @@ theorem IsCycleOn.isCycle_subtypePerm (hf : f.IsCycleOn s) (hs : s.Nontrivial) :
     ⟨⟨a, ha⟩, ne_of_apply_ne (coe : s → α) (hf.apply_ne hs ha), fun b hb =>
       (hf.2 (⟨a, ha⟩ : s).Prop b.Prop).subtypePerm⟩
 #align equiv.perm.is_cycle_on.is_cycle_subtype_perm Equiv.Perm.IsCycleOn.isCycle_subtypePerm
+-/
 
+#print Equiv.Perm.IsCycleOn.subtypePerm /-
 /-- Note that the identity is a cycle on any subsingleton set, but not a cycle. -/
 protected theorem IsCycleOn.subtypePerm (hf : f.IsCycleOn s) :
     (f.subtypePerm fun _ => hf.apply_mem_iff.symm : Perm s).IsCycleOn Set.univ :=
@@ -875,7 +1136,9 @@ protected theorem IsCycleOn.subtypePerm (hf : f.IsCycleOn s) :
   rw [eq_comm, Set.eq_univ_iff_forall]
   exact fun x => ne_of_apply_ne (coe : s → α) (hf.apply_ne hs x.Prop)
 #align equiv.perm.is_cycle_on.subtype_perm Equiv.Perm.IsCycleOn.subtypePerm
+-/
 
+#print Equiv.Perm.IsCycleOn.pow_apply_eq /-
 -- TODO: Theory of order of an element under an action
 theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) {n : ℕ} :
     (f ^ n) a = a ↔ s.card ∣ n :=
@@ -892,7 +1155,9 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
         (ne_of_apply_ne (coe : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).Prop)]
     simp only [Subtype.coe_mk, subtype_perm_pow, subtype_perm_apply]
 #align equiv.perm.is_cycle_on.pow_apply_eq Equiv.Perm.IsCycleOn.pow_apply_eq
+-/
 
+#print Equiv.Perm.IsCycleOn.zpow_apply_eq /-
 theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
     ∀ {n : ℤ}, (f ^ n) a = a ↔ (s.card : ℤ) ∣ n
   | Int.ofNat n => (hf.pow_apply_eq ha).trans Int.coe_nat_dvd.symm
@@ -900,26 +1165,39 @@ theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
     rw [zpow_negSucc, ← inv_pow]
     exact (hf.inv.pow_apply_eq ha).trans ((dvd_neg _ _).trans Int.coe_nat_dvd).symm
 #align equiv.perm.is_cycle_on.zpow_apply_eq Equiv.Perm.IsCycleOn.zpow_apply_eq
+-/
 
+#print Equiv.Perm.IsCycleOn.pow_apply_eq_pow_apply /-
 theorem IsCycleOn.pow_apply_eq_pow_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s)
     {m n : ℕ} : (f ^ m) a = (f ^ n) a ↔ m ≡ n [MOD s.card] :=
   by
   rw [Nat.modEq_iff_dvd, ← hf.zpow_apply_eq ha]
   simp [sub_eq_neg_add, zpow_add, eq_inv_iff_eq, eq_comm]
 #align equiv.perm.is_cycle_on.pow_apply_eq_pow_apply Equiv.Perm.IsCycleOn.pow_apply_eq_pow_apply
+-/
 
+#print Equiv.Perm.IsCycleOn.zpow_apply_eq_zpow_apply /-
 theorem IsCycleOn.zpow_apply_eq_zpow_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s)
     {m n : ℤ} : (f ^ m) a = (f ^ n) a ↔ m ≡ n [ZMOD s.card] :=
   by
   rw [Int.modEq_iff_dvd, ← hf.zpow_apply_eq ha]
   simp [sub_eq_neg_add, zpow_add, eq_inv_iff_eq, eq_comm]
 #align equiv.perm.is_cycle_on.zpow_apply_eq_zpow_apply Equiv.Perm.IsCycleOn.zpow_apply_eq_zpow_apply
+-/
 
+#print Equiv.Perm.IsCycleOn.pow_card_apply /-
 theorem IsCycleOn.pow_card_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
     (f ^ s.card) a = a :=
   (hf.pow_apply_eq ha).2 dvd_rfl
 #align equiv.perm.is_cycle_on.pow_card_apply Equiv.Perm.IsCycleOn.pow_card_apply
+-/
 
+/- warning: equiv.perm.is_cycle_on.exists_pow_eq -> Equiv.Perm.IsCycleOn.exists_pow_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {a : α} {b : α} {s : Finset.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) b s) -> (Exists.{1} Nat (fun (n : Nat) => Exists.{0} (LT.lt.{0} Nat Nat.hasLt n (Finset.card.{u1} α s)) (fun (H : LT.lt.{0} Nat Nat.hasLt n (Finset.card.{u1} α s)) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f n) a) b)))
+but is expected to have type
+  forall {α : Type.{u1}} {f : Equiv.Perm.{succ u1} α} {a : α} {b : α} {s : Finset.{u1} α}, (Equiv.Perm.IsCycleOn.{u1} α f (Finset.toSet.{u1} α s)) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) b s) -> (Exists.{1} Nat (fun (n : Nat) => And (LT.lt.{0} Nat instLTNat n (Finset.card.{u1} α s)) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} α) Nat (Equiv.Perm.{succ u1} α) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} α) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f n) a) b)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eqₓ'. -/
 theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
     ∃ n < s.card, (f ^ n) a = b := by
   classical
@@ -933,46 +1211,60 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
     exact is_fixed_pt.perm_zpow (hf.pow_card_apply ha) _
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
 
+#print Equiv.Perm.IsCycleOn.exists_pow_eq' /-
 theorem IsCycleOn.exists_pow_eq' (hs : s.Finite) (hf : f.IsCycleOn s) (ha : a ∈ s) (hb : b ∈ s) :
     ∃ n : ℕ, (f ^ n) a = b := by
   lift s to Finset α using id hs
   obtain ⟨n, -, hn⟩ := hf.exists_pow_eq ha hb
   exact ⟨n, hn⟩
 #align equiv.perm.is_cycle_on.exists_pow_eq' Equiv.Perm.IsCycleOn.exists_pow_eq'
+-/
 
+#print Equiv.Perm.IsCycleOn.range_pow /-
 theorem IsCycleOn.range_pow (hs : s.Finite) (h : f.IsCycleOn s) (ha : a ∈ s) :
     Set.range (fun n => (f ^ n) a : ℕ → α) = s :=
   Set.Subset.antisymm (Set.range_subset_iff.2 fun n => h.1.MapsTo.perm_pow _ ha) fun x =>
     h.exists_pow_eq' hs ha
 #align equiv.perm.is_cycle_on.range_pow Equiv.Perm.IsCycleOn.range_pow
+-/
 
+#print Equiv.Perm.IsCycleOn.range_zpow /-
 theorem IsCycleOn.range_zpow (h : f.IsCycleOn s) (ha : a ∈ s) :
     Set.range (fun n => (f ^ n) a : ℤ → α) = s :=
   Set.Subset.antisymm (Set.range_subset_iff.2 fun n => (h.1.perm_zpow _).MapsTo ha) <| h.2 ha
 #align equiv.perm.is_cycle_on.range_zpow Equiv.Perm.IsCycleOn.range_zpow
+-/
 
+#print Equiv.Perm.IsCycleOn.of_pow /-
 theorem IsCycleOn.of_pow {n : ℕ} (hf : (f ^ n).IsCycleOn s) (h : Set.BijOn f s s) : f.IsCycleOn s :=
   ⟨h, fun x hx y hy => (hf.2 hx hy).ofPow⟩
 #align equiv.perm.is_cycle_on.of_pow Equiv.Perm.IsCycleOn.of_pow
+-/
 
+#print Equiv.Perm.IsCycleOn.of_zpow /-
 theorem IsCycleOn.of_zpow {n : ℤ} (hf : (f ^ n).IsCycleOn s) (h : Set.BijOn f s s) :
     f.IsCycleOn s :=
   ⟨h, fun x hx y hy => (hf.2 hx hy).of_zpow⟩
 #align equiv.perm.is_cycle_on.of_zpow Equiv.Perm.IsCycleOn.of_zpow
+-/
 
+#print Equiv.Perm.IsCycleOn.extendDomain /-
 theorem IsCycleOn.extendDomain {p : β → Prop} [DecidablePred p] (f : α ≃ Subtype p)
     (h : g.IsCycleOn s) : (g.extendDomain f).IsCycleOn (coe ∘ f '' s) :=
   ⟨h.1.extendDomain, by
     rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩
     exact (h.2 ha hb).extendDomain⟩
 #align equiv.perm.is_cycle_on.extend_domain Equiv.Perm.IsCycleOn.extendDomain
+-/
 
+#print Equiv.Perm.IsCycleOn.countable /-
 protected theorem IsCycleOn.countable (hs : f.IsCycleOn s) : s.Countable :=
   by
   obtain rfl | ⟨a, ha⟩ := s.eq_empty_or_nonempty
   · exact Set.countable_empty
   · exact (Set.countable_range fun n : ℤ => (⇑(f ^ n) : α → α) a).mono (hs.2 ha)
 #align equiv.perm.is_cycle_on.countable Equiv.Perm.IsCycleOn.countable
+-/
 
 end IsCycleOn
 
@@ -985,11 +1277,14 @@ section CycleOf
 
 variable [DecidableEq α] [Fintype α] {f g : Perm α} {x y : α}
 
+#print Equiv.Perm.cycleOf /-
 /-- `f.cycle_of x` is the cycle of the permutation `f` to which `x` belongs. -/
 def cycleOf (f : Perm α) (x : α) : Perm α :=
   ofSubtype (subtypePerm f fun _ => sameCycle_apply_right.symm : Perm { y // SameCycle f x y })
 #align equiv.perm.cycle_of Equiv.Perm.cycleOf
+-/
 
+#print Equiv.Perm.cycleOf_apply /-
 theorem cycleOf_apply (f : Perm α) (x y : α) : cycleOf f x y = if SameCycle f x y then f y else y :=
   by
   dsimp only [cycle_of]
@@ -999,13 +1294,21 @@ theorem cycleOf_apply (f : Perm α) (x y : α) : cycleOf f x y = if SameCycle f
   · apply of_subtype_apply_of_not_mem
     exact h
 #align equiv.perm.cycle_of_apply Equiv.Perm.cycleOf_apply
+-/
 
+/- warning: equiv.perm.cycle_of_inv -> Equiv.Perm.cycleOf_inv is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f) x)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f) x)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_inv Equiv.Perm.cycleOf_invₓ'. -/
 theorem cycleOf_inv (f : Perm α) (x : α) : (cycleOf f x)⁻¹ = cycleOf f⁻¹ x :=
   Equiv.ext fun y => by
     rw [inv_eq_iff_eq, cycle_of_apply, cycle_of_apply]
     split_ifs <;> simp_all [same_cycle_inv, same_cycle_inv_apply_right]
 #align equiv.perm.cycle_of_inv Equiv.Perm.cycleOf_inv
 
+#print Equiv.Perm.cycleOf_pow_apply_self /-
 @[simp]
 theorem cycleOf_pow_apply_self (f : Perm α) (x : α) : ∀ n : ℕ, (cycleOf f x ^ n) x = (f ^ n) x
   | 0 => rfl
@@ -1014,22 +1317,30 @@ theorem cycleOf_pow_apply_self (f : Perm α) (x : α) : ∀ n : ℕ, (cycleOf f
     rw [pow_succ, mul_apply, cycle_of_apply, cycle_of_pow_apply_self, if_pos, pow_succ, mul_apply]
     exact ⟨n, rfl⟩
 #align equiv.perm.cycle_of_pow_apply_self Equiv.Perm.cycleOf_pow_apply_self
+-/
 
+#print Equiv.Perm.cycleOf_zpow_apply_self /-
 @[simp]
 theorem cycleOf_zpow_apply_self (f : Perm α) (x : α) : ∀ n : ℤ, (cycleOf f x ^ n) x = (f ^ n) x
   | (n : ℕ) => cycleOf_pow_apply_self f x n
   | -[n+1] => by
     rw [zpow_negSucc, ← inv_pow, cycle_of_inv, zpow_negSucc, ← inv_pow, cycle_of_pow_apply_self]
 #align equiv.perm.cycle_of_zpow_apply_self Equiv.Perm.cycleOf_zpow_apply_self
+-/
 
+#print Equiv.Perm.SameCycle.cycleOf_apply /-
 theorem SameCycle.cycleOf_apply : SameCycle f x y → cycleOf f x y = f y :=
   ofSubtype_apply_of_mem _
 #align equiv.perm.same_cycle.cycle_of_apply Equiv.Perm.SameCycle.cycleOf_apply
+-/
 
+#print Equiv.Perm.cycleOf_apply_of_not_sameCycle /-
 theorem cycleOf_apply_of_not_sameCycle : ¬SameCycle f x y → cycleOf f x y = y :=
   ofSubtype_apply_of_not_mem _
 #align equiv.perm.cycle_of_apply_of_not_same_cycle Equiv.Perm.cycleOf_apply_of_not_sameCycle
+-/
 
+#print Equiv.Perm.SameCycle.cycleOf_eq /-
 theorem SameCycle.cycleOf_eq (h : SameCycle f x y) : cycleOf f x = cycleOf f y :=
   by
   ext z
@@ -1038,7 +1349,9 @@ theorem SameCycle.cycleOf_eq (h : SameCycle f x y) : cycleOf f x = cycleOf f y :
   · exact (h.symm.trans hz).cycleOf_apply.symm
   · exact (cycle_of_apply_of_not_same_cycle (mt h.trans hz)).symm
 #align equiv.perm.same_cycle.cycle_of_eq Equiv.Perm.SameCycle.cycleOf_eq
+-/
 
+#print Equiv.Perm.cycleOf_apply_apply_zpow_self /-
 @[simp]
 theorem cycleOf_apply_apply_zpow_self (f : Perm α) (x : α) (k : ℤ) :
     cycleOf f x ((f ^ k) x) = (f ^ (k + 1)) x :=
@@ -1047,23 +1360,31 @@ theorem cycleOf_apply_apply_zpow_self (f : Perm α) (x : α) (k : ℤ) :
   · rw [add_comm, zpow_add, zpow_one, mul_apply]
   · exact ⟨k, rfl⟩
 #align equiv.perm.cycle_of_apply_apply_zpow_self Equiv.Perm.cycleOf_apply_apply_zpow_self
+-/
 
+#print Equiv.Perm.cycleOf_apply_apply_pow_self /-
 @[simp]
 theorem cycleOf_apply_apply_pow_self (f : Perm α) (x : α) (k : ℕ) :
     cycleOf f x ((f ^ k) x) = (f ^ (k + 1)) x := by
   convert cycle_of_apply_apply_zpow_self f x k using 1
 #align equiv.perm.cycle_of_apply_apply_pow_self Equiv.Perm.cycleOf_apply_apply_pow_self
+-/
 
+#print Equiv.Perm.cycleOf_apply_apply_self /-
 @[simp]
 theorem cycleOf_apply_apply_self (f : Perm α) (x : α) : cycleOf f x (f x) = f (f x) := by
   convert cycle_of_apply_apply_pow_self f x 1 using 1
 #align equiv.perm.cycle_of_apply_apply_self Equiv.Perm.cycleOf_apply_apply_self
+-/
 
+#print Equiv.Perm.cycleOf_apply_self /-
 @[simp]
 theorem cycleOf_apply_self (f : Perm α) (x : α) : cycleOf f x x = f x :=
   SameCycle.rfl.cycleOf_apply
 #align equiv.perm.cycle_of_apply_self Equiv.Perm.cycleOf_apply_self
+-/
 
+#print Equiv.Perm.IsCycle.cycleOf_eq /-
 theorem IsCycle.cycleOf_eq (hf : IsCycle f) (hx : f x ≠ x) : cycleOf f x = f :=
   Equiv.ext fun y =>
     if h : SameCycle f x y then by rw [h.cycle_of_apply]
@@ -1071,7 +1392,14 @@ theorem IsCycle.cycleOf_eq (hf : IsCycle f) (hx : f x ≠ x) : cycleOf f x = f :
       rw [cycle_of_apply_of_not_same_cycle h,
         Classical.not_not.1 (mt ((is_cycle_iff_same_cycle hx).1 hf).2 h)]
 #align equiv.perm.is_cycle.cycle_of_eq Equiv.Perm.IsCycle.cycleOf_eq
+-/
 
+/- warning: equiv.perm.cycle_of_eq_one_iff -> Equiv.Perm.cycleOf_eq_one_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {x : α} (f : Equiv.Perm.{succ u1} α), Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))) (Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) f x) x)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {x : α} (f : Equiv.Perm.{succ u1} α), Iff (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) f x) x)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_eq_one_iff Equiv.Perm.cycleOf_eq_one_iffₓ'. -/
 @[simp]
 theorem cycleOf_eq_one_iff (f : Perm α) : cycleOf f x = 1 ↔ f x = x :=
   by
@@ -1082,33 +1410,48 @@ theorem cycleOf_eq_one_iff (f : Perm α) : cycleOf f x = 1 ↔ f x = x :=
   · exact if_neg (mt same_cycle.apply_eq_self_iff (by tauto))
 #align equiv.perm.cycle_of_eq_one_iff Equiv.Perm.cycleOf_eq_one_iff
 
+#print Equiv.Perm.cycleOf_self_apply /-
 @[simp]
 theorem cycleOf_self_apply (f : Perm α) (x : α) : cycleOf f (f x) = cycleOf f x :=
   (sameCycle_apply_right.2 SameCycle.rfl).symm.cycleOf_eq
 #align equiv.perm.cycle_of_self_apply Equiv.Perm.cycleOf_self_apply
+-/
 
+#print Equiv.Perm.cycleOf_self_apply_pow /-
 @[simp]
 theorem cycleOf_self_apply_pow (f : Perm α) (n : ℕ) (x : α) : cycleOf f ((f ^ n) x) = cycleOf f x :=
   SameCycle.rfl.pow_leftₓ.cycleOf_eq
 #align equiv.perm.cycle_of_self_apply_pow Equiv.Perm.cycleOf_self_apply_pow
+-/
 
+#print Equiv.Perm.cycleOf_self_apply_zpow /-
 @[simp]
 theorem cycleOf_self_apply_zpow (f : Perm α) (n : ℤ) (x : α) :
     cycleOf f ((f ^ n) x) = cycleOf f x :=
   SameCycle.rfl.zpow_left.cycleOf_eq
 #align equiv.perm.cycle_of_self_apply_zpow Equiv.Perm.cycleOf_self_apply_zpow
+-/
 
+#print Equiv.Perm.IsCycle.cycleOf /-
 protected theorem IsCycle.cycleOf (hf : IsCycle f) : cycleOf f x = if f x = x then 1 else f :=
   by
   by_cases hx : f x = x
   · rwa [if_pos hx, cycle_of_eq_one_iff]
   · rwa [if_neg hx, hf.cycle_of_eq]
 #align equiv.perm.is_cycle.cycle_of Equiv.Perm.IsCycle.cycleOf
+-/
 
+/- warning: equiv.perm.cycle_of_one -> Equiv.Perm.cycleOf_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) x) (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_one Equiv.Perm.cycleOf_oneₓ'. -/
 theorem cycleOf_one (x : α) : cycleOf 1 x = 1 :=
   (cycleOf_eq_one_iff 1).mpr rfl
 #align equiv.perm.cycle_of_one Equiv.Perm.cycleOf_one
 
+#print Equiv.Perm.isCycle_cycleOf /-
 theorem isCycle_cycleOf (f : Perm α) (hx : f x ≠ x) : IsCycle (cycleOf f x) :=
   have : cycleOf f x x ≠ x := by rwa [same_cycle.rfl.cycle_of_apply]
   (isCycle_iff_sameCycle this).2 fun y =>
@@ -1120,28 +1463,41 @@ theorem isCycle_cycleOf (f : Perm α) (hx : f x ≠ x) : IsCycle (cycleOf f x) :
         rw [cycle_of_apply_of_not_same_cycle hxy] at h
         exact (h rfl).elim⟩
 #align equiv.perm.is_cycle_cycle_of Equiv.Perm.isCycle_cycleOf
+-/
 
+#print Equiv.Perm.two_le_card_support_cycleOf_iff /-
 @[simp]
-theorem two_le_card_support_cycleOf_iff : 2 ≤ card (cycleOf f x).Support ↔ f x ≠ x :=
+theorem two_le_card_support_cycleOf_iff : 2 ≤ card (cycleOf f x).support ↔ f x ≠ x :=
   by
   refine' ⟨fun h => _, fun h => by simpa using (is_cycle_cycle_of _ h).two_le_card_support⟩
   contrapose! h
   rw [← cycle_of_eq_one_iff] at h
   simp [h]
 #align equiv.perm.two_le_card_support_cycle_of_iff Equiv.Perm.two_le_card_support_cycleOf_iff
+-/
 
+#print Equiv.Perm.card_support_cycleOf_pos_iff /-
 @[simp]
-theorem card_support_cycleOf_pos_iff : 0 < card (cycleOf f x).Support ↔ f x ≠ x :=
+theorem card_support_cycleOf_pos_iff : 0 < card (cycleOf f x).support ↔ f x ≠ x :=
   by
   rw [← two_le_card_support_cycle_of_iff, ← Nat.succ_le_iff]
   exact ⟨fun h => Or.resolve_left h.eq_or_lt (card_support_ne_one _).symm, zero_lt_two.trans_le⟩
 #align equiv.perm.card_support_cycle_of_pos_iff Equiv.Perm.card_support_cycleOf_pos_iff
+-/
 
+#print Equiv.Perm.pow_apply_eq_pow_mod_orderOf_cycleOf_apply /-
 theorem pow_apply_eq_pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x : α) :
     (f ^ n) x = (f ^ (n % orderOf (cycleOf f x))) x := by
   rw [← cycle_of_pow_apply_self f, ← cycle_of_pow_apply_self f, pow_eq_mod_orderOf]
 #align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_apply_eq_pow_mod_orderOf_cycleOf_apply
+-/
 
+/- warning: equiv.perm.cycle_of_mul_of_apply_right_eq_self -> Equiv.Perm.cycleOf_mul_of_apply_right_eq_self is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f g) -> (forall (x : α), (Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) g x) x) -> (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f g) -> (forall (x : α), (Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) g x) x) -> (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_of_mul_of_apply_right_eq_self Equiv.Perm.cycleOf_mul_of_apply_right_eq_selfₓ'. -/
 theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x = x) :
     (f * g).cycleOf x = f.cycleOf x := by
   ext y
@@ -1156,6 +1512,12 @@ theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x
     simp [h.mul_zpow, zpow_apply_eq_self_of_apply_eq_self hx]
 #align equiv.perm.cycle_of_mul_of_apply_right_eq_self Equiv.Perm.cycleOf_mul_of_apply_right_eq_self
 
+/- warning: equiv.perm.disjoint.cycle_of_mul_distrib -> Equiv.Perm.Disjoint.cycleOf_mul_distrib is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (forall (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g x)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (forall (x : α), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g) x) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f x) (Equiv.Perm.cycleOf.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g x)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint.cycle_of_mul_distrib Equiv.Perm.Disjoint.cycleOf_mul_distribₓ'. -/
 theorem Disjoint.cycleOf_mul_distrib (h : f.Disjoint g) (x : α) :
     (f * g).cycleOf x = f.cycleOf x * g.cycleOf x :=
   by
@@ -1164,10 +1526,13 @@ theorem Disjoint.cycleOf_mul_distrib (h : f.Disjoint g) (x : α) :
   · simp [cycle_of_mul_of_apply_right_eq_self h.commute, hgx]
 #align equiv.perm.disjoint.cycle_of_mul_distrib Equiv.Perm.Disjoint.cycleOf_mul_distrib
 
-theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).Support = ∅ ↔ x ∉ f.Support := by simp
+#print Equiv.Perm.support_cycleOf_eq_nil_iff /-
+theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.support := by simp
 #align equiv.perm.support_cycle_of_eq_nil_iff Equiv.Perm.support_cycleOf_eq_nil_iff
+-/
 
-theorem support_cycleOf_le (f : Perm α) (x : α) : Support (f.cycleOf x) ≤ Support f :=
+#print Equiv.Perm.support_cycleOf_le /-
+theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ support f :=
   by
   intro y hy
   rw [mem_support, cycle_of_apply] at hy
@@ -1175,8 +1540,10 @@ theorem support_cycleOf_le (f : Perm α) (x : α) : Support (f.cycleOf x) ≤ Su
   · exact mem_support.mpr hy
   · exact absurd rfl hy
 #align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_le
+-/
 
-theorem mem_support_cycleOf_iff : y ∈ Support (f.cycleOf x) ↔ SameCycle f x y ∧ x ∈ Support f :=
+#print Equiv.Perm.mem_support_cycleOf_iff /-
+theorem mem_support_cycleOf_iff : y ∈ support (f.cycleOf x) ↔ SameCycle f x y ∧ x ∈ support f :=
   by
   by_cases hx : f x = x
   · rw [(cycle_of_eq_one_iff _).mpr hx]
@@ -1189,18 +1556,24 @@ theorem mem_support_cycleOf_iff : y ∈ Support (f.cycleOf x) ↔ SameCycle f x
       simpa using hx
     · simpa [hx] using hy
 #align equiv.perm.mem_support_cycle_of_iff Equiv.Perm.mem_support_cycleOf_iff
+-/
 
-theorem mem_support_cycleOf_iff' (hx : f x ≠ x) : y ∈ Support (f.cycleOf x) ↔ SameCycle f x y := by
+#print Equiv.Perm.mem_support_cycleOf_iff' /-
+theorem mem_support_cycleOf_iff' (hx : f x ≠ x) : y ∈ support (f.cycleOf x) ↔ SameCycle f x y := by
   rw [mem_support_cycle_of_iff, and_iff_left (mem_support.2 hx)]
 #align equiv.perm.mem_support_cycle_of_iff' Equiv.Perm.mem_support_cycleOf_iff'
+-/
 
-theorem SameCycle.mem_support_iff (h : SameCycle f x y) : x ∈ Support f ↔ y ∈ Support f :=
+#print Equiv.Perm.SameCycle.mem_support_iff /-
+theorem SameCycle.mem_support_iff (h : SameCycle f x y) : x ∈ support f ↔ y ∈ support f :=
   ⟨fun hx => support_cycleOf_le f x (mem_support_cycleOf_iff.mpr ⟨h, hx⟩), fun hy =>
     support_cycleOf_le f y (mem_support_cycleOf_iff.mpr ⟨h.symm, hy⟩)⟩
 #align equiv.perm.same_cycle.mem_support_iff Equiv.Perm.SameCycle.mem_support_iff
+-/
 
+#print Equiv.Perm.pow_mod_card_support_cycleOf_self_apply /-
 theorem pow_mod_card_support_cycleOf_self_apply (f : Perm α) (n : ℕ) (x : α) :
-    (f ^ (n % (f.cycleOf x).Support.card)) x = (f ^ n) x :=
+    (f ^ (n % (f.cycleOf x).support.card)) x = (f ^ n) x :=
   by
   by_cases hx : f x = x
   · rw [pow_apply_eq_self_of_apply_eq_self hx, pow_apply_eq_self_of_apply_eq_self hx]
@@ -1208,7 +1581,9 @@ theorem pow_mod_card_support_cycleOf_self_apply (f : Perm α) (n : ℕ) (x : α)
     rw [← cycle_of_pow_apply_self, ← cycle_of_pow_apply_self f, ← (is_cycle_cycle_of f hx).orderOf,
       ← pow_eq_mod_orderOf]
 #align equiv.perm.pow_mod_card_support_cycle_of_self_apply Equiv.Perm.pow_mod_card_support_cycleOf_self_apply
+-/
 
+#print Equiv.Perm.isCycle_cycleOf_iff /-
 /-- `x` is in the support of `f` iff `equiv.perm.cycle_of f x` is a cycle. -/
 theorem isCycle_cycleOf_iff (f : Perm α) : IsCycle (cycleOf f x) ↔ f x ≠ x :=
   by
@@ -1216,29 +1591,35 @@ theorem isCycle_cycleOf_iff (f : Perm α) : IsCycle (cycleOf f x) ↔ f x ≠ x
   rw [Ne.def, ← cycle_of_eq_one_iff f]
   exact hx.ne_one
 #align equiv.perm.is_cycle_cycle_of_iff Equiv.Perm.isCycle_cycleOf_iff
+-/
 
-theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleOf x).Support :=
+#print Equiv.Perm.isCycleOn_support_cycleOf /-
+theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleOf x).support :=
   ⟨f.BijOn <| by simp [mem_support_cycle_of_iff], fun a ha b hb =>
     by
     rw [mem_coe, mem_support_cycle_of_iff] at ha hb
     exact ha.1.symm.trans hb.1⟩
 #align equiv.perm.is_cycle_on_support_cycle_of Equiv.Perm.isCycleOn_support_cycleOf
+-/
 
-theorem SameCycle.exists_pow_eq_of_mem_support (h : SameCycle f x y) (hx : x ∈ f.Support) :
-    ∃ (i : ℕ)(hi' : i < (f.cycleOf x).Support.card), (f ^ i) x = y :=
+#print Equiv.Perm.SameCycle.exists_pow_eq_of_mem_support /-
+theorem SameCycle.exists_pow_eq_of_mem_support (h : SameCycle f x y) (hx : x ∈ f.support) :
+    ∃ (i : ℕ)(hi' : i < (f.cycleOf x).support.card), (f ^ i) x = y :=
   by
   rw [mem_support] at hx
   refine' (f.is_cycle_on_support_cycle_of _).exists_pow_eq _ _ <;>
     rwa [mem_support_cycle_of_iff' hx]
 #align equiv.perm.same_cycle.exists_pow_eq_of_mem_support Equiv.Perm.SameCycle.exists_pow_eq_of_mem_support
+-/
 
+#print Equiv.Perm.SameCycle.exists_pow_eq /-
 theorem SameCycle.exists_pow_eq (f : Perm α) (h : SameCycle f x y) :
-    ∃ (i : ℕ)(hi : 0 < i)(hi' : i ≤ (f.cycleOf x).Support.card + 1), (f ^ i) x = y :=
+    ∃ (i : ℕ)(hi : 0 < i)(hi' : i ≤ (f.cycleOf x).support.card + 1), (f ^ i) x = y :=
   by
   by_cases hx : x ∈ f.support
   · obtain ⟨k, hk, hk'⟩ := h.exists_pow_eq_of_mem_support hx
     cases k
-    · refine' ⟨(f.cycle_of x).Support.card, _, self_le_add_right _ _, _⟩
+    · refine' ⟨(f.cycle_of x).support.card, _, self_le_add_right _ _, _⟩
       · refine' zero_lt_one.trans (one_lt_card_support_of_ne_one _)
         simpa using hx
       · simp only [perm.coe_one, id.def, pow_zero] at hk'
@@ -1251,6 +1632,7 @@ theorem SameCycle.exists_pow_eq (f : Perm α) (h : SameCycle f x y) :
     rw [not_mem_support] at hx
     rw [pow_apply_eq_self_of_apply_eq_self hx, zpow_apply_eq_self_of_apply_eq_self hx]
 #align equiv.perm.same_cycle.exists_pow_eq Equiv.Perm.SameCycle.exists_pow_eq
+-/
 
 end CycleOf
 
@@ -1261,15 +1643,10 @@ end CycleOf
 
 variable [DecidableEq α]
 
-/- warning: equiv.perm.cycle_factors_aux -> Equiv.Perm.cycleFactorsAux is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (l : List.{u1} α) (f : Equiv.Perm.{succ u1} α), (forall {x : α}, (Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) f x) x) -> (Membership.Mem.{u1, u1} α (List.{u1} α) (List.hasMem.{u1} α) x l)) -> (Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l))))
-but is expected to have type
-  PUnit.{succ (succ u1)}
-Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_aux Equiv.Perm.cycleFactorsAuxₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Equiv.Perm.cycleFactorsAux /-
 /-- Given a list `l : list α` and a permutation `f : perm α` whose nonfixed points are all in `l`,
   recursively factors `f` into cycles. -/
 def cycleFactorsAux [Fintype α] :
@@ -1323,7 +1700,9 @@ def cycleFactorsAux [Fintype α] :
                     inv_eq_iff_eq, eq_comm],
             hm₃⟩⟩
 #align equiv.perm.cycle_factors_aux Equiv.Perm.cycleFactorsAux
+-/
 
+#print Equiv.Perm.mem_list_cycles_iff /-
 theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
     (h1 : ∀ σ : Perm α, σ ∈ l → σ.IsCycle) (h2 : l.Pairwise Disjoint) {σ : Perm α} :
     σ ∈ l ↔ σ.IsCycle ∧ ∀ (a : α) (h4 : σ a ≠ a), σ a = l.Prod a :=
@@ -1353,7 +1732,14 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
       refine' h3.eq_on_support_inter_nonempty_congr (h1 _ hτ) key _ ha
       exact key a (mem_inter_of_mem ha hτa)
 #align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
+-/
 
+/- warning: equiv.perm.list_cycles_perm_list_cycles -> Equiv.Perm.list_cycles_perm_list_cycles is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_2 : Finite.{succ u1} α] {l₁ : List.{u1} (Equiv.Perm.{succ u1} α)} {l₂ : List.{u1} (Equiv.Perm.{succ u1} α)}, (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l₁) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l₂)) -> (forall (σ : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) σ l₁) -> (Equiv.Perm.IsCycle.{u1} α σ)) -> (forall (σ : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) σ l₂) -> (Equiv.Perm.IsCycle.{u1} α σ)) -> (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l₁) -> (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l₂) -> (List.Perm.{u1} (Equiv.Perm.{succ u1} α) l₁ l₂)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_2 : Finite.{succ u1} α] {l₁ : List.{u1} (Equiv.Perm.{succ u1} α)} {l₂ : List.{u1} (Equiv.Perm.{succ u1} α)}, (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l₁) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l₂)) -> (forall (σ : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) σ l₁) -> (Equiv.Perm.IsCycle.{u1} α σ)) -> (forall (σ : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) σ l₂) -> (Equiv.Perm.IsCycle.{u1} α σ)) -> (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l₁) -> (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l₂) -> (List.Perm.{u1} (Equiv.Perm.{succ u1} α) l₁ l₂)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cyclesₓ'. -/
 theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List (Perm α)}
     (h₀ : l₁.Prod = l₂.Prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
     (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
@@ -1369,12 +1755,24 @@ theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List
     · exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
 #align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cycles
 
+/- warning: equiv.perm.cycle_factors -> Equiv.Perm.cycleFactors is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] [_inst_3 : LinearOrder.{u1} α] (f : Equiv.Perm.{succ u1} α), Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] [_inst_3 : LinearOrder.{u1} α] (f : Equiv.Perm.{succ u1} α), Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors Equiv.Perm.cycleFactorsₓ'. -/
 /-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`. -/
 def cycleFactors [Fintype α] [LinearOrder α] (f : Perm α) :
     { l : List (Perm α) // l.Prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } :=
   cycleFactorsAux (univ.sort (· ≤ ·)) f fun _ _ => (mem_sort _).2 (mem_univ _)
 #align equiv.perm.cycle_factors Equiv.Perm.cycleFactors
 
+/- warning: equiv.perm.trunc_cycle_factors -> Equiv.Perm.truncCycleFactors is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α), Trunc.{succ u1} (Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α), Trunc.{succ u1} (Subtype.{succ u1} (List.{u1} (Equiv.Perm.{succ u1} α)) (fun (l : List.{u1} (Equiv.Perm.{succ u1} α)) => And (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) f) (And (forall (g : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) g l) -> (Equiv.Perm.IsCycle.{u1} α g)) (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.trunc_cycle_factors Equiv.Perm.truncCycleFactorsₓ'. -/
 /-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`,
   without a linear order. -/
 def truncCycleFactors [Fintype α] (f : Perm α) :
@@ -1387,6 +1785,7 @@ section CycleFactorsFinset
 
 variable [Fintype α] (f : Perm α)
 
+#print Equiv.Perm.cycleFactorsFinset /-
 /-- Factors a permutation `f` into a `finset` of disjoint cyclic permutations that multiply to `f`.
 -/
 def cycleFactorsFinset : Finset (Perm α) :=
@@ -1398,7 +1797,14 @@ def cycleFactorsFinset : Finset (Perm α) :=
       (list_cycles_perm_list_cycles (hl'.left.symm ▸ hl.left) hl.right.left hl'.right.left
         hl.right.right hl'.right.right)
 #align equiv.perm.cycle_factors_finset Equiv.Perm.cycleFactorsFinset
+-/
 
+/- warning: equiv.perm.cycle_factors_finset_eq_list_to_finset -> Equiv.Perm.cycleFactorsFinset_eq_list_toFinset is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {l : List.{u1} (Equiv.Perm.{succ u1} α)}, (List.Nodup.{u1} (Equiv.Perm.{succ u1} α) l) -> (Iff (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ) (List.toFinset.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b) l)) (And (forall (f : Equiv.Perm.{succ u1} α), (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.hasMem.{u1} (Equiv.Perm.{succ u1} α)) f l) -> (Equiv.Perm.IsCycle.{u1} α f)) (And (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l) (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) σ))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {l : List.{u1} (Equiv.Perm.{succ u1} α)}, (List.Nodup.{u1} (Equiv.Perm.{succ u1} α) l) -> (Iff (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 σ) (List.toFinset.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b) l)) (And (forall (f : Equiv.Perm.{succ u1} α), (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (List.{u1} (Equiv.Perm.{succ u1} α)) (List.instMembershipList.{u1} (Equiv.Perm.{succ u1} α)) f l) -> (Equiv.Perm.IsCycle.{u1} α f)) (And (List.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.Disjoint.{u1} α) l) (Eq.{succ u1} (Equiv.Perm.{succ u1} α) (List.prod.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) l) σ))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_eq_list_to_finset Equiv.Perm.cycleFactorsFinset_eq_list_toFinsetₓ'. -/
 theorem cycleFactorsFinset_eq_list_toFinset {σ : Perm α} {l : List (Perm α)} (hn : l.Nodup) :
     σ.cycleFactorsFinset = l.toFinset ↔
       (∀ f : Perm α, f ∈ l → f.IsCycle) ∧ l.Pairwise Disjoint ∧ l.Prod = σ :=
@@ -1423,6 +1829,7 @@ theorem cycleFactorsFinset_eq_list_toFinset {σ : Perm α} {l : List (Perm α)}
     rw [hp, hp']
 #align equiv.perm.cycle_factors_finset_eq_list_to_finset Equiv.Perm.cycleFactorsFinset_eq_list_toFinset
 
+#print Equiv.Perm.cycleFactorsFinset_eq_finset /-
 theorem cycleFactorsFinset_eq_finset {σ : Perm α} {s : Finset (Perm α)} :
     σ.cycleFactorsFinset = s ↔
       (∀ f : Perm α, f ∈ s → f.IsCycle) ∧
@@ -1432,16 +1839,31 @@ theorem cycleFactorsFinset_eq_finset {σ : Perm α} {s : Finset (Perm α)} :
   obtain ⟨l, hl, rfl⟩ := s.exists_list_nodup_eq
   simp [cycle_factors_finset_eq_list_to_finset, hl]
 #align equiv.perm.cycle_factors_finset_eq_finset Equiv.Perm.cycleFactorsFinset_eq_finset
+-/
 
+#print Equiv.Perm.cycleFactorsFinset_pairwise_disjoint /-
 theorem cycleFactorsFinset_pairwise_disjoint :
     (cycleFactorsFinset f : Set (Perm α)).Pairwise Disjoint :=
   (cycleFactorsFinset_eq_finset.mp rfl).2.some
 #align equiv.perm.cycle_factors_finset_pairwise_disjoint Equiv.Perm.cycleFactorsFinset_pairwise_disjoint
+-/
 
+/- warning: equiv.perm.cycle_factors_finset_mem_commute -> Equiv.Perm.cycleFactorsFinset_mem_commute is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α), Set.Pairwise.{u1} (Equiv.Perm.{succ u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Finset.Set.hasCoeT.{u1} (Equiv.Perm.{succ u1} α)))) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α), Set.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Finset.toSet.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_mem_commute Equiv.Perm.cycleFactorsFinset_mem_commuteₓ'. -/
 theorem cycleFactorsFinset_mem_commute : (cycleFactorsFinset f : Set (Perm α)).Pairwise Commute :=
   (cycleFactorsFinset_pairwise_disjoint _).mono' fun _ _ => Disjoint.commute
 #align equiv.perm.cycle_factors_finset_mem_commute Equiv.Perm.cycleFactorsFinset_mem_commute
 
+/- warning: equiv.perm.cycle_factors_finset_noncomm_prod -> Equiv.Perm.cycleFactorsFinset_noncommProd is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (comm : optParam.{0} (Set.Pairwise.{u1} (Equiv.Perm.{succ u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Finset.Set.hasCoeT.{u1} (Equiv.Perm.{succ u1} α)))) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) (Equiv.Perm.cycleFactorsFinset_mem_commute.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Finset.noncommProd.{u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (id.{succ u1} (Equiv.Perm.{succ u1} α)) comm) f
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (f : Equiv.Perm.{succ u1} α) (comm : optParam.{0} (Set.Pairwise.{u1} (Equiv.Perm.{succ u1} α) (Finset.toSet.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)) (Commute.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))) (Equiv.Perm.cycleFactorsFinset_mem_commute.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f)), Eq.{succ u1} (Equiv.Perm.{succ u1} α) (Finset.noncommProd.{u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (id.{succ u1} (Equiv.Perm.{succ u1} α)) comm) f
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_noncomm_prod Equiv.Perm.cycleFactorsFinset_noncommProdₓ'. -/
 /-- The product of cycle factors is equal to the original `f : perm α`. -/
 theorem cycleFactorsFinset_noncommProd
     (comm : (cycleFactorsFinset f : Set (Perm α)).Pairwise Commute :=
@@ -1450,8 +1872,9 @@ theorem cycleFactorsFinset_noncommProd
   (cycleFactorsFinset_eq_finset.mp rfl).2.choose_spec
 #align equiv.perm.cycle_factors_finset_noncomm_prod Equiv.Perm.cycleFactorsFinset_noncommProd
 
+#print Equiv.Perm.mem_cycleFactorsFinset_iff /-
 theorem mem_cycleFactorsFinset_iff {f p : Perm α} :
-    p ∈ cycleFactorsFinset f ↔ p.IsCycle ∧ ∀ a ∈ p.Support, p a = f a :=
+    p ∈ cycleFactorsFinset f ↔ p.IsCycle ∧ ∀ a ∈ p.support, p a = f a :=
   by
   obtain ⟨l, hl, hl'⟩ := f.cycle_factors_finset.exists_list_nodup_eq
   rw [← hl']
@@ -1459,9 +1882,11 @@ theorem mem_cycleFactorsFinset_iff {f p : Perm α} :
   simpa [List.mem_toFinset, Ne.def, ← hl'.right.right] using
     mem_list_cycles_iff hl'.left hl'.right.left
 #align equiv.perm.mem_cycle_factors_finset_iff Equiv.Perm.mem_cycleFactorsFinset_iff
+-/
 
+#print Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff /-
 theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
-    cycleOf f x ∈ cycleFactorsFinset f ↔ x ∈ f.Support :=
+    cycleOf f x ∈ cycleFactorsFinset f ↔ x ∈ f.support :=
   by
   rw [mem_cycle_factors_finset_iff]
   constructor
@@ -1479,33 +1904,53 @@ theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
     · rw [cycle_of_apply_of_not_same_cycle H] at hy
       contradiction
 #align equiv.perm.cycle_of_mem_cycle_factors_finset_iff Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff
+-/
 
+#print Equiv.Perm.mem_cycleFactorsFinset_support_le /-
 theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactorsFinset f) :
-    p.Support ≤ f.Support := by
+    p.support ≤ f.support := by
   rw [mem_cycle_factors_finset_iff] at h
   intro x hx
   rwa [mem_support, ← h.right x hx, ← mem_support]
 #align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_le
+-/
 
+/- warning: equiv.perm.cycle_factors_finset_eq_empty_iff -> Equiv.Perm.cycleFactorsFinset_eq_empty_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, Iff (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasEmptyc.{u1} (Equiv.Perm.{succ u1} α)))) (Eq.{succ u1} (Equiv.Perm.{succ u1} α) f (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α}, Iff (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instEmptyCollectionFinset.{u1} (Equiv.Perm.{succ u1} α)))) (Eq.{succ u1} (Equiv.Perm.{succ u1} α) f (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_eq_empty_iff Equiv.Perm.cycleFactorsFinset_eq_empty_iffₓ'. -/
 theorem cycleFactorsFinset_eq_empty_iff {f : Perm α} : cycleFactorsFinset f = ∅ ↔ f = 1 := by
   simpa [cycle_factors_finset_eq_finset] using eq_comm
 #align equiv.perm.cycle_factors_finset_eq_empty_iff Equiv.Perm.cycleFactorsFinset_eq_empty_iff
 
+/- warning: equiv.perm.cycle_factors_finset_one -> Equiv.Perm.cycleFactorsFinset_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α], Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))) (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasEmptyc.{u1} (Equiv.Perm.{succ u1} α)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α], Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instEmptyCollectionFinset.{u1} (Equiv.Perm.{succ u1} α)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_one Equiv.Perm.cycleFactorsFinset_oneₓ'. -/
 @[simp]
 theorem cycleFactorsFinset_one : cycleFactorsFinset (1 : Perm α) = ∅ := by
   simp [cycle_factors_finset_eq_empty_iff]
 #align equiv.perm.cycle_factors_finset_one Equiv.Perm.cycleFactorsFinset_one
 
+#print Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff /-
 @[simp]
 theorem cycleFactorsFinset_eq_singleton_self_iff {f : Perm α} :
     f.cycleFactorsFinset = {f} ↔ f.IsCycle := by simp [cycle_factors_finset_eq_finset]
 #align equiv.perm.cycle_factors_finset_eq_singleton_self_iff Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff
+-/
 
+#print Equiv.Perm.IsCycle.cycleFactorsFinset_eq_singleton /-
 theorem IsCycle.cycleFactorsFinset_eq_singleton {f : Perm α} (hf : IsCycle f) :
     f.cycleFactorsFinset = {f} :=
   cycleFactorsFinset_eq_singleton_self_iff.mpr hf
 #align equiv.perm.is_cycle.cycle_factors_finset_eq_singleton Equiv.Perm.IsCycle.cycleFactorsFinset_eq_singleton
+-/
 
+#print Equiv.Perm.cycleFactorsFinset_eq_singleton_iff /-
 theorem cycleFactorsFinset_eq_singleton_iff {f g : Perm α} :
     f.cycleFactorsFinset = {g} ↔ f.IsCycle ∧ f = g :=
   by
@@ -1513,7 +1958,9 @@ theorem cycleFactorsFinset_eq_singleton_iff {f g : Perm α} :
   rintro rfl
   exact Iff.rfl
 #align equiv.perm.cycle_factors_finset_eq_singleton_iff Equiv.Perm.cycleFactorsFinset_eq_singleton_iff
+-/
 
+#print Equiv.Perm.cycleFactorsFinset_injective /-
 /-- Two permutations `f g : perm α` have the same cycle factors iff they are the same. -/
 theorem cycleFactorsFinset_injective : Function.Injective (@cycleFactorsFinset α _ _) :=
   by
@@ -1521,7 +1968,14 @@ theorem cycleFactorsFinset_injective : Function.Injective (@cycleFactorsFinset 
   rw [← cycle_factors_finset_noncomm_prod f]
   simpa [h] using cycle_factors_finset_noncomm_prod g
 #align equiv.perm.cycle_factors_finset_injective Equiv.Perm.cycleFactorsFinset_injective
+-/
 
+/- warning: equiv.perm.disjoint.disjoint_cycle_factors_finset -> Equiv.Perm.Disjoint.disjoint_cycleFactorsFinset is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (Disjoint.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.partialOrder.{u1} (Equiv.Perm.{succ u1} α)) (Finset.orderBot.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (Disjoint.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.partialOrder.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instOrderBotFinsetToLEToPreorderPartialOrder.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint.disjoint_cycle_factors_finset Equiv.Perm.Disjoint.disjoint_cycleFactorsFinsetₓ'. -/
 theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g) :
     Disjoint (cycleFactorsFinset f) (cycleFactorsFinset g) :=
   by
@@ -1534,6 +1988,12 @@ theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g)
   simp [ha, ← hf a ha, ← hg a ha]
 #align equiv.perm.disjoint.disjoint_cycle_factors_finset Equiv.Perm.Disjoint.disjoint_cycleFactorsFinset
 
+/- warning: equiv.perm.disjoint.cycle_factors_finset_mul_eq_union -> Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_union is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g)) (Union.union.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasUnion.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Equiv.Perm.Disjoint.{u1} α f g) -> (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) f g)) (Union.union.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instUnionFinset.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 f) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint.cycle_factors_finset_mul_eq_union Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_unionₓ'. -/
 theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f g) :
     cycleFactorsFinset (f * g) = cycleFactorsFinset f ∪ cycleFactorsFinset g :=
   by
@@ -1549,6 +2009,12 @@ theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f
     rw [cycle_factors_finset_noncomm_prod, cycle_factors_finset_noncomm_prod]
 #align equiv.perm.disjoint.cycle_factors_finset_mul_eq_union Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_union
 
+/- warning: equiv.perm.disjoint_mul_inv_of_mem_cycle_factors_finset -> Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasMem.{u1} (Equiv.Perm.{succ u1} α)) f (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)) -> (Equiv.Perm.Disjoint.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f)) f)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instMembershipFinset.{u1} (Equiv.Perm.{succ u1} α)) f (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)) -> (Equiv.Perm.Disjoint.{u1} α (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f)) f)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint_mul_inv_of_mem_cycle_factors_finset Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinsetₓ'. -/
 theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cycleFactorsFinset g) :
     Disjoint (g * f⁻¹) f := by
   rw [mem_cycle_factors_finset_iff] at h
@@ -1560,8 +2026,9 @@ theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cy
     rwa [← support_inv, apply_mem_support, support_inv, mem_support]
 #align equiv.perm.disjoint_mul_inv_of_mem_cycle_factors_finset Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset
 
+#print Equiv.Perm.cycle_is_cycleOf /-
 /-- If c is a cycle, a ∈ c.support and c is a cycle of f, then `c = f.cycle_of a` -/
-theorem cycle_is_cycleOf {f c : Equiv.Perm α} {a : α} (ha : a ∈ c.Support)
+theorem cycle_is_cycleOf {f c : Equiv.Perm α} {a : α} (ha : a ∈ c.support)
     (hc : c ∈ f.cycleFactorsFinset) : c = f.cycleOf a :=
   by
   suffices f.cycle_of a = c.cycle_of a by
@@ -1579,9 +2046,16 @@ theorem cycle_is_cycleOf {f c : Equiv.Perm α} {a : α} (ha : a ∈ c.Support)
     equiv.perm.not_mem_support.mp
       (finset.disjoint_left.mp (Equiv.Perm.Disjoint.disjoint_support hfc) ha)
 #align equiv.perm.cycle_is_cycle_of Equiv.Perm.cycle_is_cycleOf
+-/
 
 end CycleFactorsFinset
 
+/- warning: equiv.perm.cycle_induction_on -> Equiv.Perm.cycle_induction_on is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_2 : Finite.{succ u1} β] (P : (Equiv.Perm.{succ u1} β) -> Prop) (σ : Equiv.Perm.{succ u1} β), (P (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} β) 1 (One.one.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β))))))))) -> (forall (σ : Equiv.Perm.{succ u1} β), (Equiv.Perm.IsCycle.{u1} β σ) -> (P σ)) -> (forall (σ : Equiv.Perm.{succ u1} β) (τ : Equiv.Perm.{succ u1} β), (Equiv.Perm.Disjoint.{u1} β σ τ) -> (Equiv.Perm.IsCycle.{u1} β σ) -> (P σ) -> (P τ) -> (P (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.{succ u1} β) (Equiv.Perm.{succ u1} β) (instHMul.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))) σ τ))) -> (P σ)
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_2 : Finite.{succ u1} β] (P : (Equiv.Perm.{succ u1} β) -> Prop) (σ : Equiv.Perm.{succ u1} β), (P (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} β) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} β) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} β) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))))) -> (forall (σ : Equiv.Perm.{succ u1} β), (Equiv.Perm.IsCycle.{u1} β σ) -> (P σ)) -> (forall (σ : Equiv.Perm.{succ u1} β) (τ : Equiv.Perm.{succ u1} β), (Equiv.Perm.Disjoint.{u1} β σ τ) -> (Equiv.Perm.IsCycle.{u1} β σ) -> (P σ) -> (P τ) -> (P (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.{succ u1} β) (Equiv.Perm.{succ u1} β) (instHMul.{u1} (Equiv.Perm.{succ u1} β) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} β) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} β) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} β) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))))) σ τ))) -> (P σ)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_induction_on Equiv.Perm.cycle_induction_onₓ'. -/
 @[elab_as_elim]
 theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (base_one : P 1)
     (base_cycles : ∀ σ : Perm β, σ.IsCycle → P σ)
@@ -1604,6 +2078,12 @@ theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (ba
         (ih (fun τ hτ => h1 τ (List.mem_cons_of_mem σ hτ)) h2.of_cons)
 #align equiv.perm.cycle_induction_on Equiv.Perm.cycle_induction_on
 
+/- warning: equiv.perm.cycle_factors_finset_mul_inv_mem_eq_sdiff -> Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Membership.Mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasMem.{u1} (Equiv.Perm.{succ u1} α)) f (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)) -> (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) f))) (SDiff.sdiff.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasSdiff.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g) (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.hasSingleton.{u1} (Equiv.Perm.{succ u1} α)) f)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {f : Equiv.Perm.{succ u1} α} {g : Equiv.Perm.{succ u1} α}, (Membership.mem.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instMembershipFinset.{u1} (Equiv.Perm.{succ u1} α)) f (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g)) -> (Eq.{succ u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) g (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) f))) (SDiff.sdiff.{u1} (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instSDiffFinset.{u1} (Equiv.Perm.{succ u1} α) (fun (a : Equiv.Perm.{succ u1} α) (b : Equiv.Perm.{succ u1} α) => Fintype.decidableEqEquivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 a b)) (Equiv.Perm.cycleFactorsFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 g) (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Finset.{u1} (Equiv.Perm.{succ u1} α)) (Finset.instSingletonFinset.{u1} (Equiv.Perm.{succ u1} α)) f)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.cycle_factors_finset_mul_inv_mem_eq_sdiff Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiffₓ'. -/
 theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
     (h : f ∈ cycleFactorsFinset g) : cycleFactorsFinset (g * f⁻¹) = cycleFactorsFinset g \ {f} :=
   by
@@ -1653,6 +2133,12 @@ variable [Finite β]
 
 open Subgroup
 
+/- warning: equiv.perm.closure_is_cycle -> Equiv.Perm.closure_isCycle is a dubious translation:
+lean 3 declaration is
+  forall {β : Type.{u1}} [_inst_2 : Finite.{succ u1} β], Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β) (setOf.{u1} (Equiv.Perm.{succ u1} β) (fun (σ : Equiv.Perm.{succ u1} β) => Equiv.Perm.IsCycle.{u1} β σ))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)) (Subgroup.hasTop.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))
+but is expected to have type
+  forall {β : Type.{u1}} [_inst_2 : Finite.{succ u1} β], Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β) (setOf.{u1} (Equiv.Perm.{succ u1} β) (fun (σ : Equiv.Perm.{succ u1} β) => Equiv.Perm.IsCycle.{u1} β σ))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)) (Subgroup.instTopSubgroup.{u1} (Equiv.Perm.{succ u1} β) (Equiv.Perm.permGroup.{u1} β)))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.closure_is_cycle Equiv.Perm.closure_isCycleₓ'. -/
 theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤ := by
   classical
     cases nonempty_fintype β
@@ -1662,7 +2148,13 @@ theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤ := by
 
 variable [Fintype α]
 
-theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.Support = ⊤) (x : α) :
+/- warning: equiv.perm.closure_cycle_adjacent_swap -> Equiv.Perm.closure_cycle_adjacent_swap is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Top.top.{u1} (Finset.{u1} α) (BooleanAlgebra.toHasTop.{u1} (Finset.{u1} α) (Finset.booleanAlgebra.{u1} α _inst_3 (fun (a : α) (b : α) => _inst_1 a b))))) -> (forall (x : α), Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasInsert.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasSingleton.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x))))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.hasTop.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Top.top.{u1} (Finset.{u1} α) (BooleanAlgebra.toTop.{u1} (Finset.{u1} α) (Finset.booleanAlgebra.{u1} α _inst_3 (fun (a : α) (b : α) => _inst_1 a b))))) -> (forall (x : α), Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instInsertSet.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instSingletonSet.{u1} (Equiv.Perm.{succ u1} α)) (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x))))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.instTopSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swapₓ'. -/
+theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.support = ⊤) (x : α) :
     closure ({σ, swap x (σ x)} : Set (Perm α)) = ⊤ :=
   by
   let H := closure ({σ, swap x (σ x)} : Set (perm α))
@@ -1715,13 +2207,14 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.Su
   exact step4 y z
 #align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swap
 
+#print Equiv.Perm.closure_cycle_coprime_swap /-
 theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n (Fintype.card α))
-    (h1 : IsCycle σ) (h2 : σ.Support = Finset.univ) (x : α) :
+    (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
     closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ :=
   by
   rw [← Finset.card_univ, ← h2, ← h1.order_of] at h0
   cases' exists_pow_eq_self_of_coprime h0 with m hm
-  have h2' : (σ ^ n).Support = ⊤ := Eq.trans (support_pow_coprime h0) h2
+  have h2' : (σ ^ n).support = ⊤ := Eq.trans (support_pow_coprime h0) h2
   have h1' : is_cycle ((σ ^ n) ^ (m : ℤ)) := by rwa [← hm] at h1
   replace h1' : is_cycle (σ ^ n) :=
     h1'.of_pow (le_trans (support_pow_le σ n) (ge_of_eq (congr_arg support hm)))
@@ -1730,9 +2223,16 @@ theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n
     ⟨Subgroup.pow_mem (closure _) (subset_closure (Set.mem_insert σ _)) n,
       set.singleton_subset_iff.mpr (subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _)))⟩
 #align equiv.perm.closure_cycle_coprime_swap Equiv.Perm.closure_cycle_coprime_swap
+-/
 
+/- warning: equiv.perm.closure_prime_cycle_swap -> Equiv.Perm.closure_prime_cycle_swap is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, (Nat.Prime (Fintype.card.{u1} α _inst_3)) -> (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Finset.univ.{u1} α _inst_3)) -> (Equiv.Perm.IsSwap.{u1} α (fun (a : α) (b : α) => _inst_1 a b) τ) -> (Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasInsert.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.hasSingleton.{u1} (Equiv.Perm.{succ u1} α)) τ))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.hasTop.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_3 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, (Nat.Prime (Fintype.card.{u1} α _inst_3)) -> (Equiv.Perm.IsCycle.{u1} α σ) -> (Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_3 σ) (Finset.univ.{u1} α _inst_3)) -> (Equiv.Perm.IsSwap.{u1} α (fun (a : α) (b : α) => _inst_1 a b) τ) -> (Eq.{succ u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.closure.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α) (Insert.insert.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instInsertSet.{u1} (Equiv.Perm.{succ u1} α)) σ (Singleton.singleton.{u1, u1} (Equiv.Perm.{succ u1} α) (Set.{u1} (Equiv.Perm.{succ u1} α)) (Set.instSingletonSet.{u1} (Equiv.Perm.{succ u1} α)) τ))) (Top.top.{u1} (Subgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)) (Subgroup.instTopSubgroup.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.closure_prime_cycle_swap Equiv.Perm.closure_prime_cycle_swapₓ'. -/
 theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime) (h1 : IsCycle σ)
-    (h2 : σ.Support = Finset.univ) (h3 : IsSwap τ) : closure ({σ, τ} : Set (Perm α)) = ⊤ :=
+    (h2 : σ.support = Finset.univ) (h3 : IsSwap τ) : closure ({σ, τ} : Set (Perm α)) = ⊤ :=
   by
   obtain ⟨x, y, h4, h5⟩ := h3
   obtain ⟨i, hi⟩ :=
@@ -1754,10 +2254,11 @@ variable [Fintype α] {σ τ : Perm α}
 
 noncomputable section
 
+#print Equiv.Perm.isConj_of_support_equiv /-
 theorem isConj_of_support_equiv
-    (f : { x // x ∈ (σ.Support : Set α) } ≃ { x // x ∈ (τ.Support : Set α) })
+    (f : { x // x ∈ (σ.support : Set α) } ≃ { x // x ∈ (τ.support : Set α) })
     (hf :
-      ∀ (x : α) (hx : x ∈ (σ.Support : Set α)),
+      ∀ (x : α) (hx : x ∈ (σ.support : Set α)),
         (f ⟨σ x, apply_mem_support.2 hx⟩ : α) = τ ↑(f ⟨x, hx⟩)) :
     IsConj σ τ := by
   refine' isConj_iff.2 ⟨Equiv.extendSubtype f, _⟩
@@ -1771,8 +2272,10 @@ theorem isConj_of_support_equiv
     rwa [Classical.not_not.1 ((not_congr mem_support).1 (Equiv.extendSubtype_not_mem f _ _)),
       Classical.not_not.1 ((not_congr mem_support).mp hx)]
 #align equiv.perm.is_conj_of_support_equiv Equiv.Perm.isConj_of_support_equiv
+-/
 
-theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.Support.card = τ.Support.card) :
+#print Equiv.Perm.IsCycle.isConj /-
+theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.card = τ.support.card) :
     IsConj σ τ :=
   by
   refine'
@@ -1791,9 +2294,11 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.Support.car
     zpowersEquivZpowers_apply]
   rw [pow_succ, perm.mul_apply]
 #align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
+-/
 
+#print Equiv.Perm.IsCycle.isConj_iff /-
 theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
-    IsConj σ τ ↔ σ.Support.card = τ.Support.card :=
+    IsConj σ τ ↔ σ.support.card = τ.support.card :=
   ⟨by
     intro h
     obtain ⟨π, rfl⟩ := isConj_iff.1 h
@@ -1807,20 +2312,39 @@ theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
       rw [mem_support, Classical.not_not, perm.mul_apply, perm.mul_apply, hb, perm.apply_inv_self],
     hσ.IsConj hτ⟩
 #align equiv.perm.is_cycle.is_conj_iff Equiv.Perm.IsCycle.isConj_iff
+-/
 
+/- warning: equiv.perm.support_conj -> Equiv.Perm.support_conj is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) σ))) (Finset.map.{u1, u1} α α (Equiv.toEmbedding.{succ u1, succ u1} α α σ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 τ))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, Eq.{succ u1} (Finset.{u1} α) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ))) (Finset.map.{u1, u1} α α (Equiv.toEmbedding.{succ u1, succ u1} α α σ) (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 τ))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.support_conj Equiv.Perm.support_conjₓ'. -/
 @[simp]
-theorem support_conj : (σ * τ * σ⁻¹).Support = τ.Support.map σ.toEmbedding :=
+theorem support_conj : (σ * τ * σ⁻¹).support = τ.support.map σ.toEmbedding :=
   by
   ext
   simp only [mem_map_equiv, perm.coe_mul, comp_app, Ne.def, perm.mem_support, Equiv.eq_symm_apply]
   rfl
 #align equiv.perm.support_conj Equiv.Perm.support_conj
 
-theorem card_support_conj : (σ * τ * σ⁻¹).Support.card = τ.Support.card := by simp
+/- warning: equiv.perm.card_support_conj -> Equiv.Perm.card_support_conj is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, Eq.{1} Nat (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toHasInv.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) σ)))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 τ))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α}, Eq.{1} Nat (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (Inv.inv.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toInv.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))) σ)))) (Finset.card.{u1} α (Equiv.Perm.support.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 τ))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.card_support_conj Equiv.Perm.card_support_conjₓ'. -/
+theorem card_support_conj : (σ * τ * σ⁻¹).support.card = τ.support.card := by simp
 #align equiv.perm.card_support_conj Equiv.Perm.card_support_conj
 
 end
 
+/- warning: equiv.perm.disjoint.is_conj_mul -> Equiv.Perm.Disjoint.isConj_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_2 : Finite.{succ u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α} {π : Equiv.Perm.{succ u1} α} {ρ : Equiv.Perm.{succ u1} α}, (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) σ π) -> (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) τ ρ) -> (Equiv.Perm.Disjoint.{u1} α σ τ) -> (Equiv.Perm.Disjoint.{u1} α π ρ) -> (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) π ρ))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_2 : Finite.{succ u1} α] {σ : Equiv.Perm.{succ u1} α} {τ : Equiv.Perm.{succ u1} α} {π : Equiv.Perm.{succ u1} α} {ρ : Equiv.Perm.{succ u1} α}, (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) σ π) -> (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) τ ρ) -> (Equiv.Perm.Disjoint.{u1} α σ τ) -> (Equiv.Perm.Disjoint.{u1} α π ρ) -> (IsConj.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) σ τ) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (Equiv.Perm.{succ u1} α) (instHMul.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))) π ρ))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.disjoint.is_conj_mul Equiv.Perm.Disjoint.isConj_mulₓ'. -/
 theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
     (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
   classical
@@ -1879,6 +2403,12 @@ section FixedPoints
 -/
 
 
+/- warning: equiv.perm.fixed_point_card_lt_of_ne_one -> Equiv.Perm.fixed_point_card_lt_of_ne_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Ne.{succ u1} (Equiv.Perm.{succ u1} α) σ (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (OfNat.mk.{u1} (Equiv.Perm.{succ u1} α) 1 (One.one.{u1} (Equiv.Perm.{succ u1} α) (MulOneClass.toHasOne.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))))))))) -> (LT.lt.{0} Nat Nat.hasLt (Finset.card.{u1} α (Finset.filter.{u1} α (fun (x : α) => Eq.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ x) x) (fun (a : α) => _inst_1 (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) σ a) a) (Finset.univ.{u1} α _inst_2))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) (Fintype.card.{u1} α _inst_2) (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] {σ : Equiv.Perm.{succ u1} α}, (Ne.{succ u1} (Equiv.Perm.{succ u1} α) σ (OfNat.ofNat.{u1} (Equiv.Perm.{succ u1} α) 1 (One.toOfNat1.{u1} (Equiv.Perm.{succ u1} α) (InvOneClass.toOne.{u1} (Equiv.Perm.{succ u1} α) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivisionMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))))) -> (LT.lt.{0} Nat instLTNat (Finset.card.{u1} α (Finset.filter.{u1} α (fun (x : α) => Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ x) x) (fun (a : α) => _inst_1 (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) σ a) a) (Finset.univ.{u1} α _inst_2))) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) (Fintype.card.{u1} α _inst_2) (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))
+Case conversion may be inaccurate. Consider using '#align equiv.perm.fixed_point_card_lt_of_ne_one Equiv.Perm.fixed_point_card_lt_of_ne_oneₓ'. -/
 theorem fixed_point_card_lt_of_ne_one [Fintype α] {σ : Perm α} (h : σ ≠ 1) :
     (filter (fun x => σ x = x) univ).card < Fintype.card α - 1 :=
   by
@@ -1896,6 +2426,7 @@ namespace List
 
 variable [DecidableEq α] {l : List α}
 
+#print List.Nodup.isCycleOn_formPerm /-
 theorem Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn { a | a ∈ l } :=
   by
   refine' ⟨l.form_perm.bij_on fun _ => form_perm_mem_iff_mem, fun a ha b hb => _⟩
@@ -1906,6 +2437,7 @@ theorem Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn { a | a 
     Equiv.Perm.coe_mul, form_perm_pow_apply_nth_le _ h]
   rw [add_comm]
 #align list.nodup.is_cycle_on_form_perm List.Nodup.isCycleOn_formPerm
+-/
 
 end List
 
@@ -1913,10 +2445,22 @@ namespace Int
 
 open Equiv
 
+/- warning: int.add_left_one_is_cycle -> Int.addLeft_one_isCycle is a dubious translation:
+lean 3 declaration is
+  Equiv.Perm.IsCycle.{0} Int (Equiv.addLeft.{0} Int Int.addGroup (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))
+but is expected to have type
+  Equiv.Perm.IsCycle.{0} Int (Equiv.addLeft.{0} Int Int.instAddGroupInt (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))
+Case conversion may be inaccurate. Consider using '#align int.add_left_one_is_cycle Int.addLeft_one_isCycleₓ'. -/
 theorem addLeft_one_isCycle : (Equiv.addLeft 1 : Perm ℤ).IsCycle :=
   ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
 #align int.add_left_one_is_cycle Int.addLeft_one_isCycle
 
+/- warning: int.add_right_one_is_cycle -> Int.addRight_one_isCycle is a dubious translation:
+lean 3 declaration is
+  Equiv.Perm.IsCycle.{0} Int (Equiv.addRight.{0} Int Int.addGroup (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))
+but is expected to have type
+  Equiv.Perm.IsCycle.{0} Int (Equiv.addRight.{0} Int Int.instAddGroupInt (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))
+Case conversion may be inaccurate. Consider using '#align int.add_right_one_is_cycle Int.addRight_one_isCycleₓ'. -/
 theorem addRight_one_isCycle : (Equiv.addRight 1 : Perm ℤ).IsCycle :=
   ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
 #align int.add_right_one_is_cycle Int.addRight_one_isCycle
@@ -1927,14 +2471,16 @@ namespace Finset
 
 variable [DecidableEq α] [Fintype α]
 
-theorem exists_cycle_on (s : Finset α) : ∃ f : Perm α, f.IsCycleOn s ∧ f.Support ⊆ s :=
+#print Finset.exists_cycleOn /-
+theorem exists_cycleOn (s : Finset α) : ∃ f : Perm α, f.IsCycleOn s ∧ f.support ⊆ s :=
   by
   refine'
     ⟨s.to_list.form_perm, _, fun x hx => by
       simpa using List.mem_of_formPerm_apply_ne _ _ (perm.mem_support.1 hx)⟩
   convert s.nodup_to_list.is_cycle_on_form_perm
   simp
-#align finset.exists_cycle_on Finset.exists_cycle_on
+#align finset.exists_cycle_on Finset.exists_cycleOn
+-/
 
 end Finset
 
@@ -1942,7 +2488,13 @@ namespace Set
 
 variable {f : Perm α} {s : Set α}
 
-theorem Countable.exists_cycle_on (hs : s.Countable) :
+/- warning: set.countable.exists_cycle_on -> Set.Countable.exists_cycleOn is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {s : Set.{u1} α}, (Set.Countable.{u1} α s) -> (Exists.{succ u1} (Equiv.Perm.{succ u1} α) (fun (f : Equiv.Perm.{succ u1} α) => And (Equiv.Perm.IsCycleOn.{u1} α f s) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (setOf.{u1} α (fun (x : α) => Ne.{succ u1} α (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} α) (fun (_x : Equiv.{succ u1, succ u1} α α) => α -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} α α) f x) x)) s)))
+but is expected to have type
+  forall {α : Type.{u1}} [s : DecidableEq.{succ u1} α] {hs : Set.{u1} α}, (Set.Countable.{u1} α hs) -> (Exists.{succ u1} (Equiv.Perm.{succ u1} α) (fun (f : Equiv.Perm.{succ u1} α) => And (Equiv.Perm.IsCycleOn.{u1} α f hs) (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (setOf.{u1} α (fun (x : α) => Ne.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} α) α (fun (a : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => α) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α α) f x) x)) hs)))
+Case conversion may be inaccurate. Consider using '#align set.countable.exists_cycle_on Set.Countable.exists_cycleOnₓ'. -/
+theorem Countable.exists_cycleOn (hs : s.Countable) :
     ∃ f : Perm α, f.IsCycleOn s ∧ { x | f x ≠ x } ⊆ s := by
   classical
     obtain hs' | hs' := s.finite_or_infinite
@@ -1961,9 +2513,10 @@ theorem Countable.exists_cycle_on (hs : s.Countable) :
     rw [image_comp, Equiv.image_eq_preimage]
     ext
     simp
-#align set.countable.exists_cycle_on Set.Countable.exists_cycle_on
+#align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_self_eq_unionᵢ_perm /-
 theorem prod_self_eq_unionᵢ_perm (hf : f.IsCycleOn s) :
     s ×ˢ s = ⋃ n : ℤ, (fun a => (a, (f ^ n) a)) '' s :=
   by
@@ -1975,6 +2528,7 @@ theorem prod_self_eq_unionᵢ_perm (hf : f.IsCycleOn s) :
   · rintro ⟨n, a, ha, ⟨⟩⟩
     exact ⟨ha, (hf.1.perm_zpow _).MapsTo ha⟩
 #align set.prod_self_eq_Union_perm Set.prod_self_eq_unionᵢ_perm
+-/
 
 end Set
 
@@ -1982,6 +2536,7 @@ namespace Finset
 
 variable {f : Perm α} {s : Finset α}
 
+#print Finset.product_self_eq_disj_Union_perm_aux /-
 theorem product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
     (range s.card : Set ℕ).PairwiseDisjoint fun k =>
       s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩ :=
@@ -1999,6 +2554,7 @@ theorem product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
     rw [mem_coe, mem_range] at hm hn
     exact hmn.symm (h.eq_of_lt_of_lt hn hm)
 #align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disj_Union_perm_aux
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /-- We can partition the square `s ×ˢ s` into shifted diagonals as such:
@@ -2034,6 +2590,12 @@ namespace Finset
 
 variable [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : Perm ι}
 
+/- warning: finset.sum_smul_sum_eq_sum_perm -> Finset.sum_smul_sum_eq_sum_perm is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Semiring.{u2} α] [_inst_2 : AddCommMonoid.{u3} β] [_inst_3 : Module.{u2, u3} α β _inst_1 _inst_2] {s : Finset.{u1} ι} {σ : Equiv.Perm.{succ u1} ι}, (Equiv.Perm.IsCycleOn.{u1} ι σ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} ι) (Set.{u1} ι) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (Finset.Set.hasCoeT.{u1} ι))) s)) -> (forall (f : ι -> α) (g : ι -> β), Eq.{succ u3} β (SMul.smul.{u2, u3} α β (SMulZeroClass.toHasSmul.{u2, u3} α β (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (SMulWithZero.toSmulZeroClass.{u2, u3} α β (MulZeroClass.toHasZero.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α (MonoidWithZero.toMulZeroOneClass.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1)))) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (MulActionWithZero.toSMulWithZero.{u2, u3} α β (Semiring.toMonoidWithZero.{u2} α _inst_1) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (Module.toMulActionWithZero.{u2, u3} α β _inst_1 _inst_2 _inst_3)))) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u3, u1} β ι _inst_2 s (fun (i : ι) => g i))) (Finset.sum.{u3, 0} β Nat _inst_2 (Finset.range (Finset.card.{u1} ι s)) (fun (k : Nat) => Finset.sum.{u3, u1} β ι _inst_2 s (fun (i : ι) => SMul.smul.{u2, u3} α β (SMulZeroClass.toHasSmul.{u2, u3} α β (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (SMulWithZero.toSmulZeroClass.{u2, u3} α β (MulZeroClass.toHasZero.{u2} α (MulZeroOneClass.toMulZeroClass.{u2} α (MonoidWithZero.toMulZeroOneClass.{u2} α (Semiring.toMonoidWithZero.{u2} α _inst_1)))) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (MulActionWithZero.toSMulWithZero.{u2, u3} α β (Semiring.toMonoidWithZero.{u2} α _inst_1) (AddZeroClass.toHasZero.{u3} β (AddMonoid.toAddZeroClass.{u3} β (AddCommMonoid.toAddMonoid.{u3} β _inst_2))) (Module.toMulActionWithZero.{u2, u3} α β _inst_1 _inst_2 _inst_3)))) (f i) (g (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} ι) Nat (Equiv.Perm.{succ u1} ι) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} ι) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} ι) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Equiv.Perm.permGroup.{u1} ι))))) σ k) i))))))
+but is expected to have type
+  forall {ι : Type.{u3}} {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Semiring.{u1} α] [_inst_2 : AddCommMonoid.{u2} β] [_inst_3 : Module.{u1, u2} α β _inst_1 _inst_2] {s : Finset.{u3} ι} {σ : Equiv.Perm.{succ u3} ι}, (Equiv.Perm.IsCycleOn.{u3} ι σ (Finset.toSet.{u3} ι s)) -> (forall (f : ι -> α) (g : ι -> β), Eq.{succ u2} β (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (Finset.sum.{u1, u3} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => g i))) (Finset.sum.{u2, 0} β Nat _inst_2 (Finset.range (Finset.card.{u3} ι s)) (fun (k : Nat) => Finset.sum.{u2, u3} β ι _inst_2 s (fun (i : ι) => HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (SMulZeroClass.toSMul.{u1, u2} α β (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (SMulWithZero.toSMulZeroClass.{u1, u2} α β (MonoidWithZero.toZero.{u1} α (Semiring.toMonoidWithZero.{u1} α _inst_1)) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (MulActionWithZero.toSMulWithZero.{u1, u2} α β (Semiring.toMonoidWithZero.{u1} α _inst_1) (AddMonoid.toZero.{u2} β (AddCommMonoid.toAddMonoid.{u2} β _inst_2)) (Module.toMulActionWithZero.{u1, u2} α β _inst_1 _inst_2 _inst_3))))) (f i) (g (FunLike.coe.{succ u3, succ u3, succ u3} (Equiv.Perm.{succ u3} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u3, succ u3} ι ι) (HPow.hPow.{u3, 0, u3} (Equiv.Perm.{succ u3} ι) Nat (Equiv.Perm.{succ u3} ι) (instHPow.{u3, 0} (Equiv.Perm.{succ u3} ι) Nat (Monoid.Pow.{u3} (Equiv.Perm.{succ u3} ι) (DivInvMonoid.toMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Group.toDivInvMonoid.{u3} (Equiv.Perm.{succ u3} ι) (Equiv.Perm.permGroup.{u3} ι))))) σ k) i))))))
+Case conversion may be inaccurate. Consider using '#align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_permₓ'. -/
 theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
     ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) :=
   by
@@ -2041,6 +2603,12 @@ theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι
   rfl
 #align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_perm
 
+/- warning: finset.sum_mul_sum_eq_sum_perm -> Finset.sum_mul_sum_eq_sum_perm is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : Type.{u2}} [_inst_1 : Semiring.{u2} α] {s : Finset.{u1} ι} {σ : Equiv.Perm.{succ u1} ι}, (Equiv.Perm.IsCycleOn.{u1} ι σ ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} ι) (Set.{u1} ι) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} ι) (Set.{u1} ι) (Finset.Set.hasCoeT.{u1} ι))) s)) -> (forall (f : ι -> α) (g : ι -> α), Eq.{succ u2} α (HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))))) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => g i))) (Finset.sum.{u2, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) (Finset.range (Finset.card.{u1} ι s)) (fun (k : Nat) => Finset.sum.{u2, u1} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))) s (fun (i : ι) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (Distrib.toHasMul.{u2} α (NonUnitalNonAssocSemiring.toDistrib.{u2} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} α (Semiring.toNonAssocSemiring.{u2} α _inst_1))))) (f i) (g (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} ι) (fun (_x : Equiv.{succ u1, succ u1} ι ι) => ι -> ι) (Equiv.hasCoeToFun.{succ u1, succ u1} ι ι) (HPow.hPow.{u1, 0, u1} (Equiv.Perm.{succ u1} ι) Nat (Equiv.Perm.{succ u1} ι) (instHPow.{u1, 0} (Equiv.Perm.{succ u1} ι) Nat (Monoid.Pow.{u1} (Equiv.Perm.{succ u1} ι) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} ι) (Equiv.Perm.permGroup.{u1} ι))))) σ k) i))))))
+but is expected to have type
+  forall {ι : Type.{u2}} {α : Type.{u1}} [_inst_1 : Semiring.{u1} α] {s : Finset.{u2} ι} {σ : Equiv.Perm.{succ u2} ι}, (Equiv.Perm.IsCycleOn.{u2} ι σ (Finset.toSet.{u2} ι s)) -> (forall (f : ι -> α) (g : ι -> α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => f i)) (Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => g i))) (Finset.sum.{u1, 0} α Nat (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) (Finset.range (Finset.card.{u2} ι s)) (fun (k : Nat) => Finset.sum.{u1, u2} α ι (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1))) s (fun (i : ι) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (NonUnitalNonAssocSemiring.toMul.{u1} α (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} α (Semiring.toNonAssocSemiring.{u1} α _inst_1)))) (f i) (g (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.Perm.{succ u2} ι) ι (fun (_x : ι) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : ι) => ι) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} ι ι) (HPow.hPow.{u2, 0, u2} (Equiv.Perm.{succ u2} ι) Nat (Equiv.Perm.{succ u2} ι) (instHPow.{u2, 0} (Equiv.Perm.{succ u2} ι) Nat (Monoid.Pow.{u2} (Equiv.Perm.{succ u2} ι) (DivInvMonoid.toMonoid.{u2} (Equiv.Perm.{succ u2} ι) (Group.toDivInvMonoid.{u2} (Equiv.Perm.{succ u2} ι) (Equiv.Perm.permGroup.{u2} ι))))) σ k) i))))))
+Case conversion may be inaccurate. Consider using '#align finset.sum_mul_sum_eq_sum_perm Finset.sum_mul_sum_eq_sum_permₓ'. -/
 theorem sum_mul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f g : ι → α) :
     ((∑ i in s, f i) * ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i * g ((σ ^ k) i) :=
   sum_smul_sum_eq_sum_perm hσ f g

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

@@ -810,7 +810,7 @@ theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Pe
   ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy =>
     by
     rw [← preimage_inv] at hx hy
-    convert (h.2 hx hy).conj <;> rw [apply_inv_self]⟩
+    convert(h.2 hx hy).conj <;> rw [apply_inv_self]⟩
 #align equiv.perm.is_cycle_on.conj Equiv.Perm.IsCycleOn.conj
 
 theorem isCycleOn_swap [DecidableEq α] (hab : a ≠ b) : (swap a b).IsCycleOn {a, b} :=
@@ -871,7 +871,7 @@ protected theorem IsCycleOn.subtypePerm (hf : f.IsCycleOn s) :
   obtain hs | hs := s.subsingleton_or_nontrivial
   · haveI := hs.coe_sort
     exact is_cycle_on_of_subsingleton _ _
-  convert (hf.is_cycle_subtype_perm hs).IsCycleOn
+  convert(hf.is_cycle_subtype_perm hs).IsCycleOn
   rw [eq_comm, Set.eq_univ_iff_forall]
   exact fun x => ne_of_apply_ne (coe : s → α) (hf.apply_ne hs x.Prop)
 #align equiv.perm.is_cycle_on.subtype_perm Equiv.Perm.IsCycleOn.subtypePerm

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

@@ -453,7 +453,7 @@ theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ)
 
 protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.Support.card :=
   by
-  rw [order_eq_card_zpowers, ← Fintype.card_coe]
+  rw [orderOf_eq_card_zpowers, ← Fintype.card_coe]
   convert Fintype.card_congr (is_cycle.zpowers_equiv_support hf)
 #align equiv.perm.is_cycle.order_of Equiv.Perm.IsCycle.orderOf
 

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

• add mem_or_mem_of_zipWith_swap_prod_ne, a version of zipWith_swap_prod_support' without any Finsets;
• move it and related lemmas up, use them to golf lemmas about formPerm;
• convert explicit -> implicit arguments here and there;
• formPerm_reverse doesn't need Nodup

@@ -1001,7 +1001,7 @@ variable [DecidableEq α] [Fintype α]
 theorem exists_cycleOn (s : Finset α) :
     ∃ f : Perm α, f.IsCycleOn s ∧ f.support ⊆ s := by
   refine ⟨s.toList.formPerm, ?_, fun x hx => by
-    simpa using List.mem_of_formPerm_apply_ne _ _ (Perm.mem_support.1 hx)⟩
+    simpa using List.mem_of_formPerm_apply_ne (Perm.mem_support.1 hx)⟩
   convert s.nodup_toList.isCycleOn_formPerm
   simp
 #align finset.exists_cycle_on Finset.exists_cycleOn
@@ -1017,7 +1017,7 @@ theorem Countable.exists_cycleOn (hs : s.Countable) :
   classical
   obtain hs' | hs' := s.finite_or_infinite
   · refine ⟨hs'.toFinset.toList.formPerm, ?_, fun x hx => by
-      simpa using List.mem_of_formPerm_apply_ne _ _ hx⟩
+      simpa using List.mem_of_formPerm_apply_ne hx⟩
     convert hs'.toFinset.nodup_toList.isCycleOn_formPerm
     simp
   · haveI := hs.to_subtype

@@ -979,7 +979,6 @@ section
 
 variable [DecidableEq α] {l : List α}
 
-set_option linter.deprecated false in -- nthLe
 theorem Nodup.isCycleOn_formPerm (h : l.Nodup) :
     l.formPerm.IsCycleOn { a | a ∈ l } := by
   refine' ⟨l.formPerm.bijOn fun _ => List.formPerm_mem_iff_mem, fun a ha b hb => _⟩
@@ -987,7 +986,7 @@ theorem Nodup.isCycleOn_formPerm (h : l.Nodup) :
   rw [← List.indexOf_get ha, ← List.indexOf_get hb]
   refine' ⟨l.indexOf b - l.indexOf a, _⟩
   simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_natCast,
-    Equiv.Perm.coe_mul, ← List.nthLe_eq, List.formPerm_pow_apply_nthLe _ h, Function.comp]
+    Equiv.Perm.coe_mul, List.formPerm_pow_apply_get _ h, Function.comp]
   rw [add_comm]
 #align list.nodup.is_cycle_on_form_perm List.Nodup.isCycleOn_formPerm
 

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

@@ -814,10 +814,10 @@ theorem isCycleOn_swap [DecidableEq α] (hab : a ≠ b) : (swap a b).IsCycleOn {
   ⟨bijOn_swap (by simp) (by simp), fun x hx y hy => by
     rw [Set.mem_insert_iff, Set.mem_singleton_iff] at hx hy
     obtain rfl | rfl := hx <;> obtain rfl | rfl := hy
-    · exact ⟨0, by rw [zpow_zero, coe_one, id.def]⟩
+    · exact ⟨0, by rw [zpow_zero, coe_one, id]⟩
     · exact ⟨1, by rw [zpow_one, swap_apply_left]⟩
     · exact ⟨1, by rw [zpow_one, swap_apply_right]⟩
-    · exact ⟨0, by rw [zpow_zero, coe_one, id.def]⟩⟩
+    · exact ⟨0, by rw [zpow_zero, coe_one, id]⟩⟩
 #align equiv.perm.is_cycle_on_swap Equiv.Perm.isCycleOn_swap
 
 protected theorem IsCycleOn.apply_ne (hf : f.IsCycleOn s) (hs : s.Nontrivial) (ha : a ∈ s) :

This is less exhaustive than its sibling #11486 because edge cases are harder to classify. No fundamental difficulty, just me being a bit fast and lazy.

Reduce the diff of #11203

@@ -228,7 +228,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
   classical
     rintro ⟨k, rfl⟩
     use (k % orderOf f).natAbs
-    have h₀ := Int.coe_nat_pos.mpr (orderOf_pos f)
+    have h₀ := Int.natCast_pos.mpr (orderOf_pos f)
     have h₁ := Int.emod_nonneg k h₀.ne'
     rw [← zpow_natCast, Int.natAbs_of_nonneg h₁, zpow_mod_orderOf]
     refine' ⟨_, by rfl⟩

@@ -313,7 +313,7 @@ end CycleOf
 section cycleFactors
 
 open scoped List in
-/-- Given a list `l : List α` and a permutation `f : perm α` whose nonfixed points are all in `l`,
+/-- Given a list `l : List α` and a permutation `f : Perm α` whose nonfixed points are all in `l`,
   recursively factors `f` into cycles. -/
 def cycleFactorsAux [DecidableEq α] [Fintype α] :
     ∀ (l : List α) (f : Perm α),
@@ -352,8 +352,7 @@ def cycleFactorsAux [DecidableEq α] [Fintype α] :
               have hgm : (g::m.erase g) ~ m :=
                 List.cons_perm_iff_perm_erase.2 ⟨hg, List.Perm.refl _⟩
               have : ∀ h ∈ m.erase g, Disjoint g h :=
-                (List.pairwise_cons.1
-                    ((hgm.pairwise_iff @fun a b (h : Disjoint a b) => h.symm).2 hm₃)).1
+                (List.pairwise_cons.1 ((hgm.pairwise_iff Disjoint.symm).2 hm₃)).1
               by_cases id fun hgy : g y ≠ y =>
                 (disjoint_prod_right _ this y).resolve_right <| by
                   have hsc : SameCycle f⁻¹ x (f y) := by

Reduce the diff of #11499

Renames

All in the Int namespace:

• ofNat_eq_cast → ofNat_eq_natCast
• cast_eq_cast_iff_Nat → natCast_inj
• natCast_eq_ofNat → ofNat_eq_natCast
• coe_nat_sub → natCast_sub
• coe_nat_nonneg → natCast_nonneg
• sign_coe_add_one → sign_natCast_add_one
• nat_succ_eq_int_succ → natCast_succ
• succ_neg_nat_succ → succ_neg_natCast_succ
• coe_pred_of_pos → natCast_pred_of_pos
• coe_nat_div → natCast_div
• coe_nat_ediv → natCast_ediv
• sign_coe_nat_of_nonzero → sign_natCast_of_ne_zero
• toNat_coe_nat → toNat_natCast
• toNat_coe_nat_add_one → toNat_natCast_add_one
• coe_nat_dvd → natCast_dvd_natCast
• coe_nat_dvd_left → natCast_dvd
• coe_nat_dvd_right → dvd_natCast
• le_coe_nat_sub → le_natCast_sub
• succ_coe_nat_pos → succ_natCast_pos
• coe_nat_modEq_iff → natCast_modEq_iff
• coe_natAbs → natCast_natAbs
• coe_nat_eq_zero → natCast_eq_zero
• coe_nat_ne_zero → natCast_ne_zero
• coe_nat_ne_zero_iff_pos → natCast_ne_zero_iff_pos
• abs_coe_nat → abs_natCast
• coe_nat_nonpos_iff → natCast_nonpos_iff

Also rename Nat.coe_nat_dvd to Nat.cast_dvd_cast

@@ -249,12 +249,12 @@ instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f
   decidable_of_iff (∃ n ∈ List.range (Fintype.card (Perm α)), (f ^ n) x = y)
     ⟨fun ⟨n, _, hn⟩ => ⟨n, hn⟩, fun ⟨i, hi⟩ => ⟨(i % orderOf f).natAbs,
       List.mem_range.2 (Int.ofNat_lt.1 <| by
-        rw [Int.natAbs_of_nonneg (Int.emod_nonneg _ <| Int.coe_nat_ne_zero.2 (orderOf_pos _).ne')]
-        · refine' (Int.emod_lt _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _).trans_le _
+        rw [Int.natAbs_of_nonneg (Int.emod_nonneg _ <| Int.natCast_ne_zero.2 (orderOf_pos _).ne')]
+        · refine' (Int.emod_lt _ <| Int.natCast_ne_zero_iff_pos.2 <| orderOf_pos _).trans_le _
           simp [orderOf_le_card_univ]),
       by
         rw [← zpow_natCast, Int.natAbs_of_nonneg (Int.emod_nonneg _ <|
-          Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _), zpow_mod_orderOf, hi]⟩⟩
+          Int.natCast_ne_zero_iff_pos.2 <| orderOf_pos _), zpow_mod_orderOf, hi]⟩⟩
 
 end SameCycle
 
@@ -340,7 +340,7 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
   let ⟨n, hn⟩ := hf.exists_zpow_eq hx hy
   classical exact
       ⟨(n % orderOf f).toNat, by
-        {have := n.emod_nonneg (Int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
+        {have := n.emod_nonneg (Int.natCast_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
          rwa [← zpow_natCast, Int.toNat_of_nonneg this, zpow_mod_orderOf]}⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 
@@ -892,10 +892,10 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
 
 theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
     ∀ {n : ℤ}, (f ^ n) a = a ↔ (s.card : ℤ) ∣ n
-  | Int.ofNat n => (hf.pow_apply_eq ha).trans Int.coe_nat_dvd.symm
+  | Int.ofNat n => (hf.pow_apply_eq ha).trans Int.natCast_dvd_natCast.symm
   | Int.negSucc n => by
     rw [zpow_negSucc, ← inv_pow]
-    exact (hf.inv.pow_apply_eq ha).trans (dvd_neg.trans Int.coe_nat_dvd).symm
+    exact (hf.inv.pow_apply_eq ha).trans (dvd_neg.trans Int.natCast_dvd_natCast).symm
 #align equiv.perm.is_cycle_on.zpow_apply_eq Equiv.Perm.IsCycleOn.zpow_apply_eq
 
 theorem IsCycleOn.pow_apply_eq_pow_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s)

@@ -233,7 +233,7 @@ theorem mem_support_cycleOf_iff : y ∈ support (f.cycleOf x) ↔ SameCycle f x
     simp [hx]
   · rw [mem_support, cycleOf_apply]
     split_ifs with hy
-    · simp only [hx, hy, iff_true_iff, Ne.def, not_false_iff, and_self_iff, mem_support]
+    · simp only [hx, hy, iff_true_iff, Ne, not_false_iff, and_self_iff, mem_support]
       rcases hy with ⟨k, rfl⟩
       rw [← not_mem_support]
       simpa using hx
@@ -260,7 +260,7 @@ theorem pow_mod_card_support_cycleOf_self_apply (f : Perm α) (n : ℕ) (x : α)
 /-- `x` is in the support of `f` iff `Equiv.Perm.cycle_of f x` is a cycle. -/
 theorem isCycle_cycleOf_iff (f : Perm α) : IsCycle (cycleOf f x) ↔ f x ≠ x := by
   refine' ⟨fun hx => _, f.isCycle_cycleOf⟩
-  rw [Ne.def, ← cycleOf_eq_one_iff f]
+  rw [Ne, ← cycleOf_eq_one_iff f]
   exact hx.ne_one
 #align equiv.perm.is_cycle_cycle_of_iff Equiv.Perm.isCycle_cycleOf_iff
 
@@ -335,10 +335,10 @@ def cycleFactorsAux [DecidableEq α] [Fintype α] :
         intro y hy
         exact List.mem_of_ne_of_mem
             (fun h : y = x => by
-              rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycleOf_apply_self] at hy
+              rw [h, mul_apply, Ne, inv_eq_iff_eq, cycleOf_apply_self] at hy
               exact hy rfl)
             (h fun h : f y = y => by
-              rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycleOf_apply] at hy
+              rw [mul_apply, h, Ne, inv_eq_iff_eq, cycleOf_apply] at hy
               split_ifs at hy <;> tauto))
       ⟨cycleOf f x::m, by
         rw [List.prod_cons, hm₁]
@@ -495,7 +495,7 @@ theorem mem_cycleFactorsFinset_iff {f p : Perm α} :
   obtain ⟨l, hl, hl'⟩ := f.cycleFactorsFinset.exists_list_nodup_eq
   rw [← hl']
   rw [eq_comm, cycleFactorsFinset_eq_list_toFinset hl] at hl'
-  simpa [List.mem_toFinset, Ne.def, ← hl'.right.right] using
+  simpa [List.mem_toFinset, Ne, ← hl'.right.right] using
     mem_list_cycles_iff hl'.left hl'.right.left
 #align equiv.perm.mem_cycle_factors_finset_iff Equiv.Perm.mem_cycleFactorsFinset_iff
 

@@ -427,7 +427,7 @@ theorem isCycle_swap_mul_aux₁ {α : Type*} [DecidableEq α] :
       else
         have : f b ≠ b ∧ b ≠ x := ne_and_ne_of_swap_mul_apply_ne_self hb
         have hb' : (swap x (f x) * f) (f⁻¹ b) ≠ f⁻¹ b := by
-          rw [mul_apply, apply_inv_self, swap_apply_of_ne_of_ne this.2 (Ne.symm hfbx), Ne.def, ←
+          rw [mul_apply, apply_inv_self, swap_apply_of_ne_of_ne this.2 (Ne.symm hfbx), Ne, ←
             f.injective.eq_iff, apply_inv_self]
           exact this.1
         let ⟨i, hi⟩ := hn hb' (f.injective <| by
@@ -450,9 +450,8 @@ theorem isCycle_swap_mul_aux₂ {α : Type*} [DecidableEq α] :
         have hb : (swap x (f⁻¹ x) * f⁻¹) (f⁻¹ b) ≠ f⁻¹ b := by
           rw [mul_apply, swap_apply_def]
           split_ifs <;>
-              simp only [inv_eq_iff_eq, Perm.mul_apply, zpow_negSucc,
-                Ne.def, Perm.apply_inv_self] at
-                * <;> tauto
+            simp only [inv_eq_iff_eq, Perm.mul_apply, zpow_negSucc, Ne, Perm.apply_inv_self] at *
+              <;> tauto
         let ⟨i, hi⟩ :=
           isCycle_swap_mul_aux₁ n hb
             (show (f⁻¹ ^ n) (f⁻¹ x) = f⁻¹ b by

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

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

where the latter is more natural

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

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

but it seems to no longer apply.

Remarks on the PR :

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

@@ -68,7 +68,7 @@ theorem cycleOf_pow_apply_self (f : Perm α) (x : α) : ∀ n : ℕ, (cycleOf f
   intro n
   induction' n with n hn
   · rfl
-  · rw [pow_succ, mul_apply, cycleOf_apply, hn, if_pos, pow_succ, mul_apply]
+  · rw [pow_succ', mul_apply, cycleOf_apply, hn, if_pos, pow_succ', mul_apply]
     exact ⟨n, rfl⟩
 #align equiv.perm.cycle_of_pow_apply_self Equiv.Perm.cycleOf_pow_apply_self
 

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

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

where the latter is more natural

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

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

but it seems to no longer apply.

Remarks on the PR :

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

@@ -431,7 +431,7 @@ theorem isCycle_swap_mul_aux₁ {α : Type*} [DecidableEq α] :
             f.injective.eq_iff, apply_inv_self]
           exact this.1
         let ⟨i, hi⟩ := hn hb' (f.injective <| by
-          rw [apply_inv_self]; rwa [pow_succ, mul_apply] at h)
+          rw [apply_inv_self]; rwa [pow_succ', mul_apply] at h)
         ⟨i + 1, by
           rw [add_comm, zpow_add, mul_apply, hi, zpow_one, mul_apply, apply_inv_self,
             swap_apply_of_ne_of_ne (ne_and_ne_of_swap_mul_apply_ne_self hb).2 (Ne.symm hfbx)]⟩
@@ -457,7 +457,7 @@ theorem isCycle_swap_mul_aux₂ {α : Type*} [DecidableEq α] :
           isCycle_swap_mul_aux₁ n hb
             (show (f⁻¹ ^ n) (f⁻¹ x) = f⁻¹ b by
               rw [← zpow_natCast, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc,
-                ← inv_pow, pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_natCast,
+                ← inv_pow, pow_succ, mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_natCast,
                 ← pow_succ', ← pow_succ])
         have h : (swap x (f⁻¹ x) * f⁻¹) (f x) = f⁻¹ x := by
           rw [mul_apply, inv_apply_self, swap_apply_left]
@@ -735,15 +735,14 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
   intro x hx
   simp only [Perm.mul_apply, Equiv.trans_apply, Equiv.sumCongr_apply]
   obtain ⟨n, rfl⟩ := hσ.exists_pow_eq (Classical.choose_spec hσ).1 (mem_support.1 hx)
-  apply
-    Eq.trans _
-      (congr rfl (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply n).symm))))
-  apply (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply (n + 1))))).trans _
+  erw [hσ.zpowersEquivSupport_symm_apply n]
+  simp only [← Perm.mul_apply, ← pow_succ']
+  erw [hσ.zpowersEquivSupport_symm_apply (n + 1)]
   -- This used to be a `simp only` before leanprover/lean4#2644
-  erw [zpowersEquivZPowers_apply, zpowersEquivZPowers_apply]
-  dsimp
-    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-  erw [pow_succ, Perm.mul_apply]
+  erw [zpowersEquivZPowers_apply, zpowersEquivZPowers_apply, zpowersEquivSupport_apply]
+  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+  simp_rw [pow_succ', Perm.mul_apply]
+  rfl
 #align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
 
 theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :

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

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

where the latter is more natural

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

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

but it seems to no longer apply.

Remarks on the PR :

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

@@ -55,7 +55,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
     induction' n with n ih
     · exact subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _))
     · convert H.mul_mem (H.mul_mem h3 ih) (H.inv_mem h3)
-      simp_rw [mul_swap_eq_swap_mul, mul_inv_cancel_right, pow_succ]
+      simp_rw [mul_swap_eq_swap_mul, mul_inv_cancel_right, pow_succ']
       rfl
   have step2 : ∀ n : ℕ, swap x ((σ ^ n) x) ∈ H := by
     intro n
@@ -63,7 +63,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
     · simp only [Nat.zero_eq, pow_zero, coe_one, id_eq, swap_self, Set.mem_singleton_iff]
       convert H.one_mem
     · by_cases h5 : x = (σ ^ n) x
-      · rw [pow_succ, mul_apply, ← h5]
+      · rw [pow_succ', mul_apply, ← h5]
         exact h4
       by_cases h6 : x = (σ ^ (n + 1) : Perm α) x
       · rw [← h6, swap_self]

Lemma names around cancellation of multiplication and division are a mess.

This PR renames a handful of them according to the following table (each big row contains the multiplicative statement, then the three rows contain the GroupWithZero lemma name, the Group lemma, the AddGroup lemma name).

| Statement | New name | Old name | |

@@ -462,7 +462,7 @@ theorem isCycle_swap_mul_aux₂ {α : Type*} [DecidableEq α] :
         have h : (swap x (f⁻¹ x) * f⁻¹) (f x) = f⁻¹ x := by
           rw [mul_apply, inv_apply_self, swap_apply_left]
         ⟨-i, by
-          rw [← add_sub_cancel i 1, neg_sub, sub_eq_add_neg, zpow_add, zpow_one, zpow_neg,
+          rw [← add_sub_cancel_right i 1, neg_sub, sub_eq_add_neg, zpow_add, zpow_one, zpow_neg,
             ← inv_zpow, mul_inv_rev, swap_inv, mul_swap_eq_swap_mul, inv_apply_self, swap_comm _ x,
             zpow_add, zpow_one, mul_apply, mul_apply (_ ^ i), h, hi, mul_apply, apply_inv_self,
             swap_apply_of_ne_of_ne this.2 (Ne.symm hfbx')]⟩

... and add a deprecated alias for the old name. This is mostly just me discovering the power of F2

@@ -157,12 +157,12 @@ theorem sameCycle_zpow_right {n : ℤ} : SameCycle f x ((f ^ n) y) ↔ SameCycle
 
 @[simp]
 theorem sameCycle_pow_left {n : ℕ} : SameCycle f ((f ^ n) x) y ↔ SameCycle f x y := by
-  rw [← zpow_coe_nat, sameCycle_zpow_left]
+  rw [← zpow_natCast, sameCycle_zpow_left]
 #align equiv.perm.same_cycle_pow_left Equiv.Perm.sameCycle_pow_left
 
 @[simp]
 theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y := by
-  rw [← zpow_coe_nat, sameCycle_zpow_right]
+  rw [← zpow_natCast, sameCycle_zpow_right]
 #align equiv.perm.same_cycle_pow_right Equiv.Perm.sameCycle_pow_right
 
 alias ⟨SameCycle.of_apply_left, SameCycle.apply_left⟩ := sameCycle_apply_left
@@ -230,7 +230,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
     use (k % orderOf f).natAbs
     have h₀ := Int.coe_nat_pos.mpr (orderOf_pos f)
     have h₁ := Int.emod_nonneg k h₀.ne'
-    rw [← zpow_coe_nat, Int.natAbs_of_nonneg h₁, zpow_mod_orderOf]
+    rw [← zpow_natCast, Int.natAbs_of_nonneg h₁, zpow_mod_orderOf]
     refine' ⟨_, by rfl⟩
     rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
     exact Int.emod_lt_of_pos _ h₀
@@ -253,7 +253,7 @@ instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f
         · refine' (Int.emod_lt _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _).trans_le _
           simp [orderOf_le_card_univ]),
       by
-        rw [← zpow_coe_nat, Int.natAbs_of_nonneg (Int.emod_nonneg _ <|
+        rw [← zpow_natCast, Int.natAbs_of_nonneg (Int.emod_nonneg _ <|
           Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _), zpow_mod_orderOf, hi]⟩⟩
 
 end SameCycle
@@ -341,7 +341,7 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
   classical exact
       ⟨(n % orderOf f).toNat, by
         {have := n.emod_nonneg (Int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
-         rwa [← zpow_coe_nat, Int.toNat_of_nonneg this, zpow_mod_orderOf]}⟩
+         rwa [← zpow_natCast, Int.toNat_of_nonneg this, zpow_mod_orderOf]}⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 
 end Finite
@@ -456,8 +456,8 @@ theorem isCycle_swap_mul_aux₂ {α : Type*} [DecidableEq α] :
         let ⟨i, hi⟩ :=
           isCycle_swap_mul_aux₁ n hb
             (show (f⁻¹ ^ n) (f⁻¹ x) = f⁻¹ b by
-              rw [← zpow_coe_nat, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc,
-                ← inv_pow, pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_coe_nat,
+              rw [← zpow_natCast, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc,
+                ← inv_pow, pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_natCast,
                 ← pow_succ', ← pow_succ])
         have h : (swap x (f⁻¹ x) * f⁻¹) (f x) = f⁻¹ x := by
           rw [mul_apply, inv_apply_self, swap_apply_left]
@@ -688,7 +688,7 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
       · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
         simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
       · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
-        simp only [zpow_one, zpow_coe_nat] at h
+        simp only [zpow_one, zpow_natCast] at h
         rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).injective] at hfa
         contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
@@ -923,10 +923,10 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
     obtain ⟨n, rfl⟩ := hf.2 ha hb
     obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.dvd
     refine' ⟨n.natMod s.card, Int.natMod_lt (Nonempty.card_pos ⟨a, ha⟩).ne', _⟩
-    rw [← zpow_coe_nat, Int.natMod,
+    rw [← zpow_natCast, Int.natMod,
       Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2
         (Nonempty.card_pos ⟨a, ha⟩).ne'), sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
-    simp only [zpow_coe_nat, coe_mul, comp_apply, EmbeddingLike.apply_eq_iff_eq]
+    simp only [zpow_natCast, coe_mul, comp_apply, EmbeddingLike.apply_eq_iff_eq]
     exact IsFixedPt.perm_zpow (hf.pow_card_apply ha) _
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
 
@@ -988,7 +988,7 @@ theorem Nodup.isCycleOn_formPerm (h : l.Nodup) :
   rw [Set.mem_setOf, ← List.indexOf_lt_length] at ha hb
   rw [← List.indexOf_get ha, ← List.indexOf_get hb]
   refine' ⟨l.indexOf b - l.indexOf a, _⟩
-  simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_coe_nat,
+  simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_natCast,
     Equiv.Perm.coe_mul, ← List.nthLe_eq, List.formPerm_pow_apply_nthLe _ h, Function.comp]
   rw [add_comm]
 #align list.nodup.is_cycle_on_form_perm List.Nodup.isCycleOn_formPerm

The file Mathlib.GroupTheory.Perm.Cycle.Basic was too big and this PR splits it in several components:

• Mathlib.GroupTheory.Perm.Cycle.Basic contains everything related to a permutation being a cycle,
• Mathlib.GroupTheory.Perm.Cycle.Factors is about the cycles of a permutation and the decomposition of a permutation into disjoint cycles
• Mathlib.GroupTheory.Perm.Closure contains generation results for the permutation groups
• Mathlib.GroupTheory.Perm.Finite contains general results specific to permutation of finite types

I moved some results to Mathlib.GroupTheory.Perm.Support

I also moved some results from Mathlib.GroupTheory.Perm.Sign to Mathlib.GroupTheory.Perm.Finite

Some imports could be reduced, and the shake linter required a few adjustments in some other.

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

The file Mathlib.GroupTheory.Perm.Cycle.Basic was too big and this PR splits it in several components:

• Mathlib.GroupTheory.Perm.Cycle.Basic contains everything related to a permutation being a cycle,
• Mathlib.GroupTheory.Perm.Cycle.Factors is about the cycles of a permutation and the decomposition of a permutation into disjoint cycles
• Mathlib.GroupTheory.Perm.Closure contains generation results for the permutation groups
• Mathlib.GroupTheory.Perm.Finite contains general results specific to permutation of finite types

I moved some results to Mathlib.GroupTheory.Perm.Support

I also moved some results from Mathlib.GroupTheory.Perm.Sign to Mathlib.GroupTheory.Perm.Finite

Some imports could be reduced, and the shake linter required a few adjustments in some other.

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

@@ -3,20 +3,18 @@ Copyright (c) 2019 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Yaël Dillies
 -/
+
 import Mathlib.Algebra.Module.BigOperators
-import Mathlib.Data.Finset.NoncommProd
 import Mathlib.Data.Fintype.Perm
-import Mathlib.Data.Int.ModEq
+import Mathlib.GroupTheory.Perm.Finite
 import Mathlib.GroupTheory.Perm.List
-import Mathlib.GroupTheory.Perm.Sign
-import Mathlib.Logic.Equiv.Fintype
 
 #align_import group_theory.perm.cycle.basic from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
 
 /-!
-# Cyclic permutations
+# Cycles of a permutation
 
-This file develops the theory of cycles in permutations.
+This file starts the theory of cycles in permutations.
 
 ## Main definitions
 
@@ -28,23 +26,6 @@ In the following, `f : Equiv.Perm β`.
 * `Equiv.Perm.IsCycleOn`: `f` is a cycle on a set `s` when any two points of `s` are related by
   repeated applications of `f`.
 
-The following two definitions require that `β` is a `Fintype`:
-
-* `Equiv.Perm.cycleOf`: `f.cycleOf x` is the cycle of `f` that `x` belongs to.
-* `Equiv.Perm.cycleFactors`: `f.cycleFactors` is a list of disjoint cyclic permutations that
-  multiply to `f`.
-
-## Main results
-
-* This file contains several closure results:
-  - `closure_isCycle` : The symmetric group is generated by cycles
-  - `closure_cycle_adjacent_swap` : The symmetric group is generated by
-    a cycle and an adjacent transposition
-  - `closure_cycle_coprime_swap` : The symmetric group is generated by
-    a cycle and a coprime transposition
-  - `closure_prime_cycle_swap` : The symmetric group is generated by
-    a prime cycle and a transposition
-
 ## Notes
 
 `Equiv.Perm.IsCycle` and `Equiv.Perm.IsCycleOn` are different in three ways:
@@ -64,7 +45,6 @@ namespace Equiv.Perm
 
 /-! ### `SameCycle` -/
 
-
 section SameCycle
 
 variable {f g : Perm α} {p : α → Prop} {x y z : α}
@@ -282,7 +262,6 @@ end SameCycle
 ### `IsCycle`
 -/
 
-
 section IsCycle
 
 variable {f g : Perm α} {x y : α}
@@ -732,8 +711,59 @@ theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf
 
 end IsCycle
 
-/-! ### `IsCycleOn` -/
+open Equiv
+
+theorem _root_.Int.addLeft_one_isCycle : (Equiv.addLeft 1 : Perm ℤ).IsCycle :=
+  ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
+#align int.add_left_one_is_cycle Int.addLeft_one_isCycle
+
+theorem _root_.Int.addRight_one_isCycle : (Equiv.addRight 1 : Perm ℤ).IsCycle :=
+  ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
+#align int.add_right_one_is_cycle Int.addRight_one_isCycle
+
+section Conjugation
+
+variable [Fintype α] [DecidableEq α] {σ τ : Perm α}
+
+theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.card = τ.support.card) :
+    IsConj σ τ := by
+  refine'
+    isConj_of_support_equiv
+      (hσ.zpowersEquivSupport.symm.trans <|
+        (zpowersEquivZPowers <| by rw [hσ.orderOf, h, hτ.orderOf]).trans hτ.zpowersEquivSupport)
+      _
+  intro x hx
+  simp only [Perm.mul_apply, Equiv.trans_apply, Equiv.sumCongr_apply]
+  obtain ⟨n, rfl⟩ := hσ.exists_pow_eq (Classical.choose_spec hσ).1 (mem_support.1 hx)
+  apply
+    Eq.trans _
+      (congr rfl (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply n).symm))))
+  apply (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply (n + 1))))).trans _
+  -- This used to be a `simp only` before leanprover/lean4#2644
+  erw [zpowersEquivZPowers_apply, zpowersEquivZPowers_apply]
+  dsimp
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+  erw [pow_succ, Perm.mul_apply]
+#align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
+
+theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
+    IsConj σ τ ↔ σ.support.card = τ.support.card :=
+  ⟨by
+    intro h
+    obtain ⟨π, rfl⟩ := (_root_.isConj_iff).1 h
+    refine' Finset.card_congr (fun a _ => π a) (fun _ ha => _) (fun _ _ _ _ ab => π.injective ab)
+        fun b hb => _
+    · simp [mem_support.1 ha]
+    · refine' ⟨π⁻¹ b, ⟨_, π.apply_inv_self b⟩⟩
+      contrapose! hb
+      rw [mem_support, Classical.not_not] at hb
+      rw [mem_support, Classical.not_not, Perm.mul_apply, Perm.mul_apply, hb, Perm.apply_inv_self],
+    hσ.isConj hτ⟩
+#align equiv.perm.is_cycle.is_conj_iff Equiv.Perm.IsCycle.isConj_iff
+
+end Conjugation
 
+/-! ### `IsCycleOn` -/
 
 section IsCycleOn
 
@@ -940,897 +970,19 @@ protected theorem IsCycleOn.countable (hs : f.IsCycleOn s) : s.Countable := by
   · exact (Set.countable_range fun n : ℤ => (⇑(f ^ n) : α → α) a).mono (hs.2 ha)
 #align equiv.perm.is_cycle_on.countable Equiv.Perm.IsCycleOn.countable
 
-end IsCycleOn
-
-/-!
-### `cycleOf`
--/
-
-
-section CycleOf
-
-variable [DecidableEq α] [Fintype α] {f g : Perm α} {x y : α}
-
-/-- `f.cycleOf x` is the cycle of the permutation `f` to which `x` belongs. -/
-def cycleOf (f : Perm α) (x : α) : Perm α :=
-  ofSubtype (subtypePerm f fun _ => sameCycle_apply_right.symm : Perm { y // SameCycle f x y })
-#align equiv.perm.cycle_of Equiv.Perm.cycleOf
-
-theorem cycleOf_apply (f : Perm α) (x y : α) :
-    cycleOf f x y = if SameCycle f x y then f y else y := by
-  dsimp only [cycleOf]
-  split_ifs with h
-  · apply ofSubtype_apply_of_mem
-    exact h
-  · apply ofSubtype_apply_of_not_mem
-    exact h
-#align equiv.perm.cycle_of_apply Equiv.Perm.cycleOf_apply
-
-theorem cycleOf_inv (f : Perm α) (x : α) : (cycleOf f x)⁻¹ = cycleOf f⁻¹ x :=
-  Equiv.ext fun y => by
-    rw [inv_eq_iff_eq, cycleOf_apply, cycleOf_apply]
-    split_ifs <;> simp_all [sameCycle_inv, sameCycle_inv_apply_right]
-#align equiv.perm.cycle_of_inv Equiv.Perm.cycleOf_inv
-
-@[simp]
-theorem cycleOf_pow_apply_self (f : Perm α) (x : α) : ∀ n : ℕ, (cycleOf f x ^ n) x = (f ^ n) x := by
-  intro n
-  induction' n with n hn
-  · rfl
-  · rw [pow_succ, mul_apply, cycleOf_apply, hn, if_pos, pow_succ, mul_apply]
-    exact ⟨n, rfl⟩
-#align equiv.perm.cycle_of_pow_apply_self Equiv.Perm.cycleOf_pow_apply_self
-
-@[simp]
-theorem cycleOf_zpow_apply_self (f : Perm α) (x : α) :
-    ∀ n : ℤ, (cycleOf f x ^ n) x = (f ^ n) x := by
-  intro z
-  induction' z with z hz
-  · exact cycleOf_pow_apply_self f x z
-  · rw [zpow_negSucc, ← inv_pow, cycleOf_inv, zpow_negSucc, ← inv_pow, cycleOf_pow_apply_self]
-#align equiv.perm.cycle_of_zpow_apply_self Equiv.Perm.cycleOf_zpow_apply_self
-
-theorem SameCycle.cycleOf_apply : SameCycle f x y → cycleOf f x y = f y :=
-  ofSubtype_apply_of_mem _
-#align equiv.perm.same_cycle.cycle_of_apply Equiv.Perm.SameCycle.cycleOf_apply
-
-theorem cycleOf_apply_of_not_sameCycle : ¬SameCycle f x y → cycleOf f x y = y :=
-  ofSubtype_apply_of_not_mem _
-#align equiv.perm.cycle_of_apply_of_not_same_cycle Equiv.Perm.cycleOf_apply_of_not_sameCycle
-
-theorem SameCycle.cycleOf_eq (h : SameCycle f x y) : cycleOf f x = cycleOf f y := by
-  ext z
-  rw [Equiv.Perm.cycleOf_apply]
-  split_ifs with hz
-  · exact (h.symm.trans hz).cycleOf_apply.symm
-  · exact (cycleOf_apply_of_not_sameCycle (mt h.trans hz)).symm
-#align equiv.perm.same_cycle.cycle_of_eq Equiv.Perm.SameCycle.cycleOf_eq
-
-@[simp]
-theorem cycleOf_apply_apply_zpow_self (f : Perm α) (x : α) (k : ℤ) :
-    cycleOf f x ((f ^ k) x) = (f ^ (k + 1) : Perm α) x := by
-  rw [SameCycle.cycleOf_apply]
-  · rw [add_comm, zpow_add, zpow_one, mul_apply]
-  · exact ⟨k, rfl⟩
-#align equiv.perm.cycle_of_apply_apply_zpow_self Equiv.Perm.cycleOf_apply_apply_zpow_self
-
-@[simp]
-theorem cycleOf_apply_apply_pow_self (f : Perm α) (x : α) (k : ℕ) :
-    cycleOf f x ((f ^ k) x) = (f ^ (k + 1) : Perm α) x := by
-  convert cycleOf_apply_apply_zpow_self f x k using 1
-#align equiv.perm.cycle_of_apply_apply_pow_self Equiv.Perm.cycleOf_apply_apply_pow_self
-
-@[simp]
-theorem cycleOf_apply_apply_self (f : Perm α) (x : α) : cycleOf f x (f x) = f (f x) := by
-  convert cycleOf_apply_apply_pow_self f x 1 using 1
-#align equiv.perm.cycle_of_apply_apply_self Equiv.Perm.cycleOf_apply_apply_self
-
-@[simp]
-theorem cycleOf_apply_self (f : Perm α) (x : α) : cycleOf f x x = f x :=
-  SameCycle.rfl.cycleOf_apply
-#align equiv.perm.cycle_of_apply_self Equiv.Perm.cycleOf_apply_self
-
-theorem IsCycle.cycleOf_eq (hf : IsCycle f) (hx : f x ≠ x) : cycleOf f x = f :=
-  Equiv.ext fun y =>
-    if h : SameCycle f x y then by rw [h.cycleOf_apply]
-    else by
-      rw [cycleOf_apply_of_not_sameCycle h,
-        Classical.not_not.1 (mt ((isCycle_iff_sameCycle hx).1 hf).2 h)]
-#align equiv.perm.is_cycle.cycle_of_eq Equiv.Perm.IsCycle.cycleOf_eq
-
-@[simp]
-theorem cycleOf_eq_one_iff (f : Perm α) : cycleOf f x = 1 ↔ f x = x := by
-  simp_rw [ext_iff, cycleOf_apply, one_apply]
-  refine' ⟨fun h => (if_pos (SameCycle.refl f x)).symm.trans (h x), fun h y => _⟩
-  by_cases hy : f y = y
-  · rw [hy, ite_self]
-  · exact if_neg (mt SameCycle.apply_eq_self_iff (by tauto))
-#align equiv.perm.cycle_of_eq_one_iff Equiv.Perm.cycleOf_eq_one_iff
-
-@[simp]
-theorem cycleOf_self_apply (f : Perm α) (x : α) : cycleOf f (f x) = cycleOf f x :=
-  (sameCycle_apply_right.2 SameCycle.rfl).symm.cycleOf_eq
-#align equiv.perm.cycle_of_self_apply Equiv.Perm.cycleOf_self_apply
-
-@[simp]
-theorem cycleOf_self_apply_pow (f : Perm α) (n : ℕ) (x : α) : cycleOf f ((f ^ n) x) = cycleOf f x :=
-  SameCycle.rfl.pow_left.cycleOf_eq
-#align equiv.perm.cycle_of_self_apply_pow Equiv.Perm.cycleOf_self_apply_pow
-
-@[simp]
-theorem cycleOf_self_apply_zpow (f : Perm α) (n : ℤ) (x : α) :
-    cycleOf f ((f ^ n) x) = cycleOf f x :=
-  SameCycle.rfl.zpow_left.cycleOf_eq
-#align equiv.perm.cycle_of_self_apply_zpow Equiv.Perm.cycleOf_self_apply_zpow
-
-protected theorem IsCycle.cycleOf (hf : IsCycle f) : cycleOf f x = if f x = x then 1 else f := by
-  by_cases hx : f x = x
-  · rwa [if_pos hx, cycleOf_eq_one_iff]
-  · rwa [if_neg hx, hf.cycleOf_eq]
-#align equiv.perm.is_cycle.cycle_of Equiv.Perm.IsCycle.cycleOf
-
-theorem cycleOf_one (x : α) : cycleOf 1 x = 1 :=
-  (cycleOf_eq_one_iff 1).mpr rfl
-#align equiv.perm.cycle_of_one Equiv.Perm.cycleOf_one
-
-theorem isCycle_cycleOf (f : Perm α) (hx : f x ≠ x) : IsCycle (cycleOf f x) :=
-  have : cycleOf f x x ≠ x := by rwa [SameCycle.rfl.cycleOf_apply]
-  (isCycle_iff_sameCycle this).2 @fun y =>
-    ⟨fun h => mt h.apply_eq_self_iff.2 this, fun h =>
-      if hxy : SameCycle f x y then
-        let ⟨i, hi⟩ := hxy
-        ⟨i, by rw [cycleOf_zpow_apply_self, hi]⟩
-      else by
-        rw [cycleOf_apply_of_not_sameCycle hxy] at h
-        exact (h rfl).elim⟩
-#align equiv.perm.is_cycle_cycle_of Equiv.Perm.isCycle_cycleOf
-
-@[simp]
-theorem two_le_card_support_cycleOf_iff : 2 ≤ card (cycleOf f x).support ↔ f x ≠ x := by
-  refine' ⟨fun h => _, fun h => by simpa using (isCycle_cycleOf _ h).two_le_card_support⟩
-  contrapose! h
-  rw [← cycleOf_eq_one_iff] at h
-  simp [h]
-#align equiv.perm.two_le_card_support_cycle_of_iff Equiv.Perm.two_le_card_support_cycleOf_iff
-
-@[simp]
-theorem card_support_cycleOf_pos_iff : 0 < card (cycleOf f x).support ↔ f x ≠ x := by
-  rw [← two_le_card_support_cycleOf_iff, ← Nat.succ_le_iff]
-  exact ⟨fun h => Or.resolve_left h.eq_or_lt (card_support_ne_one _).symm, zero_lt_two.trans_le⟩
-#align equiv.perm.card_support_cycle_of_pos_iff Equiv.Perm.card_support_cycleOf_pos_iff
-
-theorem pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x : α) :
-    (f ^ (n % orderOf (cycleOf f x))) x = (f ^ n) x := by
-  rw [← cycleOf_pow_apply_self f, ← cycleOf_pow_apply_self f, pow_mod_orderOf]
-#align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_mod_orderOf_cycleOf_apply
-
-theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x = x) :
-    (f * g).cycleOf x = f.cycleOf x := by
-  ext y
-  by_cases hxy : (f * g).SameCycle x y
-  · obtain ⟨z, rfl⟩ := hxy
-    rw [cycleOf_apply_apply_zpow_self]
-    simp [h.mul_zpow, zpow_apply_eq_self_of_apply_eq_self hx]
-  · rw [cycleOf_apply_of_not_sameCycle hxy, cycleOf_apply_of_not_sameCycle]
-    contrapose! hxy
-    obtain ⟨z, rfl⟩ := hxy
-    refine' ⟨z, _⟩
-    simp [h.mul_zpow, zpow_apply_eq_self_of_apply_eq_self hx]
-#align equiv.perm.cycle_of_mul_of_apply_right_eq_self Equiv.Perm.cycleOf_mul_of_apply_right_eq_self
-
-theorem Disjoint.cycleOf_mul_distrib (h : f.Disjoint g) (x : α) :
-    (f * g).cycleOf x = f.cycleOf x * g.cycleOf x := by
-  cases' (disjoint_iff_eq_or_eq.mp h) x with hfx hgx
-  · simp [h.commute.eq, cycleOf_mul_of_apply_right_eq_self h.symm.commute, hfx]
-  · simp [cycleOf_mul_of_apply_right_eq_self h.commute, hgx]
-#align equiv.perm.disjoint.cycle_of_mul_distrib Equiv.Perm.Disjoint.cycleOf_mul_distrib
-
-theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.support := by simp
-#align equiv.perm.support_cycle_of_eq_nil_iff Equiv.Perm.support_cycleOf_eq_nil_iff
-
-theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ support f := by
-  intro y hy
-  rw [mem_support, cycleOf_apply] at hy
-  split_ifs at hy
-  · exact mem_support.mpr hy
-  · exact absurd rfl hy
-#align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_le
-
-theorem mem_support_cycleOf_iff : y ∈ support (f.cycleOf x) ↔ SameCycle f x y ∧ x ∈ support f := by
-  by_cases hx : f x = x
-  · rw [(cycleOf_eq_one_iff _).mpr hx]
-    simp [hx]
-  · rw [mem_support, cycleOf_apply]
-    split_ifs with hy
-    · simp only [hx, hy, iff_true_iff, Ne.def, not_false_iff, and_self_iff, mem_support]
-      rcases hy with ⟨k, rfl⟩
-      rw [← not_mem_support]
-      simpa using hx
-    · simpa [hx] using hy
-#align equiv.perm.mem_support_cycle_of_iff Equiv.Perm.mem_support_cycleOf_iff
-
-theorem mem_support_cycleOf_iff' (hx : f x ≠ x) : y ∈ support (f.cycleOf x) ↔ SameCycle f x y := by
-  rw [mem_support_cycleOf_iff, and_iff_left (mem_support.2 hx)]
-#align equiv.perm.mem_support_cycle_of_iff' Equiv.Perm.mem_support_cycleOf_iff'
-
-theorem SameCycle.mem_support_iff (h : SameCycle f x y) : x ∈ support f ↔ y ∈ support f :=
-  ⟨fun hx => support_cycleOf_le f x (mem_support_cycleOf_iff.mpr ⟨h, hx⟩), fun hy =>
-    support_cycleOf_le f y (mem_support_cycleOf_iff.mpr ⟨h.symm, hy⟩)⟩
-#align equiv.perm.same_cycle.mem_support_iff Equiv.Perm.SameCycle.mem_support_iff
-
-theorem pow_mod_card_support_cycleOf_self_apply (f : Perm α) (n : ℕ) (x : α) :
-    (f ^ (n % (f.cycleOf x).support.card)) x = (f ^ n) x := by
-  by_cases hx : f x = x
-  · rw [pow_apply_eq_self_of_apply_eq_self hx, pow_apply_eq_self_of_apply_eq_self hx]
-  · rw [← cycleOf_pow_apply_self, ← cycleOf_pow_apply_self f, ← (isCycle_cycleOf f hx).orderOf,
-      pow_mod_orderOf]
-#align equiv.perm.pow_mod_card_support_cycle_of_self_apply Equiv.Perm.pow_mod_card_support_cycleOf_self_apply
-
-/-- `x` is in the support of `f` iff `Equiv.Perm.cycle_of f x` is a cycle. -/
-theorem isCycle_cycleOf_iff (f : Perm α) : IsCycle (cycleOf f x) ↔ f x ≠ x := by
-  refine' ⟨fun hx => _, f.isCycle_cycleOf⟩
-  rw [Ne.def, ← cycleOf_eq_one_iff f]
-  exact hx.ne_one
-#align equiv.perm.is_cycle_cycle_of_iff Equiv.Perm.isCycle_cycleOf_iff
-
-theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleOf x).support :=
-  ⟨f.bijOn <| by
-    refine fun _ ↦ ⟨fun h ↦ mem_support_cycleOf_iff.2 ?_, fun h ↦ mem_support_cycleOf_iff.2 ?_⟩
-    · exact ⟨sameCycle_apply_right.1 (mem_support_cycleOf_iff.1 h).1,
-      (mem_support_cycleOf_iff.1 h).2⟩
-    · exact ⟨sameCycle_apply_right.2 (mem_support_cycleOf_iff.1 h).1,
-      (mem_support_cycleOf_iff.1 h).2⟩
-    , fun a ha b hb =>
-      by
-        rw [mem_coe, mem_support_cycleOf_iff] at ha hb
-        exact ha.1.symm.trans hb.1⟩
-#align equiv.perm.is_cycle_on_support_cycle_of Equiv.Perm.isCycleOn_support_cycleOf
-
-theorem SameCycle.exists_pow_eq_of_mem_support (h : SameCycle f x y) (hx : x ∈ f.support) :
-    ∃ i < (f.cycleOf x).support.card, (f ^ i) x = y := by
-  rw [mem_support] at hx
-  exact Equiv.Perm.IsCycleOn.exists_pow_eq (b := y) (f.isCycleOn_support_cycleOf x)
-    (by rw [mem_support_cycleOf_iff' hx]) (by rwa [mem_support_cycleOf_iff' hx])
-#align equiv.perm.same_cycle.exists_pow_eq_of_mem_support Equiv.Perm.SameCycle.exists_pow_eq_of_mem_support
-
-theorem SameCycle.exists_pow_eq (f : Perm α) (h : SameCycle f x y) :
-    ∃ i : ℕ, 0 < i ∧ i ≤ (f.cycleOf x).support.card + 1 ∧ (f ^ i) x = y := by
-  by_cases hx : x ∈ f.support
-  · obtain ⟨k, hk, hk'⟩ := h.exists_pow_eq_of_mem_support hx
-    cases' k with k
-    · refine' ⟨(f.cycleOf x).support.card, _, self_le_add_right _ _, _⟩
-      · refine' zero_lt_one.trans (one_lt_card_support_of_ne_one _)
-        simpa using hx
-      · simp only [Nat.zero_eq, pow_zero, coe_one, id_eq] at hk'
-        subst hk'
-        rw [← (isCycle_cycleOf _ <| mem_support.1 hx).orderOf, ← cycleOf_pow_apply_self,
-          pow_orderOf_eq_one, one_apply]
-    · exact ⟨k + 1, by simp, Nat.le_succ_of_le hk.le, hk'⟩
-  · refine' ⟨1, zero_lt_one, by simp, _⟩
-    obtain ⟨k, rfl⟩ := h
-    rw [not_mem_support] at hx
-    rw [pow_apply_eq_self_of_apply_eq_self hx, zpow_apply_eq_self_of_apply_eq_self hx]
-#align equiv.perm.same_cycle.exists_pow_eq Equiv.Perm.SameCycle.exists_pow_eq
-
-end CycleOf
-
-/-!
-### `cycleFactors`
--/
 
-open scoped List in
-/-- Given a list `l : List α` and a permutation `f : perm α` whose nonfixed points are all in `l`,
-  recursively factors `f` into cycles. -/
-def cycleFactorsAux [DecidableEq α] [Fintype α] :
-    ∀ (l : List α) (f : Perm α),
-      (∀ {x}, f x ≠ x → x ∈ l) →
-        { l : List (Perm α) // l.prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } := by
-  intro l f h
-  exact match l with
-  | [] => ⟨[], by
-      { simp only [imp_false, List.Pairwise.nil, List.not_mem_nil, forall_const, and_true_iff,
-          forall_prop_of_false, Classical.not_not, not_false_iff, List.prod_nil] at *
-        ext
-        simp [*]}⟩
-  | x::l =>
-    if hx : f x = x then cycleFactorsAux l f (by
-        intro y hy; exact List.mem_of_ne_of_mem (fun h => hy (by rwa [h])) (h hy))
-    else
-      let ⟨m, hm₁, hm₂, hm₃⟩ :=
-        cycleFactorsAux l ((cycleOf f x)⁻¹ * f) (by
-        intro y hy
-        exact List.mem_of_ne_of_mem
-            (fun h : y = x => by
-              rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycleOf_apply_self] at hy
-              exact hy rfl)
-            (h fun h : f y = y => by
-              rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycleOf_apply] at hy
-              split_ifs at hy <;> tauto))
-      ⟨cycleOf f x::m, by
-        rw [List.prod_cons, hm₁]
-        simp,
-        fun g hg ↦ ((List.mem_cons).1 hg).elim (fun hg => hg.symm ▸ isCycle_cycleOf _ hx) (hm₂ g),
-        List.pairwise_cons.2
-          ⟨fun g hg y =>
-            or_iff_not_imp_left.2 fun hfy =>
-              have hxy : SameCycle f x y :=
-                Classical.not_not.1 (mt cycleOf_apply_of_not_sameCycle hfy)
-              have hgm : (g::m.erase g) ~ m :=
-                List.cons_perm_iff_perm_erase.2 ⟨hg, List.Perm.refl _⟩
-              have : ∀ h ∈ m.erase g, Disjoint g h :=
-                (List.pairwise_cons.1
-                    ((hgm.pairwise_iff @fun a b (h : Disjoint a b) => h.symm).2 hm₃)).1
-              by_cases id fun hgy : g y ≠ y =>
-                (disjoint_prod_right _ this y).resolve_right <| by
-                  have hsc : SameCycle f⁻¹ x (f y) := by
-                    rwa [sameCycle_inv, sameCycle_apply_right]
-                  rw [disjoint_prod_perm hm₃ hgm.symm, List.prod_cons,
-                      ← eq_inv_mul_iff_mul_eq] at hm₁
-                  rwa [hm₁, mul_apply, mul_apply, cycleOf_inv, hsc.cycleOf_apply, inv_apply_self,
-                    inv_eq_iff_eq, eq_comm],
-            hm₃⟩⟩
-#align equiv.perm.cycle_factors_aux Equiv.Perm.cycleFactorsAux
-
-theorem mem_list_cycles_iff {α : Type*} [Finite α] {l : List (Perm α)}
-    (h1 : ∀ σ : Perm α, σ ∈ l → σ.IsCycle) (h2 : l.Pairwise Disjoint) {σ : Perm α} :
-    σ ∈ l ↔ σ.IsCycle ∧ ∀ a, σ a ≠ a → σ a = l.prod a := by
-  suffices σ.IsCycle → (σ ∈ l ↔ ∀ a, σ a ≠ a → σ a = l.prod a) by
-    exact ⟨fun hσ => ⟨h1 σ hσ, (this (h1 σ hσ)).mp hσ⟩, fun hσ => (this hσ.1).mpr hσ.2⟩
-  intro h3
-  classical
-    cases nonempty_fintype α
-    constructor
-    · intro h a ha
-      exact eq_on_support_mem_disjoint h h2 _ (mem_support.mpr ha)
-    · intro h
-      have hσl : σ.support ⊆ l.prod.support := by
-        intro x hx
-        rw [mem_support] at hx
-        rwa [mem_support, ← h _ hx]
-      obtain ⟨a, ha, -⟩ := id h3
-      rw [← mem_support] at ha
-      obtain ⟨τ, hτ, hτa⟩ := exists_mem_support_of_mem_support_prod (hσl ha)
-      have hτl : ∀ x ∈ τ.support, τ x = l.prod x := eq_on_support_mem_disjoint hτ h2
-      have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x := by
-        intro x hx
-        rw [h x (mem_support.mp (mem_of_mem_inter_left hx)), hτl x (mem_of_mem_inter_right hx)]
-      convert hτ
-      refine' h3.eq_on_support_inter_nonempty_congr (h1 _ hτ) key _ ha
-      exact key a (mem_inter_of_mem ha hτa)
-#align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
-
-open scoped List in
-theorem list_cycles_perm_list_cycles {α : Type*} [Finite α] {l₁ l₂ : List (Perm α)}
-    (h₀ : l₁.prod = l₂.prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
-    (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
-    (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by
-  classical
-    refine'
-      (List.perm_ext_iff_of_nodup (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
-            (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
-        fun σ => _
-    by_cases hσ : σ.IsCycle
-    · obtain _ := not_forall.mp (mt ext hσ.ne_one)
-      rw [mem_list_cycles_iff h₁l₁ h₂l₁, mem_list_cycles_iff h₁l₂ h₂l₂, h₀]
-    · exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
-#align equiv.perm.list_cycles_perm_list_cycles Equiv.Perm.list_cycles_perm_list_cycles
-
-/-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`. -/
-def cycleFactors [Fintype α] [LinearOrder α] (f : Perm α) :
-    { l : List (Perm α) // l.prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } :=
-  cycleFactorsAux (sort (α := α) (· ≤ ·) univ) f (fun {_ _} ↦ (mem_sort _).2 (mem_univ _))
-#align equiv.perm.cycle_factors Equiv.Perm.cycleFactors
-
-/-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`,
-  without a linear order. -/
-def truncCycleFactors [DecidableEq α] [Fintype α] (f : Perm α) :
-    Trunc { l : List (Perm α) // l.prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } :=
-  Quotient.recOnSubsingleton (@univ α _).1 (fun l h => Trunc.mk (cycleFactorsAux l f (h _)))
-    (show ∀ x, f x ≠ x → x ∈ (@univ α _).1 from fun _ _ => mem_univ _)
-#align equiv.perm.trunc_cycle_factors Equiv.Perm.truncCycleFactors
-
-section CycleFactorsFinset
-
-variable [DecidableEq α] [Fintype α] (f : Perm α)
-
-/-- Factors a permutation `f` into a `Finset` of disjoint cyclic permutations that multiply to `f`.
--/
-def cycleFactorsFinset : Finset (Perm α) :=
-  (truncCycleFactors f).lift
-    (fun l : { l : List (Perm α) // l.prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } =>
-      l.val.toFinset)
-    fun ⟨_, hl⟩ ⟨_, hl'⟩ =>
-    List.toFinset_eq_of_perm _ _
-      (list_cycles_perm_list_cycles (hl'.left.symm ▸ hl.left) hl.right.left hl'.right.left
-        hl.right.right hl'.right.right)
-#align equiv.perm.cycle_factors_finset Equiv.Perm.cycleFactorsFinset
-
-open scoped List in
-theorem cycleFactorsFinset_eq_list_toFinset {σ : Perm α} {l : List (Perm α)} (hn : l.Nodup) :
-    σ.cycleFactorsFinset = l.toFinset ↔
-      (∀ f : Perm α, f ∈ l → f.IsCycle) ∧ l.Pairwise Disjoint ∧ l.prod = σ := by
-  obtain ⟨⟨l', hp', hc', hd'⟩, hl⟩ := Trunc.exists_rep σ.truncCycleFactors
-  have ht : cycleFactorsFinset σ = l'.toFinset := by
-    rw [cycleFactorsFinset, ← hl, Trunc.lift_mk]
-  rw [ht]
-  constructor
-  · intro h
-    have hn' : l'.Nodup := nodup_of_pairwise_disjoint_cycles hc' hd'
-    have hperm : l ~ l' := List.perm_of_nodup_nodup_toFinset_eq hn hn' h.symm
-    refine' ⟨_, _, _⟩
-    · exact fun _ h => hc' _ (hperm.subset h)
-    · have := List.Perm.pairwise_iff (@Disjoint.symmetric _) hperm
-      rwa [this]
-    · rw [← hp', hperm.symm.prod_eq']
-      refine' hd'.imp _
-      exact Disjoint.commute
-  · rintro ⟨hc, hd, hp⟩
-    refine' List.toFinset_eq_of_perm _ _ _
-    refine' list_cycles_perm_list_cycles _ hc' hc hd' hd
-    rw [hp, hp']
-#align equiv.perm.cycle_factors_finset_eq_list_to_finset Equiv.Perm.cycleFactorsFinset_eq_list_toFinset
-
-theorem cycleFactorsFinset_eq_finset {σ : Perm α} {s : Finset (Perm α)} :
-    σ.cycleFactorsFinset = s ↔
-      (∀ f : Perm α, f ∈ s → f.IsCycle) ∧
-        ∃ h : (s : Set (Perm α)).Pairwise Disjoint,
-          s.noncommProd id (h.mono' fun _ _ => Disjoint.commute) = σ := by
-  obtain ⟨l, hl, rfl⟩ := s.exists_list_nodup_eq
-  simp [cycleFactorsFinset_eq_list_toFinset, hl]
-#align equiv.perm.cycle_factors_finset_eq_finset Equiv.Perm.cycleFactorsFinset_eq_finset
-
-theorem cycleFactorsFinset_pairwise_disjoint :
-    (cycleFactorsFinset f : Set (Perm α)).Pairwise Disjoint :=
-  (cycleFactorsFinset_eq_finset.mp rfl).2.choose
-#align equiv.perm.cycle_factors_finset_pairwise_disjoint Equiv.Perm.cycleFactorsFinset_pairwise_disjoint
-
-theorem cycleFactorsFinset_mem_commute : (cycleFactorsFinset f : Set (Perm α)).Pairwise Commute :=
-  (cycleFactorsFinset_pairwise_disjoint _).mono' fun _ _ => Disjoint.commute
-#align equiv.perm.cycle_factors_finset_mem_commute Equiv.Perm.cycleFactorsFinset_mem_commute
-
-/-- The product of cycle factors is equal to the original `f : perm α`. -/
-theorem cycleFactorsFinset_noncommProd
-    (comm : (cycleFactorsFinset f : Set (Perm α)).Pairwise Commute :=
-      cycleFactorsFinset_mem_commute f) :
-    f.cycleFactorsFinset.noncommProd id comm = f :=
-  (cycleFactorsFinset_eq_finset.mp rfl).2.choose_spec
-#align equiv.perm.cycle_factors_finset_noncomm_prod Equiv.Perm.cycleFactorsFinset_noncommProd
-
-theorem mem_cycleFactorsFinset_iff {f p : Perm α} :
-    p ∈ cycleFactorsFinset f ↔ p.IsCycle ∧ ∀ a ∈ p.support, p a = f a := by
-  obtain ⟨l, hl, hl'⟩ := f.cycleFactorsFinset.exists_list_nodup_eq
-  rw [← hl']
-  rw [eq_comm, cycleFactorsFinset_eq_list_toFinset hl] at hl'
-  simpa [List.mem_toFinset, Ne.def, ← hl'.right.right] using
-    mem_list_cycles_iff hl'.left hl'.right.left
-#align equiv.perm.mem_cycle_factors_finset_iff Equiv.Perm.mem_cycleFactorsFinset_iff
-
-theorem cycleOf_mem_cycleFactorsFinset_iff {f : Perm α} {x : α} :
-    cycleOf f x ∈ cycleFactorsFinset f ↔ x ∈ f.support := by
-  rw [mem_cycleFactorsFinset_iff]
-  constructor
-  · rintro ⟨hc, _⟩
-    contrapose! hc
-    rw [not_mem_support, ← cycleOf_eq_one_iff] at hc
-    simp [hc]
-  · intro hx
-    refine' ⟨isCycle_cycleOf _ (mem_support.mp hx), _⟩
-    intro y hy
-    rw [mem_support] at hy
-    rw [cycleOf_apply]
-    split_ifs with H
-    · rfl
-    · rw [cycleOf_apply_of_not_sameCycle H] at hy
-      contradiction
-#align equiv.perm.cycle_of_mem_cycle_factors_finset_iff Equiv.Perm.cycleOf_mem_cycleFactorsFinset_iff
-
-theorem mem_cycleFactorsFinset_support_le {p f : Perm α} (h : p ∈ cycleFactorsFinset f) :
-    p.support ≤ f.support := by
-  rw [mem_cycleFactorsFinset_iff] at h
-  intro x hx
-  rwa [mem_support, ← h.right x hx, ← mem_support]
-#align equiv.perm.mem_cycle_factors_finset_support_le Equiv.Perm.mem_cycleFactorsFinset_support_le
-
-theorem cycleFactorsFinset_eq_empty_iff {f : Perm α} : cycleFactorsFinset f = ∅ ↔ f = 1 := by
-  simpa [cycleFactorsFinset_eq_finset] using eq_comm
-#align equiv.perm.cycle_factors_finset_eq_empty_iff Equiv.Perm.cycleFactorsFinset_eq_empty_iff
-
-@[simp]
-theorem cycleFactorsFinset_one : cycleFactorsFinset (1 : Perm α) = ∅ := by
-  simp [cycleFactorsFinset_eq_empty_iff]
-#align equiv.perm.cycle_factors_finset_one Equiv.Perm.cycleFactorsFinset_one
-
-@[simp]
-theorem cycleFactorsFinset_eq_singleton_self_iff {f : Perm α} :
-    f.cycleFactorsFinset = {f} ↔ f.IsCycle := by simp [cycleFactorsFinset_eq_finset]
-#align equiv.perm.cycle_factors_finset_eq_singleton_self_iff Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff
-
-theorem IsCycle.cycleFactorsFinset_eq_singleton {f : Perm α} (hf : IsCycle f) :
-    f.cycleFactorsFinset = {f} :=
-  cycleFactorsFinset_eq_singleton_self_iff.mpr hf
-#align equiv.perm.is_cycle.cycle_factors_finset_eq_singleton Equiv.Perm.IsCycle.cycleFactorsFinset_eq_singleton
-
-theorem cycleFactorsFinset_eq_singleton_iff {f g : Perm α} :
-    f.cycleFactorsFinset = {g} ↔ f.IsCycle ∧ f = g := by
-  suffices f = g → (g.IsCycle ↔ f.IsCycle) by
-    rw [cycleFactorsFinset_eq_finset]
-    simpa [eq_comm]
-  rintro rfl
-  exact Iff.rfl
-#align equiv.perm.cycle_factors_finset_eq_singleton_iff Equiv.Perm.cycleFactorsFinset_eq_singleton_iff
-
-/-- Two permutations `f g : perm α` have the same cycle factors iff they are the same. -/
-theorem cycleFactorsFinset_injective : Function.Injective (@cycleFactorsFinset α _ _) := by
-  intro f g h
-  rw [← cycleFactorsFinset_noncommProd f]
-  simpa [h] using cycleFactorsFinset_noncommProd g
-#align equiv.perm.cycle_factors_finset_injective Equiv.Perm.cycleFactorsFinset_injective
-
-theorem Disjoint.disjoint_cycleFactorsFinset {f g : Perm α} (h : Disjoint f g) :
-    _root_.Disjoint (cycleFactorsFinset f) (cycleFactorsFinset g) := by
-  rw [disjoint_iff_disjoint_support] at h
-  rw [Finset.disjoint_left]
-  intro x hx hy
-  simp only [mem_cycleFactorsFinset_iff, mem_support] at hx hy
-  obtain ⟨⟨⟨a, ha, -⟩, hf⟩, -, hg⟩ := hx, hy
-  have := h.le_bot (by simp [ha, ← hf a ha, ← hg a ha] : a ∈ f.support ∩ g.support)
-  tauto
-#align equiv.perm.disjoint.disjoint_cycle_factors_finset Equiv.Perm.Disjoint.disjoint_cycleFactorsFinset
-
-theorem Disjoint.cycleFactorsFinset_mul_eq_union {f g : Perm α} (h : Disjoint f g) :
-    cycleFactorsFinset (f * g) = cycleFactorsFinset f ∪ cycleFactorsFinset g := by
-  rw [cycleFactorsFinset_eq_finset]
-  refine' ⟨_, _, _⟩
-  · simp [or_imp, mem_cycleFactorsFinset_iff, forall_swap]
-  · rw [coe_union, Set.pairwise_union_of_symmetric Disjoint.symmetric]
-    exact
-      ⟨cycleFactorsFinset_pairwise_disjoint _, cycleFactorsFinset_pairwise_disjoint _,
-        fun x hx y hy _ =>
-        h.mono (mem_cycleFactorsFinset_support_le hx) (mem_cycleFactorsFinset_support_le hy)⟩
-  · rw [noncommProd_union_of_disjoint h.disjoint_cycleFactorsFinset]
-    rw [cycleFactorsFinset_noncommProd, cycleFactorsFinset_noncommProd]
-#align equiv.perm.disjoint.cycle_factors_finset_mul_eq_union Equiv.Perm.Disjoint.cycleFactorsFinset_mul_eq_union
-
-theorem disjoint_mul_inv_of_mem_cycleFactorsFinset {f g : Perm α} (h : f ∈ cycleFactorsFinset g) :
-    Disjoint (g * f⁻¹) f := by
-  rw [mem_cycleFactorsFinset_iff] at h
-  intro x
-  by_cases hx : f x = x
-  · exact Or.inr hx
-  · refine' Or.inl _
-    rw [mul_apply, ← h.right, apply_inv_self]
-    rwa [← support_inv, apply_mem_support, support_inv, mem_support]
-#align equiv.perm.disjoint_mul_inv_of_mem_cycle_factors_finset Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset
-
-/-- If c is a cycle, a ∈ c.support and c is a cycle of f, then `c = f.cycleOf a` -/
-theorem cycle_is_cycleOf {f c : Equiv.Perm α} {a : α} (ha : a ∈ c.support)
-    (hc : c ∈ f.cycleFactorsFinset) : c = f.cycleOf a := by
-  suffices f.cycleOf a = c.cycleOf a by
-    rw [this]
-    apply symm
-    exact
-      Equiv.Perm.IsCycle.cycleOf_eq (Equiv.Perm.mem_cycleFactorsFinset_iff.mp hc).left
-        (Equiv.Perm.mem_support.mp ha)
-  let hfc := (Equiv.Perm.disjoint_mul_inv_of_mem_cycleFactorsFinset hc).symm
-  let hfc2 := Perm.Disjoint.commute hfc
-  rw [← Equiv.Perm.cycleOf_mul_of_apply_right_eq_self hfc2]
-  simp only [hfc2.eq, inv_mul_cancel_right]
-  -- a est dans le support de c, donc pas dans celui de g c⁻¹
-  exact
-    Equiv.Perm.not_mem_support.mp
-      (Finset.disjoint_left.mp (Equiv.Perm.Disjoint.disjoint_support hfc) ha)
-#align equiv.perm.cycle_is_cycle_of Equiv.Perm.cycle_is_cycleOf
-
-end CycleFactorsFinset
-
-@[elab_as_elim]
-theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (base_one : P 1)
-    (base_cycles : ∀ σ : Perm β, σ.IsCycle → P σ)
-    (induction_disjoint : ∀ σ τ : Perm β,
-      Disjoint σ τ → IsCycle σ → P σ → P τ → P (σ * τ)) : P σ := by
-  cases nonempty_fintype β
-  suffices ∀ l : List (Perm β),
-      (∀ τ : Perm β, τ ∈ l → τ.IsCycle) → l.Pairwise Disjoint → P l.prod by
-    classical
-      let x := σ.truncCycleFactors.out
-      exact (congr_arg P x.2.1).mp (this x.1 x.2.2.1 x.2.2.2)
-  intro l
-  induction' l with σ l ih
-  · exact fun _ _ => base_one
-  · intro h1 h2
-    rw [List.prod_cons]
-    exact
-      induction_disjoint σ l.prod (disjoint_prod_right _ (List.pairwise_cons.mp h2).1)
-        (h1 _ (List.mem_cons_self _ _)) (base_cycles σ (h1 σ (l.mem_cons_self σ)))
-        (ih (fun τ hτ => h1 τ (List.mem_cons_of_mem σ hτ)) h2.of_cons)
-#align equiv.perm.cycle_induction_on Equiv.Perm.cycle_induction_on
-
-theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [DecidableEq α] [Fintype α] {f g : Perm α}
-    (h : f ∈ cycleFactorsFinset g) : cycleFactorsFinset (g * f⁻¹) = cycleFactorsFinset g \ {f} := by
-  revert f
-  refine'
-    cycle_induction_on (P := fun {g : Perm α} ↦
-      ∀ {f}, (f ∈ cycleFactorsFinset g)
-        → cycleFactorsFinset (g * f⁻¹) = cycleFactorsFinset g \ {f}) _ _ _ _
-  · simp
-  · intro σ hσ f hf
-    simp only [cycleFactorsFinset_eq_singleton_self_iff.mpr hσ, mem_singleton] at hf ⊢
-    simp [hf]
-  · intro σ τ hd _ hσ hτ f
-    simp_rw [hd.cycleFactorsFinset_mul_eq_union, mem_union]
-    -- if only `wlog` could work here...
-    rintro (hf | hf)
-    · rw [hd.commute.eq, union_comm, union_sdiff_distrib, sdiff_singleton_eq_erase,
-        erase_eq_of_not_mem, mul_assoc, Disjoint.cycleFactorsFinset_mul_eq_union, hσ hf]
-      · rw [mem_cycleFactorsFinset_iff] at hf
-        intro x
-        cases' hd.symm x with hx hx
-        · exact Or.inl hx
-        · refine' Or.inr _
-          by_cases hfx : f x = x
-          · rw [← hfx]
-            simpa [hx] using hfx.symm
-          · rw [mul_apply]
-            rw [← hf.right _ (mem_support.mpr hfx)] at hx
-            contradiction
-      · exact fun H =>
-        not_mem_empty _ (hd.disjoint_cycleFactorsFinset.le_bot (mem_inter_of_mem hf H))
-    · rw [union_sdiff_distrib, sdiff_singleton_eq_erase, erase_eq_of_not_mem, mul_assoc,
-        Disjoint.cycleFactorsFinset_mul_eq_union, hτ hf]
-      · rw [mem_cycleFactorsFinset_iff] at hf
-        intro x
-        cases' hd x with hx hx
-        · exact Or.inl hx
-        · refine' Or.inr _
-          by_cases hfx : f x = x
-          · rw [← hfx]
-            simpa [hx] using hfx.symm
-          · rw [mul_apply]
-            rw [← hf.right _ (mem_support.mpr hfx)] at hx
-            contradiction
-      · exact fun H =>
-        not_mem_empty _ (hd.disjoint_cycleFactorsFinset.le_bot (mem_inter_of_mem H hf))
-#align equiv.perm.cycle_factors_finset_mul_inv_mem_eq_sdiff Equiv.Perm.cycleFactorsFinset_mul_inv_mem_eq_sdiff
-
-section Generation
-
-variable [Finite β]
-
-open Subgroup
-
-theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤ := by
-  classical
-    cases nonempty_fintype β
-    exact
-      top_le_iff.mp (le_trans (ge_of_eq closure_isSwap) (closure_mono fun _ => IsSwap.isCycle))
-#align equiv.perm.closure_is_cycle Equiv.Perm.closure_isCycle
-
-variable [DecidableEq α] [Fintype α]
+end IsCycleOn
 
-theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.support = ⊤) (x : α) :
-    closure ({σ, swap x (σ x)} : Set (Perm α)) = ⊤ := by
-  let H := closure ({σ, swap x (σ x)} : Set (Perm α))
-  have h3 : σ ∈ H := subset_closure (Set.mem_insert σ _)
-  have h4 : swap x (σ x) ∈ H := subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _))
-  have step1 : ∀ n : ℕ, swap ((σ ^ n) x) ((σ ^ (n + 1) : Perm α) x) ∈ H := by
-    intro n
-    induction' n with n ih
-    · exact subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _))
-    · convert H.mul_mem (H.mul_mem h3 ih) (H.inv_mem h3)
-      simp_rw [mul_swap_eq_swap_mul, mul_inv_cancel_right, pow_succ]
-      rfl
-  have step2 : ∀ n : ℕ, swap x ((σ ^ n) x) ∈ H := by
-    intro n
-    induction' n with n ih
-    · simp only [Nat.zero_eq, pow_zero, coe_one, id_eq, swap_self, Set.mem_singleton_iff]
-      convert H.one_mem
-    · by_cases h5 : x = (σ ^ n) x
-      · rw [pow_succ, mul_apply, ← h5]
-        exact h4
-      by_cases h6 : x = (σ ^ (n + 1) : Perm α) x
-      · rw [← h6, swap_self]
-        exact H.one_mem
-      rw [swap_comm, ← swap_mul_swap_mul_swap h5 h6]
-      exact H.mul_mem (H.mul_mem (step1 n) ih) (step1 n)
-  have step3 : ∀ y : α, swap x y ∈ H := by
-    intro y
-    have hx : x ∈ (⊤ : Finset α) := Finset.mem_univ x
-    rw [← h2, mem_support] at hx
-    have hy : y ∈ (⊤ : Finset α) := Finset.mem_univ y
-    rw [← h2, mem_support] at hy
-    cases' IsCycle.exists_pow_eq h1 hx hy with n hn
-    rw [← hn]
-    exact step2 n
-  have step4 : ∀ y z : α, swap y z ∈ H := by
-    intro y z
-    by_cases h5 : z = x
-    · rw [h5, swap_comm]
-      exact step3 y
-    by_cases h6 : z = y
-    · rw [h6, swap_self]
-      exact H.one_mem
-    rw [← swap_mul_swap_mul_swap h5 h6, swap_comm z x]
-    exact H.mul_mem (H.mul_mem (step3 y) (step3 z)) (step3 y)
-  rw [eq_top_iff, ← closure_isSwap, closure_le]
-  rintro τ ⟨y, z, _, h6⟩
-  rw [h6]
-  exact step4 y z
-#align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swap
-
-theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.Coprime n (Fintype.card α))
-    (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
-    closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ := by
-  rw [← Finset.card_univ, ← h2, ← h1.orderOf] at h0
-  cases' exists_pow_eq_self_of_coprime h0 with m hm
-  have h2' : (σ ^ n).support = ⊤ := Eq.trans (support_pow_coprime h0) h2
-  have h1' : IsCycle ((σ ^ n) ^ (m : ℤ)) := by rwa [← hm] at h1
-  replace h1' : IsCycle (σ ^ n) :=
-    h1'.of_pow (le_trans (support_pow_le σ n) (ge_of_eq (congr_arg support hm)))
-  rw [eq_top_iff, ← closure_cycle_adjacent_swap h1' h2' x, closure_le, Set.insert_subset_iff]
-  exact
-    ⟨Subgroup.pow_mem (closure _) (subset_closure (Set.mem_insert σ _)) n,
-      Set.singleton_subset_iff.mpr (subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _)))⟩
-#align equiv.perm.closure_cycle_coprime_swap Equiv.Perm.closure_cycle_coprime_swap
-
-theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime) (h1 : IsCycle σ)
-    (h2 : σ.support = Finset.univ) (h3 : IsSwap τ) : closure ({σ, τ} : Set (Perm α)) = ⊤ := by
-  obtain ⟨x, y, h4, h5⟩ := h3
-  obtain ⟨i, hi⟩ :=
-    h1.exists_pow_eq (mem_support.mp ((Finset.ext_iff.mp h2 x).mpr (Finset.mem_univ x)))
-      (mem_support.mp ((Finset.ext_iff.mp h2 y).mpr (Finset.mem_univ y)))
-  rw [h5, ← hi]
-  refine'
-    closure_cycle_coprime_swap (Nat.Coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
-  cases' h with m hm
-  rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.orderOf, pow_orderOf_eq_one, one_pow,
-    one_apply] at hi
-#align equiv.perm.closure_prime_cycle_swap Equiv.Perm.closure_prime_cycle_swap
+end Equiv.Perm
 
-end Generation
+namespace List
 
 section
 
-noncomputable section
-
-variable [DecidableEq α] [Fintype α] {σ τ : Perm α}
-
-theorem isConj_of_support_equiv
-    (f : { x // x ∈ (σ.support : Set α) } ≃ { x // x ∈ (τ.support : Set α) })
-    (hf : ∀ (x : α) (hx : x ∈ (σ.support : Set α)),
-      (f ⟨σ x, apply_mem_support.2 hx⟩ : α) = τ ↑(f ⟨x, hx⟩)) :
-    IsConj σ τ := by
-  refine' isConj_iff.2 ⟨Equiv.extendSubtype f, _⟩
-  rw [mul_inv_eq_iff_eq_mul]
-  ext x
-  simp only [Perm.mul_apply]
-  by_cases hx : x ∈ σ.support
-  · rw [Equiv.extendSubtype_apply_of_mem, Equiv.extendSubtype_apply_of_mem]
-    · exact hf x (Finset.mem_coe.2 hx)
-  · rwa [Classical.not_not.1 ((not_congr mem_support).1 (Equiv.extendSubtype_not_mem f _ _)),
-      Classical.not_not.1 ((not_congr mem_support).mp hx)]
-#align equiv.perm.is_conj_of_support_equiv Equiv.Perm.isConj_of_support_equiv
-
-theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.card = τ.support.card) :
-    IsConj σ τ := by
-  refine'
-    isConj_of_support_equiv
-      (hσ.zpowersEquivSupport.symm.trans <|
-        (zpowersEquivZPowers <| by rw [hσ.orderOf, h, hτ.orderOf]).trans hτ.zpowersEquivSupport)
-      _
-  intro x hx
-  simp only [Perm.mul_apply, Equiv.trans_apply, Equiv.sumCongr_apply]
-  obtain ⟨n, rfl⟩ := hσ.exists_pow_eq (Classical.choose_spec hσ).1 (mem_support.1 hx)
-  apply
-    Eq.trans _
-      (congr rfl (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply n).symm))))
-  apply (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply (n + 1))))).trans _
-  -- This used to be a `simp only` before leanprover/lean4#2644
-  erw [zpowersEquivZPowers_apply, zpowersEquivZPowers_apply]
-  dsimp
-    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-  erw [pow_succ, Perm.mul_apply]
-#align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
-
-theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :
-    IsConj σ τ ↔ σ.support.card = τ.support.card :=
-  ⟨by
-    intro h
-    obtain ⟨π, rfl⟩ := (_root_.isConj_iff).1 h
-    refine' Finset.card_congr (fun a _ => π a) (fun _ ha => _) (fun _ _ _ _ ab => π.injective ab)
-        fun b hb => _
-    · simp [mem_support.1 ha]
-    · refine' ⟨π⁻¹ b, ⟨_, π.apply_inv_self b⟩⟩
-      contrapose! hb
-      rw [mem_support, Classical.not_not] at hb
-      rw [mem_support, Classical.not_not, Perm.mul_apply, Perm.mul_apply, hb, Perm.apply_inv_self],
-    hσ.isConj hτ⟩
-#align equiv.perm.is_cycle.is_conj_iff Equiv.Perm.IsCycle.isConj_iff
-
-@[simp]
-theorem support_conj : (σ * τ * σ⁻¹).support = τ.support.map σ.toEmbedding := by
-  ext
-  simp only [mem_map_equiv, Perm.coe_mul, Function.comp_apply, Ne.def, Perm.mem_support,
-    Equiv.eq_symm_apply]
-  rfl
-#align equiv.perm.support_conj Equiv.Perm.support_conj
-
-theorem card_support_conj : (σ * τ * σ⁻¹).support.card = τ.support.card := by simp
-#align equiv.perm.card_support_conj Equiv.Perm.card_support_conj
-
-end
-
-theorem Disjoint.isConj_mul [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
-    (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
-  classical
-    cases nonempty_fintype α
-    obtain ⟨f, rfl⟩ := isConj_iff.1 hc1
-    obtain ⟨g, rfl⟩ := isConj_iff.1 hc2
-    have hd1' := coe_inj.2 hd1.support_mul
-    have hd2' := coe_inj.2 hd2.support_mul
-    rw [coe_union] at *
-    have hd1'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd1)
-    have hd2'' := disjoint_coe.2 (disjoint_iff_disjoint_support.1 hd2)
-    refine' isConj_of_support_equiv _ _
-    · refine'
-          ((Equiv.Set.ofEq hd1').trans (Equiv.Set.union hd1''.le_bot)).trans
-            ((Equiv.sumCongr (subtypeEquiv f fun a => _) (subtypeEquiv g fun a => _)).trans
-              ((Equiv.Set.ofEq hd2').trans (Equiv.Set.union hd2''.le_bot)).symm) <;>
-      · simp only [Set.mem_image, toEmbedding_apply, exists_eq_right, support_conj, coe_map,
-          apply_eq_iff_eq]
-    · intro x hx
-      simp only [trans_apply, symm_trans_apply, Equiv.Set.ofEq_apply, Equiv.Set.ofEq_symm_apply,
-        Equiv.sumCongr_apply]
-      rw [hd1', Set.mem_union] at hx
-      cases' hx with hxσ hxτ
-      · rw [mem_coe, mem_support] at hxσ
-        rw [Set.union_apply_left hd1''.le_bot _, Set.union_apply_left hd1''.le_bot _]
-        simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inl, comp_apply,
-          Set.union_symm_apply_left, Subtype.coe_mk, apply_eq_iff_eq]
-        · have h := (hd2 (f x)).resolve_left ?_
-          · rw [mul_apply, mul_apply] at h
-            rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
-          · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
-        · rwa [Subtype.coe_mk, mem_coe, mem_support]
-        · rwa [Subtype.coe_mk, Perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
-            apply_mem_support, mem_support]
-      · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ
-        rw [Set.union_apply_right hd1''.le_bot _, Set.union_apply_right hd1''.le_bot _]
-        simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inr, comp_apply,
-          Set.union_symm_apply_right, Subtype.coe_mk, apply_eq_iff_eq]
-        · have h := (hd2 (g (τ x))).resolve_right ?_
-          · rw [mul_apply, mul_apply] at h
-            rw [inv_apply_self, h, (hd1 (τ x)).resolve_right hxτ]
-          · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
-        · rwa [Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
-        · rwa [Subtype.coe_mk, Perm.mul_apply, (hd1 (τ x)).resolve_right hxτ,
-            mem_coe, mem_support]
-#align equiv.perm.disjoint.is_conj_mul Equiv.Perm.Disjoint.isConj_mul
-
-section FixedPoints
-
-/-!
-### Fixed points
--/
-
-
-theorem fixed_point_card_lt_of_ne_one [DecidableEq α] [Fintype α] {σ : Perm α} (h : σ ≠ 1) :
-    (filter (fun x => σ x = x) univ).card < Fintype.card α - 1 := by
-  rw [lt_tsub_iff_left, ← lt_tsub_iff_right, ← Finset.card_compl, Finset.compl_filter]
-  exact one_lt_card_support_of_ne_one h
-#align equiv.perm.fixed_point_card_lt_of_ne_one Equiv.Perm.fixed_point_card_lt_of_ne_one
-
-end FixedPoints
-
-end
-
-open Equiv
-
-namespace List
-
 variable [DecidableEq α] {l : List α}
 
 set_option linter.deprecated false in -- nthLe
-theorem _root_.List.Nodup.isCycleOn_formPerm (h : l.Nodup) :
+theorem Nodup.isCycleOn_formPerm (h : l.Nodup) :
     l.formPerm.IsCycleOn { a | a ∈ l } := by
   refine' ⟨l.formPerm.bijOn fun _ => List.formPerm_mem_iff_mem, fun a ha b hb => _⟩
   rw [Set.mem_setOf, ← List.indexOf_lt_length] at ha hb
@@ -1841,27 +993,15 @@ theorem _root_.List.Nodup.isCycleOn_formPerm (h : l.Nodup) :
   rw [add_comm]
 #align list.nodup.is_cycle_on_form_perm List.Nodup.isCycleOn_formPerm
 
-end List
-
-namespace Int
-
-open Equiv
-
-theorem _root_.Int.addLeft_one_isCycle : (Equiv.addLeft 1 : Perm ℤ).IsCycle :=
-  ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
-#align int.add_left_one_is_cycle Int.addLeft_one_isCycle
-
-theorem _root_.Int.addRight_one_isCycle : (Equiv.addRight 1 : Perm ℤ).IsCycle :=
-  ⟨0, one_ne_zero, fun n _ => ⟨n, by simp⟩⟩
-#align int.add_right_one_is_cycle Int.addRight_one_isCycle
+end
 
-end Int
+end List
 
 namespace Finset
 
 variable [DecidableEq α] [Fintype α]
 
-theorem _root_.Finset.exists_cycleOn (s : Finset α) :
+theorem exists_cycleOn (s : Finset α) :
     ∃ f : Perm α, f.IsCycleOn s ∧ f.support ⊆ s := by
   refine ⟨s.toList.formPerm, ?_, fun x hx => by
     simpa using List.mem_of_formPerm_apply_ne _ _ (Perm.mem_support.1 hx)⟩
@@ -1875,7 +1015,7 @@ namespace Set
 
 variable {f : Perm α} {s : Set α}
 
-theorem _root_.Set.Countable.exists_cycleOn (hs : s.Countable) :
+theorem Countable.exists_cycleOn (hs : s.Countable) :
     ∃ f : Perm α, f.IsCycleOn s ∧ { x | f x ≠ x } ⊆ s := by
   classical
   obtain hs' | hs' := s.finite_or_infinite
@@ -1894,7 +1034,7 @@ theorem _root_.Set.Countable.exists_cycleOn (hs : s.Countable) :
     simp
 #align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
 
-theorem _root_.Set.prod_self_eq_iUnion_perm (hf : f.IsCycleOn s) :
+theorem prod_self_eq_iUnion_perm (hf : f.IsCycleOn s) :
     s ×ˢ s = ⋃ n : ℤ, (fun a => (a, (f ^ n) a)) '' s := by
   ext ⟨a, b⟩
   simp only [Set.mem_prod, Set.mem_iUnion, Set.mem_image]
@@ -1911,7 +1051,7 @@ namespace Finset
 
 variable {f : Perm α} {s : Finset α}
 
-theorem _root_.Finset.product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
+theorem product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
     (range s.card : Set ℕ).PairwiseDisjoint fun k =>
       s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩ := by
   obtain hs | _ := (s : Set α).subsingleton_or_nontrivial
@@ -1939,7 +1079,7 @@ theorem _root_.Finset.product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
 
 The diagonals are given by the cycle `f`.
 -/
-theorem _root_.Finset.product_self_eq_disjiUnion_perm (hf : f.IsCycleOn s) :
+theorem product_self_eq_disjiUnion_perm (hf : f.IsCycleOn s) :
     s ×ˢ s =
       (range s.card).disjiUnion
         (fun k => s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩)
@@ -1960,13 +1100,13 @@ namespace Finset
 
 variable [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : Perm ι}
 
-theorem _root_.Finset.sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
+theorem sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
     ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) := by
   simp_rw [sum_smul_sum, product_self_eq_disjiUnion_perm hσ, sum_disjiUnion, sum_map]
   rfl
 #align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_perm
 
-theorem _root_.Finset.sum_mul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f g : ι → α) :
+theorem sum_mul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f g : ι → α) :
     ((∑ i in s, f i) * ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i * g ((σ ^ k) i) :=
   sum_smul_sum_eq_sum_perm hσ f g
 #align finset.sum_mul_sum_eq_sum_perm Finset.sum_mul_sum_eq_sum_perm

The file Mathlib.GroupTheory.Perm.Cycle.Basic was too big and this PR splits it in several components:

• Mathlib.GroupTheory.Perm.Cycle.Basic contains everything related to a permutation being a cycle,
• Mathlib.GroupTheory.Perm.Cycle.Factors is about the cycles of a permutation and the decomposition of a permutation into disjoint cycles
• Mathlib.GroupTheory.Perm.Closure contains generation results for the permutation groups
• Mathlib.GroupTheory.Perm.Finite contains general results specific to permutation of finite types

I moved some results to Mathlib.GroupTheory.Perm.Support

I also moved some results from Mathlib.GroupTheory.Perm.Sign to Mathlib.GroupTheory.Perm.Finite

Some imports could be reduced, and the shake linter required a few adjustments in some other.

Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

Previously these were syntactically identical to the corresponding zpow_coe_nat and coe_nat_zsmul lemmas, now they are about OfNat.ofNat.

Unfortunately, almost every call site uses the ofNat name to refer to Nat.cast, so the downstream proofs had to be adjusted too.

@@ -177,12 +177,12 @@ theorem sameCycle_zpow_right {n : ℤ} : SameCycle f x ((f ^ n) y) ↔ SameCycle
 
 @[simp]
 theorem sameCycle_pow_left {n : ℕ} : SameCycle f ((f ^ n) x) y ↔ SameCycle f x y := by
-  rw [← zpow_ofNat, sameCycle_zpow_left]
+  rw [← zpow_coe_nat, sameCycle_zpow_left]
 #align equiv.perm.same_cycle_pow_left Equiv.Perm.sameCycle_pow_left
 
 @[simp]
 theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y := by
-  rw [← zpow_ofNat, sameCycle_zpow_right]
+  rw [← zpow_coe_nat, sameCycle_zpow_right]
 #align equiv.perm.same_cycle_pow_right Equiv.Perm.sameCycle_pow_right
 
 alias ⟨SameCycle.of_apply_left, SameCycle.apply_left⟩ := sameCycle_apply_left
@@ -250,7 +250,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
     use (k % orderOf f).natAbs
     have h₀ := Int.coe_nat_pos.mpr (orderOf_pos f)
     have h₁ := Int.emod_nonneg k h₀.ne'
-    rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, zpow_mod_orderOf]
+    rw [← zpow_coe_nat, Int.natAbs_of_nonneg h₁, zpow_mod_orderOf]
     refine' ⟨_, by rfl⟩
     rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
     exact Int.emod_lt_of_pos _ h₀
@@ -273,7 +273,7 @@ instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f
         · refine' (Int.emod_lt _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _).trans_le _
           simp [orderOf_le_card_univ]),
       by
-        rw [← zpow_ofNat, Int.natAbs_of_nonneg (Int.emod_nonneg _ <|
+        rw [← zpow_coe_nat, Int.natAbs_of_nonneg (Int.emod_nonneg _ <|
           Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _), zpow_mod_orderOf, hi]⟩⟩
 
 end SameCycle
@@ -362,7 +362,7 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
   classical exact
       ⟨(n % orderOf f).toNat, by
         {have := n.emod_nonneg (Int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
-         rwa [← zpow_ofNat, Int.toNat_of_nonneg this, zpow_mod_orderOf]}⟩
+         rwa [← zpow_coe_nat, Int.toNat_of_nonneg this, zpow_mod_orderOf]}⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 
 end Finite
@@ -477,9 +477,9 @@ theorem isCycle_swap_mul_aux₂ {α : Type*} [DecidableEq α] :
         let ⟨i, hi⟩ :=
           isCycle_swap_mul_aux₁ n hb
             (show (f⁻¹ ^ n) (f⁻¹ x) = f⁻¹ b by
-              rw [← zpow_ofNat, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc, ← inv_pow,
-                pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_ofNat, ← pow_succ', ←
-                pow_succ])
+              rw [← zpow_coe_nat, ← h, ← mul_apply, ← mul_apply, ← mul_apply, zpow_negSucc,
+                ← inv_pow, pow_succ', mul_assoc, mul_assoc, inv_mul_self, mul_one, zpow_coe_nat,
+                ← pow_succ', ← pow_succ])
         have h : (swap x (f⁻¹ x) * f⁻¹) (f x) = f⁻¹ x := by
           rw [mul_apply, inv_apply_self, swap_apply_left]
         ⟨-i, by
@@ -709,7 +709,7 @@ theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b :
       · refine' ⟨(f ^ a) x, mem_support.mp hfa, _⟩
         simp only [pow_sub _ hab, Equiv.Perm.coe_mul, Function.comp_apply, inv_apply_self, ← hx']
       · have h := @Equiv.Perm.zpow_apply_comm _ f 1 a x
-        simp only [zpow_one, zpow_ofNat] at h
+        simp only [zpow_one, zpow_coe_nat] at h
         rw [not_mem_support, h, Function.Injective.eq_iff (f ^ a).injective] at hfa
         contradiction
 #align equiv.perm.is_cycle.pow_eq_pow_iff Equiv.Perm.IsCycle.pow_eq_pow_iff
@@ -893,7 +893,7 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
     obtain ⟨n, rfl⟩ := hf.2 ha hb
     obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.dvd
     refine' ⟨n.natMod s.card, Int.natMod_lt (Nonempty.card_pos ⟨a, ha⟩).ne', _⟩
-    rw [← zpow_ofNat, Int.natMod,
+    rw [← zpow_coe_nat, Int.natMod,
       Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2
         (Nonempty.card_pos ⟨a, ha⟩).ne'), sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
     simp only [zpow_coe_nat, coe_mul, comp_apply, EmbeddingLike.apply_eq_iff_eq]
@@ -1836,7 +1836,7 @@ theorem _root_.List.Nodup.isCycleOn_formPerm (h : l.Nodup) :
   rw [Set.mem_setOf, ← List.indexOf_lt_length] at ha hb
   rw [← List.indexOf_get ha, ← List.indexOf_get hb]
   refine' ⟨l.indexOf b - l.indexOf a, _⟩
-  simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_ofNat,
+  simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_coe_nat,
     Equiv.Perm.coe_mul, ← List.nthLe_eq, List.formPerm_pow_apply_nthLe _ h, Function.comp]
   rw [add_comm]
 #align list.nodup.is_cycle_on_form_perm List.Nodup.isCycleOn_formPerm

@@ -1218,12 +1218,10 @@ end CycleOf
 ### `cycleFactors`
 -/
 
-variable [DecidableEq α]
-
 open scoped List in
 /-- Given a list `l : List α` and a permutation `f : perm α` whose nonfixed points are all in `l`,
   recursively factors `f` into cycles. -/
-def cycleFactorsAux [Fintype α] :
+def cycleFactorsAux [DecidableEq α] [Fintype α] :
     ∀ (l : List α) (f : Perm α),
       (∀ {x}, f x ≠ x → x ∈ l) →
         { l : List (Perm α) // l.prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } := by
@@ -1325,7 +1323,7 @@ def cycleFactors [Fintype α] [LinearOrder α] (f : Perm α) :
 
 /-- Factors a permutation `f` into a list of disjoint cyclic permutations that multiply to `f`,
   without a linear order. -/
-def truncCycleFactors [Fintype α] (f : Perm α) :
+def truncCycleFactors [DecidableEq α] [Fintype α] (f : Perm α) :
     Trunc { l : List (Perm α) // l.prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } :=
   Quotient.recOnSubsingleton (@univ α _).1 (fun l h => Trunc.mk (cycleFactorsAux l f (h _)))
     (show ∀ x, f x ≠ x → x ∈ (@univ α _).1 from fun _ _ => mem_univ _)
@@ -1333,7 +1331,7 @@ def truncCycleFactors [Fintype α] (f : Perm α) :
 
 section CycleFactorsFinset
 
-variable [Fintype α] (f : Perm α)
+variable [DecidableEq α] [Fintype α] (f : Perm α)
 
 /-- Factors a permutation `f` into a `Finset` of disjoint cyclic permutations that multiply to `f`.
 -/
@@ -1547,7 +1545,7 @@ theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (ba
         (ih (fun τ hτ => h1 τ (List.mem_cons_of_mem σ hτ)) h2.of_cons)
 #align equiv.perm.cycle_induction_on Equiv.Perm.cycle_induction_on
 
-theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
+theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [DecidableEq α] [Fintype α] {f g : Perm α}
     (h : f ∈ cycleFactorsFinset g) : cycleFactorsFinset (g * f⁻¹) = cycleFactorsFinset g \ {f} := by
   revert f
   refine'
@@ -1607,7 +1605,7 @@ theorem closure_isCycle : closure { σ : Perm β | IsCycle σ } = ⊤ := by
       top_le_iff.mp (le_trans (ge_of_eq closure_isSwap) (closure_mono fun _ => IsSwap.isCycle))
 #align equiv.perm.closure_is_cycle Equiv.Perm.closure_isCycle
 
-variable [Fintype α]
+variable [DecidableEq α] [Fintype α]
 
 theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.support = ⊤) (x : α) :
     closure ({σ, swap x (σ x)} : Set (Perm α)) = ⊤ := by
@@ -1692,15 +1690,14 @@ end Generation
 
 section
 
-variable [Fintype α] {σ τ : Perm α}
-
 noncomputable section
 
+variable [DecidableEq α] [Fintype α] {σ τ : Perm α}
+
 theorem isConj_of_support_equiv
     (f : { x // x ∈ (σ.support : Set α) } ≃ { x // x ∈ (τ.support : Set α) })
-    (hf :
-      ∀ (x : α) (hx : x ∈ (σ.support : Set α)),
-        (f ⟨σ x, apply_mem_support.2 hx⟩ : α) = τ ↑(f ⟨x, hx⟩)) :
+    (hf : ∀ (x : α) (hx : x ∈ (σ.support : Set α)),
+      (f ⟨σ x, apply_mem_support.2 hx⟩ : α) = τ ↑(f ⟨x, hx⟩)) :
     IsConj σ τ := by
   refine' isConj_iff.2 ⟨Equiv.extendSubtype f, _⟩
   rw [mul_inv_eq_iff_eq_mul]
@@ -1762,7 +1759,7 @@ theorem card_support_conj : (σ * τ * σ⁻¹).support.card = τ.support.card :
 
 end
 
-theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
+theorem Disjoint.isConj_mul [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
     (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
   classical
     cases nonempty_fintype α
@@ -1816,7 +1813,7 @@ section FixedPoints
 -/
 
 
-theorem fixed_point_card_lt_of_ne_one [Fintype α] {σ : Perm α} (h : σ ≠ 1) :
+theorem fixed_point_card_lt_of_ne_one [DecidableEq α] [Fintype α] {σ : Perm α} (h : σ ≠ 1) :
     (filter (fun x => σ x = x) univ).card < Fintype.card α - 1 := by
   rw [lt_tsub_iff_left, ← lt_tsub_iff_right, ← Finset.card_compl, Finset.compl_filter]
   exact one_lt_card_support_of_ne_one h
@@ -1866,9 +1863,8 @@ variable [DecidableEq α] [Fintype α]
 
 theorem _root_.Finset.exists_cycleOn (s : Finset α) :
     ∃ f : Perm α, f.IsCycleOn s ∧ f.support ⊆ s := by
-  refine'
-    ⟨s.toList.formPerm, _, fun x hx => by
-      simpa using List.mem_of_formPerm_apply_ne _ _ (Perm.mem_support.1 hx)⟩
+  refine ⟨s.toList.formPerm, ?_, fun x hx => by
+    simpa using List.mem_of_formPerm_apply_ne _ _ (Perm.mem_support.1 hx)⟩
   convert s.nodup_toList.isCycleOn_formPerm
   simp
 #align finset.exists_cycle_on Finset.exists_cycleOn
@@ -1882,18 +1878,16 @@ variable {f : Perm α} {s : Set α}
 theorem _root_.Set.Countable.exists_cycleOn (hs : s.Countable) :
     ∃ f : Perm α, f.IsCycleOn s ∧ { x | f x ≠ x } ⊆ s := by
   classical
-    obtain hs' | hs' := s.finite_or_infinite
-    · refine'
-        ⟨hs'.toFinset.toList.formPerm, _, fun x hx => by
-          simpa using List.mem_of_formPerm_apply_ne _ _ hx⟩
-      convert hs'.toFinset.nodup_toList.isCycleOn_formPerm
-      simp
-    haveI := hs.to_subtype
+  obtain hs' | hs' := s.finite_or_infinite
+  · refine ⟨hs'.toFinset.toList.formPerm, ?_, fun x hx => by
+      simpa using List.mem_of_formPerm_apply_ne _ _ hx⟩
+    convert hs'.toFinset.nodup_toList.isCycleOn_formPerm
+    simp
+  · haveI := hs.to_subtype
     haveI := hs'.to_subtype
     obtain ⟨f⟩ : Nonempty (ℤ ≃ s) := inferInstance
-    refine'
-      ⟨(Equiv.addRight 1).extendDomain f, _, fun x hx =>
-        of_not_not fun h => hx <| Perm.extendDomain_apply_not_subtype _ _ h⟩
+    refine ⟨(Equiv.addRight 1).extendDomain f, ?_, fun x hx =>
+      of_not_not fun h => hx <| Perm.extendDomain_apply_not_subtype _ _ h⟩
     convert Int.addRight_one_isCycle.isCycleOn.extendDomain f
     rw [Set.image_comp, Equiv.image_eq_preimage]
     ext

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Joachim Breitner <mail@joachim-breitner.de>

@@ -544,7 +544,7 @@ theorem IsCycle.sign {f : Perm α} (hf : IsCycle f) : sign f = -(-1) ^ f.support
           card_support_swap_mul hx.1
         rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
         simp only [mul_neg, neg_mul, one_mul, neg_neg, pow_add, pow_one, mul_one]
-termination_by _ => f.support.card
+termination_by f.support.card
 #align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.sign
 
 theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
@@ -1793,9 +1793,9 @@ theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc
           · rw [mul_apply, mul_apply] at h
             rw [h, inv_apply_self, (hd1 x).resolve_left hxσ]
           · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
+        · rwa [Subtype.coe_mk, mem_coe, mem_support]
         · rwa [Subtype.coe_mk, Perm.mul_apply, (hd1 x).resolve_left hxσ, mem_coe,
             apply_mem_support, mem_support]
-        · rwa [Subtype.coe_mk, mem_coe, mem_support]
       · rw [mem_coe, ← apply_mem_support, mem_support] at hxτ
         rw [Set.union_apply_right hd1''.le_bot _, Set.union_apply_right hd1''.le_bot _]
         simp only [subtypeEquiv_apply, Perm.coe_mul, Sum.map_inr, comp_apply,
@@ -1804,9 +1804,9 @@ theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc
           · rw [mul_apply, mul_apply] at h
             rw [inv_apply_self, h, (hd1 (τ x)).resolve_right hxτ]
           · rwa [mul_apply, mul_apply, inv_apply_self, apply_eq_iff_eq]
+        · rwa [Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
         · rwa [Subtype.coe_mk, Perm.mul_apply, (hd1 (τ x)).resolve_right hxτ,
             mem_coe, mem_support]
-        · rwa [Subtype.coe_mk, mem_coe, ← apply_mem_support, mem_support]
 #align equiv.perm.disjoint.is_conj_mul Equiv.Perm.Disjoint.isConj_mul
 
 section FixedPoints

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

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

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

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

@@ -678,7 +678,7 @@ theorem IsCycle.pow_eq_one_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : 
 -- TODO: Define a `Set`-valued support to get rid of the `Finite β` assumption
 theorem IsCycle.pow_eq_one_iff' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} {x : β}
     (hx : f x ≠ x) : f ^ n = 1 ↔ (f ^ n) x = x :=
-  ⟨fun h => FunLike.congr_fun h x, fun h => hf.pow_eq_one_iff.2 ⟨x, hx, h⟩⟩
+  ⟨fun h => DFunLike.congr_fun h x, fun h => hf.pow_eq_one_iff.2 ⟨x, hx, h⟩⟩
 #align equiv.perm.is_cycle.pow_eq_one_iff' Equiv.Perm.IsCycle.pow_eq_one_iff'
 
 -- TODO: Define a `Set`-valued support to get rid of the `Finite β` assumption

and other simple lemmas about the order of elements in a group

From LeanAPAP

@@ -978,7 +978,7 @@ theorem cycleOf_pow_apply_self (f : Perm α) (x : α) : ∀ n : ℕ, (cycleOf f
   induction' n with n hn
   · rfl
   · rw [pow_succ, mul_apply, cycleOf_apply, hn, if_pos, pow_succ, mul_apply]
-    simpa [SameCycle] using ⟨n,rfl⟩
+    exact ⟨n, rfl⟩
 #align equiv.perm.cycle_of_pow_apply_self Equiv.Perm.cycleOf_pow_apply_self
 
 @[simp]

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

In some rare cases, golf proofs that needed fixing.

@@ -257,7 +257,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
 #align equiv.perm.same_cycle.exists_pow_eq' Equiv.Perm.SameCycle.exists_pow_eq'
 
 theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
-    ∃ (i : ℕ) (_ : 0 < i) (_ : i ≤ orderOf f), (f ^ i) x = y := by
+    ∃ i : ℕ, 0 < i ∧ i ≤ orderOf f ∧ (f ^ i) x = y := by
   classical
     obtain ⟨_ | i, hi, rfl⟩ := h.exists_pow_eq'
     · refine' ⟨orderOf f, orderOf_pos f, le_rfl, _⟩
@@ -1187,16 +1187,14 @@ theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleO
 #align equiv.perm.is_cycle_on_support_cycle_of Equiv.Perm.isCycleOn_support_cycleOf
 
 theorem SameCycle.exists_pow_eq_of_mem_support (h : SameCycle f x y) (hx : x ∈ f.support) :
-    ∃ (i : ℕ) (_ : i < (f.cycleOf x).support.card), (f ^ i) x = y := by
+    ∃ i < (f.cycleOf x).support.card, (f ^ i) x = y := by
   rw [mem_support] at hx
-  have := Equiv.Perm.IsCycleOn.exists_pow_eq (b := y) (f.isCycleOn_support_cycleOf x)
+  exact Equiv.Perm.IsCycleOn.exists_pow_eq (b := y) (f.isCycleOn_support_cycleOf x)
     (by rw [mem_support_cycleOf_iff' hx]) (by rwa [mem_support_cycleOf_iff' hx])
-  simp_rw [← exists_prop] at this
-  exact this
 #align equiv.perm.same_cycle.exists_pow_eq_of_mem_support Equiv.Perm.SameCycle.exists_pow_eq_of_mem_support
 
 theorem SameCycle.exists_pow_eq (f : Perm α) (h : SameCycle f x y) :
-    ∃ (i : ℕ) (_ : 0 < i) (_ : i ≤ (f.cycleOf x).support.card + 1), (f ^ i) x = y := by
+    ∃ i : ℕ, 0 < i ∧ i ≤ (f.cycleOf x).support.card + 1 ∧ (f ^ i) x = y := by
   by_cases hx : x ∈ f.support
   · obtain ⟨k, hk, hk'⟩ := h.exists_pow_eq_of_mem_support hx
     cases' k with k
@@ -1277,8 +1275,8 @@ def cycleFactorsAux [Fintype α] :
 
 theorem mem_list_cycles_iff {α : Type*} [Finite α] {l : List (Perm α)}
     (h1 : ∀ σ : Perm α, σ ∈ l → σ.IsCycle) (h2 : l.Pairwise Disjoint) {σ : Perm α} :
-    σ ∈ l ↔ σ.IsCycle ∧ ∀ (a : α) (_ : σ a ≠ a), σ a = l.prod a := by
-  suffices σ.IsCycle → (σ ∈ l ↔ ∀ (a : α) (_ : σ a ≠ a), σ a = l.prod a) by
+    σ ∈ l ↔ σ.IsCycle ∧ ∀ a, σ a ≠ a → σ a = l.prod a := by
+  suffices σ.IsCycle → (σ ∈ l ↔ ∀ a, σ a ≠ a → σ a = l.prod a) by
     exact ⟨fun hσ => ⟨h1 σ hσ, (this (h1 σ hσ)).mp hσ⟩, fun hσ => (this hσ.1).mpr hσ.2⟩
   intro h3
   classical

Normalising to naming convention rule number 6.

@@ -1720,7 +1720,7 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
   refine'
     isConj_of_support_equiv
       (hσ.zpowersEquivSupport.symm.trans <|
-        (zpowersEquivZpowers <| by rw [hσ.orderOf, h, hτ.orderOf]).trans hτ.zpowersEquivSupport)
+        (zpowersEquivZPowers <| by rw [hσ.orderOf, h, hτ.orderOf]).trans hτ.zpowersEquivSupport)
       _
   intro x hx
   simp only [Perm.mul_apply, Equiv.trans_apply, Equiv.sumCongr_apply]
@@ -1730,7 +1730,7 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
       (congr rfl (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply n).symm))))
   apply (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply (n + 1))))).trans _
   -- This used to be a `simp only` before leanprover/lean4#2644
-  erw [zpowersEquivZpowers_apply, zpowersEquivZpowers_apply]
+  erw [zpowersEquivZPowers_apply, zpowersEquivZPowers_apply]
   dsimp
     -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
   erw [pow_succ, Perm.mul_apply]

Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Tobias Grosser <tobias@grosser.es> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net>

@@ -1220,9 +1220,9 @@ end CycleOf
 ### `cycleFactors`
 -/
 
-
 variable [DecidableEq α]
 
+open scoped List in
 /-- Given a list `l : List α` and a permutation `f : perm α` whose nonfixed points are all in `l`,
   recursively factors `f` into cycles. -/
 def cycleFactorsAux [Fintype α] :
@@ -1263,7 +1263,7 @@ def cycleFactorsAux [Fintype α] :
                 List.cons_perm_iff_perm_erase.2 ⟨hg, List.Perm.refl _⟩
               have : ∀ h ∈ m.erase g, Disjoint g h :=
                 (List.pairwise_cons.1
-                    ((hgm.pairwise_iff fun a b (h : Disjoint a b) => h.symm).2 hm₃)).1
+                    ((hgm.pairwise_iff @fun a b (h : Disjoint a b) => h.symm).2 hm₃)).1
               by_cases id fun hgy : g y ≠ y =>
                 (disjoint_prod_right _ this y).resolve_right <| by
                   have hsc : SameCycle f⁻¹ x (f y) := by
@@ -1303,13 +1303,14 @@ theorem mem_list_cycles_iff {α : Type*} [Finite α] {l : List (Perm α)}
       exact key a (mem_inter_of_mem ha hτa)
 #align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
 
+open scoped List in
 theorem list_cycles_perm_list_cycles {α : Type*} [Finite α] {l₁ l₂ : List (Perm α)}
     (h₀ : l₁.prod = l₂.prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
     (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
     (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by
   classical
     refine'
-      (List.perm_ext (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
+      (List.perm_ext_iff_of_nodup (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
             (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
         fun σ => _
     by_cases hσ : σ.IsCycle
@@ -1348,6 +1349,7 @@ def cycleFactorsFinset : Finset (Perm α) :=
         hl.right.right hl'.right.right)
 #align equiv.perm.cycle_factors_finset Equiv.Perm.cycleFactorsFinset
 
+open scoped List in
 theorem cycleFactorsFinset_eq_list_toFinset {σ : Perm α} {l : List (Perm α)} (hn : l.Nodup) :
     σ.cycleFactorsFinset = l.toFinset ↔
       (∀ f : Perm α, f ∈ l → f.IsCycle) ∧ l.Pairwise Disjoint ∧ l.prod = σ := by
@@ -1361,7 +1363,8 @@ theorem cycleFactorsFinset_eq_list_toFinset {σ : Perm α} {l : List (Perm α)}
     have hperm : l ~ l' := List.perm_of_nodup_nodup_toFinset_eq hn hn' h.symm
     refine' ⟨_, _, _⟩
     · exact fun _ h => hc' _ (hperm.subset h)
-    · rwa [List.Perm.pairwise_iff Disjoint.symmetric hperm]
+    · have := List.Perm.pairwise_iff (@Disjoint.symmetric _) hperm
+      rwa [this]
     · rw [← hp', hperm.symm.prod_eq']
       refine' hd'.imp _
       exact Disjoint.commute

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

@@ -433,7 +433,7 @@ theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ)
 #align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply
 
 protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.support.card := by
-  rw [←Fintype.card_zpowers, ← Fintype.card_coe]
+  rw [← Fintype.card_zpowers, ← Fintype.card_coe]
   convert Fintype.card_congr (IsCycle.zpowersEquivSupport hf)
 #align equiv.perm.is_cycle.order_of Equiv.Perm.IsCycle.orderOf
 

This eliminates (fun a ↦ β) α in the type when applying a FunLike.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -533,7 +533,6 @@ theorem IsCycle.sign {f : Perm α} (hf : IsCycle f) : sign f = -(-1) ^ f.support
         have h : swap x (f x) * f = 1 := by
           simp only [mul_def, one_def]
           rw [hf.eq_swap_of_apply_apply_eq_self hx.1 h1, swap_apply_left, swap_swap]
-        dsimp only
         rw [sign_mul, sign_swap hx.1.symm, h, sign_one,
           hf.eq_swap_of_apply_apply_eq_self hx.1 h1, card_support_swap hx.1.symm]
         rfl
@@ -543,7 +542,6 @@ theorem IsCycle.sign {f : Perm α} (hf : IsCycle f) : sign f = -(-1) ^ f.support
             card_insert_of_not_mem (not_mem_erase _ _), sdiff_singleton_eq_erase]
         have : card (support (swap x (f x) * f)) < card (support f) :=
           card_support_swap_mul hx.1
-        dsimp only
         rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
         simp only [mul_neg, neg_mul, one_mul, neg_neg, pow_add, pow_one, mul_one]
 termination_by _ => f.support.card

The cardinality of a subgroup is greater than the order of any of its elements.

Rename

• order_eq_card_zpowers → Fintype.card_zpowers
• order_eq_card_zpowers' → Nat.card_zpowers (and turn it around to match Nat.card_subgroupPowers)
• Submonoid.powers_subset → Submonoid.powers_le
• orderOf_dvd_card_univ → orderOf_dvd_card
• orderOf_subgroup → Subgroup.orderOf
• Subgroup.nonempty → Subgroup.coe_nonempty

@@ -433,7 +433,7 @@ theorem IsCycle.zpowersEquivSupport_symm_apply {σ : Perm α} (hσ : IsCycle σ)
 #align equiv.perm.is_cycle.zpowers_equiv_support_symm_apply Equiv.Perm.IsCycle.zpowersEquivSupport_symm_apply
 
 protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.support.card := by
-  rw [orderOf_eq_card_zpowers, ← Fintype.card_coe]
+  rw [←Fintype.card_zpowers, ← Fintype.card_coe]
   convert Fintype.card_congr (IsCycle.zpowersEquivSupport hf)
 #align equiv.perm.is_cycle.order_of Equiv.Perm.IsCycle.orderOf
 

Many lemmas in GroupTheory.OrderOfElement were stated for elements of finite groups even though they work more generally for torsion elements of possibly infinite groups. This PR generalises those lemmas (and leaves convenience lemmas stated for finite groups), and fixes a bunch of names to use dot notation.

Renames

• Function.eq_of_lt_minimalPeriod_of_iterate_eq → Function.iterate_injOn_Iio_minimalPeriod
• Function.eq_iff_lt_minimalPeriod_of_iterate_eq → Function.iterate_eq_iterate_iff_of_lt_minimalPeriod
• isOfFinOrder_iff_coe → Submonoid.isOfFinOrder_coe
• orderOf_pos' → IsOfFinOrder.orderOf_pos
• pow_eq_mod_orderOf → pow_mod_orderOf (and turned around)
• pow_injective_of_lt_orderOf → pow_injOn_Iio_orderOf
• mem_powers_iff_mem_range_order_of' → IsOfFinOrder.mem_powers_iff_mem_range_orderOf
• orderOf_pow'' → IsOfFinOrder.orderOf_pow
• orderOf_pow_coprime → Nat.Coprime.orderOf_pow
• zpow_eq_mod_orderOf → zpow_mod_orderOf (and turned around)
• exists_pow_eq_one → isOfFinOrder_of_finite
• pow_apply_eq_pow_mod_orderOf_cycleOf_apply → pow_mod_orderOf_cycleOf_apply

New lemmas

• IsOfFinOrder.powers_eq_image_range_orderOf
• IsOfFinOrder.natCard_powers_le_orderOf
• IsOfFinOrder.finite_powers
• finite_powers
• infinite_powers
• Nat.card_submonoidPowers
• IsOfFinOrder.mem_powers_iff_mem_zpowers
• IsOfFinOrder.powers_eq_zpowers
• IsOfFinOrder.mem_zpowers_iff_mem_range_orderOf
• IsOfFinOrder.exists_pow_eq_one

Other changes

• Move decidableMemPowers/fintypePowers to GroupTheory.Submonoid.Membership and decidableMemZpowers/fintypeZpowers to GroupTheory.Subgroup.ZPowers.
• finEquivPowers, finEquivZpowers, powersEquivPowers and zpowersEquivZpowers now assume IsOfFinTorsion x instead of Finite G.
• isOfFinOrder_iff_pow_eq_one now takes one less explicit argument.
• Delete Equiv.Perm.IsCycle.exists_pow_eq_one since it was saying that a permutation over a finite type is torsion, but this is trivial since the group of permutation is itself finite, so we can use isOfFinOrder_of_finite instead.

@@ -250,7 +250,7 @@ theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < order
     use (k % orderOf f).natAbs
     have h₀ := Int.coe_nat_pos.mpr (orderOf_pos f)
     have h₁ := Int.emod_nonneg k h₀.ne'
-    rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, ← zpow_eq_mod_orderOf]
+    rw [← zpow_ofNat, Int.natAbs_of_nonneg h₁, zpow_mod_orderOf]
     refine' ⟨_, by rfl⟩
     rw [← Int.ofNat_lt, Int.natAbs_of_nonneg h₁]
     exact Int.emod_lt_of_pos _ h₀
@@ -274,7 +274,7 @@ instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f
           simp [orderOf_le_card_univ]),
       by
         rw [← zpow_ofNat, Int.natAbs_of_nonneg (Int.emod_nonneg _ <|
-          Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _), ← zpow_eq_mod_orderOf, hi]⟩⟩
+          Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _), zpow_mod_orderOf, hi]⟩⟩
 
 end SameCycle
 
@@ -362,7 +362,7 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
   classical exact
       ⟨(n % orderOf f).toNat, by
         {have := n.emod_nonneg (Int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
-         rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_eq_mod_orderOf]}⟩
+         rwa [← zpow_ofNat, Int.toNat_of_nonneg this, zpow_mod_orderOf]}⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
 
 end Finite
@@ -389,18 +389,7 @@ theorem IsCycle.two_le_card_support (h : IsCycle f) : 2 ≤ f.support.card :=
   two_le_card_support_of_ne_one h.ne_one
 #align equiv.perm.is_cycle.two_le_card_support Equiv.Perm.IsCycle.two_le_card_support
 
-theorem IsCycle.exists_pow_eq_one [Finite β] {f : Perm β} (hf : IsCycle f) :
-    ∃ (k : ℕ) (_ : 1 < k), f ^ k = 1 := by
-  classical
-    have : IsOfFinOrder f := by exact _root_.exists_pow_eq_one f
-    rw [isOfFinOrder_iff_pow_eq_one] at this
-    obtain ⟨x, hx, _⟩ := hf
-    obtain ⟨_ | _ | k, hk, hk'⟩ := this
-    · exact absurd hk (lt_asymm hk)
-    · rw [pow_one] at hk'
-      simp [hk'] at hx
-    · exact ⟨k + 2, by simp, hk'⟩
-#align equiv.perm.is_cycle.exists_pow_eq_one Equiv.Perm.IsCycle.exists_pow_eq_one
+#noalign equiv.perm.is_cycle.exists_pow_eq_one
 
 /-- The subgroup generated by a cycle is in bijection with its support -/
 noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ) :
@@ -1112,10 +1101,10 @@ theorem card_support_cycleOf_pos_iff : 0 < card (cycleOf f x).support ↔ f x 
   exact ⟨fun h => Or.resolve_left h.eq_or_lt (card_support_ne_one _).symm, zero_lt_two.trans_le⟩
 #align equiv.perm.card_support_cycle_of_pos_iff Equiv.Perm.card_support_cycleOf_pos_iff
 
-theorem pow_apply_eq_pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x : α) :
-    (f ^ n) x = (f ^ (n % orderOf (cycleOf f x))) x := by
-  rw [← cycleOf_pow_apply_self f, ← cycleOf_pow_apply_self f, pow_eq_mod_orderOf]
-#align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_apply_eq_pow_mod_orderOf_cycleOf_apply
+theorem pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x : α) :
+    (f ^ (n % orderOf (cycleOf f x))) x = (f ^ n) x := by
+  rw [← cycleOf_pow_apply_self f, ← cycleOf_pow_apply_self f, pow_mod_orderOf]
+#align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_mod_orderOf_cycleOf_apply
 
 theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x = x) :
     (f * g).cycleOf x = f.cycleOf x := by
@@ -1176,7 +1165,7 @@ theorem pow_mod_card_support_cycleOf_self_apply (f : Perm α) (n : ℕ) (x : α)
   by_cases hx : f x = x
   · rw [pow_apply_eq_self_of_apply_eq_self hx, pow_apply_eq_self_of_apply_eq_self hx]
   · rw [← cycleOf_pow_apply_self, ← cycleOf_pow_apply_self f, ← (isCycle_cycleOf f hx).orderOf,
-      ← pow_eq_mod_orderOf]
+      pow_mod_orderOf]
 #align equiv.perm.pow_mod_card_support_cycle_of_self_apply Equiv.Perm.pow_mod_card_support_cycleOf_self_apply
 
 /-- `x` is in the support of `f` iff `Equiv.Perm.cycle_of f x` is a cycle. -/

This reverts commit f3695eb2.

@@ -870,6 +870,9 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
       (hf.isCycle_subtypePerm hs).pow_eq_one_iff'
         (ne_of_apply_ne ((↑) : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).2)]
     simp
+    -- This used to be the end of the proof before leanprover/lean4#2644
+    erw [subtypePerm_apply]
+    simp
 #align equiv.perm.is_cycle_on.pow_apply_eq Equiv.Perm.IsCycleOn.pow_apply_eq
 
 theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
@@ -1736,10 +1739,11 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
     Eq.trans _
       (congr rfl (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply n).symm))))
   apply (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply (n + 1))))).trans _
-  simp only [Ne.def, IsCycle.zpowersEquivSupport_apply, Subtype.coe_mk,
-    zpowersEquivZpowers_apply]
+  -- This used to be a `simp only` before leanprover/lean4#2644
+  erw [zpowersEquivZpowers_apply, zpowersEquivZpowers_apply]
   dsimp
-  rw [pow_succ, Perm.mul_apply]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+  erw [pow_succ, Perm.mul_apply]
 #align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
 
 theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :

This reverts commit 26eb2b0a.

@@ -870,9 +870,6 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
       (hf.isCycle_subtypePerm hs).pow_eq_one_iff'
         (ne_of_apply_ne ((↑) : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).2)]
     simp
-    -- This used to be the end of the proof before leanprover/lean4#2644
-    erw [subtypePerm_apply]
-    simp
 #align equiv.perm.is_cycle_on.pow_apply_eq Equiv.Perm.IsCycleOn.pow_apply_eq
 
 theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
@@ -1739,11 +1736,10 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
     Eq.trans _
       (congr rfl (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply n).symm))))
   apply (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply (n + 1))))).trans _
-  -- This used to be a `simp only` before leanprover/lean4#2644
-  erw [zpowersEquivZpowers_apply, zpowersEquivZpowers_apply]
+  simp only [Ne.def, IsCycle.zpowersEquivSupport_apply, Subtype.coe_mk,
+    zpowersEquivZpowers_apply]
   dsimp
-    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-  erw [pow_succ, Perm.mul_apply]
+  rw [pow_succ, Perm.mul_apply]
 #align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
 
 theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :

This includes all the changes from #7606.

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

@@ -870,6 +870,9 @@ theorem IsCycleOn.pow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
       (hf.isCycle_subtypePerm hs).pow_eq_one_iff'
         (ne_of_apply_ne ((↑) : s → α) <| hf.apply_ne hs (⟨a, ha⟩ : s).2)]
     simp
+    -- This used to be the end of the proof before leanprover/lean4#2644
+    erw [subtypePerm_apply]
+    simp
 #align equiv.perm.is_cycle_on.pow_apply_eq Equiv.Perm.IsCycleOn.pow_apply_eq
 
 theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s) :
@@ -1736,10 +1739,11 @@ theorem IsCycle.isConj (hσ : IsCycle σ) (hτ : IsCycle τ) (h : σ.support.car
     Eq.trans _
       (congr rfl (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply n).symm))))
   apply (congr rfl (congr rfl (congr rfl (hσ.zpowersEquivSupport_symm_apply (n + 1))))).trans _
-  simp only [Ne.def, IsCycle.zpowersEquivSupport_apply, Subtype.coe_mk,
-    zpowersEquivZpowers_apply]
+  -- This used to be a `simp only` before leanprover/lean4#2644
+  erw [zpowersEquivZpowers_apply, zpowersEquivZpowers_apply]
   dsimp
-  rw [pow_succ, Perm.mul_apply]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+  erw [pow_succ, Perm.mul_apply]
 #align equiv.perm.is_cycle.is_conj Equiv.Perm.IsCycle.isConj
 
 theorem IsCycle.isConj_iff (hσ : IsCycle σ) (hτ : IsCycle τ) :

@@ -1925,7 +1925,7 @@ namespace Finset
 
 variable {f : Perm α} {s : Finset α}
 
-theorem _root_.Finset.product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
+theorem _root_.Finset.product_self_eq_disjiUnion_perm_aux (hf : f.IsCycleOn s) :
     (range s.card : Set ℕ).PairwiseDisjoint fun k =>
       s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩ := by
   obtain hs | _ := (s : Set α).subsingleton_or_nontrivial
@@ -1940,7 +1940,7 @@ theorem _root_.Finset.product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
     rw [hf.pow_apply_eq_pow_apply ha] at h
     rw [mem_coe, mem_range] at hm hn
     exact hmn.symm (h.eq_of_lt_of_lt hn hm)
-#align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disj_Union_perm_aux
+#align finset.product_self_eq_disj_Union_perm_aux Finset.product_self_eq_disjiUnion_perm_aux
 
 /-- We can partition the square `s ×ˢ s` into shifted diagonals as such:
 ```
@@ -1953,11 +1953,11 @@ theorem _root_.Finset.product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
 
 The diagonals are given by the cycle `f`.
 -/
-theorem _root_.Finset.product_self_eq_disjUnion_perm (hf : f.IsCycleOn s) :
+theorem _root_.Finset.product_self_eq_disjiUnion_perm (hf : f.IsCycleOn s) :
     s ×ˢ s =
       (range s.card).disjiUnion
         (fun k => s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩)
-        (product_self_eq_disj_Union_perm_aux hf) := by
+        (product_self_eq_disjiUnion_perm_aux hf) := by
   ext ⟨a, b⟩
   simp only [mem_product, Equiv.Perm.coe_pow, mem_disjiUnion, mem_range, mem_map,
     Function.Embedding.coeFn_mk, Prod.mk.inj_iff, exists_prop]
@@ -1966,7 +1966,7 @@ theorem _root_.Finset.product_self_eq_disjUnion_perm (hf : f.IsCycleOn s) :
     exact ⟨n, hn, a, hx.1, rfl, by rw [f.iterate_eq_pow]⟩
   · rintro ⟨n, -, a, ha, rfl, rfl⟩
     exact ⟨ha, (hf.1.iterate _).mapsTo ha⟩
-#align finset.product_self_eq_disj_Union_perm Finset.product_self_eq_disjUnionₓ_perm
+#align finset.product_self_eq_disj_Union_perm Finset.product_self_eq_disjiUnion_permₓ
 
 end Finset
 
@@ -1976,7 +1976,7 @@ variable [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : P
 
 theorem _root_.Finset.sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
     ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) := by
-  simp_rw [sum_smul_sum, product_self_eq_disjUnion_perm hσ, sum_disjiUnion, sum_map]
+  simp_rw [sum_smul_sum, product_self_eq_disjiUnion_perm hσ, sum_disjiUnion, sum_map]
   rfl
 #align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_perm
 

@@ -37,7 +37,7 @@ The following two definitions require that `β` is a `Fintype`:
 ## Main results
 
 * This file contains several closure results:
-  - `closure_is_cycle` : The symmetric group is generated by cycles
+  - `closure_isCycle` : The symmetric group is generated by cycles
   - `closure_cycle_adjacent_swap` : The symmetric group is generated by
     a cycle and an adjacent transposition
   - `closure_cycle_coprime_swap` : The symmetric group is generated by
@@ -47,10 +47,10 @@ The following two definitions require that `β` is a `Fintype`:
 
 ## Notes
 
-`Equiv.Perm.is_cycle` and `Equiv.Perm.IsCycleOn` are different in three ways:
-* `is_cycle` is about the entire type while `IsCycleOn` is restricted to a set.
-* `is_cycle` forbids the identity while `IsCycleOn` allows it (if `s` is a subsingleton).
-* `IsCycleOn` forbids fixed points on `s` (if `s` is nontrivial), while `is_cycle` allows them.
+`Equiv.Perm.IsCycle` and `Equiv.Perm.IsCycleOn` are different in three ways:
+* `IsCycle` is about the entire type while `IsCycleOn` is restricted to a set.
+* `IsCycle` forbids the identity while `IsCycleOn` allows it (if `s` is a subsingleton).
+* `IsCycleOn` forbids fixed points on `s` (if `s` is nontrivial), while `IsCycle` allows them.
 -/
 
 

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

@@ -617,7 +617,7 @@ theorem IsCycle.eq_on_support_inter_nonempty_congr (hf : IsCycle f) (hg : IsCycl
     intro y hy
     obtain ⟨k, rfl⟩ := hf.exists_pow_eq (mem_support.mp hx') (mem_support.mp hy)
     rwa [pow_eq_on_of_mem_support h _ _ (mem_inter_of_mem hx' hx''), pow_apply_mem_support]
-  rw [(inter_eq_left_iff_subset _ _).mpr this] at h
+  rw [inter_eq_left.mpr this] at h
   exact hf.support_congr hg this h
 #align equiv.perm.is_cycle.eq_on_support_inter_nonempty_congr Equiv.Perm.IsCycle.eq_on_support_inter_nonempty_congr
 

I'm exploring @kmill's combinatorial maps work and these two definitions are part of it:

https://github.com/kmill/lean-graphs/blob/bd3139daf81c0f41ce5ade951195858cdf038bd2/src/myequiv.lean#L72-L76

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -100,6 +100,14 @@ theorem SameCycle.trans : SameCycle f x y → SameCycle f y z → SameCycle f x
   fun ⟨i, hi⟩ ⟨j, hj⟩ => ⟨j + i, by rw [zpow_add, mul_apply, hi, hj]⟩
 #align equiv.perm.same_cycle.trans Equiv.Perm.SameCycle.trans
 
+variable (f) in
+theorem SameCycle.equivalence : Equivalence (SameCycle f) :=
+  ⟨SameCycle.refl f, SameCycle.symm, SameCycle.trans⟩
+
+/-- The setoid defined by the `SameCycle` relation. -/
+def SameCycle.setoid (f : Perm α) : Setoid α where
+  iseqv := SameCycle.equivalence f
+
 @[simp]
 theorem sameCycle_one : SameCycle 1 x y ↔ x = y := by simp [SameCycle]
 #align equiv.perm.same_cycle_one Equiv.Perm.sameCycle_one

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

@@ -639,7 +639,7 @@ theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npo
 #align equiv.perm.is_cycle.support_pow_of_pos_of_lt_order_of Equiv.Perm.IsCycle.support_pow_of_pos_of_lt_orderOf
 
 theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
-    IsCycle (f ^ n) ↔ n.coprime (orderOf f) := by
+    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) := by
   classical
     cases nonempty_fintype β
     constructor
@@ -723,8 +723,8 @@ theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf
     (hf' : (orderOf f).Prime) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f) : IsCycle (f ^ n) := by
   classical
     cases nonempty_fintype β
-    have : n.coprime (orderOf f) := by
-      refine' Nat.coprime.symm _
+    have : n.Coprime (orderOf f) := by
+      refine' Nat.Coprime.symm _
       rw [Nat.Prime.coprime_iff_not_dvd hf']
       exact Nat.not_dvd_of_pos_of_lt hn hn'
     obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
@@ -1660,7 +1660,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
   exact step4 y z
 #align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swap
 
-theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n (Fintype.card α))
+theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.Coprime n (Fintype.card α))
     (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
     closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ := by
   rw [← Finset.card_univ, ← h2, ← h1.orderOf] at h0
@@ -1683,7 +1683,7 @@ theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime
       (mem_support.mp ((Finset.ext_iff.mp h2 y).mpr (Finset.mem_univ y)))
   rw [h5, ← hi]
   refine'
-    closure_cycle_coprime_swap (Nat.coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
+    closure_cycle_coprime_swap (Nat.Coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
   cases' h with m hm
   rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.orderOf, pow_orderOf_eq_one, one_pow,
     one_apply] at hi

This reverts commit 6f8e8104. Unfortunately this bump was not linted correctly, as CI did not run runLinter Mathlib.

We can unrevert once that's fixed.

@@ -639,7 +639,7 @@ theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npo
 #align equiv.perm.is_cycle.support_pow_of_pos_of_lt_order_of Equiv.Perm.IsCycle.support_pow_of_pos_of_lt_orderOf
 
 theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
-    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) := by
+    IsCycle (f ^ n) ↔ n.coprime (orderOf f) := by
   classical
     cases nonempty_fintype β
     constructor
@@ -723,8 +723,8 @@ theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf
     (hf' : (orderOf f).Prime) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f) : IsCycle (f ^ n) := by
   classical
     cases nonempty_fintype β
-    have : n.Coprime (orderOf f) := by
-      refine' Nat.Coprime.symm _
+    have : n.coprime (orderOf f) := by
+      refine' Nat.coprime.symm _
       rw [Nat.Prime.coprime_iff_not_dvd hf']
       exact Nat.not_dvd_of_pos_of_lt hn hn'
     obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
@@ -1660,7 +1660,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
   exact step4 y z
 #align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swap
 
-theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.Coprime n (Fintype.card α))
+theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n (Fintype.card α))
     (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
     closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ := by
   rw [← Finset.card_univ, ← h2, ← h1.orderOf] at h0
@@ -1683,7 +1683,7 @@ theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime
       (mem_support.mp ((Finset.ext_iff.mp h2 y).mpr (Finset.mem_univ y)))
   rw [h5, ← hi]
   refine'
-    closure_cycle_coprime_swap (Nat.Coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
+    closure_cycle_coprime_swap (Nat.coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
   cases' h with m hm
   rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.orderOf, pow_orderOf_eq_one, one_pow,
     one_apply] at hi

Some changes have already been review and delegated in #6910 and #7148.

The diff that needs looking at is https://github.com/leanprover-community/mathlib4/pull/7174/commits/64d6d07ee18163627c8f517eb31455411921c5ac

The std bump PR was insta-merged already!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -639,7 +639,7 @@ theorem IsCycle.support_pow_of_pos_of_lt_orderOf (hf : IsCycle f) {n : ℕ} (npo
 #align equiv.perm.is_cycle.support_pow_of_pos_of_lt_order_of Equiv.Perm.IsCycle.support_pow_of_pos_of_lt_orderOf
 
 theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
-    IsCycle (f ^ n) ↔ n.coprime (orderOf f) := by
+    IsCycle (f ^ n) ↔ n.Coprime (orderOf f) := by
   classical
     cases nonempty_fintype β
     constructor
@@ -723,8 +723,8 @@ theorem IsCycle.isCycle_pow_pos_of_lt_prime_order [Finite β] {f : Perm β} (hf
     (hf' : (orderOf f).Prime) (n : ℕ) (hn : 0 < n) (hn' : n < orderOf f) : IsCycle (f ^ n) := by
   classical
     cases nonempty_fintype β
-    have : n.coprime (orderOf f) := by
-      refine' Nat.coprime.symm _
+    have : n.Coprime (orderOf f) := by
+      refine' Nat.Coprime.symm _
       rw [Nat.Prime.coprime_iff_not_dvd hf']
       exact Nat.not_dvd_of_pos_of_lt hn hn'
     obtain ⟨m, hm⟩ := exists_pow_eq_self_of_coprime this
@@ -1660,7 +1660,7 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
   exact step4 y z
 #align equiv.perm.closure_cycle_adjacent_swap Equiv.Perm.closure_cycle_adjacent_swap
 
-theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n (Fintype.card α))
+theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.Coprime n (Fintype.card α))
     (h1 : IsCycle σ) (h2 : σ.support = Finset.univ) (x : α) :
     closure ({σ, swap x ((σ ^ n) x)} : Set (Perm α)) = ⊤ := by
   rw [← Finset.card_univ, ← h2, ← h1.orderOf] at h0
@@ -1683,7 +1683,7 @@ theorem closure_prime_cycle_swap {σ τ : Perm α} (h0 : (Fintype.card α).Prime
       (mem_support.mp ((Finset.ext_iff.mp h2 y).mpr (Finset.mem_univ y)))
   rw [h5, ← hi]
   refine'
-    closure_cycle_coprime_swap (Nat.coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
+    closure_cycle_coprime_swap (Nat.Coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
   cases' h with m hm
   rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.orderOf, pow_orderOf_eq_one, one_pow,
     one_apply] at hi

@@ -109,7 +109,7 @@ theorem sameCycle_inv : SameCycle f⁻¹ x y ↔ SameCycle f x y :=
   (Equiv.neg _).exists_congr_left.trans <| by simp [SameCycle]
 #align equiv.perm.same_cycle_inv Equiv.Perm.sameCycle_inv
 
-alias sameCycle_inv ↔ SameCycle.of_inv SameCycle.inv
+alias ⟨SameCycle.of_inv, SameCycle.inv⟩ := sameCycle_inv
 #align equiv.perm.same_cycle.of_inv Equiv.Perm.SameCycle.of_inv
 #align equiv.perm.same_cycle.inv Equiv.Perm.SameCycle.inv
 
@@ -177,35 +177,35 @@ theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle
   rw [← zpow_ofNat, sameCycle_zpow_right]
 #align equiv.perm.same_cycle_pow_right Equiv.Perm.sameCycle_pow_right
 
-alias sameCycle_apply_left ↔ SameCycle.of_apply_left SameCycle.apply_left
+alias ⟨SameCycle.of_apply_left, SameCycle.apply_left⟩ := sameCycle_apply_left
 #align equiv.perm.same_cycle.of_apply_left Equiv.Perm.SameCycle.of_apply_left
 #align equiv.perm.same_cycle.apply_left Equiv.Perm.SameCycle.apply_left
 
-alias sameCycle_apply_right ↔ SameCycle.of_apply_right SameCycle.apply_right
+alias ⟨SameCycle.of_apply_right, SameCycle.apply_right⟩ := sameCycle_apply_right
 #align equiv.perm.same_cycle.of_apply_right Equiv.Perm.SameCycle.of_apply_right
 #align equiv.perm.same_cycle.apply_right Equiv.Perm.SameCycle.apply_right
 
-alias sameCycle_inv_apply_left ↔ SameCycle.of_inv_apply_left SameCycle.inv_apply_left
+alias ⟨SameCycle.of_inv_apply_left, SameCycle.inv_apply_left⟩ := sameCycle_inv_apply_left
 #align equiv.perm.same_cycle.of_inv_apply_left Equiv.Perm.SameCycle.of_inv_apply_left
 #align equiv.perm.same_cycle.inv_apply_left Equiv.Perm.SameCycle.inv_apply_left
 
-alias sameCycle_inv_apply_right ↔ SameCycle.of_inv_apply_right SameCycle.inv_apply_right
+alias ⟨SameCycle.of_inv_apply_right, SameCycle.inv_apply_right⟩ := sameCycle_inv_apply_right
 #align equiv.perm.same_cycle.of_inv_apply_right Equiv.Perm.SameCycle.of_inv_apply_right
 #align equiv.perm.same_cycle.inv_apply_right Equiv.Perm.SameCycle.inv_apply_right
 
-alias sameCycle_pow_left ↔ SameCycle.of_pow_left SameCycle.pow_left
+alias ⟨SameCycle.of_pow_left, SameCycle.pow_left⟩ := sameCycle_pow_left
 #align equiv.perm.same_cycle.of_pow_left Equiv.Perm.SameCycle.of_pow_left
 #align equiv.perm.same_cycle.pow_left Equiv.Perm.SameCycle.pow_left
 
-alias sameCycle_pow_right ↔ SameCycle.of_pow_right SameCycle.pow_right
+alias ⟨SameCycle.of_pow_right, SameCycle.pow_right⟩ := sameCycle_pow_right
 #align equiv.perm.same_cycle.of_pow_right Equiv.Perm.SameCycle.of_pow_right
 #align equiv.perm.same_cycle.pow_right Equiv.Perm.SameCycle.pow_right
 
-alias sameCycle_zpow_left ↔ SameCycle.of_zpow_left SameCycle.zpow_left
+alias ⟨SameCycle.of_zpow_left, SameCycle.zpow_left⟩ := sameCycle_zpow_left
 #align equiv.perm.same_cycle.of_zpow_left Equiv.Perm.SameCycle.of_zpow_left
 #align equiv.perm.same_cycle.zpow_left Equiv.Perm.SameCycle.zpow_left
 
-alias sameCycle_zpow_right ↔ SameCycle.of_zpow_right SameCycle.zpow_right
+alias ⟨SameCycle.of_zpow_right, SameCycle.zpow_right⟩ := sameCycle_zpow_right
 #align equiv.perm.same_cycle.of_zpow_right Equiv.Perm.SameCycle.of_zpow_right
 #align equiv.perm.same_cycle.zpow_right Equiv.Perm.SameCycle.zpow_right
 
@@ -223,7 +223,7 @@ theorem sameCycle_subtypePerm {h} {x y : { x // p x }} :
   exists_congr fun n => by simp [Subtype.ext_iff]
 #align equiv.perm.same_cycle_subtype_perm Equiv.Perm.sameCycle_subtypePerm
 
-alias sameCycle_subtypePerm ↔ _ SameCycle.subtypePerm
+alias ⟨_, SameCycle.subtypePerm⟩ := sameCycle_subtypePerm
 #align equiv.perm.same_cycle.subtype_perm Equiv.Perm.SameCycle.subtypePerm
 
 @[simp]
@@ -233,7 +233,7 @@ theorem sameCycle_extendDomain {p : β → Prop} [DecidablePred p] {f : α ≃ S
     rw [← extendDomain_zpow, extendDomain_apply_image, Subtype.coe_inj, f.injective.eq_iff]
 #align equiv.perm.same_cycle_extend_domain Equiv.Perm.sameCycle_extendDomain
 
-alias sameCycle_extendDomain ↔ _ SameCycle.extendDomain
+alias ⟨_, SameCycle.extendDomain⟩ := sameCycle_extendDomain
 #align equiv.perm.same_cycle.extend_domain Equiv.Perm.SameCycle.extendDomain
 
 theorem SameCycle.exists_pow_eq' [Finite α] : SameCycle f x y → ∃ i < orderOf f, (f ^ i) x = y := by
@@ -759,7 +759,7 @@ theorem isCycleOn_one : (1 : Perm α).IsCycleOn s ↔ s.Subsingleton := by
   simp [IsCycleOn, Set.bijOn_id, Set.Subsingleton]
 #align equiv.perm.is_cycle_on_one Equiv.Perm.isCycleOn_one
 
-alias isCycleOn_one ↔ IsCycleOn.subsingleton _root_.Set.Subsingleton.isCycleOn_one
+alias ⟨IsCycleOn.subsingleton, _root_.Set.Subsingleton.isCycleOn_one⟩ := isCycleOn_one
 #align equiv.perm.is_cycle_on.subsingleton Equiv.Perm.IsCycleOn.subsingleton
 #align set.subsingleton.is_cycle_on_one Set.Subsingleton.isCycleOn_one
 
@@ -777,7 +777,7 @@ theorem isCycleOn_inv : f⁻¹.IsCycleOn s ↔ f.IsCycleOn s := by
   exact fun _ ↦ ⟨fun h ↦ Set.BijOn.perm_inv h, fun h ↦ Set.BijOn.perm_inv h⟩
 #align equiv.perm.is_cycle_on_inv Equiv.Perm.isCycleOn_inv
 
-alias isCycleOn_inv ↔ IsCycleOn.of_inv IsCycleOn.inv
+alias ⟨IsCycleOn.of_inv, IsCycleOn.inv⟩ := isCycleOn_inv
 #align equiv.perm.is_cycle_on.of_inv Equiv.Perm.IsCycleOn.of_inv
 #align equiv.perm.is_cycle_on.inv Equiv.Perm.IsCycleOn.inv
 

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

@@ -1106,7 +1106,7 @@ theorem pow_apply_eq_pow_mod_orderOf_cycleOf_apply (f : Perm α) (n : ℕ) (x :
   rw [← cycleOf_pow_apply_self f, ← cycleOf_pow_apply_self f, pow_eq_mod_orderOf]
 #align equiv.perm.pow_apply_eq_pow_mod_order_of_cycle_of_apply Equiv.Perm.pow_apply_eq_pow_mod_orderOf_cycleOf_apply
 
-theorem cycleOf_mul_of_apply_right_eq_self (h : _root_.Commute f g) (x : α) (hx : g x = x) :
+theorem cycleOf_mul_of_apply_right_eq_self (h : Commute f g) (x : α) (hx : g x = x) :
     (f * g).cycleOf x = f.cycleOf x := by
   ext y
   by_cases hxy : (f * g).SameCycle x y

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

This has nice performance benefits.

@@ -58,7 +58,7 @@ open Equiv Function Finset
 
 open BigOperators
 
-variable {ι α β : Type _}
+variable {ι α β : Type*}
 
 namespace Equiv.Perm
 
@@ -440,7 +440,7 @@ protected theorem IsCycle.orderOf (hf : IsCycle f) : orderOf f = f.support.card
   convert Fintype.card_congr (IsCycle.zpowersEquivSupport hf)
 #align equiv.perm.is_cycle.order_of Equiv.Perm.IsCycle.orderOf
 
-theorem isCycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
+theorem isCycle_swap_mul_aux₁ {α : Type*} [DecidableEq α] :
     ∀ (n : ℕ) {b x : α} {f : Perm α} (_ : (swap x (f x) * f) b ≠ b) (_ : (f ^ n) (f x) = b),
       ∃ i : ℤ, ((swap x (f x) * f) ^ i) (f x) = b := by
   intro n
@@ -461,7 +461,7 @@ theorem isCycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
             swap_apply_of_ne_of_ne (ne_and_ne_of_swap_mul_apply_ne_self hb).2 (Ne.symm hfbx)]⟩
 #align equiv.perm.is_cycle_swap_mul_aux₁ Equiv.Perm.isCycle_swap_mul_aux₁
 
-theorem isCycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
+theorem isCycle_swap_mul_aux₂ {α : Type*} [DecidableEq α] :
     ∀ (n : ℤ) {b x : α} {f : Perm α} (_ : (swap x (f x) * f) b ≠ b) (_ : (f ^ n) (f x) = b),
       ∃ i : ℤ, ((swap x (f x) * f) ^ i) (f x) = b := by
   intro n
@@ -492,7 +492,7 @@ theorem isCycle_swap_mul_aux₂ {α : Type _} [DecidableEq α] :
             swap_apply_of_ne_of_ne this.2 (Ne.symm hfbx')]⟩
 #align equiv.perm.is_cycle_swap_mul_aux₂ Equiv.Perm.isCycle_swap_mul_aux₂
 
-theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type _} [DecidableEq α] {f : Perm α}
+theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type*} [DecidableEq α] {f : Perm α}
     (hf : IsCycle f) {x : α} (hfx : f x ≠ x) (hffx : f (f x) = x) : f = swap x (f x) :=
   Equiv.ext fun y =>
     let ⟨z, hz⟩ := hf
@@ -512,7 +512,7 @@ theorem IsCycle.eq_swap_of_apply_apply_eq_self {α : Type _} [DecidableEq α] {f
           tauto
 #align equiv.perm.is_cycle.eq_swap_of_apply_apply_eq_self Equiv.Perm.IsCycle.eq_swap_of_apply_apply_eq_self
 
-theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCycle f) {x : α}
+theorem IsCycle.swap_mul {α : Type*} [DecidableEq α] {f : Perm α} (hf : IsCycle f) {x : α}
     (hx : f x ≠ x) (hffx : f (f x) ≠ x) : IsCycle (swap x (f x) * f) :=
   ⟨f x, by simp [swap_apply_def, mul_apply, if_neg hffx, f.injective.eq_iff, if_neg hx, hx],
     fun y hy =>
@@ -1277,7 +1277,7 @@ def cycleFactorsAux [Fintype α] :
             hm₃⟩⟩
 #align equiv.perm.cycle_factors_aux Equiv.Perm.cycleFactorsAux
 
-theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
+theorem mem_list_cycles_iff {α : Type*} [Finite α] {l : List (Perm α)}
     (h1 : ∀ σ : Perm α, σ ∈ l → σ.IsCycle) (h2 : l.Pairwise Disjoint) {σ : Perm α} :
     σ ∈ l ↔ σ.IsCycle ∧ ∀ (a : α) (_ : σ a ≠ a), σ a = l.prod a := by
   suffices σ.IsCycle → (σ ∈ l ↔ ∀ (a : α) (_ : σ a ≠ a), σ a = l.prod a) by
@@ -1305,7 +1305,7 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
       exact key a (mem_inter_of_mem ha hτa)
 #align equiv.perm.mem_list_cycles_iff Equiv.Perm.mem_list_cycles_iff
 
-theorem list_cycles_perm_list_cycles {α : Type _} [Finite α] {l₁ l₂ : List (Perm α)}
+theorem list_cycles_perm_list_cycles {α : Type*} [Finite α] {l₁ l₂ : List (Perm α)}
     (h₀ : l₁.prod = l₂.prod) (h₁l₁ : ∀ σ : Perm α, σ ∈ l₁ → σ.IsCycle)
     (h₁l₂ : ∀ σ : Perm α, σ ∈ l₂ → σ.IsCycle) (h₂l₁ : l₁.Pairwise Disjoint)
     (h₂l₂ : l₂.Pairwise Disjoint) : l₁ ~ l₂ := by
@@ -1762,7 +1762,7 @@ theorem card_support_conj : (σ * τ * σ⁻¹).support.card = τ.support.card :
 
 end
 
-theorem Disjoint.isConj_mul {α : Type _} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
+theorem Disjoint.isConj_mul {α : Type*} [Finite α] {σ τ π ρ : Perm α} (hc1 : IsConj σ π)
     (hc2 : IsConj τ ρ) (hd1 : Disjoint σ τ) (hd2 : Disjoint π ρ) : IsConj (σ * τ) (π * ρ) := by
   classical
     cases nonempty_fintype α

• 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) 2019 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Yaël Dillies
-
-! This file was ported from Lean 3 source module group_theory.perm.cycle.basic
-! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Module.BigOperators
 import Mathlib.Data.Finset.NoncommProd
@@ -16,6 +11,8 @@ import Mathlib.GroupTheory.Perm.List
 import Mathlib.GroupTheory.Perm.Sign
 import Mathlib.Logic.Equiv.Fintype
 
+#align_import group_theory.perm.cycle.basic from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
+
 /-!
 # Cyclic permutations
 

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

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

@@ -900,7 +900,7 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
     refine' ⟨n.natMod s.card, Int.natMod_lt (Nonempty.card_pos ⟨a, ha⟩).ne', _⟩
     rw [← zpow_ofNat, Int.natMod,
       Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2
-        (Nonempty.card_pos ⟨a, ha⟩).ne'),  sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
+        (Nonempty.card_pos ⟨a, ha⟩).ne'), sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
     simp only [zpow_coe_nat, coe_mul, comp_apply, EmbeddingLike.apply_eq_iff_eq]
     exact IsFixedPt.perm_zpow (hf.pow_card_apply ha) _
 #align equiv.perm.is_cycle_on.exists_pow_eq Equiv.Perm.IsCycleOn.exists_pow_eq
@@ -1021,7 +1021,7 @@ theorem cycleOf_apply_apply_zpow_self (f : Perm α) (x : α) (k : ℤ) :
 
 @[simp]
 theorem cycleOf_apply_apply_pow_self (f : Perm α) (x : α) (k : ℕ) :
-    cycleOf f x ((f ^ k) x) = (f ^ (k + 1) : Perm α)  x := by
+    cycleOf f x ((f ^ k) x) = (f ^ (k + 1) : Perm α) x := by
   convert cycleOf_apply_apply_zpow_self f x k using 1
 #align equiv.perm.cycle_of_apply_apply_pow_self Equiv.Perm.cycleOf_apply_apply_pow_self
 
@@ -1236,7 +1236,7 @@ def cycleFactorsAux [Fintype α] :
         { l : List (Perm α) // l.prod = f ∧ (∀ g ∈ l, IsCycle g) ∧ l.Pairwise Disjoint } := by
   intro l f h
   exact match l with
-  | [] =>  ⟨[], by
+  | [] => ⟨[], by
       { simp only [imp_false, List.Pairwise.nil, List.not_mem_nil, forall_const, and_true_iff,
           forall_prop_of_false, Classical.not_not, not_false_iff, List.prod_nil] at *
         ext

This PR is the result of running

find . -type f -name "*.lean" -exec sed -i -E 's/^( +)\. /\1· /' {} \;
find . -type f -name "*.lean" -exec sed -i -E 'N;s/^( +·)\n +(.*)$/\1 \2/;P;D' {} \;

which firstly replaces . focusing dots with · and secondly removes isolated instances of such dots, unifying them with the following line. A new rule is placed in the style linter to verify this.

@@ -1713,8 +1713,7 @@ theorem isConj_of_support_equiv
   by_cases hx : x ∈ σ.support
   · rw [Equiv.extendSubtype_apply_of_mem, Equiv.extendSubtype_apply_of_mem]
     · exact hf x (Finset.mem_coe.2 hx)
-  ·
-    rwa [Classical.not_not.1 ((not_congr mem_support).1 (Equiv.extendSubtype_not_mem f _ _)),
+  · rwa [Classical.not_not.1 ((not_congr mem_support).1 (Equiv.extendSubtype_not_mem f _ _)),
       Classical.not_not.1 ((not_congr mem_support).mp hx)]
 #align equiv.perm.is_conj_of_support_equiv Equiv.Perm.isConj_of_support_equiv
 

Currently, (for both Set and Finset) insert_subset is an iff lemma stating that insert a s ⊆ t if and only if a ∈ t and s ⊆ t. For both types, this PR renames this lemma to insert_subset_iff, and adds an insert_subset lemma that gives the implication just in the reverse direction : namely theorem insert_subset (ha : a ∈ t) (hs : s ⊆ t) : insert a s ⊆ t .

This both aligns the naming with union_subset and union_subset_iff, and removes the need for the awkward insert_subset.mpr ⟨_,_⟩ idiom. It touches a lot of files (too many to list), but in a trivial way.

@@ -1672,7 +1672,7 @@ theorem closure_cycle_coprime_swap {n : ℕ} {σ : Perm α} (h0 : Nat.coprime n
   have h1' : IsCycle ((σ ^ n) ^ (m : ℤ)) := by rwa [← hm] at h1
   replace h1' : IsCycle (σ ^ n) :=
     h1'.of_pow (le_trans (support_pow_le σ n) (ge_of_eq (congr_arg support hm)))
-  rw [eq_top_iff, ← closure_cycle_adjacent_swap h1' h2' x, closure_le, Set.insert_subset]
+  rw [eq_top_iff, ← closure_cycle_adjacent_swap h1' h2' x, closure_le, Set.insert_subset_iff]
   exact
     ⟨Subgroup.pow_mem (closure _) (subset_closure (Set.mem_insert σ _)) n,
       Set.singleton_subset_iff.mpr (subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _)))⟩

This adds a couple of WellFoundedRelation instances, like for example WellFoundedRelation (WithBot Nat). Longer-term, we should probably add a WellFoundedOrder class for types with a well-founded less-than relation and a [WellFoundOrder α] : WellFoundedRelation α instance (or maybe just [LT α] [IsWellFounded fun a b : α => a < b] : WellFoundedRelation α).

@@ -529,32 +529,30 @@ theorem IsCycle.swap_mul {α : Type _} [DecidableEq α] {f : Perm α} (hf : IsCy
     isCycle_swap_mul_aux₂ (i - 1) hy hi⟩
 #align equiv.perm.is_cycle.swap_mul Equiv.Perm.IsCycle.swap_mul
 
-theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.support.card
-  | f => fun hf =>
-    let ⟨x, hx⟩ := hf
-    calc
-      Perm.sign f = Perm.sign (swap x (f x) * (swap x (f x) * f)) := by
-        {rw [← mul_assoc, mul_def, mul_def, swap_swap, trans_refl]}
-      _ = -(-1) ^ f.support.card :=
-        if h1 : f (f x) = x then by
-          have h : swap x (f x) * f = 1 := by
-            simp only [mul_def, one_def]
-            rw [hf.eq_swap_of_apply_apply_eq_self hx.1 h1, swap_apply_left, swap_swap]
-          dsimp only
-          rw [sign_mul, sign_swap hx.1.symm, h, sign_one,
-            hf.eq_swap_of_apply_apply_eq_self hx.1 h1, card_support_swap hx.1.symm]
-          rfl
-        else by
-          have h : card (support (swap x (f x) * f)) + 1 = card (support f) := by
-            rw [← insert_erase (mem_support.2 hx.1), support_swap_mul_eq _ _ h1,
-              card_insert_of_not_mem (not_mem_erase _ _), sdiff_singleton_eq_erase]
-          have : card (support (swap x (f x) * f)) < card (support f) :=
-            card_support_swap_mul hx.1
-          dsimp only
-          rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
-          simp only [mul_neg, neg_mul, one_mul, neg_neg, pow_add, pow_one, mul_one]
-      termination_by'
-  ⟨_, (measure fun f => f.support.card).wf ⟩
+theorem IsCycle.sign {f : Perm α} (hf : IsCycle f) : sign f = -(-1) ^ f.support.card :=
+  let ⟨x, hx⟩ := hf
+  calc
+    Perm.sign f = Perm.sign (swap x (f x) * (swap x (f x) * f)) := by
+      {rw [← mul_assoc, mul_def, mul_def, swap_swap, trans_refl]}
+    _ = -(-1) ^ f.support.card :=
+      if h1 : f (f x) = x then by
+        have h : swap x (f x) * f = 1 := by
+          simp only [mul_def, one_def]
+          rw [hf.eq_swap_of_apply_apply_eq_self hx.1 h1, swap_apply_left, swap_swap]
+        dsimp only
+        rw [sign_mul, sign_swap hx.1.symm, h, sign_one,
+          hf.eq_swap_of_apply_apply_eq_self hx.1 h1, card_support_swap hx.1.symm]
+        rfl
+      else by
+        have h : card (support (swap x (f x) * f)) + 1 = card (support f) := by
+          rw [← insert_erase (mem_support.2 hx.1), support_swap_mul_eq _ _ h1,
+            card_insert_of_not_mem (not_mem_erase _ _), sdiff_singleton_eq_erase]
+        have : card (support (swap x (f x) * f)) < card (support f) :=
+          card_support_swap_mul hx.1
+        dsimp only
+        rw [sign_mul, sign_swap hx.1.symm, (hf.swap_mul hx.1 h1).sign, ← h]
+        simp only [mul_neg, neg_mul, one_mul, neg_neg, pow_add, pow_one, mul_one]
+termination_by _ => f.support.card
 #align equiv.perm.is_cycle.sign Equiv.Perm.IsCycle.sign
 
 theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :

Changes are of the form

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

@@ -332,7 +332,7 @@ protected theorem IsCycle.extendDomain {p : β → Prop} [DecidablePred p] (f :
     exact Subtype.coe_injective.ne (f.injective.ne ha)
   have h : b = f (f.symm ⟨b, of_not_not <| hb ∘ extendDomain_apply_not_subtype _ _⟩) := by
     rw [apply_symm_apply, Subtype.coe_mk]
-  rw [h] at hb⊢
+  rw [h] at hb ⊢
   simp only [extendDomain_apply_image, Subtype.coe_injective.ne_iff, f.injective.ne_iff] at hb
   exact (ha' hb).extendDomain
 #align equiv.perm.is_cycle.extend_domain Equiv.Perm.IsCycle.extendDomain
@@ -1138,7 +1138,7 @@ theorem support_cycleOf_eq_nil_iff : (f.cycleOf x).support = ∅ ↔ x ∉ f.sup
 theorem support_cycleOf_le (f : Perm α) (x : α) : support (f.cycleOf x) ≤ support f := by
   intro y hy
   rw [mem_support, cycleOf_apply] at hy
-  split_ifs  at hy
+  split_ifs at hy
   · exact mem_support.mpr hy
   · exact absurd rfl hy
 #align equiv.perm.support_cycle_of_le Equiv.Perm.support_cycleOf_le
@@ -1256,7 +1256,7 @@ def cycleFactorsAux [Fintype α] :
               exact hy rfl)
             (h fun h : f y = y => by
               rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycleOf_apply] at hy
-              split_ifs  at hy <;> tauto))
+              split_ifs at hy <;> tauto))
       ⟨cycleOf f x::m, by
         rw [List.prod_cons, hm₁]
         simp,
@@ -1562,7 +1562,7 @@ theorem cycleFactorsFinset_mul_inv_mem_eq_sdiff [Fintype α] {f g : Perm α}
         → cycleFactorsFinset (g * f⁻¹) = cycleFactorsFinset g \ {f}) _ _ _ _
   · simp
   · intro σ hσ f hf
-    simp only [cycleFactorsFinset_eq_singleton_self_iff.mpr hσ, mem_singleton] at hf⊢
+    simp only [cycleFactorsFinset_eq_singleton_self_iff.mpr hσ, mem_singleton] at hf ⊢
     simp [hf]
   · intro σ τ hd _ hσ hτ f
     simp_rw [hd.cycleFactorsFinset_mul_eq_union, mem_union]
@@ -1928,7 +1928,7 @@ theorem _root_.Finset.product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
       s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩ := by
   obtain hs | _ := (s : Set α).subsingleton_or_nontrivial
   · refine' Set.Subsingleton.pairwise _ _
-    simp_rw [Set.Subsingleton, mem_coe, ← card_le_one] at hs⊢
+    simp_rw [Set.Subsingleton, mem_coe, ← card_le_one] at hs ⊢
     rwa [card_range]
   classical
     rintro m hm n hn hmn

Currently, the following notations are changed from · ×ˢ · because Lean 4 can't deal with ambiguous notations. | Definition | Notation | | :

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

@@ -1952,7 +1952,7 @@ theorem _root_.Finset.product_self_eq_disj_Union_perm_aux (hf : f.IsCycleOn s) :
 The diagonals are given by the cycle `f`.
 -/
 theorem _root_.Finset.product_self_eq_disjUnion_perm (hf : f.IsCycleOn s) :
-    s ×ᶠ s =
+    s ×ˢ s =
       (range s.card).disjiUnion
         (fun k => s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩)
         (product_self_eq_disj_Union_perm_aux hf) := by

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -31,7 +31,7 @@ In the following, `f : Equiv.Perm β`.
 * `Equiv.Perm.IsCycleOn`: `f` is a cycle on a set `s` when any two points of `s` are related by
   repeated applications of `f`.
 
-The following two definitions require that `β` is a `fintype`:
+The following two definitions require that `β` is a `Fintype`:
 
 * `Equiv.Perm.cycleOf`: `f.cycleOf x` is the cycle of `f` that `x` belongs to.
 * `Equiv.Perm.cycleFactors`: `f.cycleFactors` is a list of disjoint cyclic permutations that
@@ -691,7 +691,7 @@ theorem IsCycle.pow_eq_one_iff' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
   ⟨fun h => FunLike.congr_fun h x, fun h => hf.pow_eq_one_iff.2 ⟨x, hx, h⟩⟩
 #align equiv.perm.is_cycle.pow_eq_one_iff' Equiv.Perm.IsCycle.pow_eq_one_iff'
 
--- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
+-- TODO: Define a `Set`-valued support to get rid of the `Finite β` assumption
 theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     f ^ n = 1 ↔ ∀ x, f x ≠ x → (f ^ n) x = x :=
   ⟨fun h _ hx => (hf.pow_eq_one_iff' hx).1 h, fun h =>
@@ -699,7 +699,7 @@ theorem IsCycle.pow_eq_one_iff'' [Finite β] {f : Perm β} (hf : IsCycle f) {n :
     (hf.pow_eq_one_iff' hx).2 (h _ hx)⟩
 #align equiv.perm.is_cycle.pow_eq_one_iff'' Equiv.Perm.IsCycle.pow_eq_one_iff''
 
--- TODO: Define a `set`-valued support to get rid of the `finite β` assumption
+-- TODO: Define a `Set`-valued support to get rid of the `Finite β` assumption
 theorem IsCycle.pow_eq_pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {a b : ℕ} :
     f ^ a = f ^ b ↔ ∃ x, f x ≠ x ∧ (f ^ a) x = (f ^ b) x := by
   classical
@@ -1230,7 +1230,7 @@ end CycleOf
 
 variable [DecidableEq α]
 
-/-- Given a list `l : list α` and a permutation `f : perm α` whose nonfixed points are all in `l`,
+/-- Given a list `l : List α` and a permutation `f : perm α` whose nonfixed points are all in `l`,
   recursively factors `f` into cycles. -/
 def cycleFactorsAux [Fintype α] :
     ∀ (l : List α) (f : Perm α),
@@ -1343,7 +1343,7 @@ section CycleFactorsFinset
 
 variable [Fintype α] (f : Perm α)
 
-/-- Factors a permutation `f` into a `finset` of disjoint cyclic permutations that multiply to `f`.
+/-- Factors a permutation `f` into a `Finset` of disjoint cyclic permutations that multiply to `f`.
 -/
 def cycleFactorsFinset : Finset (Perm α) :=
   (truncCycleFactors f).lift

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>

@@ -1906,16 +1906,16 @@ theorem _root_.Set.Countable.exists_cycleOn (hs : s.Countable) :
     simp
 #align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
 
-theorem _root_.Set.prod_self_eq_unionᵢ_perm (hf : f.IsCycleOn s) :
+theorem _root_.Set.prod_self_eq_iUnion_perm (hf : f.IsCycleOn s) :
     s ×ˢ s = ⋃ n : ℤ, (fun a => (a, (f ^ n) a)) '' s := by
   ext ⟨a, b⟩
-  simp only [Set.mem_prod, Set.mem_unionᵢ, Set.mem_image]
+  simp only [Set.mem_prod, Set.mem_iUnion, Set.mem_image]
   refine' ⟨fun hx => _, _⟩
   · obtain ⟨n, rfl⟩ := hf.2 hx.1 hx.2
     exact ⟨_, _, hx.1, rfl⟩
   · rintro ⟨n, a, ha, ⟨⟩⟩
     exact ⟨ha, (hf.1.perm_zpow _).mapsTo ha⟩
-#align set.prod_self_eq_Union_perm Set.prod_self_eq_unionᵢ_perm
+#align set.prod_self_eq_Union_perm Set.prod_self_eq_iUnion_perm
 
 end Set
 
@@ -1953,11 +1953,11 @@ The diagonals are given by the cycle `f`.
 -/
 theorem _root_.Finset.product_self_eq_disjUnion_perm (hf : f.IsCycleOn s) :
     s ×ᶠ s =
-      (range s.card).disjUnionᵢ
+      (range s.card).disjiUnion
         (fun k => s.map ⟨fun i => (i, (f ^ k) i), fun i j => congr_arg Prod.fst⟩)
         (product_self_eq_disj_Union_perm_aux hf) := by
   ext ⟨a, b⟩
-  simp only [mem_product, Equiv.Perm.coe_pow, mem_disjUnionᵢ, mem_range, mem_map,
+  simp only [mem_product, Equiv.Perm.coe_pow, mem_disjiUnion, mem_range, mem_map,
     Function.Embedding.coeFn_mk, Prod.mk.inj_iff, exists_prop]
   refine' ⟨fun hx => _, _⟩
   · obtain ⟨n, hn, rfl⟩ := hf.exists_pow_eq hx.1 hx.2
@@ -1974,7 +1974,7 @@ variable [Semiring α] [AddCommMonoid β] [Module α β] {s : Finset ι} {σ : P
 
 theorem _root_.Finset.sum_smul_sum_eq_sum_perm (hσ : σ.IsCycleOn s) (f : ι → α) (g : ι → β) :
     ((∑ i in s, f i) • ∑ i in s, g i) = ∑ k in range s.card, ∑ i in s, f i • g ((σ ^ k) i) := by
-  simp_rw [sum_smul_sum, product_self_eq_disjUnion_perm hσ, sum_disjUnionᵢ, sum_map]
+  simp_rw [sum_smul_sum, product_self_eq_disjUnion_perm hσ, sum_disjiUnion, sum_map]
   rfl
 #align finset.sum_smul_sum_eq_sum_perm Finset.sum_smul_sum_eq_sum_perm
 

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

@@ -262,20 +262,14 @@ theorem SameCycle.exists_pow_eq'' [Finite α] (h : SameCycle f x y) :
 
 instance [Fintype α] [DecidableEq α] (f : Perm α) : DecidableRel (SameCycle f) := fun x y =>
   decidable_of_iff (∃ n ∈ List.range (Fintype.card (Perm α)), (f ^ n) x = y)
-    ⟨fun ⟨n, _, hn⟩ => ⟨n, hn⟩, fun ⟨i, hi⟩ =>
-      ⟨(i % orderOf f).natAbs,
-        List.mem_range.2
-          (Int.ofNat_lt.1 <|
-            by
-            rw [Int.natAbs_of_nonneg
-                (Int.emod_nonneg _ <| Int.coe_nat_ne_zero.2 (orderOf_pos _).ne')]
-            · refine' (Int.emod_lt _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _).trans_le _
-              simp [orderOf_le_card_univ]),
-        by
-        rw [← zpow_ofNat,
-          Int.natAbs_of_nonneg
-            (Int.emod_nonneg _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _),
-          ← zpow_eq_mod_orderOf, hi]⟩⟩
+    ⟨fun ⟨n, _, hn⟩ => ⟨n, hn⟩, fun ⟨i, hi⟩ => ⟨(i % orderOf f).natAbs,
+      List.mem_range.2 (Int.ofNat_lt.1 <| by
+        rw [Int.natAbs_of_nonneg (Int.emod_nonneg _ <| Int.coe_nat_ne_zero.2 (orderOf_pos _).ne')]
+        · refine' (Int.emod_lt _ <| Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _).trans_le _
+          simp [orderOf_le_card_univ]),
+      by
+        rw [← zpow_ofNat, Int.natAbs_of_nonneg (Int.emod_nonneg _ <|
+          Int.coe_nat_ne_zero_iff_pos.2 <| orderOf_pos _), ← zpow_eq_mod_orderOf, hi]⟩⟩
 
 end SameCycle
 
@@ -361,8 +355,7 @@ theorem IsCycle.exists_pow_eq (hf : IsCycle f) (hx : f x ≠ x) (hy : f y ≠ y)
     ∃ i : ℕ, (f ^ i) x = y := by
   let ⟨n, hn⟩ := hf.exists_zpow_eq hx hy
   classical exact
-      ⟨(n % orderOf f).toNat,
-        by
+      ⟨(n % orderOf f).toNat, by
         {have := n.emod_nonneg (Int.coe_nat_ne_zero.mpr (ne_of_gt (orderOf_pos f)))
          rwa [← zpow_ofNat, Int.toNat_of_nonneg this, ← zpow_eq_mod_orderOf]}⟩
 #align equiv.perm.is_cycle.exists_pow_eq Equiv.Perm.IsCycle.exists_pow_eq
@@ -460,8 +453,7 @@ theorem isCycle_swap_mul_aux₁ {α : Type _} [DecidableEq α] :
     exact if hfbx : f x = b then ⟨0, hfbx⟩
       else
         have : f b ≠ b ∧ b ≠ x := ne_and_ne_of_swap_mul_apply_ne_self hb
-        have hb' : (swap x (f x) * f) (f⁻¹ b) ≠ f⁻¹ b :=
-          by
+        have hb' : (swap x (f x) * f) (f⁻¹ b) ≠ f⁻¹ b := by
           rw [mul_apply, apply_inv_self, swap_apply_of_ne_of_ne this.2 (Ne.symm hfbx), Ne.def, ←
             f.injective.eq_iff, apply_inv_self]
           exact this.1
@@ -552,8 +544,7 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.su
           rw [sign_mul, sign_swap hx.1.symm, h, sign_one,
             hf.eq_swap_of_apply_apply_eq_self hx.1 h1, card_support_swap hx.1.symm]
           rfl
-        else
-          by
+        else by
           have h : card (support (swap x (f x) * f)) + 1 = card (support f) := by
             rw [← insert_erase (mem_support.2 hx.1), support_swap_mul_eq _ _ h1,
               card_insert_of_not_mem (not_mem_erase _ _), sdiff_singleton_eq_erase]
@@ -568,8 +559,7 @@ theorem IsCycle.sign : ∀ {f : Perm α} (hf : IsCycle f), sign f = -(-1) ^ f.su
 
 theorem IsCycle.of_pow {n : ℕ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
     IsCycle f := by
-  have key : ∀ x : α, (f ^ n) x ≠ x ↔ f x ≠ x :=
-    by
+  have key : ∀ x : α, (f ^ n) x ≠ x ↔ f x ≠ x := by
     simp_rw [← mem_support, ← Finset.ext_iff]
     exact (support_pow_le _ n).antisymm h2
   obtain ⟨x, hx1, hx2⟩ := h1
@@ -603,8 +593,7 @@ theorem IsCycle.support_congr (hf : IsCycle f) (hg : IsCycle g) (h : f.support 
     obtain ⟨x, hx, _⟩ := id hf
     have hx' : g x ≠ x := by rwa [← h' x (mem_support.mpr hx)]
     obtain ⟨m, hm⟩ := hg.exists_pow_eq hx' (mem_support.mp hz)
-    have h'' : ∀ x ∈ f.support ∩ g.support, f x = g x :=
-      by
+    have h'' : ∀ x ∈ f.support ∩ g.support, f x = g x := by
       intro x hx
       exact h' x (mem_of_mem_inter_left hx)
     rwa [← hm, ←
@@ -618,8 +607,8 @@ theorem IsCycle.support_congr (hf : IsCycle f) (hg : IsCycle g) (h : f.support 
 /-- If two cyclic permutations agree on all terms in their intersection,
 and that intersection is not empty, then the two cyclic permutations must be equal. -/
 theorem IsCycle.eq_on_support_inter_nonempty_congr (hf : IsCycle f) (hg : IsCycle g)
-    (h : ∀ x ∈ f.support ∩ g.support, f x = g x) (hx : f x = g x) (hx' : x ∈ f.support) : f = g :=
-  by
+    (h : ∀ x ∈ f.support ∩ g.support, f x = g x)
+    (hx : f x = g x) (hx' : x ∈ f.support) : f = g := by
   have hx'' : x ∈ g.support := by rwa [mem_support, ← hx, ← mem_support]
   have : f.support ⊆ g.support := by
     intro y hy
@@ -660,8 +649,7 @@ theorem IsCycle.pow_iff [Finite β] {f : Perm β} (hf : IsCycle f) {n : ℕ} :
     cases nonempty_fintype β
     constructor
     · intro h
-      have hr : support (f ^ n) = support f :=
-        by
+      have hr : support (f ^ n) = support f := by
         rw [hf.support_pow_eq_iff]
         rintro ⟨k, rfl⟩
         refine' h.ne_one _
@@ -799,15 +787,13 @@ alias isCycleOn_inv ↔ IsCycleOn.of_inv IsCycleOn.inv
 #align equiv.perm.is_cycle_on.inv Equiv.Perm.IsCycleOn.inv
 
 theorem IsCycleOn.conj (h : f.IsCycleOn s) : (g * f * g⁻¹).IsCycleOn ((g : Perm α) '' s) :=
-  ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy =>
-    by
+  ⟨(g.bijOn_image.comp h.1).comp g.bijOn_symm_image, fun x hx y hy => by
     rw [← preimage_inv] at hx hy
     convert Equiv.Perm.SameCycle.conj (h.2 hx hy) (g := g) <;> rw [apply_inv_self]⟩
 #align equiv.perm.is_cycle_on.conj Equiv.Perm.IsCycleOn.conj
 
 theorem isCycleOn_swap [DecidableEq α] (hab : a ≠ b) : (swap a b).IsCycleOn {a, b} :=
-  ⟨bijOn_swap (by simp) (by simp), fun x hx y hy =>
-    by
+  ⟨bijOn_swap (by simp) (by simp), fun x hx y hy => by
     rw [Set.mem_insert_iff, Set.mem_singleton_iff] at hx hy
     obtain rfl | rfl := hx <;> obtain rfl | rfl := hy
     · exact ⟨0, by rw [zpow_zero, coe_one, id.def]⟩
@@ -977,8 +963,8 @@ def cycleOf (f : Perm α) (x : α) : Perm α :=
   ofSubtype (subtypePerm f fun _ => sameCycle_apply_right.symm : Perm { y // SameCycle f x y })
 #align equiv.perm.cycle_of Equiv.Perm.cycleOf
 
-theorem cycleOf_apply (f : Perm α) (x y : α) : cycleOf f x y = if SameCycle f x y then f y else y :=
-  by
+theorem cycleOf_apply (f : Perm α) (x y : α) :
+    cycleOf f x y = if SameCycle f x y then f y else y := by
   dsimp only [cycleOf]
   split_ifs with h
   · apply ofSubtype_apply_of_mem
@@ -1201,10 +1187,10 @@ theorem isCycleOn_support_cycleOf (f : Perm α) (x : α) : f.IsCycleOn (f.cycleO
       (mem_support_cycleOf_iff.1 h).2⟩
     · exact ⟨sameCycle_apply_right.2 (mem_support_cycleOf_iff.1 h).1,
       (mem_support_cycleOf_iff.1 h).2⟩
-  ,fun a ha b hb =>
-    by
-    rw [mem_coe, mem_support_cycleOf_iff] at ha hb
-    exact ha.1.symm.trans hb.1⟩
+    , fun a ha b hb =>
+      by
+        rw [mem_coe, mem_support_cycleOf_iff] at ha hb
+        exact ha.1.symm.trans hb.1⟩
 #align equiv.perm.is_cycle_on_support_cycle_of Equiv.Perm.isCycleOn_support_cycleOf
 
 theorem SameCycle.exists_pow_eq_of_mem_support (h : SameCycle f x y) (hx : x ∈ f.support) :
@@ -1265,12 +1251,10 @@ def cycleFactorsAux [Fintype α] :
         cycleFactorsAux l ((cycleOf f x)⁻¹ * f) (by
         intro y hy
         exact List.mem_of_ne_of_mem
-            (fun h : y = x =>
-              by
+            (fun h : y = x => by
               rw [h, mul_apply, Ne.def, inv_eq_iff_eq, cycleOf_apply_self] at hy
               exact hy rfl)
-            (h fun h : f y = y =>
-              by
+            (h fun h : f y = y => by
               rw [mul_apply, h, Ne.def, inv_eq_iff_eq, cycleOf_apply] at hy
               split_ifs  at hy <;> tauto))
       ⟨cycleOf f x::m, by
@@ -1288,8 +1272,7 @@ def cycleFactorsAux [Fintype α] :
                 (List.pairwise_cons.1
                     ((hgm.pairwise_iff fun a b (h : Disjoint a b) => h.symm).2 hm₃)).1
               by_cases id fun hgy : g y ≠ y =>
-                (disjoint_prod_right _ this y).resolve_right <|
-                  by
+                (disjoint_prod_right _ this y).resolve_right <| by
                   have hsc : SameCycle f⁻¹ x (f y) := by
                     rwa [sameCycle_inv, sameCycle_apply_right]
                   rw [disjoint_prod_perm hm₃ hgm.symm, List.prod_cons,
@@ -1319,8 +1302,7 @@ theorem mem_list_cycles_iff {α : Type _} [Finite α] {l : List (Perm α)}
       rw [← mem_support] at ha
       obtain ⟨τ, hτ, hτa⟩ := exists_mem_support_of_mem_support_prod (hσl ha)
       have hτl : ∀ x ∈ τ.support, τ x = l.prod x := eq_on_support_mem_disjoint hτ h2
-      have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x :=
-        by
+      have key : ∀ x ∈ σ.support ∩ τ.support, σ x = τ x := by
         intro x hx
         rw [h x (mem_support.mp (mem_of_mem_inter_left hx)), hτl x (mem_of_mem_inter_right hx)]
       convert hτ
@@ -1552,11 +1534,11 @@ end CycleFactorsFinset
 @[elab_as_elim]
 theorem cycle_induction_on [Finite β] (P : Perm β → Prop) (σ : Perm β) (base_one : P 1)
     (base_cycles : ∀ σ : Perm β, σ.IsCycle → P σ)
-    (induction_disjoint : ∀ σ τ : Perm β, Disjoint σ τ → IsCycle σ → P σ → P τ → P (σ * τ)) : P σ :=
-  by
+    (induction_disjoint : ∀ σ τ : Perm β,
+      Disjoint σ τ → IsCycle σ → P σ → P τ → P (σ * τ)) : P σ := by
   cases nonempty_fintype β
-  suffices ∀ l : List (Perm β), (∀ τ : Perm β, τ ∈ l → τ.IsCycle) → l.Pairwise Disjoint → P l.prod
-    by
+  suffices ∀ l : List (Perm β),
+      (∀ τ : Perm β, τ ∈ l → τ.IsCycle) → l.Pairwise Disjoint → P l.prod by
     classical
       let x := σ.truncCycleFactors.out
       exact (congr_arg P x.2.1).mp (this x.1 x.2.2.1 x.2.2.2)
@@ -1638,16 +1620,14 @@ theorem closure_cycle_adjacent_swap {σ : Perm α} (h1 : IsCycle σ) (h2 : σ.su
   let H := closure ({σ, swap x (σ x)} : Set (Perm α))
   have h3 : σ ∈ H := subset_closure (Set.mem_insert σ _)
   have h4 : swap x (σ x) ∈ H := subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _))
-  have step1 : ∀ n : ℕ, swap ((σ ^ n) x) ((σ ^ (n + 1) : Perm α) x) ∈ H :=
-    by
+  have step1 : ∀ n : ℕ, swap ((σ ^ n) x) ((σ ^ (n + 1) : Perm α) x) ∈ H := by
     intro n
     induction' n with n ih
     · exact subset_closure (Set.mem_insert_of_mem _ (Set.mem_singleton _))
     · convert H.mul_mem (H.mul_mem h3 ih) (H.inv_mem h3)
       simp_rw [mul_swap_eq_swap_mul, mul_inv_cancel_right, pow_succ]
       rfl
-  have step2 : ∀ n : ℕ, swap x ((σ ^ n) x) ∈ H :=
-    by
+  have step2 : ∀ n : ℕ, swap x ((σ ^ n) x) ∈ H := by
     intro n
     induction' n with n ih
     · simp only [Nat.zero_eq, pow_zero, coe_one, id_eq, swap_self, Set.mem_singleton_iff]
@@ -1859,8 +1839,8 @@ namespace List
 variable [DecidableEq α] {l : List α}
 
 set_option linter.deprecated false in -- nthLe
-theorem _root_.List.Nodup.isCycleOn_formPerm (h : l.Nodup) : l.formPerm.IsCycleOn { a | a ∈ l } :=
-  by
+theorem _root_.List.Nodup.isCycleOn_formPerm (h : l.Nodup) :
+    l.formPerm.IsCycleOn { a | a ∈ l } := by
   refine' ⟨l.formPerm.bijOn fun _ => List.formPerm_mem_iff_mem, fun a ha b hb => _⟩
   rw [Set.mem_setOf, ← List.indexOf_lt_length] at ha hb
   rw [← List.indexOf_get ha, ← List.indexOf_get hb]
@@ -1890,8 +1870,8 @@ namespace Finset
 
 variable [DecidableEq α] [Fintype α]
 
-theorem _root_.Finset.exists_cycleOn (s : Finset α) : ∃ f : Perm α, f.IsCycleOn s ∧ f.support ⊆ s :=
-  by
+theorem _root_.Finset.exists_cycleOn (s : Finset α) :
+    ∃ f : Perm α, f.IsCycleOn s ∧ f.support ⊆ s := by
   refine'
     ⟨s.toList.formPerm, _, fun x hx => by
       simpa using List.mem_of_formPerm_apply_ne _ _ (Perm.mem_support.1 hx)⟩

closes #3680, see https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Stepping.20through.20simp_rw/near/326712986

@@ -418,7 +418,7 @@ noncomputable def IsCycle.zpowersEquivSupport {σ : Perm α} (hσ : IsCycle σ)
       · rintro ⟨a, m, rfl⟩ ⟨b, n, rfl⟩ h
         ext y
         by_cases hy : σ y = y
-        · simp_rw [Subtype.coe_mk, zpow_apply_eq_self_of_apply_eq_self hy]
+        · simp_rw [zpow_apply_eq_self_of_apply_eq_self hy]
         · obtain ⟨i, rfl⟩ := (Classical.choose_spec hσ).2 hy
           rw [Subtype.coe_mk, Subtype.coe_mk, zpow_apply_comm σ m i, zpow_apply_comm σ n i]
           exact congr_arg _ (Subtype.ext_iff.mp h)

Match https://github.com/leanprover-community/mathlib/pull/18698 and a bit of https://github.com/leanprover-community/mathlib/pull/18785.

• algebra.divisibility.basic@70d50ecfd4900dd6d328da39ab7ebd516abe4025..e8638a0fcaf73e4500469f368ef9494e495099b3
• algebra.euclidean_domain.basic@655994e298904d7e5bbd1e18c95defd7b543eb94..e8638a0fcaf73e4500469f368ef9494e495099b3
• algebra.group.units@369525b73f229ccd76a6ec0e0e0bf2be57599768..e8638a0fcaf73e4500469f368ef9494e495099b3
• algebra.group_with_zero.basic@2196ab363eb097c008d4497125e0dde23fb36db2..e8638a0fcaf73e4500469f368ef9494e495099b3
• algebra.group_with_zero.divisibility@f1a2caaf51ef593799107fe9a8d5e411599f3996..e8638a0fcaf73e4500469f368ef9494e495099b3
• algebra.group_with_zero.units.basic@70d50ecfd4900dd6d328da39ab7ebd516abe4025..df5e9937a06fdd349fc60106f54b84d47b1434f0
• algebra.order.monoid.canonical.defs@de87d5053a9fe5cbde723172c0fb7e27e7436473..e8638a0fcaf73e4500469f368ef9494e495099b3
• algebra.ring.divisibility@f1a2caaf51ef593799107fe9a8d5e411599f3996..e8638a0fcaf73e4500469f368ef9494e495099b3
• data.int.dvd.basic@e1bccd6e40ae78370f01659715d3c948716e3b7e..e8638a0fcaf73e4500469f368ef9494e495099b3
• data.int.dvd.pow@b3f25363ae62cb169e72cd6b8b1ac97bacf21ca7..e8638a0fcaf73e4500469f368ef9494e495099b3
• data.int.order.basic@728baa2f54e6062c5879a3e397ac6bac323e506f..e8638a0fcaf73e4500469f368ef9494e495099b3
• data.nat.gcd.basic@a47cda9662ff3925c6df271090b5808adbca5b46..e8638a0fcaf73e4500469f368ef9494e495099b3
• data.nat.order.basic@26f081a2fb920140ed5bc5cc5344e84bcc7cb2b2..e8638a0fcaf73e4500469f368ef9494e495099b3
• data.nat.order.lemmas@2258b40dacd2942571c8ce136215350c702dc78f..e8638a0fcaf73e4500469f368ef9494e495099b3
• group_theory.perm.cycle.basic@92ca63f0fb391a9ca5f22d2409a6080e786d99f7..e8638a0fcaf73e4500469f368ef9494e495099b3
• number_theory.divisors@f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c..e8638a0fcaf73e4500469f368ef9494e495099b3
• number_theory.pythagorean_triples@70fd9563a21e7b963887c9360bd29b2393e6225a..e8638a0fcaf73e4500469f368ef9494e495099b3
• number_theory.zsqrtd.basic@7ec294687917cbc5c73620b4414ae9b5dd9ae1b4..e8638a0fcaf73e4500469f368ef9494e495099b3
• ring_theory.multiplicity@ceb887ddf3344dab425292e497fa2af91498437c..e8638a0fcaf73e4500469f368ef9494e495099b3

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes, Yaël Dillies
 
 ! This file was ported from Lean 3 source module group_theory.perm.cycle.basic
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
+! leanprover-community/mathlib commit e8638a0fcaf73e4500469f368ef9494e495099b3
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -888,7 +888,7 @@ theorem IsCycleOn.zpow_apply_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
   | Int.ofNat n => (hf.pow_apply_eq ha).trans Int.coe_nat_dvd.symm
   | Int.negSucc n => by
     rw [zpow_negSucc, ← inv_pow]
-    exact (hf.inv.pow_apply_eq ha).trans ((dvd_neg _ _).trans Int.coe_nat_dvd).symm
+    exact (hf.inv.pow_apply_eq ha).trans (dvd_neg.trans Int.coe_nat_dvd).symm
 #align equiv.perm.is_cycle_on.zpow_apply_eq Equiv.Perm.IsCycleOn.zpow_apply_eq
 
 theorem IsCycleOn.pow_apply_eq_pow_apply {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈ s)

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

@@ -1926,7 +1926,6 @@ theorem _root_.Set.Countable.exists_cycleOn (hs : s.Countable) :
     simp
 #align set.countable.exists_cycle_on Set.Countable.exists_cycleOn
 
-/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem _root_.Set.prod_self_eq_unionᵢ_perm (hf : f.IsCycleOn s) :
     s ×ˢ s = ⋃ n : ℤ, (fun a => (a, (f ^ n) a)) '' s := by
   ext ⟨a, b⟩

Also fixes a lemma statement to use % notation like it did in Lean3

Co-authored-by: Jon Eugster <eugster.jon@gmail.com>

@@ -914,7 +914,7 @@ theorem IsCycleOn.exists_pow_eq {s : Finset α} (hf : f.IsCycleOn s) (ha : a ∈
     obtain ⟨n, rfl⟩ := hf.2 ha hb
     obtain ⟨k, hk⟩ := (Int.mod_modEq n s.card).symm.dvd
     refine' ⟨n.natMod s.card, Int.natMod_lt (Nonempty.card_pos ⟨a, ha⟩).ne', _⟩
-    rw [← zpow_ofNat, Int.natMod, ← Int.mod_def',
+    rw [← zpow_ofNat, Int.natMod,
       Int.toNat_of_nonneg (Int.emod_nonneg _ <| Nat.cast_ne_zero.2
         (Nonempty.card_pos ⟨a, ha⟩).ne'),  sub_eq_iff_eq_add'.1 hk, zpow_add, zpow_mul]
     simp only [zpow_coe_nat, coe_mul, comp_apply, EmbeddingLike.apply_eq_iff_eq]

Lotsa stuff to do, please help. Also, Equiv.Perm.Support should be named Equiv.Perm.support, right? I carried out that renaming in here.

Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Arien Malec <arien.malec@gmail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com>