108 Signed permutations

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

108.1 Permuted for signed permutations

`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 ]```

108.2 PermutationMat for signed permutations

`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 ] ]```

108.3 SignedPerm

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

108.4 Cycles for signed permutations

`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 ] ]```

108.5 SignedPermListList

`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 ]```

108.6 SignedMatStab

`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```

108.7 SignedPermMatMat

`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