group_theory.perm.option | Mathlib porting status

Changes since the initial port

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

Changes in mathlib3

c3019c79

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

ee05e9ce

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Mathbin.Data.Fintype.Perm
-import Mathbin.GroupTheory.Perm.Sign
-import Mathbin.Logic.Equiv.Option
+import Data.Fintype.Perm
+import GroupTheory.Perm.Sign
+import Logic.Equiv.Option
 
 #align_import group_theory.perm.option from "leanprover-community/mathlib"@"ee05e9ce1322178f0c12004eb93c00d2c8c00ed2"

ee05e9ce

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module group_theory.perm.option
-! leanprover-community/mathlib commit ee05e9ce1322178f0c12004eb93c00d2c8c00ed2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fintype.Perm
 import Mathbin.GroupTheory.Perm.Sign
 import Mathbin.Logic.Equiv.Option
 
+#align_import group_theory.perm.option from "leanprover-community/mathlib"@"ee05e9ce1322178f0c12004eb93c00d2c8c00ed2"
+
 /-!
 # Permutations of `option α`

ee05e9ce

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -22,11 +22,14 @@ import Mathbin.Logic.Equiv.Option
 
 open Equiv
 
+#print Equiv.optionCongr_one /-
 @[simp]
 theorem Equiv.optionCongr_one {α : Type _} : (1 : Perm α).optionCongr = 1 :=
   Equiv.optionCongr_refl
 #align equiv.option_congr_one Equiv.optionCongr_one
+-/
 
+#print Equiv.optionCongr_swap /-
 @[simp]
 theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
     optionCongr (swap x y) = swap (some x) (some y) :=
@@ -37,7 +40,9 @@ theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
     simp [hx, swap_apply_of_ne_of_ne]
     by_cases hy : i = y <;> simp [hx, hy, swap_apply_of_ne_of_ne]
 #align equiv.option_congr_swap Equiv.optionCongr_swap
+-/
 
+#print Equiv.optionCongr_sign /-
 @[simp]
 theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign e.optionCongr = Perm.sign e :=
@@ -47,7 +52,9 @@ theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e :
   · intro f x y hne h
     simp [h, hne, perm.mul_def, ← Equiv.optionCongr_trans]
 #align equiv.option_congr_sign Equiv.optionCongr_sign
+-/
 
+#print map_equiv_removeNone /-
 @[simp]
 theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option α)) :
     (removeNone σ).optionCongr = swap none (σ none) * σ :=
@@ -64,6 +71,7 @@ theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option 
         simp [remove_none_some _ ⟨_, h⟩, ← h, swap_apply_of_ne_of_ne hn hσn]
   simpa using this
 #align map_equiv_remove_none map_equiv_removeNone
+-/
 
 #print Equiv.Perm.decomposeOption /-
 /-- Permutations of `option α` are equivalent to fixing an
@@ -89,10 +97,13 @@ theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type _} [DecidableEq
 #align equiv.perm.decompose_option_symm_of_none_apply Equiv.Perm.decomposeOption_symm_of_none_apply
 -/
 
+#print Equiv.Perm.decomposeOption_symm_sign /-
 theorem Equiv.Perm.decomposeOption_symm_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e := by simp
 #align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_sign
+-/
 
+#print Finset.univ_perm_option /-
 /-- The set of all permutations of `option α` can be constructed by augmenting the set of
 permutations of `α` by each element of `option α` in turn. -/
 theorem Finset.univ_perm_option {α : Type _} [DecidableEq α] [Fintype α] :
@@ -100,4 +111,5 @@ theorem Finset.univ_perm_option {α : Type _} [DecidableEq α] [Fintype α] :
       (Finset.univ : Finset <| Option α × Perm α).map Equiv.Perm.decomposeOption.symm.toEmbedding :=
   (Finset.univ_map_equiv_to_embedding _).symm
 #align finset.univ_perm_option Finset.univ_perm_option
+-/

ee05e9ce

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -22,23 +22,11 @@ import Mathbin.Logic.Equiv.Option
 
 open Equiv
 
-/- warning: equiv.option_congr_one -> Equiv.optionCongr_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, 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} α))))))))) (OfNat.ofNat.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) 1 (OfNat.mk.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) 1 (One.one.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (MulOneClass.toHasOne.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α)))))))))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, 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} α)))))))) (OfNat.ofNat.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) 1 (One.toOfNat1.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (InvOneClass.toOne.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Group.toDivisionMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))))
-Case conversion may be inaccurate. Consider using '#align equiv.option_congr_one Equiv.optionCongr_oneₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_one {α : Type _} : (1 : Perm α).optionCongr = 1 :=
   Equiv.optionCongr_refl
 #align equiv.option_congr_one Equiv.optionCongr_one
 
-/- warning: equiv.option_congr_swap -> Equiv.optionCongr_swap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (x : α) (y : α), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x y)) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.some.{u1} α x) (Option.some.{u1} α y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (x : α) (y : α), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x y)) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.some.{u1} α x) (Option.some.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align equiv.option_congr_swap Equiv.optionCongr_swapₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
     optionCongr (swap x y) = swap (some x) (some y) :=
@@ -50,12 +38,6 @@ theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
     by_cases hy : i = y <;> simp [hx, hy, swap_apply_of_ne_of_ne]
 #align equiv.option_congr_swap Equiv.optionCongr_swap
 
-/- warning: equiv.option_congr_sign -> Equiv.optionCongr_sign is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (Equiv.optionCongr.{u1, u1} α α e)) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
-Case conversion may be inaccurate. Consider using '#align equiv.option_congr_sign Equiv.optionCongr_signₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign e.optionCongr = Perm.sign e :=
@@ -66,12 +48,6 @@ theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e :
     simp [h, hne, perm.mul_def, ← Equiv.optionCongr_trans]
 #align equiv.option_congr_sign Equiv.optionCongr_sign
 
-/- warning: map_equiv_remove_none -> map_equiv_removeNone is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (instHMul.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (MulOneClass.toHasMul.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) => (Option.{u1} α) -> (Option.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (instHMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Option.{u1} α) (fun (_x : Option.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Option.{u1} α) => Option.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
-Case conversion may be inaccurate. Consider using '#align map_equiv_remove_none map_equiv_removeNoneₓ'. -/
 @[simp]
 theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option α)) :
     (removeNone σ).optionCongr = swap none (σ none) * σ :=
@@ -113,19 +89,10 @@ theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type _} [DecidableEq
 #align equiv.perm.decompose_option_symm_of_none_apply Equiv.Perm.decomposeOption_symm_of_none_apply
 -/
 
-/- warning: equiv.perm.decompose_option_symm_sign -> Equiv.Perm.decomposeOption_symm_sign is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_signₓ'. -/
 theorem Equiv.Perm.decomposeOption_symm_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e := by simp
 #align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_sign
 
-/- warning: finset.univ_perm_option -> Finset.univ_perm_option 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} (Option.{u1} α))) (Finset.univ.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.fintype.{u1, u1} (Option.{u1} α) (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2) (Option.fintype.{u1} α _inst_2))) (Finset.map.{u1, u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.toEmbedding.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b)))) (Finset.univ.{u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Prod.fintype.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.fintype.{u1} α _inst_2) (Equiv.fintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_2))))
-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} (Option.{u1} α))) (Finset.univ.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (equivFintype.{u1, u1} (Option.{u1} α) (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2) (instFintypeOption.{u1} α _inst_2))) (Finset.map.{u1, u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.toEmbedding.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b)))) (Finset.univ.{u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (instFintypeProd.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (instFintypeOption.{u1} α _inst_2) (equivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_2))))
-Case conversion may be inaccurate. Consider using '#align finset.univ_perm_option Finset.univ_perm_optionₓ'. -/
 /-- The set of all permutations of `option α` can be constructed by augmenting the set of
 permutations of `α` by each element of `option α` in turn. -/
 theorem Finset.univ_perm_option {α : Type _} [DecidableEq α] [Fintype α] :

ee05e9ce

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -114,10 +114,7 @@ theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type _} [DecidableEq
 -/
 
 /- warning: equiv.perm.decompose_option_symm_sign -> Equiv.Perm.decomposeOption_symm_sign is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) => (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) -> (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (a : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (_x : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
+<too large>
 Case conversion may be inaccurate. Consider using '#align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_signₓ'. -/
 theorem Equiv.Perm.decomposeOption_symm_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e := by simp

ee05e9ce

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -54,7 +54,7 @@ theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (Equiv.optionCongr.{u1, u1} α α e)) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (Equiv.optionCongr.{u1, u1} α α e)) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
 Case conversion may be inaccurate. Consider using '#align equiv.option_congr_sign Equiv.optionCongr_signₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
@@ -70,7 +70,7 @@ theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (instHMul.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (MulOneClass.toHasMul.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) => (Option.{u1} α) -> (Option.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (instHMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Option.{u1} α) (fun (_x : Option.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Option.{u1} α) => Option.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (instHMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Option.{u1} α) (fun (_x : Option.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Option.{u1} α) => Option.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
 Case conversion may be inaccurate. Consider using '#align map_equiv_remove_none map_equiv_removeNoneₓ'. -/
 @[simp]
 theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option α)) :
@@ -117,7 +117,7 @@ theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type _} [DecidableEq
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) => (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) -> (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (a : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (_x : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (a : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (_x : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
 Case conversion may be inaccurate. Consider using '#align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_signₓ'. -/
 theorem Equiv.Perm.decomposeOption_symm_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e := by simp

ee05e9ce

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -54,7 +54,7 @@ theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (Equiv.optionCongr.{u1, u1} α α e)) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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.2372 : 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) e)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (Equiv.optionCongr.{u1, u1} α α e)) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
 Case conversion may be inaccurate. Consider using '#align equiv.option_congr_sign Equiv.optionCongr_signₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
@@ -70,7 +70,7 @@ theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (instHMul.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (MulOneClass.toHasMul.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) => (Option.{u1} α) -> (Option.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (instHMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Option.{u1} α) (fun (_x : Option.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Option.{u1} α) => Option.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (instHMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Option.{u1} α) (fun (_x : Option.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Option.{u1} α) => Option.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
 Case conversion may be inaccurate. Consider using '#align map_equiv_remove_none map_equiv_removeNoneₓ'. -/
 @[simp]
 theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option α)) :
@@ -117,7 +117,7 @@ theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type _} [DecidableEq
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) => (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) -> (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (a : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (_x : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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.2372 : 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) e)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (a : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (_x : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
 Case conversion may be inaccurate. Consider using '#align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_signₓ'. -/
 theorem Equiv.Perm.decomposeOption_symm_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e := by simp

ee05e9ce

bump to nightly-2023-03-08-18

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

10f15343

Diff

@@ -54,7 +54,7 @@ theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (Equiv.optionCongr.{u1, u1} α α e)) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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.2398 : 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) e)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (Equiv.optionCongr.{u1, u1} α α e)) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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.2372 : 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) e)
 Case conversion may be inaccurate. Consider using '#align equiv.option_congr_sign Equiv.optionCongr_signₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
@@ -117,7 +117,7 @@ theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type _} [DecidableEq
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) => (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) -> (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (a : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (_x : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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.2398 : 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) e)
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (a : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (_x : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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.2372 : 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) e)
 Case conversion may be inaccurate. Consider using '#align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_signₓ'. -/
 theorem Equiv.Perm.decomposeOption_symm_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e := by simp

ee05e9ce

bump to nightly-2023-03-02-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

db7421c3

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 
 ! This file was ported from Lean 3 source module group_theory.perm.option
-! leanprover-community/mathlib commit c3019c79074b0619edb4b27553a91b2e82242395
+! leanprover-community/mathlib commit ee05e9ce1322178f0c12004eb93c00d2c8c00ed2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Logic.Equiv.Option
 
 /-!
 # Permutations of `option α`
+
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
 -/

c3019c79

bump to nightly-2023-02-27-18

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

e210689e

Diff

@@ -19,11 +19,23 @@ import Mathbin.Logic.Equiv.Option
 
 open Equiv
 
+/- warning: equiv.option_congr_one -> Equiv.optionCongr_one is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}}, Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, 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} α))))))))) (OfNat.ofNat.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) 1 (OfNat.mk.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) 1 (One.one.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (MulOneClass.toHasOne.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α)))))))))
+but is expected to have type
+  forall {α : Type.{u1}}, Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, 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} α)))))))) (OfNat.ofNat.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) 1 (One.toOfNat1.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (InvOneClass.toOne.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivInvOneMonoid.toInvOneClass.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivisionMonoid.toDivInvOneMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Group.toDivisionMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))))
+Case conversion may be inaccurate. Consider using '#align equiv.option_congr_one Equiv.optionCongr_oneₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_one {α : Type _} : (1 : Perm α).optionCongr = 1 :=
   Equiv.optionCongr_refl
 #align equiv.option_congr_one Equiv.optionCongr_one
 
+/- warning: equiv.option_congr_swap -> Equiv.optionCongr_swap is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (x : α) (y : α), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x y)) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.some.{u1} α x) (Option.some.{u1} α y))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (x : α) (y : α), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.swap.{succ u1} α (fun (a : α) (b : α) => _inst_1 a b) x y)) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.some.{u1} α x) (Option.some.{u1} α y))
+Case conversion may be inaccurate. Consider using '#align equiv.option_congr_swap Equiv.optionCongr_swapₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
     optionCongr (swap x y) = swap (some x) (some y) :=
@@ -35,6 +47,12 @@ theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
     by_cases hy : i = y <;> simp [hx, hy, swap_apply_of_ne_of_ne]
 #align equiv.option_congr_swap Equiv.optionCongr_swap
 
+/- warning: equiv.option_congr_sign -> Equiv.optionCongr_sign is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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) e)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (Equiv.optionCongr.{u1, u1} α α e)) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (Equiv.optionCongr.{u1, u1} α α e)) (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.2398 : 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) e)
+Case conversion may be inaccurate. Consider using '#align equiv.option_congr_sign Equiv.optionCongr_signₓ'. -/
 @[simp]
 theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign e.optionCongr = Perm.sign e :=
@@ -45,6 +63,12 @@ theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e :
     simp [h, hne, perm.mul_def, ← Equiv.optionCongr_trans]
 #align equiv.option_congr_sign Equiv.optionCongr_sign
 
+/- warning: map_equiv_remove_none -> map_equiv_removeNone is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (instHMul.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (MulOneClass.toHasMul.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (coeFn.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) => (Option.{u1} α) -> (Option.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] (σ : Equiv.Perm.{succ u1} (Option.{u1} α)), Eq.{succ u1} (Equiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) (Equiv.optionCongr.{u1, u1} α α (Equiv.removeNone.{u1, u1} α α σ)) (HMul.hMul.{u1, u1, u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (instHMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))))) (Equiv.swap.{succ u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.none.{u1} α) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Option.{u1} α) (fun (_x : Option.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Option.{u1} α) => Option.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Option.{u1} α) (Option.{u1} α)) σ (Option.none.{u1} α))) σ)
+Case conversion may be inaccurate. Consider using '#align map_equiv_remove_none map_equiv_removeNoneₓ'. -/
 @[simp]
 theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option α)) :
     (removeNone σ).optionCongr = swap none (σ none) * σ :=
@@ -62,6 +86,7 @@ theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option 
   simpa using this
 #align map_equiv_remove_none map_equiv_removeNone
 
+#print Equiv.Perm.decomposeOption /-
 /-- Permutations of `option α` are equivalent to fixing an
 `option α` and permuting the remaining with a `perm α`.
 The fixed `option α` is swapped with `none`. -/
@@ -77,15 +102,30 @@ def Equiv.Perm.decomposeOption {α : Type _} [DecidableEq α] : Perm (Option α)
       Equiv.optionCongr_injective (by simp [← mul_assoc])
     simp [← perm.eq_inv_iff_eq, this]
 #align equiv.perm.decompose_option Equiv.Perm.decomposeOption
+-/
 
+#print Equiv.Perm.decomposeOption_symm_of_none_apply /-
 theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type _} [DecidableEq α] (e : Perm α)
     (i : Option α) : Equiv.Perm.decomposeOption.symm (none, e) i = i.map e := by simp
 #align equiv.perm.decompose_option_symm_of_none_apply Equiv.Perm.decomposeOption_symm_of_none_apply
+-/
 
+/- warning: equiv.perm.decompose_option_symm_sign -> Equiv.Perm.decomposeOption_symm_sign is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} (Units.{0} Int Int.monoid) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (fun (_x : MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) => (Equiv.Perm.{succ u1} (Option.{u1} α)) -> (Units.{0} Int Int.monoid)) (MonoidHom.hasCoeToFun.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.monoid) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.mulOneClass.{0} Int Int.monoid)) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) => (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) -> (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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) e)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : Fintype.{u1} α] (e : Equiv.Perm.{succ u1} α), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (a : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) a) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (FunLike.coe.{succ u1, succ u1, 1} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (fun (_x : Equiv.Perm.{succ u1} (Option.{u1} α)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : Equiv.Perm.{succ u1} (Option.{u1} α)) => Units.{0} Int Int.instMonoidInt) _x) (MulHomClass.toFunLike.{u1, u1, 0} (MonoidHom.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{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} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt) (MonoidHom.monoidHomClass.{u1, 0} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Units.{0} Int Int.instMonoidInt) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.Perm.permGroup.{u1} (Option.{u1} α))))) (Units.instMulOneClassUnits.{0} Int Int.instMonoidInt)))) (Equiv.Perm.sign.{u1} (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (fun (_x : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) => Equiv.Perm.{succ u1} (Option.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α))) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Prod.mk.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.none.{u1} α) e))) (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.2398 : 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) e)
+Case conversion may be inaccurate. Consider using '#align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_signₓ'. -/
 theorem Equiv.Perm.decomposeOption_symm_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e := by simp
 #align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_sign
 
+/- warning: finset.univ_perm_option -> Finset.univ_perm_option 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} (Option.{u1} α))) (Finset.univ.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.fintype.{u1, u1} (Option.{u1} α) (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (fun (a : Option.{u1} α) (b : Option.{u1} α) => Option.decidableEq.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (Option.fintype.{u1} α _inst_2) (Option.fintype.{u1} α _inst_2))) (Finset.map.{u1, u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.toEmbedding.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b)))) (Finset.univ.{u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Prod.fintype.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (Option.fintype.{u1} α _inst_2) (Equiv.fintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_2))))
+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} (Option.{u1} α))) (Finset.univ.{u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (equivFintype.{u1, u1} (Option.{u1} α) (Option.{u1} α) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (fun (a : Option.{u1} α) (b : Option.{u1} α) => instDecidableEqOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b) a b) (instFintypeOption.{u1} α _inst_2) (instFintypeOption.{u1} α _inst_2))) (Finset.map.{u1, u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.toEmbedding.{succ u1, succ u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.{succ u1} (Option.{u1} α)) (Equiv.symm.{succ u1, succ u1} (Equiv.Perm.{succ u1} (Option.{u1} α)) (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (Equiv.Perm.decomposeOption.{u1} α (fun (a : α) (b : α) => _inst_1 a b)))) (Finset.univ.{u1} (Prod.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α)) (instFintypeProd.{u1, u1} (Option.{u1} α) (Equiv.Perm.{succ u1} α) (instFintypeOption.{u1} α _inst_2) (equivFintype.{u1, u1} α α (fun (a : α) (b : α) => _inst_1 a b) (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_2))))
+Case conversion may be inaccurate. Consider using '#align finset.univ_perm_option Finset.univ_perm_optionₓ'. -/
 /-- The set of all permutations of `option α` can be constructed by augmenting the set of
 permutations of `α` by each element of `option α` in turn. -/
 theorem Finset.univ_perm_option {α : Type _} [DecidableEq α] [Fintype α] :

c3019c79

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

c3019c79

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

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -29,7 +29,7 @@ theorem Equiv.optionCongr_swap {α : Type*} [DecidableEq α] (x y : α) :
   ext (_ | i)
   · simp [swap_apply_of_ne_of_ne]
   · by_cases hx : i = x
-    simp only [hx, optionCongr_apply, Option.map_some', swap_apply_left, Option.mem_def,
+    · simp only [hx, optionCongr_apply, Option.map_some', swap_apply_left, Option.mem_def,
              Option.some.injEq]
     by_cases hy : i = y <;> simp [hx, hy, swap_apply_of_ne_of_ne]
 #align equiv.option_congr_swap Equiv.optionCongr_swap

c3019c79

chore(GroupTheory/Perm/Cycle/Basic): Split (#10907)

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>

5925ea9b

Diff

@@ -3,7 +3,9 @@ Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
+import Mathlib.Data.Fintype.Option
 import Mathlib.Data.Fintype.Perm
+import Mathlib.Data.Fintype.Prod
 import Mathlib.GroupTheory.Perm.Sign
 import Mathlib.Logic.Equiv.Option

c3019c79

chore: remove nonterminal simp (#7580)

Removes nonterminal simps on lines looking like simp [...]

6fc8e6ec

Diff

@@ -27,7 +27,8 @@ theorem Equiv.optionCongr_swap {α : Type*} [DecidableEq α] (x y : α) :
   ext (_ | i)
   · simp [swap_apply_of_ne_of_ne]
   · by_cases hx : i = x
-    simp [hx, swap_apply_of_ne_of_ne]
+    simp only [hx, optionCongr_apply, Option.map_some', swap_apply_left, Option.mem_def,
+             Option.some.injEq]
     by_cases hy : i = y <;> simp [hx, hy, swap_apply_of_ne_of_ne]
 #align equiv.option_congr_swap Equiv.optionCongr_swap

c3019c79

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -17,12 +17,12 @@ import Mathlib.Logic.Equiv.Option
 open Equiv
 
 @[simp]
-theorem Equiv.optionCongr_one {α : Type _} : (1 : Perm α).optionCongr = 1 :=
+theorem Equiv.optionCongr_one {α : Type*} : (1 : Perm α).optionCongr = 1 :=
   Equiv.optionCongr_refl
 #align equiv.option_congr_one Equiv.optionCongr_one
 
 @[simp]
-theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
+theorem Equiv.optionCongr_swap {α : Type*} [DecidableEq α] (x y : α) :
     optionCongr (swap x y) = swap (some x) (some y) := by
   ext (_ | i)
   · simp [swap_apply_of_ne_of_ne]
@@ -32,7 +32,7 @@ theorem Equiv.optionCongr_swap {α : Type _} [DecidableEq α] (x y : α) :
 #align equiv.option_congr_swap Equiv.optionCongr_swap
 
 @[simp]
-theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
+theorem Equiv.optionCongr_sign {α : Type*} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign e.optionCongr = Perm.sign e := by
   refine Perm.swap_induction_on e ?_ ?_
   · simp [Perm.one_def]
@@ -41,7 +41,7 @@ theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e :
 #align equiv.option_congr_sign Equiv.optionCongr_sign
 
 @[simp]
-theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option α)) :
+theorem map_equiv_removeNone {α : Type*} [DecidableEq α] (σ : Perm (Option α)) :
     (removeNone σ).optionCongr = swap none (σ none) * σ := by
   ext1 x
   have : Option.map (⇑(removeNone σ)) x = (swap none (σ none)) (σ x) := by
@@ -59,7 +59,7 @@ theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option 
 `Option α` and permuting the remaining with a `Perm α`.
 The fixed `Option α` is swapped with `none`. -/
 @[simps]
-def Equiv.Perm.decomposeOption {α : Type _} [DecidableEq α] : Perm (Option α) ≃ Option α × Perm α
+def Equiv.Perm.decomposeOption {α : Type*} [DecidableEq α] : Perm (Option α) ≃ Option α × Perm α
     where
   toFun σ := (σ none, removeNone σ)
   invFun i := swap none i.1 * i.2.optionCongr
@@ -70,17 +70,17 @@ def Equiv.Perm.decomposeOption {α : Type _} [DecidableEq α] : Perm (Option α)
     simp [← Perm.eq_inv_iff_eq, this]
 #align equiv.perm.decompose_option Equiv.Perm.decomposeOption
 
-theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type _} [DecidableEq α] (e : Perm α)
+theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type*} [DecidableEq α] (e : Perm α)
     (i : Option α) : Equiv.Perm.decomposeOption.symm (none, e) i = i.map e := by simp
 #align equiv.perm.decompose_option_symm_of_none_apply Equiv.Perm.decomposeOption_symm_of_none_apply
 
-theorem Equiv.Perm.decomposeOption_symm_sign {α : Type _} [DecidableEq α] [Fintype α] (e : Perm α) :
+theorem Equiv.Perm.decomposeOption_symm_sign {α : Type*} [DecidableEq α] [Fintype α] (e : Perm α) :
     Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e := by simp
 #align equiv.perm.decompose_option_symm_sign Equiv.Perm.decomposeOption_symm_sign
 
 /-- The set of all permutations of `Option α` can be constructed by augmenting the set of
 permutations of `α` by each element of `Option α` in turn. -/
-theorem Finset.univ_perm_option {α : Type _} [DecidableEq α] [Fintype α] :
+theorem Finset.univ_perm_option {α : Type*} [DecidableEq α] [Fintype α] :
     @Finset.univ (Perm <| Option α) _ =
       (Finset.univ : Finset <| Option α × Perm α).map Equiv.Perm.decomposeOption.symm.toEmbedding :=
   (Finset.univ_map_equiv_to_embedding _).symm

c3019c79

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module group_theory.perm.option
-! leanprover-community/mathlib commit c3019c79074b0619edb4b27553a91b2e82242395
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fintype.Perm
 import Mathlib.GroupTheory.Perm.Sign
 import Mathlib.Logic.Equiv.Option
 
+#align_import group_theory.perm.option from "leanprover-community/mathlib"@"c3019c79074b0619edb4b27553a91b2e82242395"
+
 /-!
 # Permutations of `Option α`
 -/

c3019c79

chore: fix upper/lowercase in comments (#4360)

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

27d257fc

Diff

@@ -13,7 +13,7 @@ import Mathlib.GroupTheory.Perm.Sign
 import Mathlib.Logic.Equiv.Option
 
 /-!
-# Permutations of `option α`
+# Permutations of `Option α`
 -/

c3019c79

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

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

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

14167e48

Diff

@@ -47,8 +47,7 @@ theorem Equiv.optionCongr_sign {α : Type _} [DecidableEq α] [Fintype α] (e :
 theorem map_equiv_removeNone {α : Type _} [DecidableEq α] (σ : Perm (Option α)) :
     (removeNone σ).optionCongr = swap none (σ none) * σ := by
   ext1 x
-  have : Option.map (⇑(removeNone σ)) x = (swap none (σ none)) (σ x) :=
-    by
+  have : Option.map (⇑(removeNone σ)) x = (swap none (σ none)) (σ x) := by
     cases' x with x
     · simp
     · cases h : σ (some _)
@@ -68,8 +67,7 @@ def Equiv.Perm.decomposeOption {α : Type _} [DecidableEq α] : Perm (Option α)
   toFun σ := (σ none, removeNone σ)
   invFun i := swap none i.1 * i.2.optionCongr
   left_inv σ := by simp
-  right_inv := fun ⟨x, σ⟩ =>
-    by
+  right_inv := fun ⟨x, σ⟩ => by
     have : removeNone (swap none x * σ.optionCongr) = σ :=
       Equiv.optionCongr_injective (by simp [← mul_assoc])
     simp [← Perm.eq_inv_iff_eq, this]

c3019c79

feat: port GroupTheory.Perm.Option (#2523)

5d95a0a0

`group_theory.perm.option` ⟷ `Mathlib.GroupTheory.Perm.Option`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 372

group_theory.perm.option ⟷ Mathlib.GroupTheory.Perm.Option

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 372

`group_theory.perm.option` ⟷ `Mathlib.GroupTheory.Perm.Option`