netket.symmetry.TranslationRepresentation

class netket.symmetry.TranslationRepresentation

Bases: LabeledRepresentation

A Representation for the translation group of a Lattice, with Bloch-momentum indexing.

Extends LabeledRepresentation with:

• k_points() — (n_irreps, n_active_axes) array of Bloch momenta.

• irrep_labels — "k=vπ" (1D) or "k=(v0π, v1π)" (nD) labels.

• projector() accepting a k= argument in addition to label= and the integer character_index.

The projection operator for a given k is built directly from momentum_irrep(), without consulting the character table.

K-vector convention

k is the Bloch momentum: k=π is the zone boundary, k=0 is Γ. Valid values are \(k = 2\pi m/L\) for \(m = 0, 1, \ldots, L-1\). Values lie in the half-open interval (-\pi, \pi].

Examples

lattice = nk.graph.Square(4, pbc=True)
hi = nk.hilbert.Spin(0.5, lattice.n_nodes)

rep = nk.symmetry.canonical_representation(hi, lattice.translation_group())

print(rep.irrep_labels)
# ['k=(0, 0)', 'k=(0.5π, 0)', 'k=(0, 0.5π)', ...]

proj_gamma = rep.projector(k=(0.0, 0.0))
proj_x     = rep.projector(k=(np.pi / 2, 0.0))
proj_label = rep.projector(label="k=(0.5π, 0)")
proj_index = rep.projector(0)              # backward compat

Inheritance

__init__(group, representation_dict)

Parameters:

• group – A TranslationGroup.

• representation_dict – Mapping from group elements to operators.

Attributes

active_axes

Indices of lattice axes with more than one translation step.

character

The vector storing the character of the representation.

Corresponds to [op.trace() for (_, op) in self].

Requires that each operator of the representation implements the trace method.

irrep_labels

"k=vπ" (1D) or "k=(v0π, v1π, ...)" (nD) labels for every irrep.

Zero components are formatted as "0" (no π suffix).

k_points

Bloch momenta for all irreps.

Returns an array of shape (n_irreps, n_active_axes).

Values are consistent with momentum_irrep(): the m-th irrep corresponds to k such that to_reciprocal_lattice(k) == m (integer).

For a strided group (strides > 1), the BZ boundary is at π / stride, not at π; this method accounts for that via the actual lattice dimensions.

representation_dict

Dictionary associating every group element to a representation

Equivalent to {el: rep for (el, rep) in (self.group.elems, self.operators)}

Methods

coset_filter(subgroup)

Build the coset Fourier filter for this group G modulo a subgroup H.

Returns a TranslationCosetFilter storing the len(G)/len(H) coset-representative operators.

The filter satisfies:

F_C(k) @ sub_rep.projector(k)  ==  full_rep.projector(k)

for any full-lattice momentum k.

Parameters:

subgroup (TranslationRepresentation) – TranslationRepresentation for H <= G. Must have strides that are component-wise multiples of self’s strides.

Return type:

TranslationCosetFilter

Returns:

TranslationCosetFilter with len(G)/len(H) coset operators.

Example — single level:

lattice = nk.graph.Chain(8, pbc=True)
hi      = nk.hilbert.Spin(0.5, 8)
T_full  = nk.symmetry.canonical_representation(hi, lattice.translation_group())
T_half  = nk.symmetry.canonical_representation(hi, lattice.translation_group(strides=2))

C = T_full.coset_filter(T_half)
# C has 2 coset representatives: {T^0, T^1}

# 2-term refinement filter (apply on top of a T_half-symmetrised state):
F = C.projector_refinement(k=np.pi/2)
# F_C @ T_half.projector(k=np.pi/2) == T_full.projector(k=np.pi/2)

irrep_subspace_dims()

Return the dimension of the subspace associated to each irreducible representation.

Requires that each operator of the representation implements the trace method.

Return type:

int

project(state, character_index=None, *, atol=1e-15, **kwargs)

Return the state projected onto the subspace associated to the irreducible representation specified by character_index.

Additional keyword arguments are forwarded to projector(), so subclasses that accept label=, k=, etc. can be used here too.

Return type:

MCState

Parameters:

atol (float)

projector(character_index=None, *, k=None, label=None, atol=1e-15)

Build the projection operator onto a momentum sector.

Exactly one of character_index, k, or label must be provided.

When k or label is given the projector is built directly from momentum_irrep(), bypassing the character table entirely. When only character_index is given it falls back to the character-table path of the base class.

Parameters:

• character_index – Integer index into the character table (0-based). Provided for backward compatibility with Representation.

• k – Bloch momentum as a scalar (1D) or sequence (nD), one component per active translation axis. k=0 is the Γ point, k=π is the zone boundary. Valid values are \(k = 2\pi m / L\) for integer \(m\).

• label – Irrep label string from irrep_labels, e.g. "k=0.5π" (1D) or "k=(0.5π, 0)" (2D).

• atol – Absolute tolerance for dropping near-zero projector terms.

Return type:

DiscreteJaxOperator

Returns:

A SumOperator representing the projection operator \(P_k = \frac{1}{|G|} \sum_g \chi_k(g)^* \, T_g\) onto the momentum-k sector.

Raises:

• TypeError – If not exactly one of the three selector arguments is given.

• InvalidWaveVectorError – If k is not a valid Brillouin-zone momentum for this lattice.

• ValueError – If label is not in irrep_labels.

symmetry_adapted_basis()

Return a tuple (mat, irrep_dims), where mat is the change of basis matrix associated to a symmetry adapted basis, and irrep_dims is an array giving the dimension of the subspace associated to each irreducible representation.

The basis vectors of mat are ordered by the index of their irreducible representation.

Return type:

tuple[ndarray, ndarray]