Utility Functions

Here are the various functions used throughout the PyCCE code. There is no real structure in this section.

InteractionMap

class InteractionMap(rows=None, columns=None, tensors=None)

Dict-like object containing information about tensor interactions between two spins.

Each key is a tuple of two spin indexes.

Parameters:

rows (array-like with shape (n, )) – Indexes of the bath spins, appearing on the left in the pairwise interaction.
columns (array-like with shape (n, )) – Indexes of the bath spins, appearing on the right in the pairwise interaction.
tensors (array-like with shape (n, 3, 3)) – Tensors of pairwise interactions between two spins with the indexes in rows and columns.

mapping

Actual dictionary storing the data.

Type:: dict

property indexes

Array with the indexes of pairs of spins, for which the tensors are stored.

Type:: ndarray with shape (n, 2)

shift(start, inplace=True)

Add an offset start to the indexes. If inplace is False, returns the copy of InteractionMap.

Parameters:

start (int) – Offset in indexes.
inplace (bool) – If True, makes changes inplace. Otherwise returns copy of the map.

Returns:

Map with shifted indexes.

Return type:

InteractionMap

keys() → a set-like object providing a view on D's keys

items() → a set-like object providing a view on D's items

subspace(array)

Get new InteractionMap with indexes readressed from array. Within the subspace indexes are renumbered.

Examples

The subspace of [3,4,7] indexes will contain InteractionMap only within [3,4,7] elements with new indexes [0, 1, 2].

>>> import numpy as np
>>> im = InteractionMap()
>>> im[0, 3] = np.eye(3)
>>> im[3, 7] = np.ones(3)
>>> for k in im: print(k, '\n', im[k],)
(0, 3)
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
(3, 7)
 [[1. 1. 1.]
  [1. 1. 1.]
  [1. 1. 1.]]
>>> array = [3, 4, 7]
>>> sim = im.subspace(array)
>>> for k in sim: print(k, '\n', sim[k])
(0, 2)
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

Parameters:: array (ndarray) – Either bool array containing True for elements within the subspace or array of indexes presented in the subspace.
Returns:: The map for the subspace.
Return type:: InteractionMap

classmethod from_dict(dictionary, presorted=False)

Generate InteractionMap from the dictionary.

Parameters:

dictionary (dict) – Dictionary with tensors.
presorted (bool) – If true, assumes that the keys in the dictionary were already presorted.

Returns:

New instance generated from the dictionary.

Return type:

InteractionMap

Noise Filter Functions

Module with helper functions to obtain CPMG coherence from the noise autocorrelation function.

filterfunc(ts, tau, npulses)

Time-domain filter function for the given CPMG sequence.

Parameters:

ts (ndarray with shape (n,)) – Time points at which filter function will be computed.
tau (float) – Delay between pulses.
npulses (int) – Number of pulses in CPMG sequence.

Returns:

Filter function for the given CPMG sequence.

Return type:

ndarray with shape (n,)

gaussian_phase(timespace, corr, npulses, units='khz')

Compute average random phase squared assuming Gaussian noise.

Parameters:

timespace (ndarray with shape (n,)) – Time points at which correlation function was computed.
corr (ndarray with shape (n,)) – Noise autocorrelation function.
npulses (int) – Number of pulses in CPMG sequence.
units (str) – If units contain frequency or angular frequency (‘rad’ in units).

Returns:

Random phase accumulated by the qubit.

Return type:

ndarray with shape (n,)

Spin matrix generators

class SpinMatrix(s)

Class containing the spin matrices in Sz basis.

Parameters:: s (float) – Total spin.

class MatrixDict(*spins)

Class for storing the SpinMatrix objects.

keys() → a set-like object providing a view on D's keys

stevo(sm, k, q)

Stevens operators (from I.D. Ryabov, Journal of Magnetic Resonance 140, 141–145 (1999)).

Parameters:

sm (SpinMatrix) – Spin matrices of the given spin.
k (int) – \(k\) index of the Stevens operator.
q (int) – \(q\) index of the Stevens operator.

Returns:

Stevens operator representation in \(S_z\) basis.

Return type:

ndarray with shape (n, n)

dimensions_spinvectors(bath=None, central_spin=None)

Generate two arrays, containing dimensions of the spins in the cluster and the vectors with spin matrices.

Parameters:

bath (BathArray with shape (n,)) – Array of the n spins within cluster.
central_spin (CenterArray, optional) – If provided, include dimensions of the central spins.

Returns:

tuple containing:

ndarray with shape (n,): Array with dimensions for each spin.

list: List with vectors of spin matrices for each spin in the cluster (Including central spin if central_spin is not None). Each with shape (3, N, N) where N = prod(dimensions).

Return type:

tuple

vecs_from_dims(dimensions)

Generate ndarray of spin vectors, given the array of spin dimensions.

Parameters:: dimensions (ndarray with shape (n,)) – Dimensions of spins.
Returns:: Array of spin vectors in full Hilbert space.
Return type:: ndarray with shape (n, 3, X, X)

spinvec(j, dimensions)

Generate single spin vector, given the index and dimensions of all spins in the cluster.

Parameters:

j (int) – Index of the spin.
dimensions (ndarray with shape (n,)) – Dimensions of spins.

Returns:

Spin vector of \(j\)-sth spin in full Hilbert space.

Return type:

ndarray with shape (3, X, X)

numba_gen_sm(dim)

Numba-friendly spin matrix. :param dim: dimensions of the spin marix. :type dim: int

Return type:: ndarray

Other

rotmatrix(initial_vector, final_vector)

Generate 3D rotation matrix which applied on initial vector will produce vector, aligned with final vector.

Examples

>>> R = rotmatrix([0,0,1], [1,1,1])
>>> R @ np.array([0,0,1])
array([0.577, 0.577, 0.577])

Parameters:

initial_vector (ndarray with shape(3, )) – Initial vector.
final_vector (ndarray with shape (3, )) – Final vector.

Returns:

Rotation matrix.

Return type:

ndarray with shape (3, 3)

expand(matrix, i, dim)

Expand matrix M from it’s own dimensions to the total Hilbert space.

Parameters:

matrix (ndarray with shape (dim[i], dim[i])) – Inital matrix.
i (int) – Index of the spin dimensions in dim parameter.
dim (ndarray) – Array pf dimensions of all spins present in the cluster.

Returns:

Expanded matrix.

Return type:

ndarray with shape (prod(dim), prod(dim))

partial_trace(dmarray, dimensions, sel)

Compute partial trace of the operator (or array of operators).

Parameters:

dmarray (ndarray with shape (N, N) or (m, N, N) –
dimensions (array-like) – Array of all dimensions of the system.
sel (int or array-like) – Index or indexes of dimensions to keep.

Returns:

Partially traced operator.

Return type:

ndarray with shape (n, n) or (m, n, n)

partial_inner_product(avec, total, dimensions, index=-1)

Returns partial inner product \(\ket{b}=\bra{a}\ket{\psi}\), where \(\ket{a}\) provided by avec contains degrees of freedom to be “traced out” and \(\ket{\psi}\) provided by total is the total statevector.

Parameters:

avec (ndarray with shape (a,)) –
total (ndarray with shape (a*b,)) –
dimensions (ndarray with shape (n,)) –
() (index) –

Returns:

shorten_dimensions(dimensions, central_number)

Combine the dimensions, corresponding to the central spins.

Parameters:

dimensions (ndarray with shape (n, )) – Array of the dimensions of the spins in the cluster.
central_number (int) – Number of central spins.

Returns:

Array of the shortened dimensions;

Return type:

ndarray with shape (n - central_number)

outer(s1, s2)

Outer product of two complex vectors \(\ket{s_1}ra{s_2}\).

Parameters:

s1 (ndarray with shape (n, )) – First vector.
s2 (ndarray with shape (m, )) – Second vector.

Returns:

Outer product.

Return type:

ndarray with shape (n, m)

tensor_vdot(tensor, ivec)

Compute product of the tensor and spin vector.

Parameters:

tensor (ndarray with shape (3, 3)) – Tensor in real space.
ivec (ndarray with shape (3, n, n)) – Spin vector.

Returns:

Right-side tensor vector product \(Tv\).

Return type:

ndarray with shape (3, n, n)

vvdot(vec_1, vec_2)

Compute product of two spin vectors.

Parameters:

vec_1 (ndarray with shape (3, N, N)) – First spin vector.
vec_2 (ndarray with shape (3, N, N)) – Second spin vector.

Returns:

Product of two vectors.

Return type:

ndarray with shape (N, N)

rotate_tensor(tensor, rotation=None, style='col')

Rootate tensor in real space, given rotation matrix.

Parameters:

tensor (ndarray with shape (3, 3)) – Tensor to be rotated.
rotation (ndarray with shape (3, 3)) – Rotation matrix.
style (str) – Can be ‘row’ or ‘col’. Determines how rotation matrix is initialized.

Returns:

Rotated tensor.

Return type:

ndarray with shape (3, 3)

rotate_coordinates(xyz, rotation=None, cell=None, style='col')

Rootate coordinates in real space, given rotation matrix.

Parameters:

xyz (ndarray with shape (..., 3)) – Array of coordinates.
rotation (ndarray with shape (3, 3)) – Rotation matrix.
cell (ndarray with shape (3, 3)) – Cell matrix if coordinates are given in cell coordinates.
style (str) – Can be ‘row’ or ‘col’. Determines how rotation matrix and cell matrix are initialized.

Returns:

Array of rotated coordinates.

Return type:

ndarray with shape (…, 3))

normalize(vec)

Normalize vector to 1.

Parameters:: vec (ndarray with shape (n, )) – Vector to be normalized.
Returns:: Normalized vector.
Return type:: ndarray with shape (n, )

vec_tensor_vec(v1, tensor, v2)

Compute product v @ T @ v. :param v1: Leftmost expanded spin vector. :type v1: ndarray with shape (3, n, n) :param tensor: 3x3 interaction tensor in real space. :type tensor: ndarray with shape (3, 3) :param v2: Rightmost expanded spin vector. :type v2: ndarray with shape (3, n, n)

Returns:: Product \(vTv\).
Return type:: ndarray with shape (n, n)

gen_state_list(states, dims)

Generate list of states from \(S_z\) projections of the pure states.

Parameters:

states (ndarray with shape (n,)) – Array of \(S_z\) projections.
dims (ndarray with shape (n,)) – Array of the dimensions of the spins in the cluster.

Returns:

list of state vectors.

Return type:

List

vector_from_s(s, d)

Generate vector state from \(S_z\) projection.

Parameters:

s (float) – \(S_z\) projection.
d (int) – Dimensions of the given spin.

Returns:

State vector of a pure state.

Return type:

ndarray with shape (d, )