SU2 Singlets

class ed_lgt.operators.SU2_singlets.SU2_singlet(J_config, M_configs, CG_values, pure_theory=True, psi_vacuum=None)

Bases: object

This class collects a configuration of a set of angular momenta Js (and their corresponding Z-momentum) that form an SU(2) singlet state with a certain Clebsh-Gordon coeffiicient. The set of momenta is typically referred to SU(2) gauge fields, but it can eventually include a matter state (in first position) describing Flavorless Color 1/2 Dirac fermions with 4 possible states:

• (J,M)=(0,0)

• (J,M)=(1/2,1/2)

• (J,M)=(1/2,-1/2)

• (J,M)=(1/2,0)

Parameters:

• J_config (list) – list of Total angular momentum J of a set of particles/entities

• M_configs (list) – list of possible sets of angular z-momentum (each set has the same length of J_config) of the J_config that allows for a singlet.

• CG_values (list) – list of intermediate Clebsh-Gordon coefficients, to be multiplied together for the overall CG coefficient of the J configuration.

• pure_theory (bool, optional) – If False, the theory also involves Flavorless Color 1/2 Dirac fermions. Defaults to True.

• psi_vacuum (bool, optional) – If it used, it specifies which type of 0 singlet the matter state is corresponding to. Defaults to None.

Raises:

• TypeError – If the input arguments are of incorrect types or formats.

• ValueError – If M_configs and CG_values do not have the same # of entries

• ValueError – If any of M config is NOT made of len(J_config)

• ValueError – If any entry of M_config does not have len(J_config)-1 CGs,

display_singlets()

Print the list of singlets (s1 … sN) in the following way:

Js J1, J2, J3, … JN

s1 [ m1, m2, m3, … mN] CG1

s2 [ m1, m2, m3, … mN] CG2

s3 [ m1, m2, m3, … mN] CG3

ed_lgt.operators.SU2_singlets.SU2_singlet_canonical_vector(spin_list, singlet)

Constructs the canonical state vector representing a specific SU2 singlet configuration within the total Hilbert space formed by the tensor product of individual spin Hilbert spaces. Each spin space is defined (via “get_spin_Hilbert_spaces”) up to the maximum irrep given in spin_list. This function calculates the state vector in the composite system space that corresponds to the combination of individual spin degrees of freedom forming the specified singlet state.

Parameters:

• spin_list (list of (half)integers) – List of the maximal spin irreps for each degree of freedom (dof) in the system. The Hilbert space for each dof spans from the singlet state up to the maximal irrep specified in this list.

• singlet (SU2_singlet) – An instance of the SU2_singlet class representing the specific singlet state for which the canonical state vector is to be constructed. This singlet should be compatible with the spin configurations defined by spin_list.

Returns:

A one-dimensional array representing the normalized canonical state vector of the

specified singlet in the total Hilbert space. The length of this vector equals the product of the dimensions of the individual spin Hilbert spaces defined by spin_list.

Return type:

np.ndarray

ed_lgt.operators.SU2_singlets.add_new_spin(previous_configs, new_spin, get_singlet)

Couples a list of spin configurations with a new spin and determines the resulting configurations. Overall, this function is a wrapper of the previous function “couple_two_spins”.

Parameters:

• previous_configs (list) –

  The current list of spin-configurations. Each spin-configuration is a list whose last two terms corresponds to:

  • spin_config[-2]= J1 total spin associated to the spin-configuration

  • spin_config[-1]= M1 correspinding z-component of the total spin of the given configuration

  These two variables will be combined with the new_spin to obtain a new configuation

• new_spin (half/integer) – The new spin to be coupled with each configuration in previous_config.

• get_singlet (bool) – Specify if the resulting configuration must be a singlet.

Returns:

Updated list of spin configurations after coupling with new_spin.

Return type:

list

ed_lgt.operators.SU2_singlets.couple_two_spins(j1, j2, get_singlet=False, M=None)

This function computes SU(2) states obtained by combining two spins j1, j2 and computing Clebsh-Gordan coefficients CG. The possible outcomes j3,m3 are the ones with non null CG

Parameters:

• j1 (integer/half-integer) – spin of the 1st particle

• j2 (integer/half-integer) – spin of the 2nd particle

• get_singlet (bool, optional) – if true, look only at the (j1, j2)-combinations providing an SU(2) singlet. Defaults to False.

• M (integer/half-integer, optional) – spin-z component of the 1st particle. Defaults to None.

Returns:

[(j1, m1,) j2, m2, CG, j3, m3]

Return type:

list

ed_lgt.operators.SU2_singlets.get_SU2_singlets(spin_list, pure_theory=True, psi_vacuum=None)

This function aims to identify all possible SU(2) singlet states that can be formed from a given set (list) of spin representations. Singlet states are those where the total spin equals zero, meaning they are invariant under SU(2) transformations (rotationally invariant).

Parameters:

• spin_list (list) – list of spin representations to be coupled in order to get a singlet

• pure_theory (bool, optional) – if True, only gauge fields

• psi_vacuum (bool, optional) – If True, the first element of spin_list is the vacuum of matter. If False, the first element of spin_list is the pair (up & down) of matter. Default to None.

Returns:

Iinstances of SU2_singlet; if there is no singlet, just None

Return type:

list

ed_lgt.operators.SU2_singlets.get_spin_Hilbert_spaces(max_spin_irrep_list, pure_theory=True)

This function generates the Hilbert spaces for quantum systems characterized by their spin degrees of freedom. For each degree of freedom, it calculates the possible spin states (J) and their corresponding magnetic quantum numbers (M), spanning from the singlet state J,M=0 up to the maximum spin representation provided. The function supports both pure gauge field configurations and mixed systems including Fermionic particles by adjusting the pure_theory flag. In non-pure theory mode, additional states are included to represent the vacuum and fermion pairs.

Parameters:

• max_spin_irrep_list (list) – List of the maximal spin-irrep of each degree of freedom (dof) in the system. For each d.o.f, the Hilbert space will span from the smallest=0-irrep to the maximal irrep.

• pure_theory (bool, optional) –

  Defaults to True. If False, it will add Fermionic spin 1/2 particles, whose Hilbert space is 4dimensional and can be characterized by the following values of spin and its z-component:

  • J = [0, 1 / 2, 1 / 2, 0]

  • M = [0, 1 / 2, -1 / 2, 0]

  Where the first J=0 is referred to the absence of spin particles V=vacuum, while the second J=0 is referred to the case of a pair of particles with opposite spin P=pair

Returns:

A list of lists, where each sublist represents the possible J values (total spin values) for a dof. - m_list: A list of lists parallel to j_list, representing the corresponding M values (magnetic quantum numbers) for each J value.

Each list has len = len(max_spin_irrep_list) The length of each internal list is exactly the sum of (2s+1) for s from 0 to the coorresponding max_spin

Return type:

• j_list

Example

if spins=[1,1], we will get

• J=[[0, 1/2, 1/2, 1, 1, 1],

  [0, 1/2, 1/2, 1, 1, 1]]

• M=[[0, 1/2, -1/2, 1, 0, -1],

  [0, 1/2, -1/2, 1, 0, -1]]

ed_lgt.operators.SU2_singlets.group_sorted_spin_configs(spin_configs, spin_list, pure_theory, psi_vacuum)

Groups and sorts spin-configurations based on their total spin and individual spin z-components.

Parameters:

• spin_configs (list of lists) – The list of spin-configurations to sort and group.

• spin_list (list) – list of spin representations giving rise to all the spin-configs

• pure_theory (bool, optional) – if True, only gauge fields

• psi_vacuum (bool, optional) – If True, the first element of spin_list is the vacuum of matter. If False, the first element of spin_list is the pair (up & down) of matter. Default to None.

Returns:

List of grouped and sorted spin configurations.

Return type:

list