def main(nqubits, layers, compress, lambdas): def cost_function(params, count): """Evaluates the cost function to be minimized. Args: params (array or list): values of the parameters. Returns: Value of the cost function. """ circuit = models.Circuit(nqubits) for l in range(layers): 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)) for q in range(nqubits): circuit.add(gates.RY(q, theta=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=0)) cost = 0 circuit.set_parameters( params) # this will change all thetas to the appropriate values for i in range(len(ising_groundstates)): final_state = circuit(np.copy(ising_groundstates[i])) cost += encoder.expectation(final_state).numpy().real if count[0] % 50 == 0: print(count[0], cost / len(ising_groundstates)) count[0] += 1 return cost / len(ising_groundstates) nparams = 2 * nqubits * layers + nqubits initial_params = np.random.uniform(0, 2 * np.pi, nparams) encoder = 0.5 * (compress + hamiltonians.Z(nqubits)) ising_groundstates = [] for lamb in lambdas: ising_ham = -1 * hamiltonians.TFIM(nqubits, h=lamb) ising_groundstates.append(ising_ham.eigenvectors()[0]) count = [0] result = minimize(lambda p: cost_function(p, count), initial_params, method='L-BFGS-B', options={ 'maxiter': 2.0e3, 'maxfun': 2.0e3 }) print('Final parameters: ', result.x) print('Final cost function: ', result.fun)
def test_state_evolution_final_state(): """Check time-independent Hamiltonian state evolution.""" evolution = models.StateEvolution(hamiltonians.Z(2), dt=1) # Analytical solution phase = np.exp(2j) initial_psi = np.ones(4) / 2 target_psi = np.array([phase, 1, 1, phase.conj()]) final_psi = evolution(final_time=1, initial_state=initial_psi) assert_states_equal(final_psi, target_psi)
def test_state_evolution_time_dependent_hamiltonian(backend, nqubits, dt): ham = lambda t: np.cos(t) * hamiltonians.Z(nqubits) # Analytical solution target_psi = [np.ones(2**nqubits) / np.sqrt(2**nqubits)] for n in range(int(1 / dt)): prop = expm(-1j * dt * K.to_numpy(ham(n * dt).matrix)) target_psi.append(prop.dot(target_psi[-1])) checker = TimeStepChecker(target_psi, atol=1e-8) evolution = models.StateEvolution(ham, dt=dt, callbacks=[checker]) final_psi = evolution(final_time=1, initial_state=np.copy(target_psi[0]))
def test_state_evolution_init(): ham = hamiltonians.Z(2) evolution = models.StateEvolution(ham, dt=1) assert evolution.nqubits == 2 # time-dependent Hamiltonian bad type with pytest.raises(TypeError): evol = models.StateEvolution(lambda t: "abc", dt=1e-2) # dt < 0 with pytest.raises(ValueError): adev = models.StateEvolution(ham, dt=-1e-2) # pass accelerators without trotter Hamiltonian with pytest.raises(NotImplementedError): adev = models.StateEvolution(ham, dt=1e-2, accelerators={"/GPU:0": 2})
def encoder_hamiltonian_simple(nqubits, ncompress): """Creates the encoding Hamiltonian. Args: nqubits (int): total number of qubits. ncompress (int): number of discarded/trash qubits. Returns: Encoding Hamiltonian. """ m0 = K.to_numpy(hamiltonians.Z(ncompress).matrix) m1 = np.eye(2**(nqubits - ncompress), dtype=m0.dtype) ham = hamiltonians.Hamiltonian(nqubits, np.kron(m1, m0)) return 0.5 * (ham + ncompress)
def test_state_evolution_constant_hamiltonian(backend, solver, atol): nsteps = 200 t = np.linspace(0, 1, nsteps + 1) phase = np.exp(2j * t)[:, np.newaxis] ones = np.ones((nsteps + 1, 2)) target_psi = np.concatenate([phase, ones, phase.conj()], axis=1) dt = t[1] - t[0] checker = TimeStepChecker(target_psi, atol=atol) evolution = models.StateEvolution(hamiltonians.Z(2), dt=dt, solver=solver, callbacks=[checker]) final_psi = evolution(final_time=1, initial_state=target_psi[0])
def test_state_evolution(solver, atol): """Check state evolution under H = Z1 + Z2.""" # Analytical solution t = np.linspace(0, 1, 1001) phase = np.exp(2j * t)[:, np.newaxis] ones = np.ones((1001, 2)) target_psi = np.concatenate([phase, ones, phase.conj()], axis=1) dt = t[1] - t[0] checker = TimeStepChecker(target_psi, atol=atol) evolution = models.StateEvolution(hamiltonians.Z(2), dt=dt, solver=solver, callbacks=[checker]) final_psi = evolution(final_time=1, initial_state=target_psi[0])
def test_state_evolution_errors(): """Test ``ValueError``s for ``StateEvolution`` model.""" ham = hamiltonians.Z(2) evolution = models.StateEvolution(ham, dt=1) # time-dependent Hamiltonian bad type with pytest.raises(TypeError): evol = models.StateEvolution(lambda t: "abc", dt=1e-2) # execute without initial state with pytest.raises(ValueError): final_state = evolution(final_time=1) # dt < 0 with pytest.raises(ValueError): adev = models.StateEvolution(ham, dt=-1e-2) # pass accelerators without trotter Hamiltonian with pytest.raises(NotImplementedError): adev = models.StateEvolution(ham, dt=1e-2, accelerators={"/GPU:0": 2})
def hamiltonian(nqubits, position): identity = [[1, 0], [0, 1]] m0 = hamiltonians.Z(1).matrix kron = [] for i in range(nqubits): if i == position: kron.append(m0) else: kron.append(identity) for i in range(nqubits - 1): if i == 0: ham = np.kron(kron[i + 1], kron[i]) else: ham = np.kron(kron[i + 1], ham) ham = hamiltonians.Hamiltonian(nqubits, ham) return ham
def main(nqubits, layers, maxsteps, T_max): nparams = 2 * nqubits * layers + nqubits initial_parameters = np.random.uniform(0, 0.01, nparams) #Define the easy Hamiltonian and the problem Hamiltonian. easy_hamiltonian = hamiltonians.Z(nqubits) problem_hamiltonian = -1 * hamiltonians.TFIM(nqubits, h=1.0) #Run the AAVQE best, params = AAVQE(nqubits, layers, maxsteps, T_max, initial_parameters, easy_hamiltonian, problem_hamiltonian) 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 - eigenvalue[0].numpy().real) print('Log difference: ', -np.log10(best - eigenvalue[0].numpy().real))
def test_state_evolution_get_initial_state(): ham = hamiltonians.Z(2) evolution = models.StateEvolution(ham, dt=1) # execute without initial state with pytest.raises(ValueError): final_state = evolution(final_time=1)