def test_adiabatic_evolution_errors(): """Test errors of ``AdiabaticEvolution`` model.""" # Hamiltonians of bad type h0 = hamiltonians.X(3) s = lambda t: t with pytest.raises(TypeError): adev = models.AdiabaticEvolution(h0, lambda t: h0, s, dt=1e-2) h1 = hamiltonians.TFIM(2) with pytest.raises(TypeError): adev = models.AdiabaticEvolution(lambda t: h1, h1, s, dt=1e-2) # Hamiltonians with different number of qubits with pytest.raises(ValueError): adev = models.AdiabaticEvolution(h0, h1, s, dt=1e-2) # s with three arguments h0 = hamiltonians.X(2) s = lambda t, a, b: t + a + b with pytest.raises(ValueError): adev = models.AdiabaticEvolution(h0, h1, s, dt=1e-2) # s(0) != 0 with pytest.raises(ValueError): adev = models.AdiabaticEvolution(h0, h1, lambda t: t + 1, dt=1e-2) # s(T) != 0 with pytest.raises(ValueError): adev = models.AdiabaticEvolution(h0, h1, lambda t: t / 2, dt=1e-2) # Non-zero ``start_time`` adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=1e-2) with pytest.raises(NotImplementedError): final_state = adev(final_time=2, start_time=1) # execute without specifying variational parameters sp = lambda t, p: (1 - p) * np.sqrt(t) + p * t adevp = models.AdiabaticEvolution(h0, h1, sp, dt=1e-1) with pytest.raises(ValueError): final_state = adevp(final_time=1)
def test_trotter_hamiltonian_t(nqubits, h=1.0, dt=1e-3): """Test using ``TrotterHamiltonian`` in adiabatic evolution model.""" dense_h0 = hamiltonians.X(nqubits) dense_h1 = hamiltonians.TFIM(nqubits, h=h) dense_adev = models.AdiabaticEvolution(dense_h0, dense_h1, lambda t: t, dt) local_h0 = hamiltonians.X(nqubits, trotter=True) local_h1 = hamiltonians.TFIM(nqubits, h=h, trotter=True) local_adev = models.AdiabaticEvolution(local_h0, local_h1, lambda t: t, dt) for t in np.random.random(10): local_matrix = local_adev.hamiltonian(t, total_time=1).dense.matrix target_matrix = dense_adev.hamiltonian(t, total_time=1).matrix np.testing.assert_allclose(local_matrix, target_matrix)
def test_energy_callback(solver, dt, atol): """Test using energy callback in adiabatic evolution.""" h0 = hamiltonians.X(2) h1 = hamiltonians.TFIM(2) energy = callbacks.Energy(h1) adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=dt, callbacks=[energy], solver=solver) final_psi = adev(final_time=1) target_psi = np.ones(4) / 2 calc_energy = lambda psi: psi.conj().dot(K.to_numpy(h1.matrix).dot(psi)) target_energies = [calc_energy(target_psi)] ham = lambda t: h0 * (1 - t) + h1 * t for n in range(int(1 / dt)): prop = K.to_numpy(ham(n * dt).exp(dt)) target_psi = prop.dot(target_psi) target_energies.append(calc_energy(target_psi)) assert_states_equal(final_psi, target_psi, atol=atol) target_energies = K.cast(target_energies) K.assert_allclose(energy[:], target_energies, atol=atol)
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_adiabatic_evolution_hamiltonian(backend, dense): """Test adiabatic evolution hamiltonian as a function of time.""" h0 = hamiltonians.X(2, dense=dense) h1 = hamiltonians.TFIM(2, dense=dense) adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=1e-2) # try accessing hamiltonian before setting it with pytest.raises(RuntimeError): adev.hamiltonian(0.1) m1 = np.array([[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]]) m2 = np.diag([2, -2, -2, 2]) ham = lambda t, T: -(1 - t / T) * m1 - (t / T) * m2 adev.hamiltonian.total_time = 1 for t in [0, 0.3, 0.7, 1.0]: if dense: matrix = adev.hamiltonian(t).matrix else: matrix = adev.hamiltonian(t).dense.matrix K.assert_allclose(matrix, ham(t, 1)) #try using a different total time adev.hamiltonian.total_time = 2 for t in [0, 0.3, 0.7, 1.0]: if dense: matrix = adev.hamiltonian(t).matrix else: matrix = adev.hamiltonian(t).dense.matrix K.assert_allclose(matrix, ham(t, 2))
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 = np.linalg.eigvalsh(ham(t)).real 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 test_qaoa_execution(backend, solver, dense, accel=None): h = hamiltonians.TFIM(6, h=1.0, dense=dense) m = hamiltonians.X(6, dense=dense) # Trotter and RK require small p's! params = 0.01 * (1 - 2 * np.random.random(4)) state = random_state(6) # set absolute test tolerance according to solver if "rk" in solver: atol = 1e-2 elif not dense: atol = 1e-5 else: atol = 0 target_state = np.copy(state) h_matrix = K.to_numpy(h.matrix) m_matrix = K.to_numpy(m.matrix) for i, p in enumerate(params): if i % 2: u = expm(-1j * p * m_matrix) else: u = expm(-1j * p * h_matrix) target_state = u @ target_state qaoa = models.QAOA(h, mixer=m, solver=solver, accelerators=accel) qaoa.set_parameters(params) final_state = qaoa(np.copy(state)) K.assert_allclose(final_state, target_state, atol=atol)
def test_qaoa_execution(solver, trotter, accelerators): h = hamiltonians.TFIM(4, h=1.0, trotter=trotter) m = hamiltonians.X(4, trotter=trotter) # Trotter and RK require small p's! params = 0.01 * (1 - 2 * np.random.random(4)) state = utils.random_numpy_state(4) # set absolute test tolerance according to solver if "rk" in solver: atol = 1e-2 elif trotter: atol = 1e-5 else: atol = 0 target_state = np.copy(state) h_matrix = h.matrix.numpy() m_matrix = m.matrix.numpy() for i, p in enumerate(params): if i % 2: u = expm(-1j * p * m_matrix) else: u = expm(-1j * p * h_matrix) target_state = u @ target_state qaoa = models.QAOA(h, mixer=m, solver=solver, accelerators=accelerators) qaoa.set_parameters(params) final_state = qaoa(np.copy(state)) np.testing.assert_allclose(final_state, target_state, atol=atol)
def main(nqubits_list, dt, solver, trotter=False, accelerators=None): """Performs adiabatic evolution with critical TFIM as the "hard" Hamiltonian.""" if accelerators is not None: trotter = True solver = "exp" print(f"Using {solver} solver and dt = {dt}.") print(f"Accelerators: {accelerators}") for nqubits in nqubits_list: start_time = time.time() h0 = hamiltonians.X(nqubits, trotter=trotter) h1 = hamiltonians.TFIM(nqubits, h=1.0, trotter=trotter) ham_creation_time = time.time() - start_time print(f"\nnqubits = {nqubits}, solver = {solver}") print(f"trotter = {trotter}, accelerators = {accelerators}") print("Hamiltonians created in:", ham_creation_time) start_time = time.time() evolution = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=dt, solver=solver, accelerators=accelerators) creation_time = time.time() - start_time print("Evolution model created in:", creation_time) start_time = time.time() final_psi = evolution(final_time=1.0) simulation_time = time.time() - start_time print("Simulation time:", simulation_time)
def test_gap(backend, trotter, check_degenerate): original_backend = qibo.get_backend() qibo.set_backend(backend) from qibo import hamiltonians h0 = hamiltonians.X(4, trotter=trotter) if check_degenerate: # use h=0 to make this Hamiltonian degenerate h1 = hamiltonians.TFIM(4, h=0, trotter=trotter) else: h1 = hamiltonians.TFIM(4, h=1, trotter=trotter) ham = lambda t: (1 - t) * h0.matrix + t * h1.matrix targets = {"ground": [], "excited": [], "gap": []} for t in np.linspace(0, 1, 11): eigvals = np.linalg.eigvalsh(ham(t)).real 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) np.testing.assert_allclose(ground[:], targets["ground"]) np.testing.assert_allclose(excited[:], targets["excited"]) np.testing.assert_allclose(gap[:], targets["gap"]) qibo.set_backend(original_backend)
def test_gap(trotter): """Check gap callback for adiabatic evolution model.""" from qibo import hamiltonians h0 = hamiltonians.X(3, trotter=trotter) h1 = hamiltonians.TFIM(3, h=1.0, trotter=trotter) ham = lambda t: ((1 - t) * h0.matrix + t * h1.matrix).numpy() targets = {"ground": [], "excited": [], "gap": []} for t in np.linspace(0, 1, 11): eigvals = np.linalg.eigvalsh(ham(t)).real targets["ground"].append(eigvals[0]) targets["excited"].append(eigvals[1]) targets["gap"].append(eigvals[1] - eigvals[0]) gap = callbacks.Gap() 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) np.testing.assert_allclose(ground[:], targets["ground"]) np.testing.assert_allclose(excited[:], targets["excited"]) np.testing.assert_allclose(gap[:], targets["gap"]) # check not implemented for density matrices with pytest.raises(NotImplementedError): gap(np.zeros(8), is_density_matrix=True)
def test_initial_state(): """Test that adiabatic evolution initial state is the ground state of H0.""" h0 = hamiltonians.X(3) h1 = hamiltonians.TFIM(3) adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=1e-2) target_psi = np.ones(8) / np.sqrt(8) init_psi = adev.get_initial_state() assert_states_equal(init_psi, target_psi)
def main(nqubits, hfield, T, dt, solver, save): """Performs adiabatic evolution with critical TFIM as the "hard" Hamiltonian. Plots how the <H1> energy and the overlap with the actual ground state changes during the evolution. Linear scheduling is used. Args: nqubits (int): Number of qubits in the system. hfield (float): Transverse field Ising model h-field h value. T (float): Total time of the adiabatic evolution. dt (float): Time step used for integration. solver (str): Solver used for integration. save (bool): Whether to save the plots. """ h0 = hamiltonians.X(nqubits) h1 = hamiltonians.TFIM(nqubits, h=hfield) # Calculate target values (H1 ground state) target_state = h1.ground_state() target_energy = h1.eigenvalues()[0].numpy().real # Check ground state state_energy = callbacks.Energy(h1)(target_state).numpy() np.testing.assert_allclose(state_energy.real, target_energy) energy = callbacks.Energy(h1) overlap = callbacks.Overlap(target_state) evolution = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=dt, solver=solver, callbacks=[energy, overlap]) final_psi = evolution(final_time=T) # Plots tt = np.linspace(0, T, int(T / dt) + 1) plt.figure(figsize=(12, 4)) plt.subplot(121) plt.plot(tt, energy[:], linewidth=2.0, label="Evolved state") plt.axhline(y=target_energy, color="red", linewidth=2.0, label="Ground state") plt.xlabel("$t$") plt.ylabel("$H_1$") plt.legend() plt.subplot(122) plt.plot(tt, overlap[:], linewidth=2.0) plt.xlabel("$t$") plt.ylabel("Overlap") if save: plt.savefig(f"images/dynamics_n{nqubits}T{T}.png", bbox_inches="tight") else: plt.show()
def test_qaoa_errors(): # Invalid Hamiltonian type with pytest.raises(TypeError): qaoa = models.QAOA("test") # Hamiltonians of different type h = hamiltonians.TFIM(4, h=1.0, dense=False) m = hamiltonians.X(4, dense=True) with pytest.raises(TypeError): qaoa = models.QAOA(h, mixer=m) # Hamiltonians acting on different qubit numbers h = hamiltonians.TFIM(6, h=1.0) m = hamiltonians.X(4) with pytest.raises(ValueError): qaoa = models.QAOA(h, mixer=m) # distributed execution with RK solver with pytest.raises(NotImplementedError): qaoa = models.QAOA(h, solver="rk4", accelerators={"/GPU:0": 2}) # minimize with odd number of parameters qaoa = models.QAOA(h) with pytest.raises(ValueError): qaoa.minimize(np.random.random(5))
def test_scheduling_optimization(method, options, messages, trotter, filename): """Test optimization of s(t).""" h0 = hamiltonians.X(3, trotter=trotter) h1 = hamiltonians.TFIM(3, trotter=trotter) sp = lambda t, p: (1 - p) * np.sqrt(t) + p * t adevp = models.AdiabaticEvolution(h0, h1, sp, dt=1e-1) best, params = adevp.minimize([0.5, 1], method=method, options=options, messages=messages) if filename is not None: utils.assert_regression_fixture(params, filename)
def test_trotterized_adiabatic_evolution(nqubits, accelerators, dt): """Test adiabatic evolution using trotterization of ``TrotterHamiltonian``.""" dense_h0 = hamiltonians.X(nqubits) dense_h1 = hamiltonians.TFIM(nqubits) target_psi = [np.ones(2**nqubits) / np.sqrt(2**nqubits)] ham = lambda t: dense_h0 * (1 - t) + dense_h1 * t for n in range(int(1 / dt)): prop = ham(n * dt).exp(dt).numpy() target_psi.append(prop.dot(target_psi[-1])) local_h0 = hamiltonians.X(nqubits, trotter=True) local_h1 = hamiltonians.TFIM(nqubits, trotter=True) checker = TimeStepChecker(target_psi, atol=dt) adev = models.AdiabaticEvolution(local_h0, local_h1, lambda t: t, dt, callbacks=[checker], accelerators=accelerators) final_psi = adev(final_time=1)
def test_adiabatic_evolution_schedule(): h0 = hamiltonians.X(3) h1 = hamiltonians.TFIM(3) adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=1e-2) assert adev.schedule(0.2) == 0.2 # pylint: disable=E1102 assert adev.schedule(0.8) == 0.8 # pylint: disable=E1102 # s(0) != 0 with pytest.raises(ValueError): adev = models.AdiabaticEvolution(h0, h1, lambda t: t + 1, dt=1e-2) # s(T) != 0 with pytest.raises(ValueError): adev = models.AdiabaticEvolution(h0, h1, lambda t: t / 2, dt=1e-2)
def test_adiabatic_evolution_init(): # Hamiltonians of bad type h0 = hamiltonians.X(3) s = lambda t: t with pytest.raises(TypeError): adev = models.AdiabaticEvolution(h0, lambda t: h0, s, dt=1e-2) h1 = hamiltonians.TFIM(2) with pytest.raises(TypeError): adev = models.AdiabaticEvolution(lambda t: h1, h1, s, dt=1e-2) # Hamiltonians with different number of qubits with pytest.raises(ValueError): adev = models.AdiabaticEvolution(h0, h1, s, dt=1e-2) # Adiabatic Hamiltonian with bad hamiltonian types from qibo.core.adiabatic import AdiabaticHamiltonian with pytest.raises(TypeError): h = AdiabaticHamiltonian("a", "b") # pylint: disable=E0110 # s with three arguments h0 = hamiltonians.X(2) s = lambda t, a, b: t + a + b with pytest.raises(ValueError): adev = models.AdiabaticEvolution(h0, h1, s, dt=1e-2)
def test_adiabatic_evolution_execute_errors(): h0 = hamiltonians.X(3) h1 = hamiltonians.TFIM(3) # Non-zero ``start_time`` adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=1e-2) with pytest.raises(NotImplementedError): final_state = adev(final_time=2, start_time=1) # execute without specifying variational parameters sp = lambda t, p: (1 - p) * np.sqrt(t) + p * t adevp = models.AdiabaticEvolution(h0, h1, sp, dt=1e-1) with pytest.raises(RuntimeError): final_state = adevp(final_time=1)
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 main(nqubits, hfield, params, dt, solver, method, maxiter, save): """Optimizes the scheduling of the adiabatic evolution. The ansatz for s(t) is a polynomial whose order is defined by the length of ``params`` given. Args: nqubits (int): Number of qubits in the system. hfield (float): Transverse field Ising model h-field h value. params (str): Initial guess for the free parameters. dt (float): Time step used for integration. solver (str): Solver used for integration. method (str): Which scipy optimizer to use. maxiter (int): Maximum iterations for scipy optimizer. save (str): Name to use for saving optimization history. If ``None`` history will not be saved. """ h0 = hamiltonians.X(nqubits) h1 = hamiltonians.TFIM(nqubits, h=hfield) # Calculate target values (H1 ground state) target_state = h1.ground_state() target_energy = h1.eigenvalues()[0].numpy().real # Check ground state state_energy = callbacks.Energy(h1)(target_state).numpy() np.testing.assert_allclose(state_energy.real, target_energy) evolution = models.AdiabaticEvolution(h0, h1, spolynomial, dt=dt, solver=solver) options = {"maxiter": maxiter, "disp": True} energy, parameters, _ = evolution.minimize(params, method=method, options=options, messages=True) print("\nBest energy found:", energy) print("Final parameters:", parameters) final_state = evolution(parameters[-1]) overlap = callbacks.Overlap(target_state)(final_state).numpy() print("Target energy:", target_energy) print("Overlap:", overlap) if save: evolution.opt_history["loss"].append(target_energy) np.save(f"optparams/{save}_n{nqubits}_loss.npy", evolution.opt_history["loss"]) np.save(f"optparams/{save}_n{nqubits}_params.npy", evolution.opt_history["params"])
def main(nqubits, dt, solver, backend, dense=False, accelerators=None, filename=None): """Performs adiabatic evolution with critical TFIM as the "hard" Hamiltonian.""" qibo.set_backend(backend) if accelerators is not None: dense = False solver = "exp" logs = BenchmarkLogger(filename) logs.append({ "nqubits": nqubits, "dt": dt, "solver": solver, "dense": dense, "backend": qibo.get_backend(), "precision": qibo.get_precision(), "device": qibo.get_device(), "threads": qibo.get_threads(), "accelerators": accelerators }) print(f"Using {solver} solver and dt = {dt}.") print(f"Accelerators: {accelerators}") print("Backend:", logs[-1]["backend"]) start_time = time.time() h0 = hamiltonians.X(nqubits, dense=dense) h1 = hamiltonians.TFIM(nqubits, h=1.0, dense=dense) logs[-1]["hamiltonian_creation_time"] = time.time() - start_time print(f"\nnqubits = {nqubits}, solver = {solver}") print(f"dense = {dense}, accelerators = {accelerators}") print("Hamiltonians created in:", logs[-1]["hamiltonian_creation_time"]) start_time = time.time() evolution = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=dt, solver=solver, accelerators=accelerators) logs[-1]["creation_time"] = time.time() - start_time print("Evolution model created in:", logs[-1]["creation_time"]) start_time = time.time() final_psi = evolution(final_time=1.0) logs[-1]["simulation_time"] = time.time() - start_time print("Simulation time:", logs[-1]["simulation_time"]) logs.dump()
def test_set_scheduling_parameters(): """Test ``AdiabaticEvolution.set_parameters``.""" h0 = hamiltonians.X(3) h1 = hamiltonians.TFIM(3) sp = lambda t, p: (1 - p[0]) * np.sqrt(t) + p[0] * t adevp = models.AdiabaticEvolution(h0, h1, sp, 1e-2) adevp.set_parameters([0.5, 1]) final_psi = adevp(final_time=1) s = lambda t: 0.5 * np.sqrt(t) + 0.5 * t adev = models.AdiabaticEvolution(h0, h1, s, 1e-2) target_psi = adev(final_time=1) np.testing.assert_allclose(final_psi, target_psi)
def test_set_scheduling_parameters(): """Test ``AdiabaticEvolution.set_parameters``.""" h0 = hamiltonians.X(3) h1 = hamiltonians.TFIM(3) sp = lambda t, p: (1 - p[0]) * np.sqrt(t) + p[0] * t adevp = models.AdiabaticEvolution(h0, h1, sp, 1e-2) # access parametrized scheduling before setting parameters with pytest.raises(ValueError): s = adevp.schedule adevp.set_parameters([0.5, 1]) target_s = lambda t: 0.5 * np.sqrt(t) + 0.5 * t for t in np.random.random(10): assert adevp.schedule(t) == target_s(t) # pylint: disable=E1102
def test_adiabatic_evolution(dt): """Test adiabatic evolution with exponential solver.""" h0 = hamiltonians.X(2) h1 = hamiltonians.TFIM(2) adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=dt) m1 = np.array([[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]]) m2 = np.diag([2, -2, -2, 2]) ham = lambda t: -(1 - t) * m1 - t * m2 target_psi = np.ones(4) / 2 nsteps = int(1 / dt) for n in range(nsteps): target_psi = expm(-1j * dt * ham(n * dt)).dot(target_psi) final_psi = adev(final_time=1) assert_states_equal(final_psi, target_psi)
def test_x_hamiltonian_from_symbols(nqubits, hamtype, calcterms): """Check creating sum(X) Hamiltonian using sympy.""" if hamtype == "symbolic": from qibo.symbols import X symham = -sum(X(i) for i in range(nqubits)) ham = hamiltonians.SymbolicHamiltonian(symham) else: x_symbols = sympy.symbols(" ".join((f"X{i}" for i in range(nqubits)))) symham = -sum(x_symbols) symmap = {x: (i, matrices.X) for i, x in enumerate(x_symbols)} ham = hamiltonians.Hamiltonian.from_symbolic(symham, symmap) if calcterms: _ = ham.terms final_matrix = ham.matrix target_matrix = hamiltonians.X(nqubits).matrix K.assert_allclose(final_matrix, target_matrix)
def test_rk4_evolution(solver, dt=1e-3): """Test adiabatic evolution with Runge-Kutta solver.""" h0 = hamiltonians.X(3) h1 = hamiltonians.TFIM(3) target_psi = [np.ones(8) / np.sqrt(8)] ham = lambda t: h0 * (1 - t) + h1 * t for n in range(int(1 / dt)): prop = ham(n * dt).exp(dt).numpy() target_psi.append(prop.dot(target_psi[-1])) checker = TimeStepChecker(target_psi, atol=dt) adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt, solver="rk4", callbacks=[checker]) final_psi = adev(final_time=1, initial_state=np.copy(target_psi[0]))
def test_hamiltonian_t(): """Test adiabatic evolution hamiltonian as a function of time.""" h0 = hamiltonians.X(2) h1 = hamiltonians.TFIM(2) adev = models.AdiabaticEvolution(h0, h1, lambda t: t, dt=1e-2) # try accessing hamiltonian before setting it with pytest.raises(RuntimeError): adev.hamiltonian() m1 = np.array([[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]]) m2 = np.diag([2, -2, -2, 2]) ham = lambda t, T: -(1 - t / T) * m1 - (t / T) * m2 adev.set_hamiltonian(total_time=1) for t in [0, 0.3, 0.7, 1.0]: matrix = adev.hamiltonian(t).matrix np.testing.assert_allclose(matrix, ham(t, 1)) #try using a different total time for t in [0, 0.3, 0.7, 1.0]: matrix = adev.hamiltonian(t, total_time=2).matrix np.testing.assert_allclose(matrix, ham(t, 2))
def test_scheduling_optimization(method, options, messages, dense, filename): """Test optimization of s(t).""" from qibo.tests.test_models_variational import assert_regression_fixture h0 = hamiltonians.X(3, dense=dense) h1 = hamiltonians.TFIM(3, dense=dense) sp = lambda t, p: (1 - p) * np.sqrt(t) + p * t adevp = models.AdiabaticEvolution(h0, h1, sp, dt=1e-1) if method == "sgd": from qibo import K if not K.supports_gradients: with pytest.raises(RuntimeError): best, params, _ = adevp.minimize([0.5, 1], method=method, options=options, messages=messages) else: best, params, _ = adevp.minimize([0.5, 1], method=method, options=options, messages=messages) if filename is not None: assert_regression_fixture(params, filename)