Group product constructions

Product constructions enable the user to construct new groups from the groups provided in RepLAB. The product constructions below also provide ways to construct standard representations that arise from representations of the factor groups.

  • DirectProductGroup represents the (outer) direct product of compact groups, the elements are represented by row cell arrays.

  • SemidirectProductGroup represents an outer semidirect product arising from the action of a group on another.

  • WreathProductGroup describes the wreath product of a compact group by a permutation group.

DirectProductGroup

class replab.DirectProductGroup

Bases: replab.CompactGroup

Describes an external direct product of compact groups

This is an abstract base class. Use DirectProductGroup.make or CompactGroup.directProduct to construct an instance.

Constructors are defined in subclasses, as for other group products.

Own members

factors

Factor groups

Type

cell(1,*) of subclass of CompactGroup

commutingFactorMorphismsMorphism(self, target, factorMorphisms)

Constructs a morphism from morphisms of the factors with commuting images

Parameters
  • target (CompactGroup) – Target group

  • factorMorphisms (cell(1,*) of Morphism) – Morphisms for each of the factor groups

Returns

The computed morphism

Return type

Morphism

commutingFactorMorphismsMorphismFun(self, target, fun)

Constructs a morphism from morphisms of the factors with commuting images (function version)

Parameters
  • target (CompactGroup) – Target group

  • fun (function_handle) – A function valid for each factor group that maps the group and its index to one of its morphisms

Returns

The computed morphism

Return type

Morphism

commutingFactorRepsRep(self, field, dimension, factorReps)

Constructs a representation from commuting representations of the factors

Parameters
  • field ({'R', 'C'}) – Field

  • dimension (integer) – Dimension of the representation

  • factorReps (cell(1,*) of Rep) – Representations for each of the factor groups (factorReps{i} is a representation of factor(i))

Returns

A representation computed from the product of representations

Return type

replab.Rep

commutingFactorRepsRepFun(self, field, dimension, fun)

Constructs a representation from commuting representations of the factors (function version)

Parameters
  • field ({'R', 'C'}) – Field

  • dimension (integer) – Dimension of the representation

  • fun (function_handle) – A function valid for each factor group that maps the group and its index to one of its representations

Returns

A representation computed from the product of representations

Return type

replab.Rep

directSumFactorRep(self, field, factorReps)

Constructs a direct sum representation

Parameters
  • field ({'R', 'C'}) – Field

  • factorReps (cell(1,*) of Rep) – Representations for each of the factor groups (factorReps{i} is a representation of factor(i))

Returns

A direct sum representation

Return type

replab.Rep

directSumFactorRepFun(self, field, fun)

Constructs a direct sum representation from a function that maps factors to representations

Parameters
  • field ({'R', 'C'}) – Field

  • fun (function_handle) – A function valid for each factor group that maps the group and its index to one of its representations

Returns

A direct sum representation

Return type

replab.Rep

factor(self, i)

Returns a factor in this direct product

Parameters

i (integer) – Factor idnex

Returns

The i-th factor

Return type

Group

injection(self, i)

Returns the morphism embedding the i-th factor into the direct product

Example

>>> S2 = replab.S(2);
>>> D = S2.directProduct(S2);
>>> m = D.injection(1);
>>> D.eqv({[2 1] [1 2]}, m.imageElement([2 1]))
    1
Parameters

i (integer) – Factor index

Returns

The injection morphism

Return type

Morphism

nFactors(self)

Returns the number of factors in this direct product

Returns

Number of factors

Return type

integer

projection(self, i)

Returns the morphism projecting this group into its i-th factor

Example

>>> S2 = replab.S(2);
>>> D = S2.directProduct(S2);
>>> m = D.projection(1);
>>> S2.eqv([2 1], m.imageElement({[2 1] [1 2]}))
    1
Parameters

i (integer) – Factor index

Returns

The projection

Return type

Morphism

tensorFactorRep(self, field, factorReps)

Constructs a tensor product representation

Parameters
  • field ({'R', 'C'}) – Field

  • factorReps (cell(1,*) of Rep)) – Representations for each of the factor groups (factorReps{i} is a representation of factor(i))

Returns

A tensor representation

Return type

replab.Rep

tensorFactorRepFun(self, field, fun)

Constructs a direct sum representation from a function that maps factors to representations

Parameters
  • field ({'R', 'C'}) – Field

  • fun (function_handle) – A function valid for each factor group that maps the group and its index to one of its representations

Returns

A tensor representation

Return type

replab.Rep

SemidirectProductGroup

class replab.SemidirectProductGroup

Bases: replab.Group

Semidirect product of compact groups through the external/outer construction

This is an abstract base class. Call CompactGroup.semidirectProduct or make to construct an instance.

Construction and multiplication rule

An outer semidirect product constructs a group from two given groups, with its set of elements being the Cartesian product of those two groups, and the multiplication operation given by the action of one group on the other.

Formally, we have two groups, \(H\) and \(N\), with \(H\) acting on \(N\) in the following way. We have a group action \(\phi: H \times N \rightarrow N\), obeying the following:

  • \(\phi(h_1, \phi(h_2, n)) = \phi(h_1 h_2, n)\)

  • \(\phi(h, n_1) \phi(h, n_2) = \phi(h, n_1 n_2)\)

for \(h,h_1,h_2 \in H\) and \(n,n_1,n_2 \in N\).

Equivalently, this action corresponds to a group morphism \(\phi: H \rightarrow (N \rightarrow N)\) or \(\phi: H \rightarrow \operatorname{Aut}(N)\) from \(H\) into the automorphism group of \(N\).

We now construct the semidirect product \(G = H \ltimes N\). An element of the product is written \(G = (h, n)\), where \(h \in H\) and \(n \in N\).

Note that compared to other references such as Wikipedia ( https://en.wikipedia.org/wiki/Semidirect_product ), we write the element of the acting group \(H\) first, and this changes the rule for multiplying group elements.

The multiplication rule of the group is \((h_1, n_1) \cdot (h_2, n_2) = (h_1 h_2, \phi(h_2^{-1}, n_1) n_2)\). The inverse of \((h, n)\) is given by \((h^{-1}, \phi(h, n))\).

How do we interpret this multiplication rule? First, we want to interpret the elements of \(H\) and \(N\) as “being part” of \(G\).

We can embed elements of \(H\) into \(G\) by writing the injection \(f(h) = (h, 1_N)\) where \(1_N\) is the identity of \(N\). We can embed elements of \(N\) into \(G\) by writing the injection \(g(n) = (1_H, n)\) where \(1_H\) is the identity of \(H\).

Both \(f\) and \(g\) are morphisms: \(f(h_1) f(h_2) = f(h_1 h_2)\) and \(g(n_1) g(n_2) = g(n_1 n_2)\).

Those those injections are available using the methods Hinjection and Ninjection.

Noting that \((h,n) = f(h) g(n)\), we write:

\((h_1,n_1) (h_2,n_2) = f(h_1) g(n_1) f(h_2) g(n_2) = h_1 n_1 h_2 n_2\), with the \(f()\) and \(g()\) injections implicit.

If we could swap \(n_1\) and \(h_2\), as is the case with a direct product, we could rewrite the product as a pair of elements of \(H\) and \(N\) respectively. Now, we write \(h_1 n_1 h_2 n_2 = h_1 h_2 h_2^{-1} n_1 h_2 n_2\), and we define \(h_2^{-1} n_1 h_2 = \phi(h_2^{-1}, n_1)\).

Thus, \(h_1 n_1 h_2 n_2 = (h_1 h_2) (\phi(h_2^{-1}, n_1) n_2) = (h_1 h_2, \phi(h_2^{-1}, n_1) n_2)\).

Thus, we interpret that group action \(\phi\) as defining the conjugation of elements of \(N\) by elements of \(H\).

Representations

Representations of semidirect products can be constructed using the semidirectProductRep method, given compatible representations of the groups \(H\) and \(N\).

Implementation note

As semidirect product groups are used as a base for wreath product groups, the constructors are duplicated in subclasses as to keep a simple hierarchy of constructor calls.

Example

>>> N = replab.S(3);
>>> H = replab.PermutationGroup.cyclic(3);
>>> A = N.innerAutomorphism([2 3 1]);
>>> phi = H.morphismByImages(replab.AutomorphismGroup(N), 'images', {A});
>>> sd = H.semidirectProduct(N, @(h, n) phi.imageElement(h).imageElement(n));
>>> sd.laws.checkSilent
    1

Own members

H

Group acting

Type

replab.CompactGroup

N

Group acted upon

Type

replab.CompactGroup

phi

Action of H on N

Type

replab.Action

Hinjection(self)

Returns the morphism that expresses elements of H in the semidirect product

Returns

The morphism from H to this semidirect product group

Return type

Morphism

Hprojection(self)

Returns the morphism that projects elements of the semidirect product into H

Note that for a semidirect product G, the morphism G.Hinjection.andThen(G.Hprojection is the identity.

Returns

The morphism from the semidirect product to H

Return type

Morphism

Ninjection(self)

Returns the morphism that expresses elements of N in the semidirect product

Returns

The morphism from N to this semidirect product group

Return type

Morphism

static make(phi)

Constructs a semidirect product group from an action

Parameters

phi (replab.Action) – Action of a compact group on another compact group

Returns

A specialized instance of SemidirectProductGroup

Return type

SemidirectProductGroup

semidirectProductRep(self, Hrep, Nrep)

Constructs a representation by a product of representations of the two groups in the semidirect product construction

Those representations Hrep and Nrep must obey the following law.

Let phi be the semidirect product group uncurried homomorphism with h \in H and n \in N:

Nrep.image(phi(h, n)) == Hrep.image(h) * Nrep.image(n) * Hrep.inverseImage(h).

Parameters
  • Hrep (Rep) – Representation of H

  • Nrep (Rep) – Representation of N

Returns

Group representation

Return type

Rep

WreathProductGroup

class replab.WreathProductGroup

Bases: replab.SemidirectProductGroup

Wreath product group

This group contains:

  • a permutation group H acting on \(n\) elements,

  • \(n\) copies of a compact group A (the base group), collected in the direct product group H,

and those two groups are related through a semidirect product construction (see SemidirectProductGroup), where the permutation group acts on H by permuting the copies of A.

Note that compared to Wikipedia https://en.wikipedia.org/wiki/Wreath_product we write the elements of this wreath product as a tuple \((h, n)\) where the element \(h \in H\) is written first, followed by \(n = (a_1, ..., a_n)\) with \(n \in N\) and \(a_i \in A\).

The permutation group \(H\) acts on \(N\) as follows. Let \(h \in H\) be a permutation and \(n = (a_1, ..., a_n)\), and \(h(n)\) the result of the action of \(h\) on \(n\). Then \(h(n)_{h(i)} = a_i\), so that \(h(n)_i = a_{h^{-1}(i)}\).

According to the literature (see also Wikipedia above), a wreath product defines two canonical actions, the imprimitive wreath product action and the primitive wreath product action.

Correspondingly, given a representation of the base group A, we provide methods to construct “imprimitive” and “primitive$ representations of this wreath product group using imprimitiveRep and primitiveRep.

Own members

A

Base factor group

Type

CompactGroup

n

Number of copies of the base group

Type

integer

imprimitivePermutation(self, w, phiA)

Returns the permutation corresponding to the canonical imprimitive action

See https://en.wikipedia.org/wiki/Wreath_product

Parameters
  • w (element) – Wreath product group element to compute the image of

  • phi (function_handle, optional) – Morphism from elements of A to permutations If omitted default to identity, valid only when A is a permutation group

Returns

The permutation corresponding to the imprimitive action of w

Return type

permutation

imprimitiveRep(self, factorRep)

Returns an imprimitive representation of this wreath product

It acts on a space of dimension self.n * factorRep.dimension, which is a direct sum of copies of factorRep. The permutation group acts by permuting the blocks.

Parameters

factorRep (Rep) – A representation of the base factor group A

Returns

The corresponding imprimitive representation

Return type

Rep

imprimitiveRepFun(self, fun)

Returns an imprimitive representation of this wreath product

See imprimitiveRep.

Parameters

fun (function_handle) – A function that returns a representation of A when called on A as in Arep = fun(self.A)

Returns

The corresponding imprimitive representation

Return type

Rep

static make(H, A)

Constructs a wreath product group

Parameters
  • H (PermutationGroup) – Complement group that permutes the factors

  • A (CompactGroup) – Base factor group of which the direct product composes the base

Returns

A specialized instance of WreathProductGroup

Return type

WreathProductGroup

primitivePermutation(self, w, phiA)

Returns the permutation corresponding to the canonical primitive action

See https://en.wikipedia.org/wiki/Wreath_product

Parameters
  • w (element) – Wreath product group element to compute the image of

  • phi (function_handle, optional) – Morphism from elements of A to permutations If omitted default to identity, valid only when A is a permutation group

Returns

The permutation corresponding to the primitive action of w

Return type

permutation

primitiveRep(self, factorRep)

Returns a primitive representation of this wreath product

It acts on a space of dimension factorRep.dimension^self.n, which is a tensor product of copies of factorRep. The permutation group acts by permuting tensor indices.

Parameters

factorRep (Rep) – A representation of the base factor group A

Returns

The corresponding primitive representation

Return type

Rep

primitiveRepFun(self, fun)

Returns an primitive representation of this wreath product

See primitiveRep

Parameters

fun (function_handle) – A function that returns a representation of A when called on A as in Arep = fun(self.A)

Returns

The corresponding primitive representation

Return type

Rep