def check_trace_preservation(supop_builder, supop_setup):
"""Make sure that the identity component of the density operator doesn't
evolve.
:param supop_builder: Function that constructs a superoperator matrix
given the output from supop_setup.
:param supop_setup: Function that takes a coupling op and basis (minus
identity) as arguments and returns the arguments
needed for supop_builder to construct the
appropriate matrix.
"""
for dim in range(2, 3 + 1):
for row in range(dim):
for col in range(dim):
# Couple using all the different Gell-Mann matrices
c_op = gm.gellmann(row + 1, col + 1, dim)
kwargs = supop_setup(c_op, basis(dim)[:-1])
D_matrix = supop_builder(**kwargs)
for entry in D_matrix[-1]:
assert_almost_equal(0, entry, 7)
for dim in range(2, 3 + 1):
np.random.seed(dim)
# Couple using random matrices
rand_c_op = np.random.randn(dim, dim) + 1.j * np.random.randn(dim, dim)
kwargs = supop_setup(rand_c_op, basis(dim)[:-1])
D_matrix = sb.diffusion_op(**kwargs)
for entry in D_matrix[-1]:
assert_almost_equal(0, entry, 7)
def check_trace_preservation(supop_builder, supop_setup):
"""Make sure that the identity component of the density operator doesn't
evolve.
:param supop_builder: Function that constructs a superoperator matrix
given the output from supop_setup.
:param supop_setup: Function that takes a coupling op and basis (minus
identity) as arguments and returns the arguments
needed for supop_builder to construct the
appropriate matrix.
"""
for dim in range(2, 3 + 1):
for row in range(dim):
for col in range(dim):
# Couple using all the different Gell-Mann matrices
c_op = gm.gellmann(row + 1, col + 1, dim)
kwargs = supop_setup(c_op, basis(dim)[:-1])
D_matrix = supop_builder(**kwargs)
for entry in D_matrix[-1]:
assert_almost_equal(0, entry, 7)
for dim in range(2, 3 + 1):
np.random.seed(dim)
# Couple using random matrices
rand_c_op = np.random.randn(dim, dim) + 1.j*np.random.randn(dim, dim)
kwargs = supop_setup(rand_c_op, basis(dim)[:-1])
D_matrix = sb.diffusion_op(**kwargs)
for entry in D_matrix[-1]:
assert_almost_equal(0, entry, 7)
def basis(n):
"""Return an orthogonal basis for n-by-n operators, with the identity in the
last position.
"""
return [gm.gellmann(j, k, n) for j in range(1, n + 1) for k in
range(1, n + 1)]
def basis(n):
"""Return an orthogonal basis for n-by-n operators, with the identity in the
last position.
"""
return [gm.gellmann(j, k, n) for j in range(1, n + 1) for k in
range(1, n + 1)]
def test_gellmann():
for d in range(1, 5 + 1):
matrices = [[gm.gellmann(j, k, d) for k in range(1, d + 1)]
for j in range(1, d + 1)]
for j in range(1, d + 1):
for k in range(1, d + 1):
check_hermitian(matrices[j - 1][k - 1])
if j != d or k != d:
check_traceless(matrices[j - 1][k - 1])
check_norm(matrices[j - 1][k - 1], np.sqrt(2))
else:
check_norm(matrices[j - 1][k - 1], np.sqrt(d))
for jj in range(1, d + 1):
for kk in range(1, d + 1):
if jj != j or kk != k:
check_orthogonal(matrices[j - 1][k - 1],
matrices[jj - 1][kk - 1])
def test_gellmann():
for d in range(1, 5 + 1):
matrices = [ [ gm.gellmann(j, k, d) for k in range(1, d + 1) ] for j in
range(1, d + 1) ]
for j in range(1, d + 1):
for k in range(1, d + 1):
check_hermitian(matrices[j - 1][k - 1])
if j != d or k != d:
check_traceless(matrices[j - 1][k - 1])
check_norm(matrices[j - 1][k - 1], np.sqrt(2))
else:
check_norm(matrices[j - 1][k - 1], np.sqrt(d))
for jj in range(1, d + 1):
for kk in range(1, d + 1):
if jj != j or kk != k:
check_orthogonal(matrices[j - 1][k - 1],
matrices[jj - 1][kk - 1])
def orthonormalize(A):
"""Return an orthonormal basis in which `A` has a sparse representation.
`A` will have support only on the first three elements. The first element
is guaranteed to be proportional to the identity. This basis is
constructed using Gram-Schmidt orthogonalization.
Parameters
----------
A : numpy.array
The operator to be represented sparsely.
Returns
-------
list of numpy.array
A basis in which `A` is represented sparsely.
"""
d = max(A.shape) # Code won't currently work unless A is square.
G = [ [ gm.gellmann(j, k, d) for k in range(1, d + 1) ] for j in
range(1, d + 1) ]
ordering = list(product(range(1, d + 1), range(1, d + 1)))
hermitian = (A + A.conj().T)/2
antiherm = (A - A.conj().T)/2.j
hermitian_comps = [np.trace(np.dot(hermitian, G[j - 1][k - 1]))/np.sqrt(2)
if j != d or k!= d else
np.trace(np.dot(hermitian, G[j - 1][k - 1]))/np.sqrt(d)
for j, k in ordering]
antiherm_comps = [np.trace(np.dot(antiherm, G[j - 1][k - 1]))/np.sqrt(2)
if j != d or k!= d else
np.trace(np.dot(antiherm, G[j - 1][k - 1]))/np.sqrt(d)
for j, k in ordering]
# Identify the Gell-Mann matrices that have the most support on the
# Hermitian and anti-Hermitian parts of A (other than identity) so that they
# can be discarded prior to Gram-Schmidt orthogonalization.
max_comps = [max(abs(herm_comp), abs(anti_comp)) if j != d or k != d else 0
for herm_comp, anti_comp, (j, k)
in zip(hermitian_comps, antiherm_comps, ordering)]
# Ensure the identity is the first element in this list.
ordered_max_comps = [list(enumerate(max_comps))[-1]] + \
sorted(list(enumerate(max_comps))[0:-1], key=lambda elem: elem[1])
discarded_indices = [ordered_max_comps[-1][0], ordered_max_comps[-2][0]]
other_vectors = [ [ 0 if n != idx else 1 for n in range(d**2) ] for idx in
range(d**2) if not idx in discarded_indices ]
vector_set = np.array([other_vectors[-1], hermitian_comps, antiherm_comps] +
other_vectors[0:-1]).T.real
basis, R = np.linalg.qr(vector_set)
basis = np.dot(basis, np.diag([1 if elem >= 0 else -1
for elem in np.diag(R)]))
basis = basis.T
G_new = [sum([G[j-1][k-1]*coeff/np.sqrt(2) if j != d or k!= d
else G[j-1][k-1]*coeff/np.sqrt(d) for coeff, (j, k)
in zip(vect, ordering)]) for vect in basis]
A_coeffs = [
np.trace(np.dot(G_new[0], A)),
np.trace(np.dot(G_new[1], A)),
np.trace(np.dot(G_new[2], A)),
]
A_recon = A_coeffs[0]*G_new[0] + A_coeffs[1]*G_new[1] + A_coeffs[2]*G_new[2]
return G_new
def orthonormalize(A):
"""Return an orthonormal basis in which `A` has a sparse representation.
`A` will have support only on the first three elements. The first element
is guaranteed to be proportional to the identity. This basis is
constructed using Gram-Schmidt orthogonalization.
Parameters
----------
A : numpy.array
The operator to be represented sparsely.
Returns
-------
list of numpy.array
A basis in which `A` is represented sparsely.
"""
d = max(A.shape) # Code won't currently work unless A is square.
G = [[gm.gellmann(j, k, d) for k in range(1, d + 1)]
for j in range(1, d + 1)]
ordering = list(product(range(1, d + 1), range(1, d + 1)))
hermitian = (A + A.conj().T) / 2
antiherm = (A - A.conj().T) / 2.j
hermitian_comps = [
np.trace(np.dot(hermitian, G[j - 1][k - 1])) / np.sqrt(2)
if j != d or k != d else np.trace(np.dot(hermitian, G[j - 1][k - 1])) /
np.sqrt(d) for j, k in ordering
]
antiherm_comps = [
np.trace(np.dot(antiherm, G[j - 1][k - 1])) / np.sqrt(2) if j != d
or k != d else np.trace(np.dot(antiherm, G[j - 1][k - 1])) / np.sqrt(d)
for j, k in ordering
]
# Identify the Gell-Mann matrices that have the most support on the
# Hermitian and anti-Hermitian parts of A (other than identity) so that they
# can be discarded prior to Gram-Schmidt orthogonalization.
max_comps = [
max(abs(herm_comp), abs(anti_comp)) if j != d or k != d else 0
for herm_comp, anti_comp, (
j, k) in zip(hermitian_comps, antiherm_comps, ordering)
]
# Ensure the identity is the first element in this list.
ordered_max_comps = [list(enumerate(max_comps))[-1]] + \
sorted(list(enumerate(max_comps))[0:-1], key=lambda elem: elem[1])
discarded_indices = [ordered_max_comps[-1][0], ordered_max_comps[-2][0]]
other_vectors = [[0 if n != idx else 1 for n in range(d**2)]
for idx in range(d**2) if not idx in discarded_indices]
vector_set = np.array(
[other_vectors[-1], hermitian_comps, antiherm_comps] +
other_vectors[0:-1]).T.real
basis, R = np.linalg.qr(vector_set)
basis = np.dot(basis,
np.diag([1 if elem >= 0 else -1 for elem in np.diag(R)]))
basis = basis.T
G_new = [
sum([
G[j - 1][k - 1] * coeff /
np.sqrt(2) if j != d or k != d else G[j - 1][k - 1] * coeff /
np.sqrt(d) for coeff, (j, k) in zip(vect, ordering)
]) for vect in basis
]
A_coeffs = [
np.trace(np.dot(G_new[0], A)),
np.trace(np.dot(G_new[1], A)),
np.trace(np.dot(G_new[2], A)),
]
A_recon = A_coeffs[0] * G_new[0] + A_coeffs[1] * G_new[1] + A_coeffs[
2] * G_new[2]
return G_new