netket.symmetry.group.PointGroup

class netket.symmetry.group.PointGroup

Bases: FiniteGroup

Collection of point group symmetries acting on n-dimensional vectors.

Group elements need not all be of type netket.utils.group.PGSymmetry, only act on such vectors when called. Currently, however, only Identity and PGSymmetry have canonical forms implemented.

The class can contain elements that are distinct as objects (e.g., Identity() and Rotation(0)) but have identical action. Those can be removed by calling remove_duplicates.

Inheritance

Attributes

character_table_by_class

Calculates the character table using Burnside’s algorithm.

Each row of the output lists the characters of one irrep in the order the conjugacy classes are listed in conjugacy_classes.

Assumes that Identity() == self[0], if not, the sign of some characters may be flipped. The irreps are sorted by dimension.

conjugacy_classes

The conjugacy classes of the group.

Returns:

A tuple (classes, representatives, inverse) where classes is a boolean array whose rows indicate the elements belonging to each conjugacy class, representatives contains the lowest-indexed member of each conjugacy class, and inverse stores the conjugacy-class index of every group element.

conjugacy_table

The conjugacy table of the group.

Assuming the definitions

g = self[idx_g]
h = self[idx_h]

self[self.conjugacy_table[idx_g,idx_h]] corresponds to \(h^{-1}gh\).

inverse

Indices of the inverse of each element.

Assuming the definitions

g = self[idx_g]
h = self[self.inverse[idx_g]]

gh = product(g, h) is equivalent to Identity()

is_symmorphic

True if the point group is symmorphic, i.e., if every group element leaves the origin invariant.

product_table

A table of indices corresponding to \(g^{-1} h\) over the group.

Assuming the definitions

g = self[idx_g]
h = self[idx_h]
idx_u = self.product_table[idx_g, idx_h]

self[idx_u] corresponds to \(u = g^{-1} h\) .

shape

Tuple (<# of group elements>, <ndim>, <ndim>). Equivalent to self.to_array().shape.

unit_cell: ndarray | Array | None = None

Lattice vectors of the unit cell on which the point group acts. It is used to match non-symmorphic symmetries modulo lattice translations.

ndim: int

Dimension of the Euclidean space the point group acts on.

elems: list[Element]

List of group elements.

Methods

__call__(initial)

Apply all group elements to all entries of initial along the last axis.

affine_matrix(x)

Return type:

Union[ndarray, Array]

Parameters:

x (Element)

change_origin(origin)

Returns a new PointGroup, out, such that all elements of out describe pure point-group transformations around origin and out[i] has the same transformation matrix as self[i].

Return type:

PointGroup

Parameters:

origin (ndarray | Array)

character_table(multiplier=None)

Calculates the character table using Burnside’s algorithm.

Parameters:

multiplier (Union[ndarray, Array, None]) – (optional) Schur multiplier

Return type:

ndarray

Returns:

a matrix of all linear irrep characters (if multiplier is None) or projective irrep characters with the given multiplier, sorted by dimension.

Each row of lists the characters of all group elements for one irrep, i.e. self.character_table()[i,g] gives \(\chi_i(g)\).

It is assumed that Identity() == self[0]. If not, the sign of some characters may be flipped and the sorting by dimension will be wrong.

character_table_readable(multiplier=None, full=False)

Returns a conventional rendering of the character table.

Parameters:

• multiplier (Union[ndarray, Array, None]) – (optional) Schur multiplier

• full (bool) – whether the character table for all group elements (True) or one representative per conjugacy class (False, default)

Return type:

tuple[list[str], Union[ndarray, Array]]

Returns:

A tuple (classes, characters) where classes is a list of string labels for each conjugacy-class representative (or for each group element when full=True), and characters is a matrix whose rows list the characters of one irrep.

check_multiplier(multiplier, rtol=1e-08, atol=0)

Checks the associativity constraint of Schur multipliers.

\[\alpha(x, y) \alpha(xy, z) = \alpha(x, yz) \alpha(y, z).\]

Parameters:

• multiplier (Union[ndarray, Array]) – the array of Schur multipliers \(\alpha(x,y)\)

• rtol – relative tolerance

• atol – absolute tolerance

Return type:

bool

Returns:

whether multiplier is a valid Schur multiplier up to the given tolerance

Raises:

ValueError – if the shape of multiplier does not match the size of the group

irrep_matrices()

Returns matrices that realise all irreps of the group.

Return type:

list[Union[ndarray, Array]]

Returns:

A list of 3D arrays such that self.irrep_matrices()[i][g] contains the representation of self[g] consistent with the characters in self.character_table()[i].

is_subgroup(other, *, proper=False)

Return True if other is a subgroup of self.

Checks Lagrange’s theorem (|self| divisible by |other|) and that every element of other is present in self.

Parameters:

• other (FiniteGroup) – the candidate subgroup.

• proper (bool) – if True, also require |other| < |self| (i.e. other != self).

Return type:

bool

Returns:

True if every element of other belongs to self (and other is strictly smaller if proper=True).

matrices()

Return type:

Union[ndarray, Array]

matrix(x)

Return type:

Union[ndarray, Array]

Parameters:

x (Element)

projective_characters_by_class(multiplier)

Calculates the character table of projective representations with a given Schur multiplier α using a modified Burnside algorithm.

Parameters:

multiplier (Union[ndarray, Array, None]) – the unitary Schur multiplier. If unspecified, computes linear representation characters.

Return type:

tuple[ndarray, ndarray]

Returns:

If multiplier is None, returns characters_by_class, a 2D array whose rows contain the characters of one linear irrep evaluated on a representative of each conjugacy class. Otherwise it returns a tuple (characters_by_class, class_factors), where class_factors is a 1D array listing the per-element factors needed to recover the character of each element from the character of its class representative.

Note: the algorithm and the definitions above are explained in more detail in https://arxiv.org/abs/2505.14790.

remove_duplicates(*, return_inverse=False)

Returns a new PointGroup with duplicate elements (that is, elements which represent identical transformations) removed.

Parameters:

return_inverse – If True, also return indices to reconstruct the original group from the result.

Returns:

The point group with duplicate elements removed. If return_inverse==True, then it also returns the list of indices needed to reconstruct the original group from the result.

replace(**updates)

Returns a new object replacing the specified fields with new values.

rotation_group()

Returns a new PointGroup that represents the subgroup of rotations (i.e. symmetries where the determinant of the transformation matrix is +1) in self

Return type:

PointGroup

to_array()

Convert the abstract group operations to an array of transformation matrices

For symmorphic groups, self.to_array()[i] contains the transformation matrix of the i`th group element. For nonsymmorphic groups, `self.to_array()[i] is a (d+1)×(d+1) block matrix of the form [[W,w],[0,1]]: multiplying these matrices is equivalent to multiplying the symmetry operations.

Return type:

Union[ndarray, Array]

translation(x)

Return type:

Union[ndarray, Array]

Parameters:

x (Element)

translations()

Return type:

Union[ndarray, Array]