# Abstract groups and atlas¶

Abstract groups are defined using a presentation, without direct reference to a concrete realization. They are thus used when user-defined groups are recognized.

• `AbstractGroup` is a finite group whose elements are written as words composed of products of generators.

• `Atlas` is the infrastructure that recognizes groups. In particular, it is used to tip the user of the type of the group they just constructed. It is also used in exact decompositions, to retrieve the character table of a particular finite group.

• `AtlasEntry` contains a sketch of the structure of a finite group known by RepLAB. It is used to speed up the recognition process.

## AbstractGroup¶

class replab.AbstractGroup(generatorNames, relators, varargin)

Bases: `replab.gen.FiniteGroup`

Finite group defined using a presentation: a set of generators and a set of relations among generators

The name of generator always start with a letter (a-z or A-Z), and then contain either letters (a-z or A-Z), digits (0-9) or underscores. Words in the generators are strings (charstring) containing generators separated by spaces, that sequence being understood as a product of generators.

In a word, generators can be taken to an integer power, using the syntax `x^n` where `x` is the name of a generator and `n` is an integer. In the word syntax, we optionally accept explicit multiplication operators (`*`), division operators (then `x/y` is understood as `x y^-1`), parenthesis, and commutators `[x, y] = x^-1 y^-1 x y`.

The abstract group is defined by a set of relations, that define equivalence relations between words. For example, a cyclic group is defined by the generator `x` and the relation `x^n = 1` where `n` is the order of the group. Then we deduce the relations `x^(n+m) = x^m` and that `x^-m = x^(n-m)` for any integer `m`.

Informally, the abstract group is the “largest” group with the sets of generators subject to these relations. Note that RepLAB rewrites all relations as `lhs = 1`, and those left hand sides are named “relators”.

See https://en.wikipedia.org/wiki/Presentation_of_a_group for a detailed discussion.

Internally, RepLAB computes a realization of the abstract group as a permutation group, and delegates the computations to that permutation group.

Example

```>>> [G, x] = replab.AbstractGroup.fromPresentation('< x | x^3 = 1 >');
>>> x
'x'
>>> G.compose(x, x)
'x^2'
>>> G.order
3
```

Example

```>>> G = replab.AbstractGroup({'x'}, {'x^3'});
>>> G.order
3
```

Abstract groups can also be created by isomorphisms from an explicit group.

Example

```>>> S3 = replab.S(3);
>>> G = S3.withGeneratorNames({'s', 't'});
>>> f = G.abstractIsomorphism;
>>> f.imageElement([2 3 1])
's'
```

### Own members

inAtlas

Whether this group is already part of the atlas

Type

logical

name

Group name

Type

charstring

AbstractGroup(generatorNames, relators, varargin)

Creates an abstract group from generator names and relators

Parameters
• generatorNames (`cell(1,*) of charstring`) – Generator names

• relators (`cell(1,*) of charstring, optional`) – Relators

• name – Group name, optional

• order – Group order

• permutationGenerators – Realization of the generators using permutations

• inAtlas – Whether this group is part of the atlas

Kwtype name

charstring, optional

Kwtype order

integer, optional

Kwtype permutationGenerators

cell(1,*) of permutation

Kwtype inAtlas

logical, optional

static fromPresentation(str, varargin)

Creates an abstract group from a presentation string

Returns the finite group generators as additional output arguments.

Additional arguments are passed to the `AbstractGroup` constructor.

Example

```>>> [G, x] = replab.AbstractGroup.fromPresentation('< x | x^3 = 1 >');
>>> [G, x, y] = replab.AbstractGroup.fromPresentation('< x, y | x^3 = y^2 = x y x y^-1 = 1 >');
```
Parameters

str (`charstring`) – Single-line description string

Returns

The parsed abstract group

Return type

`AbstractGroup`

simplify(self, word)

Attempts to simplify the given word

Parameters

word (`charstring`) – Word to simplify

Returns

Simplified word

Return type

charstring

## Atlas¶

class replab.Atlas

An atlas of finite groups

### Own members

Computes the irreps of the given group and write the corresponding JSON file to the atlas

If the group is already recognized by RepLAB, an error is thrown.

Note that the `FiniteGroup.recognize` result is cached, so to be recognized, the given group `G` must be constructed again in user code for the new atlas entry to be found.

Parameters

G (`FiniteGroup`) – Finite group not present in the atlas

static recognize(group)

Attempts to identify the given group

Returns

A result in case of positive identification; or `[]` if unrecognized.

Return type

## AtlasEntry¶

class replab.AtlasEntry(filename, md5, order, derivedSeriesAbelianInvariants, varargin)

Bases: `replab.Obj`

Describes an Atlas entry available in the replab/atlas directory

Note: the JSON file must contain only ASCII characters; check if our parser `replab.util.parseJSON` supports escape sequences.

### Own members

derivedSeriesAbelianInvariants

Abelian invariants of the group derived series

Type

cell(1,*) of integer(1,*)

filename

Filename, excluding path, including `.json` extension

Type

charstring

md5

MD5 hash in hexadecimal notation, without spaces and letters uppercase

Type

charstring

order

Group order

Type

vpi

canMatch(self, group)

Returns whether this atlas entry can match the given group

data(self)

Returns the parsed data

Returns

Parsed JSON data

Return type

struct or cell array

static fromFile(filename)

Constructs an `AtlasEntry` from a JSON file

This method parses the JSON enough to read the group order and the abelian invariants. The group itself is constructed lazily when requested.

Parameters

filename (`charstring`) – Filename, excluding path but including the `.json` extension

Returns

The parsed atlas entry

Return type

`AtlasEntry`

group(self)

Returns the group corresponding to this atlas entry

Returns

Group

Return type

`AbstractGroup`

static groupFromJSONData(data)

Computes the group stored in this entry from the known JSON data

json(self)

Returns the JSON data as text

Returns

Data

Return type

charstring

match(self, group)

Attemps to match the given group to this group

Returns, if it exists, the isomorphism from the stored atlas group to the given group

Returns

The isomorphism if it exists or `[]`

Return type

`FiniteIsomorphism` or `[]`