netket.utils.group.PermutationGroup#

class netket.utils.group.PermutationGroup[source]#

Bases: netket.utils.group._group.FiniteGroup

Collection of permutation operations acting on sequences of length degree.

Group elements need not all be of type netket.utils.group.Permutation, only act as such on a sequence when called.

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

Inheritance
Inheritance diagram of netket.utils.group.PermutationGroup
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 self.conjugacy_classes.

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

Return type

Union[ndarray, DeviceArray, Tracer]

conjugacy_classes#

The conjugacy classes of the group.

Return type

Tuple[Union[ndarray, DeviceArray, Tracer], Union[ndarray, DeviceArray, Tracer], Union[ndarray, DeviceArray, Tracer]]

Returns

The three arrays

  • classes: a boolean array, each row indicating the elements that belong to one conjugacy class

  • representatives: the lowest-indexed member of each conjugacy class

  • inverse: the conjugacy class index of every group element

conjugacy_table#

The conjugacy table of this Permutation 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\).

Return type

Union[ndarray, DeviceArray, Tracer]

inverse#
Return type

Union[ndarray, DeviceArray, Tracer]

product_table#
Return type

Union[ndarray, DeviceArray, Tracer]

shape#

Tuple (<# of group elements>, <degree>).

Equivalent to self.to_array().shape.

Return type

Sequence[int]

degree: int#

Number of elements the permutations act on.

elems: List[Element]#
Methods
__call__(initial)#

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

character_table()#

Calculates the character table using Burnside’s algorithm.

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

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

Return type

Union[ndarray, DeviceArray, Tracer]

character_table_readable()#

Returns a conventional rendering of the character table.

Return type

Tuple[List[str], Union[ndarray, DeviceArray, Tracer]]

Returns

A tuple containing a list of strings and an array

  • classes: a text description of a representative of each conjugacy class as a list

  • characters: a matrix, each row of which lists the characters of one irrep

irrep_matrices()#

Returns matrices that realise all irreps of the group.

Return type

List[Union[ndarray, DeviceArray, Tracer]]

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].

remove_duplicates(*, return_inverse=False)[source]#

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

Parameters

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

Return type

PermutationGroup

Returns

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

replace(**updates)#

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

to_array()[source]#

Convert the abstract group operations to an array of permutation indices.

It returns a matrix where the i-th row contains the indices corresponding to the i-th group element. That is, self.to_array()[i, j] is \(g_i^{-1}(j)\). Moreover,

G = # this permutation group...
V = np.arange(G.degree)
assert np.all(G(V) == V[..., G.to_array()])
Return type

Union[ndarray, DeviceArray, Tracer]

Returns

A matrix that can be used to index arrays in the computational basis in order to obtain their permutations.