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)
