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)