Arrays (a.k.a. vectors, tensors, operators)¶

A HilbertArray is a vector in a HilbertSpace. Internally, it is backed by a numpy.array. HilbertArray’s are to be created using the HilbertSpace.array() method.

class qitensor.array.HilbertArray¶

Bases: object

HilbertArray(HilbertSpace space, data, bool noinit_data, bool reshape, input_axes)

H¶

HilbertArray.H(self)

Returns the adjoint (Hermitian conjugate) of this array.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> x = ha.array([1j, 0]); x
HilbertArray(|a>,
array([ 0.+1.j,  0.+0.j]))
>>> x.H
HilbertArray(<a|,
array([ 0.-1.j,  0.-0.j]))
>>> y = ha.O.array([[1+2j, 3+4j], [5+6j, 7+8j]]); y
HilbertArray(|a><a|,
array([[ 1.+2.j,  3.+4.j],
       [ 5.+6.j,  7.+8.j]]))
>>> y.H
HilbertArray(|a><a|,
array([[ 1.-2.j,  5.-6.j],
       [ 3.-4.j,  7.-8.j]]))

I¶

HilbertArray.I(self)

Returns the matrix inverse of this array.

It is required that the dimension of the bra space be equal to the dimension of the ket space.

This is just a shortcut for self.inv(), which offers more options.

See also: inv()

>>> from qitensor import qubit, qudit
>>> ha = qubit('a')
>>> x = ha.O.random_array()
>>> (x * x.I - ha.eye()).norm() < 1e-13
True
>>> hb = qubit('b')
>>> hc = qudit('c', 4)
>>> y = (ha * hb * hc.H).random_array()
>>> (y * y.I - (ha * hb).eye()).norm() < 1e-13
True
>>> (y.I * y - hc.eye()).norm() < 1e-13
True

O¶

HilbertArray.O(self)

Makes a density operator from a pure state.

The input must be a ket vector. The output is self * self.H.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> x = ha.array([1j, 2]); x
HilbertArray(|a>,
array([ 0.+1.j,  2.+0.j]))
>>> x.O
HilbertArray(|a><a|,
array([[ 1.+0.j,  0.+2.j],
       [ 0.-2.j,  4.+0.j]]))

QR(self, inner_space=None)¶

Returns operators Q and R such that Q is an isometry, R is upper triangular, and self=Q*R.

The bra space of Q (and the ket space of R) is the smaller of the bra or ket spaces of the input. This can be overridden using the inner_space parameter.

Parameters:	inner_space (HilbertSpace) – bra space of Q (and the ket space of R)

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> hb = qubit('b')
>>> hc = qubit('c')
>>> m = (hb*hc*ha.H).random_array()
>>> (q, r) = m.QR()
>>> (q.space, r.space)
(|b,c><a|, |a><a|)
>>> (q.H * q - ha.eye()).norm() < 1e-14
True
>>> (q*r - m).norm() < 1e-14
True
>>> (q, r) = ha.O.random_array().QR(inner_space=hb)
>>> (q.space, r.space)
(|a><b|, |b><a|)

T¶

HilbertArray.T(self)

Returns the transpose of this array.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> x = ha.array([1j, 0]); x
HilbertArray(|a>,
array([ 0.+1.j,  0.+0.j]))
>>> x.T
HilbertArray(<a|,
array([ 0.+1.j,  0.+0.j]))
>>> y = ha.O.array([[1+2j, 3+4j], [5+6j, 7+8j]]); y
HilbertArray(|a><a|,
array([[ 1.+2.j,  3.+4.j],
       [ 5.+6.j,  7.+8.j]]))
>>> y.T
HilbertArray(|a><a|,
array([[ 1.+2.j,  5.+6.j],
       [ 3.+4.j,  7.+8.j]]))

apply_map(self, fn)¶

Apply the given function to each element of the array.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> v = ha.array([1, -2])
>>> v.apply_map(lambda x: abs(x))
HilbertArray(|a>,
array([ 1.+0.j,  2.+0.j]))

as_np_matrix(self, dtype=None, row_space=None, col_space=None)¶

Returns the underlying data as a numpy.matrix. Returns a copy, not a view.

Parameters:	dtype – datatype of returned matrix. row_space (HilbertSpace, list, or tuple) – the HilbertSpace to use for the row space of the matrix, default is the bra space of the input array. col_space (HilbertSpace, list, or tuple) – the HilbertSpace to use for the column space of the matrix, default is the ket space of the input array.

>>> import numpy
>>> from qitensor import qubit, qudit
>>> ha = qubit('a')
>>> hb = qudit('b', 3)
>>> x = (ha.O * hb).random_array()
>>> x.space
|a,b><a|
>>> x.as_np_matrix().shape
(6, 2)
>>> # returns a copy, not a view
>>> x.as_np_matrix().fill(0); x.norm() == 0
False
>>> x.as_np_matrix(col_space=ha.O).shape
(4, 3)
>>> x.as_np_matrix(row_space=ha.O).shape
(3, 4)
>>> numpy.allclose(x.as_np_matrix(col_space=ha.O), x.as_np_matrix(row_space=ha.O).T)
True

assert_density_matrix(self, check_hermitian=True, check_normalized=True, check_positive=True)¶

Throws an error unless the input is a density matrix.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> hb = qubit('b')

>>> ha.random_density().assert_density_matrix()
>>> # small errors are accepted
>>> (ha.random_density() + ha.O.random_array()*1e-14).assert_density_matrix()

>>> ha.eye().assert_density_matrix()
Traceback (most recent call last):
    ...
HilbertError: 'density matrix was not normalized: trace=(2+0j)'

>>> (ha.ket(0) * hb.bra(0)).assert_density_matrix()
Traceback (most recent call last):
    ...
HilbertError: 'not a density matrix: |a><b|'

>>> ha.random_unitary().assert_density_matrix()
Traceback (most recent call last):
    ...
HilbertError: 'not a density matrix: not Hermitian'

>>> U = ha.random_unitary()
>>> (U * ha.diag([ 1.1, -0.1 ]) * U.H).assert_density_matrix()
Traceback (most recent call last):
    ...
HilbertError: 'not a density matrix: had negative eigenvalue (-0.1)'

axes¶: axes: list

closeto(self, other, rtol=1e-05, atol=1e-08)¶

Checks whether two arrays are nearly equal, similar to numpy.allclose.

For details, see the numpy.allclose documentation.

>>> from qitensor import qudit
>>> ha = qudit('a', 10)
>>> x = ha.random_array()
>>> y = ha.random_array()
>>> x.closeto(y)
False
>>> x.closeto(x * (1+1e-10))
True
>>> x == x * (1+1e-10)
False

conj(self)¶

Returns the complex conjugate of this array.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> x = ha.array([1j, 0]); x
HilbertArray(|a>,
array([ 0.+1.j,  0.+0.j]))
>>> x.conj()
HilbertArray(|a>,
array([ 0.-1.j,  0.-0.j]))
>>> y = ha.O.array([[1+2j, 3+4j], [5+6j, 7+8j]]); y
HilbertArray(|a><a|,
array([[ 1.+2.j,  3.+4.j],
       [ 5.+6.j,  7.+8.j]]))
>>> y.conj()
HilbertArray(|a><a|,
array([[ 1.-2.j,  3.-4.j],
       [ 5.-6.j,  7.-8.j]]))

conj_by(self, U)¶

Returns U*self*U.H.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> U = ha.random_unitary()
>>> x = ha.random_density()
>>> (U*x*U.H - x.conj_by(U)).norm() < 1e-13
True

copy(self)¶

Creates a copy (not a view) of this array.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> x = ha.array([1, 2]); x
HilbertArray(|a>,
array([ 1.+0.j,  2.+0.j]))
>>> y = x.copy()
>>> y[0] = 3
>>> y
HilbertArray(|a>,
array([ 3.+0.j,  2.+0.j]))
>>> x
HilbertArray(|a>,
array([ 1.+0.j,  2.+0.j]))

det(self)¶

Returns the matrix determinant of this array.

It is required that the dimension of the bra space be equal to the dimension of the ket space.

>>> import numpy.linalg
>>> from qitensor import qubit, qudit
>>> ha = qubit('a')
>>> hb = qubit('b')
>>> hc = qudit('c', 4)
>>> y = (ha * hb * hc.H).random_array()
>>> abs( y.det() - numpy.linalg.det(y.as_np_matrix()) ) < 1e-14
True

diag(self, as_np=False)¶

Returns the diagonal elements of this operator, as a ket vector (if as_np=False) or as a numpy array (if as_np=True). Only applicable to square operators.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> hb = qubit('b')
>>> A = ha.O.array([[1,2],[3,4]])
>>> B = hb.O.array([[1,10],[100,1000]])
>>> A.diag()
HilbertArray(|a>,
array([ 1.+0.j,  4.+0.j]))
>>> A.diag(as_np=True)
array([ 1.+0.j,  4.+0.j])
>>> (A*B).diag()
HilbertArray(|a,b>,
array([[    1.+0.j,  1000.+0.j],
       [    4.+0.j,  4000.+0.j]]))
>>> (A*B).diag(as_np=True)
array([    1.+0.j,  1000.+0.j,     4.+0.j,  4000.+0.j])

eig(self, w_space=None, hermit=False)¶

Return the eigenvalues and right eigenvectors of this array.

Parameters:	w_space (HilbertSpace; default None) – space for the diagonal matrix, if None the space of the input array is used. hermit (bool; default False) – set this to True if the input is Hermitian

NOTE: in the case of degenerate eigenvalues, with hermit=False, it may be the case that the returned eigenvectors array is not full rank. See the documentation for numpy.linalg.eig for details.

>>> from qitensor import qubit, qudit
>>> ha = qubit('a')
>>> hb = qudit('b', 3)
>>> hc = qudit('c', 6)
>>> epsilon = 1e-13

>>> op = (ha*hb).O.random_array()
>>> # make a normal operator
>>> op = op.H * op
>>> (W, V) = op.eig()
>>> V.space
|a,b><a,b|
>>> W.space
|a,b><a,b|
>>> (V.H * V - (ha*hb).eye()).norm() < epsilon
True
>>> (V.H * op * V - W).norm() < epsilon
True
>>> (op * V - V * W).norm() < epsilon
True

>>> # NOTE: this is not a normal operator, so V won't be unitary.
>>> op = (ha*hb).O.random_array()
>>> (W, V) = op.eig(w_space=hc)
>>> V.space
|a,b><c|
>>> W.space
|c><c|
>>> (op * V - V * W).norm() < epsilon
True

>>> vec = hb.random_array().normalized()
>>> dyad = vec * vec.H
>>> (W, V) = dyad.eig(hermit=True)
>>> (W - hb.diag([1, 0, 0])).norm() < epsilon
True
>>> (V.H * V - hb.eye()).norm() < epsilon
True
>>> vec2 = V[:, 0]
>>> # Correct for phase ambiguity
>>> vec2 *= (vec[0]/vec2[0]) / abs(vec[0]/vec2[0])
>>> (vec - vec2).norm() < epsilon
True

eigvals(self, hermit=False)¶

Return the eigenvalues of this array, sorted in order of decreasing real component.

Parameters:	hermit (bool; default False) – set this to True if the input is Hermitian. In this case, the returned eigenvalues will be real.

>>> from qitensor import qubit, qudit
>>> ha = qubit('a')
>>> hb = qudit('b', 3)
>>> epsilon = 1e-13

>>> op = (ha*hb).O.random_array()
>>> # make a normal operator
>>> op = op.H * op
>>> (W1, V1) = op.eig()
>>> W2 = op.eigvals()
>>> (ha*hb).diag(W2) == W1
True

entropy(self, normalize=False, checks=True)¶

Returns the von Neumann entropy of a density operator, in bits.

Parameters:	normalize (bool; default False) – if True, the input is automatically normalized to trace one. If false, an exception is raised if the trace is not one. checks (bool; default True) – if False, don’t check that the input is a valid density matrix or Hermitian. This is sometimes needed for symbolic computations.

>>> import numpy as np
>>> from qitensor import qubit, qudit
>>> ha = qubit('a')
>>> hb = qudit('b', 3)
>>> # entropy of a pure state is zero
>>> ha.ket(0).O.entropy()
0.0
>>> # a fully mixed state of dimension 2
>>> (ha.ket(0).O/2 + ha.ket(1).O/2).entropy()
1.0
>>> # a fully mixed state of dimension 3
>>> abs( (hb.eye()/3).entropy() - np.log2(3) ) < 1e-10
True
>>> # automatic normalization
>>> abs( hb.eye().entropy(normalize=True) - np.log2(3) ) < 1e-10
True
>>> # a bipartite pure state
>>> s = (ha.ket(0) * hb.array([1/np.sqrt(2),0,0]) + ha.ket(1) * hb.array([0,0.5,0.5]))
>>> np.round(s.O.entropy(), 10)
0.0
>>> # entanglement across the a-b cut
>>> (s.O.trace(hb)).entropy()
1.0
>>> # entanglement across the a-b cut is the same as across b-a cut
>>> s = (ha*hb).random_array().normalized().O
>>> abs(s.trace(ha).entropy() - s.trace(hb).entropy()) < 1e-10
True

expm(self)¶

Return the matrix exponential of this array.

It is required that the dimension of the bra space be equal to the dimension of the ket space.

>>> import numpy
>>> from qitensor import qubit
>>> ha = qubit('a')
>>> ((ha.X * numpy.pi * 1j).expm() + ha.eye()).norm() < 1e-12
True

fill(self, val)¶

Fills every entry of this array with a constant value.

NOTE: the array is modified in-place and is not returned.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> x = ha.random_array()
>>> x.fill(2)
>>> x
HilbertArray(|a>,
array([ 2.+0.j,  2.+0.j]))

get_dim(self, atom)¶

Returns the axis corresponding to the given HilbertAtom.

This is useful when working with the underlying numpy array.

>>> from qitensor import qubit
>>> ha = qubit('a')
>>> hb = qubit('b')
>>> x = (ha * hb).array([[1, 2], [4, 8]])
>>> [x.get_dim(h) for h in (ha, hb)]
[0, 1]
>>> x.nparray.sum(axis=x.get_dim(ha))
array([  5.+0.j,  10.+0.j])
>>> x.nparray.sum(axis=x.get_dim(hb))
array([  3.+0.j,  12.+0.j])

inv(self, row_space=None)¶

Returns the matrix inverse of this array.

Parameters:	row_space (HilbertSpace, list, or tuple) – the HilbertSpace to use for the row space of the matrix, default is the bra space of the input array. This parameter allows computing the inverse of the cross operator.

Arrays (a.k.a. vectors, tensors, operators)¶

Previous topic

Next topic

This Page

Navigation

Arrays (a.k.a. vectors, tensors, operators)¶

Previous topic

Next topic

This Page

Quick search

Navigation