[Previous] [Contents]

## `Dom::SymmetricGroup` -- symmetric groups

#### Introduction

`Dom::SymmetricGroup``(n)` creates the symmetric group of order n, that is, the domain of all the permutations of {1,...,n} elements.

#### Domain

`Dom::SymmetricGroup(n)`

#### Parameters

`n` | - | positive integer

#### Details

- A permutation of n elements is a bijective mapping of the set {1, ..., n } onto itself.

- `Dom::SymmetricGroup` inherits from all the methods and entries defined in its super domain `Dom::PermutationGroup`.

#### Introduction

The domain element `Dom::SymmetricGroup``(n)(l)` represents the bijective mapping of the first n positive integers that maps the integer i to `l[i]`, for 1 ≤i ≤n.

#### Creating Elements

``Dom::SymmetricGroup`(n)(l)`

#### Parameters

`l` | - | list or array consisting of the first n integers in some order.

#### Categories

`Cat::Group`

#### Related Domains

`Dom::PermutationGroup`

#### Entries

one

the identical mapping of the set {1, ..., n } to itself.

#### Method _mult: product of permutations

- `_mult(dom a1...)`

- The product `a1*a2*...*ak` of permutations is defined to be the mapping that assigns, to every integer `i` between 1 and n, the integer `a1(a2(...ak(i) ...))`.
- This method overloads the function `_mult`.

#### Method _invert: inverse of a permutation

- `_invert(dom a)`

- This method computes a permutation `b` such that `a*b` is the identity mapping.
- This method overloads the function `_invert`.

#### Method func_call: function value of a permutation at a point

- `func_call(dom a, integer i)`

- This method overloads the round brackets `(...)`, i.e. it may be called in the form `a(i)`.
- It computes the function value of `a` at `i`, i.e., the integer that `i` is mapped to by the permutation `a`; `i` must be an integer between 1 and n.

#### Method cycles: cycle representation of a permutation

- `cycles(dom a)`

- This method computes a cycle representation of `a`. A cycle representation is a list `[orbit1, ..., orbitk]`; each of the orbits is a list of integers of the form `[i, a(i), a(a(i)), ...]` with just as many elements such that `i` does not occur in it for a second time; each integer between 1 and n appears in exactly one of the orbits.

#### Method order: order of a permutation

- `order(dom a)`

- The order of `a` is defined to be the least positive integer `k` for which ak is the identity.

#### Method inversions: number of inversions

- `inversions(dom a)`

- This method computes the number of all pairs i,j of integers for which i<j but a(i) > a(j).

#### Method sign: sign of a permutation

- `sign(dom a)`

- This method returns the sign of the permutation `a`. The sign of a permutation is defined to be 1 if its number of inversions is even, and -1 otherwise.

#### Method random: random permutation

- `random()`

- This method returns a random element of the permutation group.

#### Method allElements: return all elements of the group

- `allElements()`

- This method returns the list of the elements of the group.

#### Method size: return the size of the group

- `size()`

- This method returns the size of the group.

#### Method convert: conversion of an object into a permutation

- `convert(any x)`

- This method tries to convert `x` into a permutation. This is only possible if `x` is a list or an array in which each of the integers 1 through n occurs exactly once.

#### Method convert_to: conversion of a permutation into another type

- `convert_to(dom a, any T)`

- Tries to convert `a` into type `T`. Currently, only a conversion into a list of type `DOM_LIST` is possible.

#### Method expr: convert a permutation into a list

- `expr(dom a)`

- This method returns a list such that generating a permutation from that list would result in `a`.

#### Example 1

Consider the group of permutations of the first seven positive integers:

    >> G := Dom::SymmetricGroup(7)

                              Dom::SymmetricGroup(7)

We create an element of `G` by providing the image of 1, 2, etc.:

    >> a:=G([2,4,6,1,3,5,7])

                               [2, 4, 6, 1, 3, 5, 7]

    >> a(3)

                                         6

#### Super-Domain

`Dom::PermutationGroup`

#### Axioms

`Ax::canonicalRep`

[Previous] [Contents]

MuPAD Combinat, an open source algebraic combinatorics package