def construct_hamiltonian():
if sparse_type is None:
return hamiltonians.XXZ(nqubits=2, delta=0.5, dense=dense)
else:
ham = hamiltonians.XXZ(nqubits=5, delta=0.5)
m = getattr(sparse, f"{sparse_type}_matrix")(K.to_numpy(ham.matrix))
return hamiltonians.Hamiltonian(5, m)
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_hamiltonian_exponentiation(dense):
from scipy.linalg import expm
H = hamiltonians.XXZ(nqubits=2, delta=0.5, dense=dense)
target_matrix = expm(-0.5j * K.to_numpy(H.matrix))
K.assert_allclose(H.exp(0.5), target_matrix)
H = hamiltonians.XXZ(nqubits=2, delta=0.5, dense=dense)
_ = H.eigenvectors()
K.assert_allclose(H.exp(0.5), target_matrix)
def test_hamiltonian_ground_state(sparse_type, dense):
"""Test Hamiltonian ground state."""
if sparse_type is None:
H = hamiltonians.XXZ(nqubits=2, delta=0.5, dense=dense)
else:
from scipy import sparse
H = hamiltonians.XXZ(nqubits=5, delta=0.5)
m = getattr(sparse, f"{sparse_type}_matrix")(K.to_numpy(H.matrix))
H = hamiltonians.Hamiltonian(5, m)
V = K.to_numpy(H.eigenvectors())
K.assert_allclose(H.ground_state(), V[:, 0])
def test_hamiltonian_operation_errors():
"""Testing hamiltonian not implemented errors."""
H1 = hamiltonians.XXZ(nqubits=2, delta=0.5)
H2 = hamiltonians.XXZ(nqubits=2, delta=0.1)
with pytest.raises(NotImplementedError):
R = H1 * H2
with pytest.raises(NotImplementedError):
R = H1 + "a"
with pytest.raises(NotImplementedError):
R = H2 - (2,)
with pytest.raises(NotImplementedError):
R = [3] - H1
def test_hamiltonian_algebraic_operations(dtype, sparse_type):
"""Test basic hamiltonian overloading."""
def transformation_a(a, b):
c1 = dtype(0.1)
return a + c1 * b
def transformation_b(a, b):
c1 = dtype(2)
c2 = dtype(3.5)
return c1 * a - b * c2
def transformation_c(a, b, use_eye=False):
c1 = dtype(4.5)
if use_eye:
return a + c1 * np.eye(a.shape[0]) - b
else:
return a + c1 - b
def transformation_d(a, b, use_eye=False):
c1 = dtype(10.5)
c2 = dtype(2)
if use_eye:
return c1 * np.eye(a.shape[0]) - a + c2 * b
else:
return c1 - a + c2 * b
if sparse_type is None:
H1 = hamiltonians.XXZ(nqubits=2, delta=0.5)
H2 = hamiltonians.XXZ(nqubits=2, delta=1)
mH1, mH2 = K.to_numpy(H1.matrix), K.to_numpy(H2.matrix)
else:
mH1 = sparse.rand(64, 64, format=sparse_type)
mH2 = sparse.rand(64, 64, format=sparse_type)
H1 = hamiltonians.Hamiltonian(6, mH1)
H2 = hamiltonians.Hamiltonian(6, mH2)
hH1 = transformation_a(mH1, mH2)
hH2 = transformation_b(mH1, mH2)
hH3 = transformation_c(mH1, mH2, use_eye=True)
hH4 = transformation_d(mH1, mH2, use_eye=True)
HT1 = transformation_a(H1, H2)
HT2 = transformation_b(H1, H2)
HT3 = transformation_c(H1, H2)
HT4 = transformation_d(H1, H2)
K.assert_allclose(hH1, HT1.matrix)
K.assert_allclose(hH2, HT2.matrix)
K.assert_allclose(hH3, HT3.matrix)
K.assert_allclose(hH4, HT4.matrix)
def test_qaoa_optimization(method, options, trotter, filename):
h = hamiltonians.XXZ(3, trotter=trotter)
qaoa = models.QAOA(h)
initial_p = [0.05, 0.06, 0.07, 0.08]
best, params = qaoa.minimize(initial_p, method=method, options=options)
if filename is not None:
utils.assert_regression_fixture(params, filename)
def main(nqubits, nlayers, varlayer=False, method="Powell", maxiter=None):
"""Performs a VQE circuit minimization test."""
print("Number of qubits:", nqubits)
print("Number of layers:", nlayers)
start_time = time.time()
if varlayer:
circuit = varlayer_circuit(nqubits, nlayers)
else:
circuit = standard_circuit(nqubits, nlayers)
hamiltonian = hamiltonians.XXZ(nqubits=nqubits)
vqe = models.VQE(circuit, hamiltonian)
creation_time = time.time() - start_time
target = np.real(np.min(hamiltonian.eigenvalues().numpy()))
print("\nTarget state =", target)
np.random.seed(0)
nparams = 2 * nqubits * nlayers + nqubits
initial_parameters = np.random.uniform(0, 2 * np.pi, nparams)
start_time = time.time()
options = {'disp': True, 'maxiter': maxiter}
best, params, _ = vqe.minimize(initial_parameters, method=method,
options=options, compile=False)
minimization_time = time.time() - start_time
epsilon = np.log10(1/np.abs(best-target))
print("Found state =", best)
print("Final eps =", epsilon)
print("\nCreation time =", creation_time)
print("Minimization time =", minimization_time)
print("Total time =", minimization_time + creation_time)
def test_trotter_hamiltonian_operation_errors():
"""Test errors in ``SymbolicHamiltonian`` addition and subtraction."""
h1 = hamiltonians.SymbolicHamiltonian(symbolic_tfim(3, h=1.0))
h2 = hamiltonians.SymbolicHamiltonian(symbolic_tfim(4, h=1.0))
with pytest.raises(RuntimeError):
h = h1 + h2
with pytest.raises(RuntimeError):
h = h1 - h2
with pytest.raises(NotImplementedError):
h = h1 + "test"
with pytest.raises(NotImplementedError):
h = "test" + h1
with pytest.raises(NotImplementedError):
h = h1 - "test"
with pytest.raises(NotImplementedError):
h = "test" - h1
with pytest.raises(NotImplementedError):
h = h1 * "test"
with pytest.raises(NotImplementedError):
h = h1 @ "test"
with pytest.raises(NotImplementedError):
h = h1 @ np.ones((2, 2, 2, 2))
h2 = hamiltonians.XXZ(3, dense=False)
with pytest.raises(NotImplementedError):
h = h1 @ h2
def main(nqubits,
nlayers,
backend,
varlayer=False,
method="Powell",
maxiter=None,
filename=None):
"""Performs a VQE circuit minimization test."""
qibo.set_backend(backend)
logs = BenchmarkLogger(filename)
logs.append({
"nqubits": nqubits,
"nlayers": nlayers,
"varlayer": varlayer,
"backend": qibo.get_backend(),
"precision": qibo.get_precision(),
"device": qibo.get_device(),
"threads": qibo.get_threads(),
"method": method,
"maxiter": maxiter
})
print("Number of qubits:", nqubits)
print("Number of layers:", nlayers)
print("Backend:", logs[-1]["backend"])
start_time = time.time()
if varlayer:
circuit = varlayer_circuit(nqubits, nlayers)
else:
circuit = standard_circuit(nqubits, nlayers)
hamiltonian = hamiltonians.XXZ(nqubits=nqubits)
vqe = models.VQE(circuit, hamiltonian)
logs[-1]["creation_time"] = time.time() - start_time
target = np.real(np.min(K.to_numpy(hamiltonian.eigenvalues())))
print("\nTarget state =", target)
np.random.seed(0)
nparams = 2 * nqubits * nlayers + nqubits
initial_parameters = np.random.uniform(0, 2 * np.pi, nparams)
start_time = time.time()
options = {'disp': False, 'maxiter': maxiter}
best, params, _ = vqe.minimize(initial_parameters,
method=method,
options=options,
compile=False)
logs[-1]["minimization_time"] = time.time() - start_time
epsilon = np.log10(1 / np.abs(best - target))
print("Found state =", best)
print("Final eps =", epsilon)
logs[-1]["best_energy"] = float(best)
logs[-1]["epsilon_energy"] = float(epsilon)
print("\nCreation time =", logs[-1]["creation_time"])
print("Minimization time =", logs[-1]["minimization_time"])
print("Total time =",
logs[-1]["minimization_time"] + logs[-1]["creation_time"])
logs.dump()
def test_hamiltonian_addition():
H1 = hamiltonians.Y(nqubits=3)
H2 = hamiltonians.TFIM(nqubits=3, h=1.0)
H = H1 + H2
matrix = H1.matrix + H2.matrix
K.assert_allclose(H.matrix, matrix)
H = H1 - 0.5 * H2
matrix = H1.matrix - 0.5 * H2.matrix
K.assert_allclose(H.matrix, matrix)
H1 = hamiltonians.XXZ(nqubits=2, delta=0.5)
H2 = hamiltonians.XXZ(nqubits=3, delta=0.1)
with pytest.raises(RuntimeError):
R = H1 + H2
with pytest.raises(RuntimeError):
R = H1 - H2
def test_hamiltonian_eigenvectors(dtype, dense):
"""Testing hamiltonian eigenvectors scaling."""
H1 = hamiltonians.XXZ(nqubits=2, delta=0.5, dense=dense)
V1 = K.to_numpy(H1.eigenvectors())
U1 = K.to_numpy(H1.eigenvalues())
K.assert_allclose(H1.matrix, V1 @ np.diag(U1) @ V1.T)
c1 = dtype(2.5)
H2 = c1 * H1
V2 = K.to_numpy(H2._eigenvectors)
U2 = K.to_numpy(H2._eigenvalues)
K.assert_allclose(H2.matrix, V2 @ np.diag(U2) @ V2.T)
c2 = dtype(-11.1)
H3 = H1 * c2
V3 = K.to_numpy(H3.eigenvectors())
U3 = K.to_numpy(H3._eigenvalues)
K.assert_allclose(H3.matrix, V3 @ np.diag(U3) @ V3.T)
c3 = dtype(0)
H4 = c3 * H1
V4 = K.to_numpy(H4._eigenvectors)
U4 = K.to_numpy(H4._eigenvalues)
K.assert_allclose(H4.matrix, V4 @ np.diag(U4) @ V4.T)
def main(nqubits, layers, maxsteps, T_max):
circuit = models.Circuit(nqubits)
for l in range(layers):
circuit.add((gates.RY(q, theta=0) for q in range(nqubits)))
circuit.add((gates.CZ(q, q + 1) for q in range(0, nqubits - 1, 2)))
circuit.add((gates.RY(q, theta=0) for q in range(nqubits)))
circuit.add((gates.CZ(q, q + 1) for q in range(1, nqubits - 2, 2)))
circuit.add(gates.CZ(0, nqubits - 1))
circuit.add((gates.RY(q, theta=0) for q in range(nqubits)))
problem_hamiltonian = hamiltonians.XXZ(nqubits)
easy_hamiltonian = hamiltonians.X(nqubits)
s = lambda t: t
aavqe = models.variational.AAVQE(circuit, easy_hamiltonian, problem_hamiltonian, s, nsteps=maxsteps, t_max=T_max)
initial_parameters = np.random.uniform(0, 2 * np.pi*0.1,
2 * nqubits * layers + nqubits)
best, params = aavqe.minimize(initial_parameters)
print('Final parameters: ', params)
print('Final energy: ', best)
#We compute the difference from the exact value to check performance
eigenvalue = problem_hamiltonian.eigenvalues()
print('Difference from exact value: ',best - K.real(eigenvalue[0]))
print('Log difference: ',-np.log10(best - K.real(eigenvalue[0])))
def test_hamiltonian_expectation_errors():
h = hamiltonians.XXZ(nqubits=3, delta=0.5)
state = random_complex((4, 4, 4))
with pytest.raises(ValueError):
h.expectation(state)
with pytest.raises(TypeError):
h.expectation("test")
def test_falqon_optimization(backend, delta_t, max_layers, tolerance,
filename):
h = hamiltonians.XXZ(3)
falqon = models.FALQON(h)
best, params, extra = falqon.minimize(delta_t, max_layers, tol=tolerance)
if filename is not None:
assert_regression_fixture(params, filename)
def test_vqe_custom_gates_errors():
"""Check that ``RuntimeError``s is raised when using custom gates."""
if "qibotf" not in qibo.K.available_backends: # pragma: no cover
pytest.skip("Custom backend not available.")
original_backend = qibo.get_backend()
qibo.set_backend("qibotf")
nqubits = 6
circuit = models.Circuit(nqubits)
for q in range(nqubits):
circuit.add(gates.RY(q, theta=0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
hamiltonian = hamiltonians.XXZ(nqubits=nqubits)
initial_parameters = np.random.uniform(0, 2 * np.pi, 2 * nqubits + nqubits)
v = models.VQE(circuit, hamiltonian)
# compile with custom gates
with pytest.raises(RuntimeError):
best, params, _ = v.minimize(initial_parameters,
method="BFGS",
options={'maxiter': 1},
compile=True)
# use SGD with custom gates
with pytest.raises(RuntimeError):
best, params, _ = v.minimize(initial_parameters,
method="sgd",
compile=False)
qibo.set_backend(original_backend)
def test_qaoa_optimization(backend, method, options, dense, filename):
if method == "sgd" and qibo.get_backend() != "tensorflow":
pytest.skip("Skipping SGD test for unsupported backend.")
h = hamiltonians.XXZ(3, dense=dense)
qaoa = models.QAOA(h)
initial_p = [0.05, 0.06, 0.07, 0.08]
best, params, _ = qaoa.minimize(initial_p, method=method, options=options)
if filename is not None:
assert_regression_fixture(params, filename)
def test_falqon_optimization_callback(backend):
class TestCallback:
def __call__(self, x):
return K.sum(x)
callback = TestCallback()
h = hamiltonians.XXZ(3)
falqon = models.FALQON(h)
best, params, extra = falqon.minimize(0.1, 5, callback=callback)
assert len(extra["callbacks"]) == 5
def main(nqubits, delta_t=.1, max_layers=100):
# create XXZ Hamiltonian for nqubits qubits
hamiltonian = hamiltonians.XXZ(nqubits)
# create FALQON model for this Hamiltonian
falqon = models.FALQON(hamiltonian)
best_energy, final_parameters = falqon.minimize(delta_t, max_layers)[:2]
print('The optimal energy found is', best_energy)
return best_energy, final_parameters
def main(nqubits,
nangles,
dense=True,
solver="exp",
method="Powell",
maxiter=None,
filename=None):
"""Performs a QAOA minimization test."""
print("Number of qubits:", nqubits)
print("Number of angles:", nangles)
logs = BenchmarkLogger(filename)
logs.append({
"nqubits": nqubits,
"nangles": nangles,
"dense": dense,
"solver": solver,
"backend": qibo.get_backend(),
"precision": qibo.get_precision(),
"device": qibo.get_device(),
"threads": qibo.get_threads(),
"method": method,
"maxiter": maxiter
})
hamiltonian = hamiltonians.XXZ(nqubits=nqubits, dense=dense)
start_time = time.time()
qaoa = models.QAOA(hamiltonian, solver=solver)
logs[-1]["creation_time"] = time.time() - start_time
target = np.real(np.min(K.to_numpy(hamiltonian.eigenvalues())))
print("\nTarget state =", target)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 0.1, nangles)
start_time = time.time()
options = {'disp': True, 'maxiter': maxiter}
best, params, _ = qaoa.minimize(initial_parameters,
method=method,
options=options)
logs[-1]["minimization_time"] = time.time() - start_time
logs[-1]["best_energy"] = float(best)
logs[-1]["target_energy"] = float(target)
logs[-1]["epsilon"] = np.log10(1 / np.abs(best - target))
print("Found state =", best)
print("Final eps =", logs[-1]["epsilon"])
print("\nCreation time =", logs[-1]["creation_time"])
print("Minimization time =", logs[-1]["minimization_time"])
print("Total time =",
logs[-1]["creation_time"] + logs[-1]["minimization_time"])
logs.dump()
def test_qaoa_optimization(backend, method, options, trotter, filename):
original_backend = qibo.get_backend()
if method == "sgd" and backend != "matmuleinsum":
pytest.skip("Skipping SGD test for unsupported backend.")
qibo.set_backend(backend)
h = hamiltonians.XXZ(3, trotter=trotter)
qaoa = models.QAOA(h)
initial_p = [0.05, 0.06, 0.07, 0.08]
best, params, _ = qaoa.minimize(initial_p, method=method, options=options)
if filename is not None:
assert_regression_fixture(params, filename)
qibo.set_backend(original_backend)
def test_hamiltonian_addition(sparse_type):
if sparse_type is None:
H1 = hamiltonians.Y(nqubits=3)
H2 = hamiltonians.TFIM(nqubits=3, h=1.0)
else:
H1 = hamiltonians.Hamiltonian(6, sparse.rand(64, 64, format=sparse_type))
H2 = hamiltonians.Hamiltonian(6, sparse.rand(64, 64, format=sparse_type))
H = H1 + H2
matrix = H1.matrix + H2.matrix
K.assert_allclose(H.matrix, matrix)
H = H1 - 0.5 * H2
matrix = H1.matrix - 0.5 * H2.matrix
K.assert_allclose(H.matrix, matrix)
H1 = hamiltonians.XXZ(nqubits=2, delta=0.5)
H2 = hamiltonians.XXZ(nqubits=3, delta=0.1)
with pytest.raises(RuntimeError):
R = H1 + H2
with pytest.raises(RuntimeError):
R = H1 - H2
def test_symbolicxxz_hamiltonian_to_dense(backend, nqubits, calcterms):
from qibo.symbols import X, Y, Z
sham = sum(X(i) * X(i + 1) for i in range(nqubits - 1))
sham += sum(Y(i) * Y(i + 1) for i in range(nqubits - 1))
sham += 0.5 * sum(Z(i) * Z(i + 1) for i in range(nqubits - 1))
sham += X(0) * X(nqubits - 1) + Y(0) * Y(nqubits -
1) + 0.5 * Z(0) * Z(nqubits - 1)
final_ham = hamiltonians.SymbolicHamiltonian(sham)
target_ham = hamiltonians.XXZ(nqubits)
if calcterms:
_ = final_ham.terms
K.assert_allclose(final_ham.matrix, target_ham.matrix, atol=1e-15)
def test_aavqe(backend, method, options, compile, filename, skip_parallel):
"""Performs a AAVQE circuit minimization test."""
original_threads = qibo.get_threads()
if method == 'parallel_L-BFGS-B': # pragma: no cover
if skip_parallel:
pytest.skip("Skipping parallel test.")
from qibo.tests.test_parallel import is_parallel_supported
backend_name = qibo.get_backend()
if not is_parallel_supported(backend_name):
pytest.skip(
"Skipping parallel test due to unsupported configuration.")
qibo.set_threads(1)
nqubits = 6
layers = 4
circuit = models.Circuit(nqubits)
for l in range(layers):
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(1, nqubits - 2, 2):
circuit.add(gates.CZ(q, q + 1))
circuit.add(gates.CZ(0, nqubits - 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
easy_hamiltonian = hamiltonians.X(nqubits)
problem_hamiltonian = hamiltonians.XXZ(nqubits)
s = lambda t: t
aavqe = models.AAVQE(circuit,
easy_hamiltonian,
problem_hamiltonian,
s,
nsteps=10,
t_max=1)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 2 * np.pi,
2 * nqubits * layers + nqubits)
best, params = aavqe.minimize(params=initial_parameters,
method=method,
options=options,
compile=compile)
if method == "cma":
# remove `outcmaes` folder
import shutil
shutil.rmtree("outcmaes")
if filename is not None:
assert_regression_fixture(params, filename, rtol=1e-2)
qibo.set_threads(original_threads)
def test_vqe(backend, method, options, compile, filename):
"""Performs a VQE circuit minimization test."""
original_backend = qibo.get_backend()
original_threads = qibo.get_threads()
if (method == "sgd" or compile) and backend != "matmuleinsum":
pytest.skip("Skipping SGD test for unsupported backend.")
qibo.set_backend(backend)
if method == 'parallel_L-BFGS-B':
device = qibo.get_device()
if device is not None and "GPU" in device: # pragma: no cover
pytest.skip("unsupported configuration")
import os
if os.name == 'nt': # pragma: no cover
pytest.skip("Parallel L-BFGS-B not supported on Windows.")
qibo.set_threads(1)
nqubits = 6
layers = 4
circuit = models.Circuit(nqubits)
for l in range(layers):
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(1, nqubits - 2, 2):
circuit.add(gates.CZ(q, q + 1))
circuit.add(gates.CZ(0, nqubits - 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
hamiltonian = hamiltonians.XXZ(nqubits=nqubits)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 2 * np.pi,
2 * nqubits * layers + nqubits)
v = models.VQE(circuit, hamiltonian)
best, params, _ = v.minimize(initial_parameters,
method=method,
options=options,
compile=compile)
if method == "cma":
# remove `outcmaes` folder
import shutil
shutil.rmtree("outcmaes")
if filename is not None:
assert_regression_fixture(params, filename)
qibo.set_backend(original_backend)
qibo.set_threads(original_threads)
def test_vqe(backend, method, options, compile, filename, skip_parallel):
"""Performs a VQE circuit minimization test."""
original_threads = qibo.get_threads()
if (method == "sgd" or compile) and qibo.get_backend() != "tensorflow":
pytest.skip("Skipping SGD test for unsupported backend.")
if method == 'parallel_L-BFGS-B': # pragma: no cover
if skip_parallel:
pytest.skip("Skipping parallel test.")
from qibo.tests.test_parallel import is_parallel_supported
backend_name = qibo.get_backend()
if not is_parallel_supported(backend_name):
pytest.skip(
"Skipping parallel test due to unsupported configuration.")
qibo.set_threads(1)
nqubits = 6
layers = 4
circuit = models.Circuit(nqubits)
for l in range(layers):
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(1, nqubits - 2, 2):
circuit.add(gates.CZ(q, q + 1))
circuit.add(gates.CZ(0, nqubits - 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
hamiltonian = hamiltonians.XXZ(nqubits=nqubits)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 2 * np.pi,
2 * nqubits * layers + nqubits)
v = models.VQE(circuit, hamiltonian)
best, params, _ = v.minimize(initial_parameters,
method=method,
options=options,
compile=compile)
if method == "cma":
# remove `outcmaes` folder
import shutil
shutil.rmtree("outcmaes")
if filename is not None:
assert_regression_fixture(params, filename)
qibo.set_threads(original_threads)
def test_hamiltonian_expectation(dense, density_matrix):
h = hamiltonians.XXZ(nqubits=3, delta=0.5, dense=dense)
matrix = K.to_numpy(h.matrix)
if density_matrix:
state = random_complex((8, 8))
state = state + state.T.conj()
norm = np.trace(state)
target_ev = np.trace(matrix.dot(state)).real
else:
state = random_complex(8)
norm = np.sum(np.abs(state)**2)
target_ev = np.sum(state.conj() * matrix.dot(state)).real
K.assert_allclose(h.expectation(state), target_ev)
K.assert_allclose(h.expectation(state, True), target_ev / norm)
def test_hamiltonian_eigenvalues(dtype, dense):
"""Testing hamiltonian eigenvalues scaling."""
H1 = hamiltonians.XXZ(nqubits=2, delta=0.5, dense=dense)
H1_eigen = H1.eigenvalues()
hH1_eigen = np.linalg.eigvalsh(H1.matrix)
K.assert_allclose(H1_eigen, hH1_eigen)
c1 = dtype(2.5)
H2 = c1 * H1
hH2_eigen = np.linalg.eigvalsh(c1 * H1.matrix)
K.assert_allclose(H2._eigenvalues, hH2_eigen)
c2 = dtype(-11.1)
H3 = H1 * c2
hH3_eigen = np.linalg.eigvalsh(H1.matrix * c2)
K.assert_allclose(H3._eigenvalues, hH3_eigen)
def test_hamiltonian_expectation(backend, dense, density_matrix, sparse_type):
"""Test Hamiltonian expectation value calculation."""
if sparse_type is None:
h = hamiltonians.XXZ(nqubits=3, delta=0.5, dense=dense)
else:
h = hamiltonians.Hamiltonian(6, random_sparse_matrix(64, sparse_type))
matrix = K.to_numpy(h.matrix)
if density_matrix:
state = random_complex((2 ** h.nqubits, 2 ** h.nqubits))
state = state + state.T.conj()
norm = np.trace(state)
target_ev = np.trace(matrix.dot(state)).real
else:
state = random_complex(2 ** h.nqubits)
norm = np.sum(np.abs(state) ** 2)
target_ev = np.sum(state.conj() * matrix.dot(state)).real
K.assert_allclose(h.expectation(state), target_ev)
K.assert_allclose(h.expectation(state, True), target_ev / norm)
def main(nqubits,
nangles,
trotter=False,
solver="exp",
method="Powell",
maxiter=None):
"""Performs a QAOA minimization test."""
print("Number of qubits:", nqubits)
print("Number of angles:", nangles)
hamiltonian = hamiltonians.XXZ(nqubits=nqubits, trotter=trotter)
start_time = time.time()
qaoa = models.QAOA(hamiltonian, solver=solver)
creation_time = time.time() - start_time
target = np.real(np.min(hamiltonian.eigenvalues().numpy()))
print("\nTarget state =", target)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 0.1, nangles)
start_time = time.time()
options = {'disp': True, 'maxiter': maxiter}
best, params, _ = qaoa.minimize(initial_parameters,
method=method,
options=options)
minimization_time = time.time() - start_time
epsilon = np.log10(1 / np.abs(best - target))
print("Found state =", best)
print("Final eps =", epsilon)
print("\nCreation time =", creation_time)
print("Minimization time =", minimization_time)
print("Total time =", minimization_time + creation_time)
