A **signed permutation** of `[1..n]`

is a permutation of the set
*{-n,...,-1,1,...,n}* which preserves the pairs *[-i,i]*. It is
represented internally as the images of *[1..n]*. It is printed as a
product of signed cycles.

A signed permutation can be represented in two other ways which may be
convenient. The first way is to replace the integers
*{1,...,n,-n,...,-1}* by *{1,3,...,2n-1,2,4,...,2n}* to
have **GAP3** permutations, which form the hyperoctaedral group (see
CoxeterGroupHyperoctaedralGroup).

The second way is to represent the signed permutation by a monomial matrix
with entries `1`

or `-1`

. If such a matrix `m` represents the signed
permutation `sp`, then `l*m`

is the same as `Permuted(`

.
`l`,`sp`)

- Permuted for signed permutations
- PermutationMat for signed permutations
- SignedPerm
- Cycles for signed permutations
- SignedPermListList
- SignedMatStab
- SignedPermMatMat

`Permuted( `

`l`, `sp`)

`Permuted`

returns a new list `n` that contains the elements of the list
`l` permuted according to the signed permutation `sp`. If `sp` is given as
a list, then

.
`n`[AbsInt(i^sp)] = `l`[`i`]SignInt(i^sp)

gap> p:=SignedPerm([-2,-1,-3]); (1,-2)(3,-3) gap> Permuted([20,30,40],p); [ -30, -20, -40 ]

`PermutationMat( `

`sp` [,`d`])

This function returns the signed permutation matrix of the signed
permutation `sp`. This is a matrix `m` such that `Permuted(l,sp)=l*m`

for
any list of numbers l. If an additional argument `d` is given the matrix is
returned of that dimension.

gap> p:=SignedPerm([-2,-1,-3]); (1,-2)(3,-3) gap> PermutationMat(p); [ [ 0, -1, 0 ], [ -1, 0, 0 ], [ 0, 0, -1 ] ]

`SignedPerm( `

`sp` [,`d` or `sgns`])

This function converts to a signed permutation a list, an element of the
hyperoctaedral group, a signed permutation matrix, or a pair of a
permutation and of a list of signs. If given an element of the
hyperoctaedral group, the rank `d` of that group can be given as an
argument, otherwise a representation of `sp` as a list is given
corresponding to the smallest hyperoctaedral group to which it belongs.

gap> SignedPerm([[0,-1,0],[0,0,-1],[-1,0,0]]); (1,-2,3,-1,2,-3) gap> SignedPerm((1,4,5,2,3,6)); (1,-2,3,-1,2,-3) gap> SignedPerm((1,2,3),[-1,-1,-1]); (1,-2,3,-1,2,-3) gap> SignedPerm([-2,-3,-1]); (1,-2,3,-1,2,-3)

`Cycles( `

`sp` )

Returns the list of cycles of the signed permutation `sp` on
*{-n,...,-1,1,...,n}*. If one cycle is the negative of another,
only one of the two cycles is given.

gap> Cycles(SignedPerm([-2,-3,-1])); [ [ 1, -2, 3, -1, 2, -3 ] ] gap> Cycles(SignedPerm([-2,-1,-3])); [ [ 1, -2 ], [ 3, -3 ] ] gap> Cycles(SignedPerm([-2,-1,3])); [ [ 1, -2 ] ]

`SignedPermListList( `

`list1`, `list2` )

`SignedPermListList`

returns a signed permutation that may be applied to
`list1` to obtain `list2`, if there is one. Otherwise it returns `false`

.

gap> SignedPermListList([20,30,40],[-40,-20,-30]); (1,-2,3,-1,2,-3) gap> Permuted([20,30,40],last); [ -40, -20, -30 ]

`SignedMatStab(`

`M`[, `l`])

Finds the stabilizer of `M` in the group of signed permutations.

gap> uc:=UnipotentCharacters(ComplexReflectionGroup(6)); UnipotentCharacters( G6 ) gap> SignedMatStab(Fourier(uc.families[2])); Group( (2,19)(4,-14)(5,20)(7,12), (1,-1)(2,-2)(3,-3)(4,-4)(5,-5)(6,-6)\ (7,-7)(8,-8)(9,-9)(10,-10)(11,-11)(12,-12)(13,-13)(14,-14)(15,-15)(16,\ -16)(17,-17)(18,-18)(19,-19)(20,-20)(21,-21)(22,-22), (1,3)(2,19)(4,-1\ 4)(5,-5)(6,-18)(7,-7)(8,10)(11,15)(12,-12)(13,22)(16,21)(17,-17)(20,-2\ 0), (1,6)(2,-19)(3,-18)(4,14)(8,16)(9,-9)(10,21)(11,-13)(15,-22), (1,1\ 1)(3,15)(4,14)(6,-13)(7,-12)(8,-10)(9,-9)(16,-21)(18,22) ) gap> Size(last); 32

`SignedPermMatMat( `

`M` , `N` [, `l1`, `l2`])

`M` and `N` should be symmetric matrices. `PermMatMat`

returns a signed
permutation `p` such that `OnMatrices(M,p)=N`

if such a permutation exists,
and `false`

otherwise. If list arguments `l1` and `l2` are given, the
permutation `p` should also satisfy `Permuted(l1,p)=l2`

.

This routine is useful to identify two objects which are isomorphic but
with different labelings. It is used in **CHEVIE** to identify Lusztig
Fourier transform matrices with standard (classified) data. The program
uses sophisticated algorithms, and can often handle matrices up to
*80× 80*.

gap> f:=SubFamilyij(CHEVIE.families.X(12),1,3,(3+ER(-3))/2); Family("RZ/12^2[1,3]") gap> M:=Fourier(ComplexConjugate(f));; gap> uc:=UnipotentCharacters(ComplexReflectionGroup(6)); UnipotentCharacters( G6 ) gap> N:=Fourier(uc.families[2]);; gap> SignedPermMatMat(M,N); (1,13)(2,19,-2,-19)(3,22)(4,-4)(5,-5)(6,-11)(7,12)(8,21,-8,-21)(9,-9)(\ 10,16)(15,-18,-15,18) gap> OnMatrices(M,last)=N; true

gap3-jm

24 Apr 2021