# zsy man page

zsy — symmetrized tensor product of a matrix or permutation

## Synopsis

**zsy** [Options] *<Mode> <Inp> <Out>*

## Description

This program reads a matrix or permutation, calculates its symmetrized tensor product according to *Mode*, and writes out the result.

The *Mode* argument specifies the tensor product to be taken and the kind of symmetrization to be performed. Currently there are 4 Modes available:

**s2**- The symmetric tensor square. The output has size n(n+1)/2 (For matrices, number of lines, for permutations, degree).
**e2**- The antisymmetric tensor square. The output has size n(n-1)/2.
**e3**- The antisymmetric tensor cube. The output has size n(n-1)(n-2)/6.
**e4**- The antisymmetric fourth power. The output has size n(n-1)(n-2)(n-3)/24.

Since the typical application of **zsy** is to generate new representations from existing ones, it will usually be used with square matrices. However, the input is not required to be square.

### Permutations

Currently, only modes s2, e2 and e3 are available for permutations. The result gives the operation of the input permutation on unordered pairs (e2, s2) or triples (e3) of points. More precisely, if the given permutation operates on 1...n, then:

- ·
- s2 is the operation on (i,k) with 1≤i≤k≤n.
- ·
- e2 is the operation on (i,k) with 1≤i<k≤n.
- ·
- e3 is the operation on (i,k,l) with 1≤i<k<l≤n.

In the output, pairs and triples are numbered lexicographically. For example, E2 uses the following order: (1,2), (1,3), (2,3), (1,4), .... Notice that the symmetric square is never transitive but decomposes into the diagonal and the antisymmetric square. Here are some examples:

p | = (1 5 4 3 2) |

e2(p) | = (1 7 10 6 3)(2 8 4 9 5) |

s2(p) | = (1 15 10 6 3)(2 11 14 9 5)(7 14 8 4 12) |

e3(p) | = (1 5 8 10 4)(2 6 9 3 7) |

### Matrices

The rth exterior power (modes e2, e3, e4) has as its entries the determinants of r times r submatrices of the input. Rows and columns are ordered lexicographically, which is equivalent to taking the following basis in the tensor product:

**e2**- v_i ∧ v_j with 1≤i<j≤n
**e3**- v_i ∧ v_j ∧ v_k with 1≤i<j<k≤n
**e4**- v_i ∧ v_j ∧ v_k ∧ v_l with 1≤i<j<k<l≤n

The basis vectors are ordered lexicographically, for example (e2): v_1∧v_2, v_1∧v_3, ..., v_1∧v_n, v_2∧v_3, v_2∧v_4, ..., v_3∧v_n, ..., v_n-1∧v_n.

The symmetric square of a matrix with r rows and c columns is a matrix with r(r+1)/2 rows and c(c+1)/2 columns, with entries given by the formulae

c(c-1)/2 | c | |

= | = | = |

r*(r-1)/2 | ad+bc | ac |

r | 2ab | a^2 |

where the upper left is the r(r-1)/2 by c(c-1)/2 matrix of permanents. The program orders both the rows and the columns in lexicographical order, i.e. v_1·v_2, v_1·v_3, ..., v_1·v_n, v_2·v_3, v_2·v_4, ... v_2·v_n, v_3·v_4, ... v_{n-1}·v_n, v_1·v_1, v_2·v_2, ... v_n·v_n, with the assumption that v_i·v_j = v_j·v_i, i.e. the action is on quadratic polynomials.

The symmetric square is, in general, irreducible except in characteristic 2. In that case there is a copy of the Frobenius square as an invariant submodule, as can be seen from the 2ab in the above formulae. Invariant subspaces in characteristic 2 correspond to special groups (i.e., groups of the form 2^nx2^m) on which the group given acts on the quotient 2^n.

Here are some examples:

(1 2 1 3) (1 2 1 3 6 2)

E2 (0 1 2 1) = (0 1 0 2 0 4) (mod 7)

(1 2 2 3) (6 5 6 5 1 4)

(1 0 2 0 2) (1 0 1 4 0 1 0 0 0 0)

E3 (1 1 2 1 2) = (1 4 3 4 0 3 2 1 3 4) (mod 5)

(3 3 2 3 2) (1 2 2 3 2 3 1 3 4 2)

(1 2 3 1 0) (4 0 4 0 2 0 4 2 1 3)

(1 2 1 5 5 7 0 2 2 3)

(1 2 1 3) (4 3 6 6 12 9 1 4 2 9)

S2 (0 1 2 1) = (1 2 1 6 5 8 0 2 4 3) (mod 13)

(1 2 2 3) (4 2 6 4 12 6 1 4 1 9)

(0 0 0 4 2 4 0 1 4 1)

(4 4 6 8 12 12 1 4 4 9)

## Options

**-Q**- Quiet, no messages.
**-V**- Verbose, more messages.
**-T***<MaxTime>*- Set CPU time limit
**-G**- Produce output in GAP format. This option implies -Q.

## Implementation Details

If the input file contains more than one permutation, only the first permutation is read in and processed.

If the input is a matrix, the whole input matrix and one row of the result must fit into memory. In case of permutations both the input and the result must fit into memory.