SpinHalfSite¶

full name: tenpy.networks.site.SpinHalfSite
parent module: tenpy.networks.site
type: class

Inheritance Diagram

Methods

`SpinHalfSite.__init__`([conserve, sort_charge])
`SpinHalfSite.add_op`(name, op[, need_JW, hc, ...])	Add one on-site operators.
`SpinHalfSite.change_charge`([new_leg_charge, ...])	Change the charges of the site (in place).
`SpinHalfSite.from_hdf5`(hdf5_loader, h5gr, ...)	Load instance from a HDF5 file.
`SpinHalfSite.get_hc_op_name`(name)	Return the hermitian conjugate of a given operator.
`SpinHalfSite.get_op`(name)	Return operator of given name.
`SpinHalfSite.multiply_op_names`(names)	Multiply operator names together.
`SpinHalfSite.multiply_operators`(operators)	Multiply local operators (possibly given by their names) together.
`SpinHalfSite.op_needs_JW`(name)	Whether an (composite) onsite operator is fermionic and needs a Jordan-Wigner string.
`SpinHalfSite.remove_op`(name)	Remove an added operator.
`SpinHalfSite.rename_op`(old_name, new_name)	Rename an added operator.
`SpinHalfSite.save_hdf5`(hdf5_saver, h5gr, subpath)	Export self into a HDF5 file.
`SpinHalfSite.sort_charge`([bunch])	Sort the `leg` charges (in place).
`SpinHalfSite.state_index`(label)	Return index of a basis state from its label.
`SpinHalfSite.state_indices`(labels)	Same as `state_index()`, but for multiple labels.
`SpinHalfSite.test_sanity`()	Sanity check, raises ValueErrors, if something is wrong.
`SpinHalfSite.valid_opname`(name)	Check whether 'name' labels a valid onsite-operator.

Class Attributes and Properties

`SpinHalfSite.dim`	Dimension of the local Hilbert space.
`SpinHalfSite.onsite_ops`	Dictionary of on-site operators for iteration.

class tenpy.networks.site.SpinHalfSite(conserve='Sz', sort_charge=None)[source]¶

Bases: Site

Spin-1/2 site.

Local states are up (0) and down (1). Local operators are the usual spin-1/2 operators, e.g. Sz = [[0.5, 0.], [0., -0.5]], Sx = 0.5*sigma_x for the Pauli matrix sigma_x.

operator	description
`Id, JW`	Identity \(\mathbb{1}\)
`Sx, Sy, Sz`	Spin components \(S^{x,y,z}\), equal to half the Pauli matrices.
`Sigmax, Sigmay, Sigmaz`	Pauli matrices \(\sigma^{x,y,z}\)
`Sp, Sm`	Spin flips \(S^{\pm} = S^{x} \pm i S^{y}\)

conserve	qmod	excluded onsite operators
`'Sz'`	[1]	`Sx, Sy, Sigmax, Sigmay`
`'parity'`	[2]	–
`'None'`	[]	–

Parameters

conserve (str | None) – Defines what is conserved, see table above.
sort_charge (bool) – Whether sort_charge() should be called at the end of initialization. This is usually a good idea to reduce potential overhead when using charge conservation. Note that this permutes the order of the local basis states! For backwards compatibility with existing data, it is not (yet) enabled by default.

conserve¶

Defines what is conserved, see table above.

Type: str

add_op(name, op, need_JW=False, hc=None, permute_dense=None)[source]¶

Add one on-site operators.

Parameters

name (str) – A valid python variable name, used to label the operator. The name under which op is added as attribute to self.
op (np.ndarray | Array) – A matrix acting on the local hilbert space representing the local operator. Dense numpy arrays are automatically converted to Array. LegCharges have to be [leg, leg.conj()]. We set labels 'p', 'p*'.
need_JW (bool) – Whether the operator needs a Jordan-Wigner string. If True, add name to need_JW_string.
hc (None | False | str) – The name for the hermitian conjugate operator, to be used for hc_ops. By default (None), try to auto-determine it. If False, disable adding antries to hc_ops.
permute_dense (bool | None) – Flag to enable/disable permuations when converting op from numpy to np_conserved arrays. If True, the operator is permuted with perm to account for permutations induced by sorting charges; False disables the permutations. By default (None), the value of used_sort_charge is used.

change_charge(new_leg_charge=None, permute=None)[source]¶

Change the charges of the site (in place).

Parameters

new_leg_charge (LegCharge | None) – The new charges to be used. If None, use trivial charges.
permute (ndarray | None) – The permuation applied to the physical leg, which also gets used to adjust state_labels and perm. If you sorted the previous leg with perm_qind, new_leg_charge = leg.sort(), use old_leg.perm_flat_from_perm_qind(perm_qind). Ignored if None.

property dim¶: Dimension of the local Hilbert space.

classmethod from_hdf5(hdf5_loader, h5gr, subpath)[source]¶

Load instance from a HDF5 file.

This method reconstructs a class instance from the data saved with save_hdf5().

Parameters

hdf5_loader (Hdf5Loader) – Instance of the loading engine.
h5gr (Group) – HDF5 group which is represent the object to be constructed.
subpath (str) – The name of h5gr with a '/' in the end.

Returns

obj – Newly generated class instance containing the required data.

Return type

cls

get_hc_op_name(name)[source]¶

Return the hermitian conjugate of a given operator.

Parameters: name (str) – The name of the operator to be returned. Multiple operators separated by whitespace are interpreted as an operator product, exactly as get_op() does.
Returns: hc_op_name – Operator name for the hermi such that get_op() of
Return type: str

get_op(name)[source]¶

Return operator of given name.

Parameters: name (str) – The name of the operator to be returned. In case of multiple operator names separated by whitespace, we multiply them together to a single on-site operator (with the one on the right acting first).
Returns: op – The operator given by name, with labels 'p', 'p*'. If name already was an npc Array, it’s directly returned.
Return type: np_conserved

multiply_op_names(names)[source]¶

Multiply operator names together.

Join the operator names in names such that get_op returns the product of the corresponding operators.

Parameters: names (list of str) – List of valid operator labels.
Returns: combined_opname – A valid operator name Operatorname representing the product of operators in names.
Return type: str

multiply_operators(operators)[source]¶

Multiply local operators (possibly given by their names) together.

Parameters: operators (list of {str | Array}) – List of valid operator names (to be translated with get_op()) or directly on-site operators in the form of npc arrays with 'p', 'p*' label. The operators are multiplied left-to-right.
Returns: combined_operator – The product of the given operators in a left-to-right multiplication following the usual mathematical convention. For example, if operators=['Sz', 'Sp', 'Sx'], the final operator is equivalent to site.get_op('Sz Sp Sx'), with the 'Sx' operator acting first on any physical state.
Return type: Array

property onsite_ops¶

Dictionary of on-site operators for iteration.

Single operators are accessible as attributes.

op_needs_JW(name)[source]¶

Whether an (composite) onsite operator is fermionic and needs a Jordan-Wigner string.

Parameters: name (str) – The name of the operator, as in get_op().
Returns: needs_JW – Whether the operator needs a Jordan-Wigner string, judging from need_JW_string.
Return type: bool

remove_op(name)[source]¶

Remove an added operator.

Parameters: name (str) – The name of the operator to be removed.

rename_op(old_name, new_name)[source]¶

Rename an added operator.

Parameters

old_name (str) – The old name of the operator.
new_name (str) – The new name of the operator.

save_hdf5(hdf5_saver, h5gr, subpath)[source]¶

Export self into a HDF5 file.

This method saves all the data it needs to reconstruct self with from_hdf5().

This implementation saves the content of __dict__ with save_dict_content(), storing the format under the attribute 'format'.

Parameters

hdf5_saver (Hdf5Saver) – Instance of the saving engine.
h5gr (:class`Group`) – HDF5 group which is supposed to represent self.
subpath (str) – The name of h5gr with a '/' in the end.

sort_charge(bunch=True)[source]¶

Sort the leg charges (in place).

Parameters: bunch (bool) – Whether to also group equal charges into larger blocks (usually a good idea).
Returns: perm – The permutation
Return type: 1D ndarray

state_index(label)[source]¶

Return index of a basis state from its label.

Parameters: label (int | string) – eather the index directly or a label (string) set before.
Returns: state_index – the index of the basis state associated with the label.
Return type: int

state_indices(labels)[source]¶: Same as state_index(), but for multiple labels.

test_sanity()[source]¶: Sanity check, raises ValueErrors, if something is wrong.

valid_opname(name)[source]¶

Check whether ‘name’ labels a valid onsite-operator.

Parameters: name (str) – Label for the operator. Can be multiple operator(labels) separated by whitespace, indicating that they should be multiplied together.
Returns: valid – True if name is a valid argument to get_op().
Return type: bool