def test_hamiltonian_eigenvalues(dtype, sparse_type, dense):
"""Testing hamiltonian eigenvalues scaling."""
if sparse_type is None:
H1 = hamiltonians.XXZ(nqubits=2, delta=0.5, dense=dense)
else:
from scipy import sparse
H1 = hamiltonians.XXZ(nqubits=5, delta=0.5)
m = getattr(sparse, f"{sparse_type}_matrix")(K.to_numpy(H1.matrix))
H1 = hamiltonians.Hamiltonian(5, m)
H1_eigen = sorted(K.to_numpy(H1.eigenvalues()))
hH1_eigen = sorted(K.to_numpy(K.eigvalsh(H1.matrix)))
K.assert_allclose(sorted(H1_eigen), hH1_eigen)
c1 = dtype(2.5)
H2 = c1 * H1
H2_eigen = sorted(K.to_numpy(H2._eigenvalues))
hH2_eigen = sorted(K.to_numpy(K.eigvalsh(c1 * H1.matrix)))
K.assert_allclose(H2_eigen, hH2_eigen)
c2 = dtype(-11.1)
H3 = H1 * c2
if sparse_type is None:
H3_eigen = sorted(K.to_numpy(H3._eigenvalues))
hH3_eigen = sorted(K.to_numpy(K.eigvalsh(H1.matrix * c2)))
K.assert_allclose(H3_eigen, hH3_eigen)
else:
assert H3._eigenvalues is None
def test_gap(backend, dense, check_degenerate):
from qibo import hamiltonians
h0 = hamiltonians.X(4, dense=dense)
if check_degenerate:
# use h=0 to make this Hamiltonian degenerate
h1 = hamiltonians.TFIM(4, h=0, dense=dense)
else:
h1 = hamiltonians.TFIM(4, h=1, dense=dense)
ham = lambda t: (1 - t) * h0.matrix + t * h1.matrix
targets = {"ground": [], "excited": [], "gap": []}
for t in np.linspace(0, 1, 11):
eigvals = K.real(K.eigvalsh(ham(t)))
targets["ground"].append(eigvals[0])
targets["excited"].append(eigvals[1])
targets["gap"].append(eigvals[1] - eigvals[0])
if check_degenerate:
targets["gap"][-1] = eigvals[3] - eigvals[0]
gap = callbacks.Gap(check_degenerate=check_degenerate)
ground = callbacks.Gap(0)
excited = callbacks.Gap(1)
evolution = AdiabaticEvolution(h0,
h1,
lambda t: t,
dt=1e-1,
callbacks=[gap, ground, excited])
final_state = evolution(final_time=1.0)
targets = {k: K.stack(v) for k, v in targets.items()}
K.assert_allclose(ground[:], targets["ground"])
K.assert_allclose(excited[:], targets["excited"])
K.assert_allclose(gap[:], targets["gap"])
def entropy(self, rho):
"""Calculates entropy of a density matrix via exact diagonalization."""
# Diagonalize
eigvals = K.real(K.eigvalsh(rho))
# Treating zero and negative eigenvalues
drop_condition = eigvals > EIGVAL_CUTOFF
masked_eigvals = K.gather(eigvals, condition=drop_condition)
spectrum = -1 * K.log(masked_eigvals)
if self.compute_spectrum:
self.spectrum.append(spectrum)
entropy = K.sum(masked_eigvals * spectrum)
return entropy / self._log2
