quimb.calc

Functions for more advanced calculations of quantities and properties of quantum objects.

Module Contents

Functions

fidelity(p1, p2[, squared])	Fidelity between two quantum states. By default, the unsquared fidelity
purify(rho)	Take state rho and purify it into a wavefunction of squared
kraus_op(rho, Ek[, dims, where, check])	Operate on a mixed state with a set of kraus operators:
projector(A[, eigenvalue, tol, autoblock])	Compute the projector for the target eigenvalue of operator
measure(p, A[, eigenvalue, tol])	Measure state p with observable A, collapsing the state in the
simulate_counts(p, C[, phys_dim, seed])	Simulate measuring each qubit of p in the computational basis,
dephase(rho, p[, rand_rank])	Dephase rho by amount p, that is, mix it
entropy(a[, rank])	Compute the (von Neumann) entropy.
mutinf(p[, dims, sysa, rank])	Find the mutual information for a bipartition of a state.
check_dims_and_indices(dims, *syss)	Make sure all indices found in the tuples syss are in
mutinf_subsys(psi_abc, dims, sysa, sysb[, approx_thresh])	Calculate the mutual information of two subsystems of a pure state,
schmidt_gap(psi_ab, dims, sysa)	Find the schmidt gap of the bipartition of psi_ab. That is, the
tr_sqrt(A[, rank])	Return the trace of the sqrt of a positive semidefinite operator.
partial_transpose(p[, dims, sysa])	Partial transpose of a density operator.
partial_transpose_norm(p, dims, sysa)	Compute the norm of the partial transpose for (log)-negativity,
logneg(p[, dims, sysa])	Compute logarithmic negativity between two subsytems.
logneg_subsys(psi_abc, dims, sysa, sysb[, approx_thresh])	Compute the logarithmic negativity between two subsystems of a pure
negativity(p[, dims, sysa])	Compute negativity between two subsytems.
concurrence(p[, dims, sysa, sysb])	Concurrence of two-qubit state.
one_way_classical_information(p_ab, prjs[, precomp_func])	One way classical information for two qubit density operator.
quantum_discord(p[, dims, sysa, sysb, method, tol, ...])	Quantum Discord for two qubit density operator.
trace_distance(p1, p2)	Trace distance between two states:
cprint(psi[, prec])	Print a state in the computational basis.
decomp(a, fn, fn_args, fn_d, nmlz_func[, mode, tol])	Decomposes an operator via the Hilbert-schmidt inner product.
correlation(p, A, B, sysa, sysb[, dims, sparse, ...])	Calculate the correlation between two sites given two operators.
pauli_correlations(p[, ss, sysa, sysb, sum_abs, ...])	Calculate the correlation between sites for a list of operator pairs
ent_cross_matrix(p[, sz_blc, ent_fn, calc_self_ent, ...])	Calculate the pair-wise function ent_fn between all sites or blocks
qid(p, dims, inds[, precomp_func, sparse_comp, ...])
is_degenerate(op[, tol])	Check if operator has any degenerate eigenvalues, determined relative
is_eigenvector(x, A[, tol])	Determines whether a vector is an eigenvector of an operator.
page_entropy(sz_subsys, sz_total)	Calculate the page entropy, i.e. expected entropy for a subsytem
heisenberg_energy(L)	Get the analytic isotropic heisenberg chain ground energy for length L.

Attributes

entropy_subsys	Calculate the entropy of a pure states' subsystem, optionally switching
mutual_information
tr_sqrt_subsys	Compute the trace sqrt of a subsystem, possibly using an approximate
logarithmic_negativity
pauli_decomp	Decompose an operator into Paulis.
bell_decomp	Decompose an operator into bell-states.

quimb.calc.fidelity(p1, p2, squared=False)

Fidelity between two quantum states. By default, the unsquared fidelity is used, equivalent in the pure state case to |<psi|phi>|.

Parameters:

• p1 (vector or operator) – First state.

• p2 (vector or operator) – Second state.

• squared (bool, optional) – Whether to use the squared convention or not, by default False.

Return type:

float

quimb.calc.purify(rho)

Take state rho and purify it into a wavefunction of squared dimension.

Parameters:

rho (operator) – Density operator to purify.

Returns:

The purified ket.

Return type:

vector

quimb.calc.kraus_op(rho, Ek, dims=None, where=None, check=False)

Operate on a mixed state with a set of kraus operators:

\[\sigma = \sum_k E_k \rho E_k^{\dagger}\]

Parameters:

• rho ((d, d) density matrix) – The density operator to perform operation on.

• Ek ((K, d, d) array or sequence of K (d, d) arrays) – The Kraus operator(s).

• dims (sequence of int, optional) – The subdimensions of rho.

• where (int or sequence of int, optional) – Which of the subsystems to apply the operation on.

• check (bool, optional) – Where to check sum_k(Ek.H @ Ek) == 1.

Returns:

sigma – The state after the kraus operation.

Return type:

density matrix

Examples

The depolarising channel:

In [1]: import quimb as qu

In [2]: rho = qu.rand_rho(2)

In [3]: I, X, Y, Z = (qu.pauli(s) for s in 'IXYZ')

In [4]: [qu.expec(rho, A) for A in (X, Y, Z)]
Out[4]: [-0.652176185230622, -0.1301762132792484, 0.22362918368272583]

In [5]: p = 0.1

In [6]: Ek = [
   ...:     (1 - p)**0.5 * I,
   ...:     (p / 3)**0.5 * X,
   ...:     (p / 3)**0.5 * Y,
   ...:     (p / 3)**0.5 * Z
   ...: ]

In [7]: sigma = qu.kraus_op(rho, Ek)

In [8]: [qu.expec(sigma, A) for A in (X, Y, Z)]
Out[8]: [-0.5652193605332058, -0.11281938484201527, 0.1938119591916957]

quimb.calc.projector(A, eigenvalue=1.0, tol=1e-12, autoblock=False)

Compute the projector for the target eigenvalue of operator A.

Parameters:

• A (operator or tuple[array, operator].) – The hermitian observable. If a tuple is supplied, assume this is the eigendecomposition of the observable.

• eigenvalue (float, optional) – The target eigenvalue to construct the projector for, default: 1.

• tol (float, optional) – The tolerance with which to select all eigenvalues.

• autoblock (bool, optional) – Whether to use automatic symmetry exploitation.

Returns:

P – The projector onto the target eigenspace.

Return type:

dense matrix

quimb.calc.measure(p, A, eigenvalue=None, tol=1e-12)

Measure state p with observable A, collapsing the state in the process and returning the relevant eigenvalue.

\[\left| \psi \right\rangle \rightarrow \frac{ P_i \left| \psi \right\rangle }{ \sqrt{\left\langle \psi \right| P_i \left| \psi \right\rangle} }\]

and

\[\rho \rightarrow \frac{ P_i \rho P_i^{\dagger} }{ \text{Tr} \left[ P_i \rho \right] }\]

along with the corresponding eigenvalue \(\lambda_i\).

Parameters:

• p (vector or matrix) – The quantum state to measure.

• A (matrix or tuple[array, matrix]) – The hermitian operator corresponding to an observable. You can supply also a pre-diagonalized operator here as a tuple of eigenvalues and eigenvectors.

• tol (float, optional) – The tolerance within which to group eigenspaces.

• eigenvalue (float, optional) – If specified, deterministically collapse to this result. Otherwise randomly choose a result as in ‘real-life’.

Returns:

• result (float) – The result of the measurement.

• p_after (vector or matrix) – The quantum state post measurement.

quimb.calc.simulate_counts(p, C, phys_dim=2, seed=None)

Simulate measuring each qubit of p in the computational basis, producing output like that of qiskit.

Parameters:

• p (vector or operator) – The quantum state, assumed to be normalized, as either a ket or density operator.

• C (int) – The number of counts to perform.

• phys_dim (int, optional) – The assumed size of the subsystems of p, defaults to 2 for qubits.

Returns:

results – The counts for each bit string measured.

Return type:

dict[str, int]

Examples

Simulate measuring the state of each qubit in a GHZ-state:

>>> import quimb as qu
>>> psi = qu.ghz_state(3)
>>> qu.simulate_counts(psi, 1024)
{'000': 514, '111': 510}

quimb.calc.dephase(rho, p, rand_rank=None)

Dephase rho by amount p, that is, mix it with the maximally mixed state:

rho -> (1 - p) * rho + p * I / d

Parameters:

• rho (operator) – The state.

• p (float) – The final proportion of identity.

• rand_rank (int or float, optional) – If given, dephase with a random diagonal operator with this many non-zero entries. If float, proportion of full size.

Returns:

rho_dephase – The dephased density operator.

Return type:

operator

quimb.calc.entropy(a, rank=None)

Compute the (von Neumann) entropy.

Parameters:

• a (operator or 1d array) – Positive operator or list of positive eigenvalues.

• rank (int (optional)) – If operator has known rank, then a partial decomposition can be used to accelerate the calculation.

Returns:

The von Neumann entropy.

Return type:

float

See also

mutinf, entropy_subsys, entropy_subsys_approx

quimb.calc.entropy_subsys

Calculate the entropy of a pure states’ subsystem, optionally switching to an approximate lanczos method when the subsystem is very large.

Parameters:

• psi_ab (vector) – Bipartite state.

• dims (sequence of int) – The sub-dimensions of the state.

• sysa (sequence of int) – The indices of which dimensions to calculate the entropy for.

• approx_thresh (int, optional) – The size of sysa at which to switch to the approx method. Set to None to never use the approximation.

• **approx_opts – Supplied to entropy_subsys_approx(), if used.

Returns:

The subsytem entropy.

Return type:

float

See also

entropy, entropy_subsys_approx, mutinf_subsys

quimb.calc.mutinf(p, dims=(2, 2), sysa=0, rank=None)

Find the mutual information for a bipartition of a state.

That is, H(A) + H(B) - H(AB), for von Neumann entropy H, and two subsystems A and B.

Parameters:

• p (vector or operator) – State, can be vector or operator.

• dims (tuple(int), optional) – Internal dimensions of state.

• sysa (int, optional) – Index of first subsystem, A.

• sysb (int, optional) – Index of second subsystem, B.

• rank (int, optional) – If known, the rank of rho_ab, to speed calculation of H(AB) up. For example, if p comes from tracing out three qubits from a system, then its rank is 2^3 = 8 etc.

Return type:

float

See also

entropy, mutinf_subsys, entropy_subsys_approx

quimb.calc.mutual_information

quimb.calc.check_dims_and_indices(dims, *syss)

Make sure all indices found in the tuples syss are in range(len(dims)).

quimb.calc.mutinf_subsys(psi_abc, dims, sysa, sysb, approx_thresh=2**13, **approx_opts)

Calculate the mutual information of two subsystems of a pure state, possibly using an approximate lanczos method for large subsytems.

Parameters:

• psi_abc (vector) – Tri-partite pure state.

• dims (sequence of int) – The sub dimensions of the state.

• sysa (sequence of int) – The index(es) of the subsystem(s) to consider part of ‘A’.

• sysb (sequence of int) – The index(es) of the subsystem(s) to consider part of ‘B’.

• approx_thresh (int, optional) – The size of subsystem at which to switch to the approximate lanczos method. Set to None to never use the approximation.

• approx_opts – Supplied to entropy_subsys_approx(), if used.

Returns:

The mutual information.

Return type:

float

See also

mutinf, entropy_subsys, entropy_subsys_approx, logneg_subsys

quimb.calc.schmidt_gap(psi_ab, dims, sysa)

Find the schmidt gap of the bipartition of psi_ab. That is, the difference between the two largest eigenvalues of the reduced density operator.

Parameters:

• psi_ab (vector) – Bipartite state.

• dims (sequence of int) – The sub-dimensions of the state.

• sysa (sequence of int) – The indices of which dimensions to calculate the entropy for.

Return type:

float

quimb.calc.tr_sqrt(A, rank=None)

Return the trace of the sqrt of a positive semidefinite operator.

quimb.calc.tr_sqrt_subsys

Compute the trace sqrt of a subsystem, possibly using an approximate lanczos method when the subsytem is big.

Parameters:

• psi_ab (vector) – Bipartite state.

• dims (sequence of int) – The sub-dimensions of the state.

• sysa (sequence of int) – The indices of which dimensions to calculate the trace sqrt for.

• approx_thresh (int, optional) – The size of sysa at which to switch to the approx method. Set to None to never use the approximation.

• **approx_opts – Supplied to tr_sqrt_subsys_approx(), if used.

Returns:

The subsytem entropy.

Return type:

float

See also

tr_sqrt, tr_sqrt_subsys_approx, partial_transpose_norm

quimb.calc.partial_transpose(p, dims=(2, 2), sysa=0)

Partial transpose of a density operator.

Parameters:

• p (operator or vector) – The state to partially transpose.

• dims (tuple(int), optional) – The internal dimensions of the state.

• sysa (sequence of int) – The indices of ‘system A’, everything else assumed to be ‘system B’.

Return type:

operator

See also

logneg, negativity

quimb.calc.partial_transpose_norm(p, dims, sysa)

Compute the norm of the partial transpose for (log)-negativity, taking a shortcut (trace sqrt of reduced subsytem), when system is a vector.

quimb.calc.logneg(p, dims=(2, 2), sysa=0)

Compute logarithmic negativity between two subsytems. This is defined as log_2( | rho_{AB}^{T_B} | ). This only handles bipartitions (including pure states efficiently), and will not trace anything out.

Parameters:

• p (ket vector or density operator) – State to compute logarithmic negativity for.

• dims (tuple(int), optional) – The internal dimensions of p.

• sysa (int, optional) – Index of the first subsystem, A, relative to dims.

Return type:

float

See also

negativity, partial_transpose, logneg_subsys_approx

quimb.calc.logarithmic_negativity

quimb.calc.logneg_subsys(psi_abc, dims, sysa, sysb, approx_thresh=2**13, **approx_opts)

Compute the logarithmic negativity between two subsystems of a pure state, possibly using an approximate lanczos for large subsystems. Uses a special method if the two subsystems form a bipartition of the state.

Parameters:

• psi_abc (vector) – Tri-partite pure state.

• dims (sequence of int) – The sub dimensions of the state.

• sysa (sequence of int) – The index(es) of the subsystem(s) to consider part of ‘A’.

• sysb (sequence of int) – The index(es) of the subsystem(s) to consider part of ‘B’.

• approx_thresh (int, optional) – The size of subsystem at which to switch to the approximate lanczos method. Set to None to never use the approximation.

• approx_opts – Supplied to logneg_subsys_approx(), if used.

Returns:

The logarithmic negativity.

Return type:

float

See also

logneg, mutinf_subsys, logneg_subsys_approx

quimb.calc.negativity(p, dims=(2, 2), sysa=0)

Compute negativity between two subsytems.

This is defined as (| rho_{AB}^{T_B} | - 1) / 2. If len(dims) > 2, then the non-target dimensions will be traced out first.

Parameters:

• p (ket vector or density operator) – State to compute logarithmic negativity for.

• dims (tuple(int), optional) – The internal dimensions of p.

• sysa (int, optional) – Index of the first subsystem, A, relative to dims.

Return type:

float

See also

logneg, partial_transpose, negativity_subsys_approx

quimb.calc.concurrence(p, dims=(2, 2), sysa=0, sysb=1)

Concurrence of two-qubit state.

If len(dims) > 2, then the non-target dimensions will be traced out first.

Parameters:

• p (ket vector or density operator) – State to compute concurrence for.

• dims (tuple(int), optional) – The internal dimensions of p.

• sysa (int, optional) – Index of the first subsystem, A, relative to dims.

• sysb (int, optional) – Index of the first subsystem, B, relative to dims.

Return type:

float

quimb.calc.one_way_classical_information(p_ab, prjs, precomp_func=False)

One way classical information for two qubit density operator.

Parameters:

• p_ab (operator) – State of two qubits

• prjs (sequence of matrices) – The POVMs.

• precomp_func (bool, optional) – Whether to return a pre-computed function, closed over the actual state.

Returns:

The one-way classical information or the function to compute it for the given state which takes a set of POVMs as its single argument.

Return type:

float or callable

quimb.calc.quantum_discord(p, dims=(2, 2), sysa=0, sysb=1, method='COBYLA', tol=1e-12, maxiter=2**14)

Quantum Discord for two qubit density operator.

If len(dims) > 2, then the non-target dimensions will be traced out first.

Parameters:

• p (ket vector or density operator) – State to compute quantum discord for.

• dims (tuple(int), optional) – The internal dimensions of p.

• sysa (int, optional) – Index of the first subsystem, A, relative to dims.

• sysb (int, optional) – Index of the first subsystem, B, relative to dims.

Return type:

float

quimb.calc.trace_distance(p1, p2)

Trace distance between two states:

\[\delta(\rho, \sigma) = \frac{1}{2} \left| \rho - \sigma \right|_\mathrm{tr}\]

If two wavefunctions are supplied the trace distance will be computed via the more efficient expression:

\[\delta(|\psi\rangle\langle\psi|, |\phi\rangle\langle\phi|) = \sqrt{1 - \langle \psi | \phi \rangle^2}\]

Parameters:

• p1 (ket or density operator) – The first state.

• p2 (ket or density operator) – The second state.

Return type:

float

quimb.calc.cprint(psi, prec=6)

Print a state in the computational basis.

Parameters:

• psi (vector) – The pure state.

• prec (int, optional) – How many significant figures to print.

Examples

>>> cprint(rand_ket(2**2))
(-0.0751069-0.192635j) |00>
  (0.156837-0.562213j) |01>
(-0.307381+0.0291168j) |10>
  (-0.14302+0.707661j) |11>

>>> cprint(w_state(4))
(0.5+0j) |0001>
(0.5+0j) |0010>
(0.5+0j) |0100>
(0.5+0j) |1000>

quimb.calc.decomp(a, fn, fn_args, fn_d, nmlz_func, mode='p', tol=0.001)

Decomposes an operator via the Hilbert-schmidt inner product.

Can both print the decomposition or return it.

Parameters:

• a (ket or density operator) – Operator to decompose.

• fn (callable) – Function to generate operator/state to decompose with.

• fn_args – Sequence of args whose permutations will be supplied to fn.

• fn_d (int) – The dimension of the operators that fn produces.

• nmlz_func (callable) – Function to produce a normlization coefficient given the n permutations of operators that will be produced.

• mode – String, include 'p' to print the decomp and/or 'c' to return OrderedDict, sorted by size of contribution.

• tol – Print operators with contirbution above tol only.

Returns:

Pauli operator name and expec with a.

Return type:

None or OrderedDict

See also

pauli_decomp, bell_decomp

quimb.calc.pauli_decomp

Decompose an operator into Paulis.

quimb.calc.bell_decomp

Decompose an operator into bell-states.

quimb.calc.correlation(p, A, B, sysa, sysb, dims=None, sparse=None, precomp_func=False)

Calculate the correlation between two sites given two operators.

Parameters:

• p (ket or density operator) – State to compute correlations for, ignored if precomp_func=True.

• A (operator) – Operator to act on first subsystem.

• B (operator) – Operator to act on second subsystem.

• sysa (int) – Index of first subsystem.

• sysb (int) – Index of second subsystem.

• dims (tuple of int, optional) – Internal dimensions of p, will be assumed to be qubits if not given.

• sparse (bool, optional) – Whether to compute with sparse operators.

• precomp_func (bool, optional) – Whether to return result or single arg function closed over precomputed operator.

Returns:

The correlation, <ab> - <a><b>, or a function to compute for an arbitrary state.

Return type:

float or callable

quimb.calc.pauli_correlations(p, ss=('xx', 'yy', 'zz'), sysa=0, sysb=1, sum_abs=False, precomp_func=False)

Calculate the correlation between sites for a list of operator pairs choisen from the pauli matrices.

Parameters:

• p (ket or density operator) – State to compute correlations for. Ignored if precomp_func=True.

• ss (tuple or str) – List of pairs specifiying pauli matrices.

• sysa (int, optional) – Index of first site.

• sysb (int, optional) – Index of second site.

• sum_abs (bool, optional) – Whether to sum over the absolute values of each correlation

• precomp_func (bool, optional) – whether to return the values or a single argument function closed over precomputed operators etc.

Returns:

Either the value(s) of each correlation or the function(s) to compute the correlations for an arbitrary state, depending on sum_abs and precomp_func.

Return type:

list of float, list of callable, float or callable

quimb.calc.ent_cross_matrix(p, sz_blc=1, ent_fn=logneg, calc_self_ent=True, upscale=False)

Calculate the pair-wise function ent_fn between all sites or blocks of a state.

Parameters:

• p (ket or density operator) – State.

• sz_blc (int) – Size of the blocks to partition the state into. If the number of individual sites is not a multiple of this then the final (smaller) block will be ignored.

• ent_fn (callable) – Bipartite function, notionally entanglement

• calc_self_ent (bool) – Whether to calculate the function for each site alone, purified. If the whole state is pure then this is the entanglement with the whole remaining system.

• upscale (bool, optional) – Whether, if sz_blc != 1, to upscale the results so that the output array is the same size as if it was.

Returns:

array of pairwise ent_fn results.

Return type:

2D-array

quimb.calc.qid(p, dims, inds, precomp_func=False, sparse_comp=True, norm_func=norm, power=2, coeff=1)

quimb.calc.is_degenerate(op, tol=1e-12)

Check if operator has any degenerate eigenvalues, determined relative to mean spacing of all eigenvalues.

Parameters:

• op (operator or 1d-array) – Operator or assumed eigenvalues to check degeneracy for.

• tol (float) – How much closer than evenly spaced the eigenvalue gap has to be to count as degenerate.

Returns:

n_dgen – Number of degenerate eigenvalues.

Return type:

int

quimb.calc.is_eigenvector(x, A, tol=1e-14)

Determines whether a vector is an eigenvector of an operator.

Parameters:

• x (vector) – Vector to check.

• A (operator) – Matrix to check.

• tol (float, optional) – The variance must be smaller than this value.

Returns:

Whether A @ x = l * x for some scalar l.

Return type:

bool

quimb.calc.page_entropy(sz_subsys, sz_total)

Calculate the page entropy, i.e. expected entropy for a subsytem of a random state in Hilbert space.

Parameters:

• sz_subsys (int) – Dimension of subsystem.

• sz_total (int) – Dimension of total system.

Returns:

s – Entropy in bits.

Return type:

float

quimb.calc.heisenberg_energy(L)

Get the analytic isotropic heisenberg chain ground energy for length L. Useful for testing. Assumes the heisenberg model is defined with spin operators not pauli matrices (overall factor of 2 smaller). Taken from [1].

[1] Nickel, Bernie. “Scaling corrections to the ground state energy of the spin-½ isotropic anti-ferromagnetic Heisenberg chain.” Journal of Physics Communications 1.5 (2017): 055021

Parameters:

L (int) – The length of the chain.

Returns:

energy – The ground state energy.

Return type:

float