# Continuous groups¶

RepLAB provides constructions of standard continuous groups.

First, we consider torus-like groups.

Then, we have the classical compact groups.

• `ClassicalCompactGroup`: Class implementing all the groups below.

• `O`: Constructs the group of (real) orthogonal matrices of a given size.

• `SO`: Constructs the group of (real) special orthogonal matrices of a given size.

• `U`: Constructs the group of (complex) unitary matrices of a given size.

• `SU`: Constructs the group of (complex) special unitary matrices of a given size.

• `Sp`: Constructs the compact symplectic group of a given size, which encodes using complex numbers the generalization of the unitary group to quaternions.

## TorusGroup¶

class replab.TorusGroup(E, names)

Describes a compact, connected, abelian Lie group

Its elements are column vectors of angles expressed in turns (see https://en.wikipedia.org/wiki/Turn_(angle)), i.e. real numbers between 0 and 1, 1 not included. The group binary operation is addition modulo 1, the identity is the turn `0`, and the inverse operation maps any non-zero turn `x` to `1-x`.

When there are no additional restrictions on the elements of a given torus group, it is the standard torus group, and it can be constructed with the function `replab.T`.

Torus morphisms from integer matrices: https://math.stackexchange.com/questions/2229088/automorphisms-of-a-torus. Let `s = [s1;...;sn]` be the element of a (standard) torus of dimension `n` and `t = [t1;...;tm]` the element of a (standard) torus of dimension `m`. A torus morphism `f` is given by a `m x n` integer matrix `M`, with the image of `s` being written `t = f(s) = mod(M * s, 1)`.

Let the coefficients `[t1; t2; ...; tn]` be the coefficients of this column vector, where `n` is the torus group dimension. The coefficients may or may not obey equations of the form `mod(a1*t1 + a2*t2 + ... + an*tn, 1) == 0`, where the coefficients `a1 ... an` are integers. Those equations are collected as rows in the `E` integer matrix. Equivalently, the torus group obeying those relations is the kernel of the torus morphism encoded in `E`.

How do we deal with those equations? We use the Hermite normal form of the matrix `E` to extract a pair of morphisms from `T` (whose elements obey the equations) to a standard torus `S` (whose dimension is then the rank of `T`). The morphism `projection` from `T` to `S` is surjective, and the morphism `injection` from `S` to `T` is injective, and while `projection(injection(s)) = s`. Both morphisms are given by integer matrices.

The defining representation of this group (`definingRep`) is the `n x n` matrix with diagonal elements `u1``un`.

Automorphisms of a torus group are given by invertible square integer matrices `M` such that `E*M*injection = 0`.

The explicit group elements (for example, the value returned by `sample`) are written using the additive convention; while the equations are written multiplicatively in symbolic form.

### Own members

E

Equations obeyed by the elements of this torus

Type

integer(*,n)

injection

Injection map from maximal torus to this torus

Type

integer(n,r)

n

Torus dimension

Type

integer

names

Names of coefficients in the multiplicative convention

Type

cell(1,*) of charstring

projection

Projection map from this torus to a maximal torus

Type

integer(r,n)

r

Torus rank

Type

integer

TorusGroup(E, names)

Constructs a torus group obeying the given equations, with optional element names

Parameters
• E (`integer(*,n)`) – Integer matrix describing the equations; its number of columns provide the torus dimension

• names (`cell(1,n) of charstring, optional`) – Names of the group element coefficients in their unit complex form

automorphism(self, varargin)

Constructs an automorphism of this torus from an integer matrix describing a torus map

This function accepts a variable number of arguments. Each argument must be of the form:

Those arguments will be parsed and concatenated vertically to form an integer matrix describing the torus map. That matrix must be invertible.

Returns

The constructed automorphism

Return type

`Isomorphism`

definingRep(self)

Returns the defining representation of this torus group

The defining representation of a torus group of dimension `n` is a n-dimensional representation, whose images are diagonal in the standard Euclidean basis.

Returns

Representation

Return type

`Rep`

diagonalRep(self, torusMap)

Returns a diagonal representation of this torus group

Constructs a representation using a `torusMap`, whose images are diagonal matrices. The diagonal elements are monomials of the phases of the torus group. Each row of `torusMap` corresponds to a diagonal element, and the columns give the integer exponents corresponding to every phase.

Parameters

torusMap (`integer(d, n)`) – Phase exponents

Returns

Representation

Return type

`Rep`

diagonalRepWith(self, varargin)

Returns a diagonal rep of this torus group

endomorphism(self, varargin)

Constructs an endomorphism of this torus from an integer matrix describing a torus map

This function accepts a variable number of arguments. Each argument must be of the form:

Those arguments will be parsed and concatenated vertically to form an integer matrix describing the torus map.

Returns

The constructed endomorphism

Return type

`Morphism`

equation(self, i)

Returns the i-th equation defining this torus group in monomial form

Parameters

i (`integer`) – Equation index

Returns

Equation in monomial form (whose value must be equal to one)

Return type

charstring

equations(self)

Returns all equations that this torus group obeys in monomial form

Returns

Equations defining this torus group in monomial form

Return type

cell(1,*) of charstring

nEquations(self)

Returns the number of equations defining this torus group

Returns

Number of equations

Return type

integer

semidirectProductByFiniteGroup(self, group, varargin)

Returns the semidirect product of a finite group and this torus, with the finite group action defined by images

Parameters
• group (`FiniteGroup`) – Finite group acting on this torus group

• preimages – Preimages of the morphism which generate `group`, defaults to `group.generators`

• images – Action on the torus for the given preimages, defaults to a permutation action if `group` is a permutation group

Kwtype preimages

cell(1, *) of `group` elements

Kwtype images

cell(1, *) of `target` elements

Returns

Semidirect product of `group` and this torus group

Return type

`SemidirectProductGroup`

semidirectProductFromRep(self, rep)

Returns the semidirect product of a finite group on the torus elements using one of its integer representations

Invertible integer matrices represent automorphisms of a torus group of the same dimension; thus, given a group `G`, a representation of `G` with integer images defines a morphism from `G` to the automorphism group of a torus `T`.

One can then use this morphism to construct an outer semidirect product of `G` acting on `T`.

Parameters

rep (`Rep`) – Group representation with integer coefficients

Returns

Semidirect product of `rep.group` and this torus group

Return type

`SemidirectProductGroup`

subgroup(self, newE)

Returns a subgroup of this torus that obeys the equations given in integer matrix form

Parameters

E (`integer(*, n)`) – New equations

Returns

Torus group satisfying the equations of this group and the additional ones given

Return type

`TorusGroup`

subgroupWith(self, varargin)

Returns a subgroup of this torus that obeys the equations given in monomial form

This function accepts a variable number of arguments. Each argument must be of the form:

• An integer matrix with `n` columns, defining equations as in the call to `subgroup`,

• A charstring containing an equation in monomial form. If the equation has no right-hand side, the right-hand side is assumed to be the identity.

Returns

Torus group satisfying the equations of this group and the additional ones given

Return type

`TorusGroup`

torusMorphism(self, target, varargin)

Constructs a morphism from this torus group to another torus group from an integer matrix

After the `target` argument, this function accepts a variable number of arguments. Each of these arguments must be of the form:

Parameters

target (`TorusGroup`) – Torus group target of the morphism

Returns

A morphism from this torus group to a torus group of dimension `n1`

Return type

`Morphism`

static torusRepImage(t)

Returns the sparse diagonal matrix corresponding to the given torus element

Equivalent to `torusGroup.definingRep.image(t)`, without constructing additional objects.

Parameters

t (`double(n,1)`) – Torus group element

Returns

Diagonal matrix corresponding to the torus element

Return type

double(n,n), sparse

static torusRepRealImage(t)

Returns the sparse block-diagonal matrix corresponding to the given torus element

The element `t(i)` will correspond to a 2x2 block: `[c s; -s c]` where `c = cos(2*pi*t(i))` and `s = sin(2*pi*t(i))`.

Parameters

t (`double(n,1)`) – Torus group element

Returns

Block diagonal matrix of 2x2 real matrices

Return type

double(2*n,2*n)

withNames(self, newNames)

Returns a copy of this torus group with the names of the unit complex coefficients replaced

Parameters

newNames (`cell(1,n) of charstring`) – New names of the complex coefficients

Returns

Updated group

Return type

`TorusGroup`

## T¶

replab.T(n)

Returns the standard torus group of given rank

Parameters

n (`integer`) – Torus group rank

Returns

Standard torus group

Return type

`replab.TorusGroup`

## ClassicalCompactGroup¶

class replab.ClassicalCompactGroup(n, algebra, isSpecial)

Describes a classical compact group of square real/complex/quaternionic matrices

Group elements are matrices whose coefficients are encoded using double floating-point arithmetic. Of course, they will only be approximately orthogonal and thus do not represent directly a group element.

Instead, we postulate that the matrix encodes the nearest group element in Frobenius norm. For non-special groups, this element can be found as `U = X*sqrtm(X'*X)` where `X` is the approximate element.

While inverses should be exact (we take the conjugate transpose), the composition is only approximate. Thus, to be able to check the usual group laws, we compare group elements up to a certain tolerance, defined in `replab.globals.matrixGroupTol`.

### Own members

algebra

Unital associative algebra over which the group is defined

Type

‘R’, ‘C’ or ‘H’

isSpecial

Whether the matrices should have determinant one; must be false when algebra = ‘H’

Type

logical

n

Dimension of the matrices

Type

integer

ClassicalCompactGroup(n, algebra, isSpecial)

Constructs a classical compact group

Parameters
• n (`integer`) – Size of the `n x n` matrices

• algebra (`'R', 'C' or 'H'`) – Unital associatvie algebra over which the group is defined

• isSpecial (`logical`) – Whether the matrices should have `det(X) == 1`

definingRep(self, field)

Returns the defining representation of this unitary group

“Defining representation” is a loosely defined term designing the smallest faithful representation of a group. In our case, the defining representation of `O(n)` or `SO(n)` is a n-dimensional real representation, the defining representation of `U(n)` or `SU(n)` is a n-dimension complex representation, while the defining representation of `Sp(n)` is a 2n-dimension complex representation.

All these representations are unitary. By specifying the field, one can encode the representation in a different field: if the natural field is real (`O(n)`, `SO(n)`), the representation can be complexified into a representation of the same dimension. If the natural field is complex (`U(n)`, `SU(n)`, `Sp(n)`), the complex representation can be encoded into a real representation, doubling its dimension.

Parameters

field (`'R', 'C', optional`) – Field over which to define the matrices, default: group dependent, see above

Returns

Defining representation

Return type

`Rep`

## O¶

replab.O(d)

Returns the group of d x d orthonormal matrices

## SO¶

replab.SO(d)

Returns the group of d x d orthonormal matrices with determinant one

## U¶

replab.U(d)

Returns the group of d x d unitary complex matrices

## SU¶

replab.SU(d)

Returns the group of d x d unitary complex matrices with determinant one

## Sp¶

replab.Sp(d)

Returns the compact symplectic group whose elements are unitary quaternion matrices