### Barred Permutations

These partitions are elements of the wreath product *S*_{2} wr S_{n}, the
Hyperoctahedral group. These elements are
objects of the type PERMUTATION, but now the kind of the
permutation is BAR or BARCYCLE.
The permutation is of length *n,* and the
entries are between 1 and *n,* but here they *can be positive or negative.*
The first routine we describe is that which
computes the label of the conjugacy class of the
element *a.*

- NAME:
*class_bar*
- SYNOPSIS:
*INT class_bar(OP a,b)*

In order to use the next routine,
you enter the label of a class, and the routine computes
an representative element *b* of that class:
- NAME:
*class_rep_bar*
- SYNOPSIS:
*INT class_rep_bar(OP a,b)*

Another routine
computes the Lehmer code of a barred permutation *a.*
The result is a two-element VECTORobject, whose two entries
are INTEGER - VECTOR objects, whose lengths are the length of the
PERMUTATIONobject *a.*
The first VECTOR is a 0-1-vector, the i-th entry is one if the
element i+1 is negative in the PERMUTATIONobject *a.*
The second VECTOR is the ordinary Lehmer code of a permutation,
but taken into account that we may have negative entries.
- NAME:
*lehmercode_bar*
- SYNOPSIS:
*INT lehmercode_bar(OP a,b)*
- An EXAMPLE: If we are given the barred permutation
*3 -5 2 -1 4*

the result of an application of *lehmercode_bar* is
* [[1,0,0,0,1][3,0,1,0,0]]*

The next routine
is the inverse routine of the above routine:
- NAME:
*lehmercode_vector_bar*
- SYNOPSIS:
*INT lehmercode_vector_bar(OP a,b)*

The following routine
computes the reduced length of the barred permutation *a.*
- NAME:
*length_bar*
- SYNOPSIS:
*INT length_bar(OP a,b)*

This routine
computes a vector containing all the labelings of the classes of
the group *S*_{2} wr S_{a}:
- NAME:
*makevectorof_class_bar*
- SYNOPSIS:
*INT makevectorof_class_bar(OP a,b)*

Another routine
computes a vector with representatives of all the conjugacy classes of
the group *S*_{2} wr S_{a}, the ordering of classes is as in the
function *makevectorof_class_bar.*
- NAME:
*makevectorof_class_rep_bar*
- SYNOPSIS:
*INT makevectorof_class_rep_bar(OP a,b)*

The following routine
computes the order of the centraliser of the class
labeled by *a.*
- NAME:
*ordcen_bar*
- SYNOPSIS:
*INT ordcen_bar(OP a,b)*

This routine
multiplies *a* and *b* (as permutations: ''first *b* then *a*):
- NAME:
*mult_bar_bar*
- SYNOPSIS:
*INT mult_bar_bar(OP a,b,c)*

This one
computes the order of the class labeled by *a.*
- NAME:
*ordcon_bar*
- SYNOPSIS:
*INT ordcon_bar(OP a,b)*

The next routine
computes a random element of given length, so *b* becomes
an element of *S*_{2} wr S_{a}, while *a* is an INTEGERobject:
- NAME:
*random_bar*
- SYNOPSIS:
*INT random_bar(OP a,b)*

Here is a routine that
transforms a barred permutation *a* in list-notation into
cycle notation
- NAME:
*t_BAR_BARCYCLE*
- SYNOPSIS:
*INT t_BAR_BARCYCLE(OP a,b)*
- BUG:
*a* and *b* must be different

The next routine
transforms a barred permutation *a* in cycle-notation into
list notation:
- NAME:
*t_BARCYCLE_BAR*
- SYNOPSIS:
*INT t_BARCYCLE_BAR(OP a,b)*
- BUG:
*a* and *b* must be different

harald.fripertinger@kfunigraz.ac.at,

last changed: November 19, 2001