def test_just_input_variables(initial_input_values):
U = tq.gates.Rx('a', 0) + tq.gates.Rx('b', 1) + tq.gates.CNOT(
1, 3) + tq.gates.CNOT(0, 2) + tq.gates.CNOT(0, 1)
H1 = tq.paulis.Qm(1)
H2 = tq.paulis.Qm(2)
H3 = tq.paulis.Qm(3)
stackable = [
tq.ExpectationValue(U, H1),
tq.ExpectationValue(U, H2),
tq.ExpectationValue(U, H3)
]
stacked = tq.vectorize(stackable)
cargs = {'samples': None, 'backend': None, 'initial_values': None}
input_vars = ['a', 'b']
tensorflowed = tq.ml.to_platform(stacked,
platform='tensorflow',
compile_args=cargs,
input_vars=input_vars)
tensorflowed.set_input_values(initial_input_values)
learning_rate = .1
momentum = 0.9
optimizer = optimizers.SGD(lr=learning_rate, momentum=momentum)
# We train all trainable variables (which are just input_variables)
var_list_fn = lambda: tensorflowed.trainable_variables
loss = lambda: tf.reduce_sum(tensorflowed())
for i in range(STEPS):
optimizer.minimize(loss, var_list_fn)
called = tf.math.reduce_sum(tensorflowed()).numpy().tolist()
assert np.isclose(called, 0.0, atol=1e-3)
def test_example_training():
U = tq.gates.Rx('a', 0) + tq.gates.Rx('b', 1) + tq.gates.CNOT(
1, 3) + tq.gates.CNOT(0, 2) + tq.gates.CNOT(0, 1)
H1 = tq.paulis.Qm(1)
H2 = tq.paulis.Qm(2)
H3 = tq.paulis.Qm(3)
stackable = [
tq.ExpectationValue(U, H1),
tq.ExpectationValue(U, H2),
tq.ExpectationValue(U, H3)
]
stacked = tq.vectorize(stackable)
initial_values = {'a': 1.5, 'b': 2.}
cargs = {
'samples': None,
'backend': 'random',
'initial_values': initial_values
}
torched = tq.ml.to_platform(stacked, platform='torch', compile_args=cargs)
optimizer = optim.SGD(torched.parameters(), lr=.1, momentum=0.9)
for i in range(80):
optimizer.zero_grad()
out = torched()
loss = out.sum()
loss.backward()
optimizer.step()
called = torched().sum().detach().numpy()
assert np.isclose(called, 0.0, atol=1e-3)
def test_get_qubit_wise():
'''
Testing whether the get_qubit_wise methods correctly gives the all-Z form of the hamiltonian
'''
H, _, _, _ = prepare_test_hamiltonian()
H = BinaryHamiltonian.init_from_qubit_hamiltonian(H)
qwc, qwc_U = H.get_qubit_wise()
# Check qwc has all z
for term, val in qwc.items():
for qub in term:
assert qub[1] == 'Z'
# Checking the expectation values are the same
U = tq.gates.ExpPauli(angle="a", paulistring=tq.PauliString.from_string('X(0)Y(1)'))
variables = {"a": np.random.rand(1) * 2 * np.pi}
e_ori = tq.ExpectationValue(H=H.to_qubit_hamiltonian(), U=U)
e_qwc = tq.ExpectationValue(H=qwc, U=U + qwc_U)
e_integrated = tq.ExpectationValue(H=H.to_qubit_hamiltonian(), U=U, optimize_measurements=True)
result_ori = tq.simulate(e_ori, variables)
result_qwc = tq.simulate(e_qwc, variables)
result_integrated = tq.simulate(e_qwc, variables)
assert np.isclose(result_ori, result_qwc)
assert np.isclose(result_ori, result_integrated)
# Checking the optimized expectation values are the same
initial_values = {k: np.random.uniform(0.0, 6.0, 1) for k in e_ori.extract_variables()}
sol1 = tq.minimize(method='bfgs', objective=e_ori, initial_values=initial_values)
sol2 = tq.minimize(method='bfgs', objective=e_qwc, initial_values=initial_values)
sol3 = tq.minimize(method='bfgs', objective=e_integrated, initial_values=initial_values)
assert np.isclose(sol1.energy, sol2.energy)
assert np.isclose(sol1.energy, sol3.energy)
def test_hamiltonian_reductions(backend):
for q in [0, 1, 2, 3, 4]:
H = tq.paulis.Z(qubit=[0, 1, 2, 3, 4])
U = tq.gates.X(target=q)
U2 = tq.gates.X(target=q) + tq.gates.X(target=[0, 1, 2, 3, 4]) + tq.gates.X(target=[0, 1, 2, 3, 4])
E1 = tq.compile(tq.ExpectationValue(H=H, U=U), backend=backend)
E2 = tq.compile(tq.ExpectationValue(H=H, U=U2), backend=backend)
assert E1.get_expectationvalues()[0]._reduced_hamiltonians[0] == tq.paulis.Z(q)
assert numpy.isclose(E1(), E2())
def test_circuits(H, UMF, mf_variables, n_circuits=1, n_trials=1, n_samples=1000, g=1.0, connectivity="local_line", generators=["Y", "XY", "YZ"], depth=None, fix_mean_field=True, only_samples=False, draw_from_normal_distribution=False, **kwargs):
# initial mean-field like state
n_qubits = H.n_qubits
# encoder to save circuits as string
encoder = CircuitGenEncoder()
if fix_mean_field:
fixed_variables = mf_variables
else:
fixed_variables = {}
generator = CircuitGenerator(n_qubits=n_qubits, connectivity=connectivity, depth=depth, generators=generators, **kwargs)
print(generator)
data = []
for i in range(n_circuits):
circuit = UMF + generator()
E = tq.ExpectationValue(H=H, U=circuit)
E = tq.compile(E, backend="qulacs")
sampled_energies = []
sampled_variables = []
for sample in range(n_samples):
if draw_from_normal_distribution:
variables = {k:numpy.random.normal(loc=1.0, scale=1.0)*numpy.pi for k in circuit.extract_variables()}
else:
variables = {k:numpy.random.uniform(0.0,4.0,1)[0]*numpy.pi for k in circuit.extract_variables()}
variables = {**variables, **fixed_variables}
sampled_energies.append(E(variables=variables))
sampled_variables.append(variables)
best_variables = sorted( [(sampled_energies[i],sampled_variables[i]) for i in range(n_samples)] , key=lambda x:x[0] )
best_variables = [best_variables[i][1] for i in range(n_trials)]
starting_points = best_variables
starting_points = [{k:0.0 for k in circuit.extract_variables()}] + starting_points
starting_points = [{k:numpy.random.uniform(-0.1,0.1,1)[0]*numpy.pi for k in circuit.extract_variables()}] + starting_points
ev_samples = []
encoded_circuit = encoder(circuit, variables=fixed_variables)
if not only_samples:
for j,variables in enumerate(starting_points):
print("step {} from {} in circuit {} from {}\n".format(j, len(starting_points), i ,n_circuits))
variables = {**variables, **fixed_variables}
active_variables = [x for x in E.extract_variables() if x not in fixed_variables.keys()]
E = tq.ExpectationValue(H=H, U=circuit)
result = tq.minimize(E, initial_values=variables, variables=active_variables)
variables = result.variables
energy = result.energy
ev_samples.append({"energy":energy, "variables":{str(k):v for k,v in variables.items()} })
energy_samples={"circuit":encoded_circuit, "vqe_energies": sorted(ev_samples, key=lambda x: x["energy"]), "random_energies":sampled_energies}
data.append(energy_samples)
data = sorted(data, key=lambda x: x["vqe_energies"][0]["energy"])
else:
zeroes={k:0.0 for k in E.extract_variables()}
energy_samples={"circuit":encoded_circuit, "vqe_energies": [{"energy":tq.simulate(E, variables=zeroes), "variables":{str(k):v for k,v in zeroes.items()}}], "random_energies":sampled_energies}
data.append(energy_samples)
print("finished test_circuits")
return data
def test_hamiltonian_reduction(backend):
mol = tq.chemistry.Molecule(geometry="H 0.0 0.0 0.0\nH 0.0 0.0 0.7", basis_set="6-31G")
hf = mol.energies["hf"]
U = mol.prepare_reference()
H = mol.make_hamiltonian()
E = tq.simulate(tq.ExpectationValue(H=H,U=U), backend=backend)
assert numpy.isclose(E, hf, atol=1.e-4)
for q in range(8):
U2 = U + tq.gates.X(target=q) + tq.gates.Y(target=q)+ tq.gates.Y(target=q)+ tq.gates.X(target=q)
E = tq.simulate(tq.ExpectationValue(H=H, U=U2), backend=backend)
assert numpy.isclose(E, hf, atol=1.e-4)
def test_madness_he_data():
# relies that he_xtensor.npy are present (x=g,h)
geomstring = "He 0.0 0.0 0.0"
molecule = tq.Molecule(name="he", geometry=geomstring)
H = molecule.make_hamiltonian()
UHF = molecule.prepare_reference()
EHF = tq.simulate(tq.ExpectationValue(H=H, U=UHF))
assert (numpy.isclose(-2.861522e+00, EHF, atol=1.e-5))
U = molecule.make_upccgsd_ansatz()
E = tq.ExpectationValue(H=H, U=U)
result = tq.minimize(method="bfgs", objective=E, initial_values=0.0, silent=True)
print(result.energy)
assert (numpy.isclose(-2.87761809, result.energy, atol=1.e-5))
def test_madness_full_he():
# relies on madness being compiled and MAD_ROOT_DIR exported
# or pno_integrals in the path
geomstring = "He 0.0 0.0 0.0"
molecule = tq.Molecule(geometry=geomstring, n_pno=1)
H = molecule.make_hamiltonian()
UHF = molecule.prepare_reference()
EHF = tq.simulate(tq.ExpectationValue(H=H, U=UHF))
assert (numpy.isclose(-2.861522e+00, EHF, atol=1.e-5))
U = molecule.make_upccgsd_ansatz()
E = tq.ExpectationValue(H=H, U=U)
result = tq.minimize(method="bfgs", objective=E, initial_values=0.0, silent=True)
assert (numpy.isclose(-2.87761809, result.energy, atol=1.e-5))
def test_madness_full_li_plus():
# relies on madness being compiled and MAD_ROOT_DIR exported
# or pno_integrals in the path
geomstring = "Li 0.0 0.0 0.0"
molecule = tq.Molecule(name="li+", geometry=geomstring, n_pno=1, charge=1, frozen_core=False) # need to deactivate frozen_core, otherwise there is no active orbital
H = molecule.make_hamiltonian()
UHF = molecule.prepare_reference()
EHF = tq.simulate(tq.ExpectationValue(H=H, U=UHF))
assert (numpy.isclose(-7.236247e+00, EHF, atol=1.e-5))
U = molecule.make_upccgsd_ansatz()
E = tq.ExpectationValue(H=H, U=U)
result = tq.minimize(method="bfgs", objective=E, initial_values=0.0, silent=True)
assert (numpy.isclose(-7.251177798, result.energy, atol=1.e-5))
def test_madness_full_be():
# relies on madness being compiled and MAD_ROOT_DIR exported
# or pno_integrals in the path
geomstring = "Be 0.0 0.0 0.0"
molecule = tq.Molecule(name="be", geometry=geomstring, n_pno=3, frozen_core=True)
H = molecule.make_hamiltonian()
UHF = molecule.prepare_reference()
EHF = tq.simulate(tq.ExpectationValue(H=H, U=UHF))
assert (numpy.isclose(-14.57269300, EHF, atol=1.e-5))
U = molecule.make_upccgsd_ansatz()
E = tq.ExpectationValue(H=H, U=U)
result = tq.minimize(method="bfgs", objective=E, initial_values=0.0, silent=True)
assert (numpy.isclose(-14.614662051580321, result.energy, atol=1.e-3))
def test_sampling_expvals(backend):
U = tq.gates.X([0, 1, 2])
H = tq.paulis.Z(0)
E1 = tq.simulate(tq.ExpectationValue(H=H, U=U), backend=backend, samples=1000)
assert numpy.isclose(E1, -1.0)
H = tq.paulis.Z([0, 1])
E1 = tq.simulate(tq.ExpectationValue(H=H, U=U), backend=backend, samples=1000)
assert numpy.isclose(E1, 1.0)
H = tq.paulis.Z([0, 1, 2])
E1 = tq.simulate(tq.ExpectationValue(H=H, U=U), backend=backend, samples=1000)
assert numpy.isclose(E1, -1.0)
U = tq.gates.H([0, 1, 2])
H = tq.paulis.X(0)
E1 = tq.simulate(tq.ExpectationValue(H=H, U=U), backend=backend, samples=1000)
assert numpy.isclose(E1, 1.0)
H = tq.paulis.X([0, 1])
E1 = tq.simulate(tq.ExpectationValue(H=H, U=U), backend=backend, samples=1000)
assert numpy.isclose(E1, 1.0)
H = tq.paulis.X([0, 1, 2])
E1 = tq.simulate(tq.ExpectationValue(H=H, U=U), backend=backend, samples=1000)
assert numpy.isclose(E1, 1.0)
U = tq.gates.H([0, 1, 2])
H = tq.paulis.Zero()
E1 = tq.simulate(tq.ExpectationValue(H=H, U=U), backend=backend, samples=1000)
assert numpy.isclose(E1, 0.0)
U = tq.gates.H([0, 1, 2])
H = tq.paulis.X(3) + 1.234 * tq.paulis.I()
E1 = tq.simulate(tq.ExpectationValue(H=H, U=U), backend=backend, samples=1000)
assert numpy.isclose(E1, 1.234)
def get_eigvals(mat=[]):
"""Get eigenvalues for Hermitianmatrix."""
herm = HermitianSolver(mat)
matrix = herm.mat
H = tq.paulis.Zero()
rows = matrix.shape[0]
columns = matrix.shape[0]
n_qubits = herm.n_qubits()
print("true values", np.linalg.eigh(matrix)[0])
for i in range(rows):
for j in range(columns):
H += matrix[i, j] * tq.paulis.KetBra(
ket=i, bra=j, n_qubits=n_qubits)
hermitian, anti = H.split()
eigenValues, eigenVectors = numpy.linalg.eigh(hermitian.to_matrix())
# print(tq.QubitWaveFunction(eigenVectors[:, 2]))
circuits = []
energies = []
factor = 22
# TODO: replace factor with reverse VQE value
opt_variables = {}
for i in range(rows):
U = tq.gates.Ry(angle=(0, i), target=0)
U += tq.gates.Ry(angle=(1, i), target=1)
U += tq.gates.Ry(angle=(2, i), target=2)
active_variables = U.extract_variables()
E = tq.ExpectationValue(H=hermitian, U=U)
ex_objective = E
P1 = tq.paulis.Projector("1.0*|000>")
for k in range(i):
S = tq.ExpectationValue(H=P1, U=U + circuits[k].dagger())
ex_objective += factor * abs(energies[k]) * S
opt_variables = {
**opt_variables,
**{k: 1.0e-3
for k in active_variables},
}
result = tq.minimize(
objective=ex_objective,
method="bfgs",
variables=active_variables,
initial_values=opt_variables,
)
circuits.append(U)
energies.append(result.energy)
opt_variables = {**opt_variables, **result.variables}
return energies
def test_qubit_maps():
qubit_map = {0:1, 1:2, 2:3}
H1 = tq.paulis.X(0) + tq.paulis.Z(0)*tq.paulis.Z(1) + tq.paulis.Y(2)
U1 = tq.gates.Ry(angle="a",target=0) + tq.gates.CNOT(0,1) + tq.gates.H(target=2)
E1 = tq.ExpectationValue(H=H1, U=U1)
H2 = tq.paulis.X(qubit_map[0]) + tq.paulis.Z(qubit_map[0]) * tq.paulis.Z(qubit_map[1]) + tq.paulis.Y(qubit_map[2])
U2 = tq.gates.Ry(angle="a", target=qubit_map[0]) + tq.gates.CNOT(qubit_map[0], qubit_map[1]) + tq.gates.H(target=qubit_map[2])
E2 = tq.ExpectationValue(H=H2, U=U2)
E3 = E1.map_qubits(qubit_map=qubit_map)
for angle in numpy.random.uniform(0.0, 10.0, 10):
variables = {"a":angle}
assert np.isclose(tq.simulate(E2, variables=variables), tq.simulate(E3, variables=variables))
def test_parametrized_interface(backend, samples):
if samples is not None and backend not in INSTALLED_SAMPLERS:
pytest.skip(
"sampling not yet supported for backend={}".format(backend))
H = tq.paulis.X(0)
U = tq.gates.Ry(angle="a", target=0)
variables = {"a": numpy.pi / 2}
CU = tq.compile(objective=U, backend=backend, samples=None)
a = tq.simulate(objective=U,
backend=backend,
variables=variables,
samples=None)
aa = CU(variables=variables, samples=None)
aaa = tq.compile_to_function(objective=U, backend=backend,
samples=samples)(variables["a"], samples=None)
assert (isinstance(a, tq.QubitWaveFunction))
assert (aa.isclose(a))
assert (aaa.isclose(a))
E = tq.ExpectationValue(H=H, U=U)
CE = tq.compile(objective=E, backend=backend, samples=samples)
a = tq.simulate(objective=E,
backend=backend,
variables=variables,
samples=samples)
aa = CE(variables=variables, samples=samples)
aaa = tq.compile_to_function(objective=E, backend=backend)(variables["a"],
samples=samples)
assert (isinstance(a, numbers.Number))
assert numpy.isclose(aa, a, 1.e-1)
assert numpy.isclose(aaa, a, 1.e-1)
def test_gradient_based_methods_qng(simulator, method):
H = tq.paulis.Y(0)
U = tq.gates.Ry(numpy.pi / 4, 0) + tq.gates.Ry(
numpy.pi / 3, 1) + tq.gates.Ry(numpy.pi / 7, 2)
U += tq.gates.Rz('a', 0) + tq.gates.Rz('b', 1)
U += tq.gates.CNOT(control=0, target=1) + tq.gates.CNOT(control=1,
target=2)
U += tq.gates.Ry('c', 1) + tq.gates.Rx('d', 2)
U += tq.gates.CNOT(control=0, target=1) + tq.gates.CNOT(control=1,
target=2)
E = tq.ExpectationValue(H=H, U=U)
initial_values = {"a": -0.01, "b": 1.60, 'c': 1.52, 'd': -0.53}
result = tq.optimizer_scipy.minimize(objective=-E,
gradient='qng',
backend=simulator,
method=method,
tol=1.e-3,
method_options={
"gtol": 1.e-3,
"eps": 1.e-4
},
initial_values=initial_values,
silent=True)
assert (numpy.isclose(result.energy, -0.612, atol=1.e-1))
def run_ising_circuits(n_qubits, g=1.0, *args, **kwargs):
H = simplified_ising(n_qubits=n_qubits, g=g)
if n_qubits < 10:
exact_gs = numpy.linalg.eigvalsh(H.to_matrix())[0]
else:
exact_gs = None
# orquestra workaround
if "generators" in kwargs:
kwargs["generators"] = json.loads(kwargs["generators"])
if "fix_angles" in kwargs:
kwargs["fix_angles"] = yaml.load(kwargs["fix_angles"], Loader=yaml.SafeLoader)
if "connectivity" in kwargs:
kwargs["connectivity"] = yaml.load(kwargs["connectivity"], Loader=yaml.SafeLoader)
# initial mean-field like state
n_qubits = H.n_qubits
UMF = sum([tq.gates.Ry(angle=("a", q), target=q) for q in range(n_qubits)],tq.QCircuit())
# encoder to save circuits as string
encoder = CircuitGenEncoder()
# solve "mean field"
EMF = tq.ExpectationValue(H=H, U=UMF)
result = tq.minimize(EMF)
result_dict = {"schema":"schema"}
result_dict["data"] = test_circuits(H=H, UMF=UMF, mf_variables=result.variables, *args, **kwargs)
result_dict["kwargs"]=kwargs
result_dict["g"]=g
result_dict["exact_ground_state"]=exact_gs
result_dict["mean_field_energy"]=float(result.energy)
with open("isingdata.json", "w") as f:
f.write(json.dumps(result_dict, indent=2))
def test_hessian_based_methods(simulator, method, use_hessian):
wfn = tq.QubitWaveFunction.from_string(string="1.0*|00> + 1.0*|11>")
H = tq.paulis.Projector(wfn=wfn.normalize())
U = tq.gates.Ry(angle=tq.assign_variable("a") * numpy.pi, target=0)
U += tq.gates.Ry(angle=tq.assign_variable("b") * numpy.pi,
target=1,
control=0)
E = tq.ExpectationValue(H=H, U=U)
method_options = {"gtol": 1.e-4}
# need to improve starting points for some of the optimizations
initial_values = {"a": 0.002, "b": 0.01}
if method not in ["TRUST-CONSTR", "TRUST_KRYLOV]"]:
method_options['eta'] = 0.1
method_options['initial_trust_radius'] = 0.1
method_options['max_trust_radius'] = 0.25
initial_values = {"a": 0.3, "b": 0.8}
# numerical hessian only works for this method
if use_hessian in ['2-point', '3-point']:
if method != "TRUST-CONSTR":
return
initial_values = {"a": 0.3, "b": 0.8}
result = tq.optimizer_scipy.minimize(objective=-E,
backend=simulator,
hessian=use_hessian,
method=method,
tol=1.e-4,
method_options=method_options,
initial_values=initial_values,
silent=True)
assert (numpy.isclose(result.energy, -1.0, atol=1.e-1))
def test_gradient_based_methods(simulator, method, use_gradient):
wfn = tq.QubitWaveFunction.from_string(string="1.0*|00> + 1.0*|11>")
H = tq.paulis.Projector(wfn=wfn.normalize())
U = tq.gates.Ry(angle=tq.assign_variable("a") * numpy.pi, target=0)
U += tq.gates.Ry(angle=tq.assign_variable("b") * numpy.pi,
target=1,
control=0)
E = tq.ExpectationValue(H=H, U=U)
initial_values = {"a": 3.45, "b": 2.85}
# eps is absolute finite difference step of scipy (used only for gradient = False or scipy < 1.5)
# finite_diff_rel_step is relative step
result = tq.optimizer_scipy.minimize(objective=-E,
backend=simulator,
gradient=use_gradient,
method=method,
tol=1.e-3,
method_options={
"gtol": 1.e-4,
"eps": 1.e-4,
"finite_diff_rel_step": 1.e-4
},
initial_values=initial_values,
silent=True)
assert (numpy.isclose(result.energy, -1.0, atol=1.e-1))
def test_gradient_based_methods_qng(simulator, method):
H = tq.paulis.Y(0)
U = tq.gates.Ry(numpy.pi / 4, 0) + tq.gates.Ry(
numpy.pi / 3, 1) + tq.gates.Ry(numpy.pi / 7, 2)
U += tq.gates.Rz('a', 0) + tq.gates.Rz('b', 1)
U += tq.gates.CNOT(control=0, target=1) + tq.gates.CNOT(control=1,
target=2)
U += tq.gates.Ry('c', 1) + tq.gates.Rx('d', 2)
U += tq.gates.CNOT(control=0, target=1) + tq.gates.CNOT(control=1,
target=2)
E = tq.ExpectationValue(H=H, U=U)
# just equal to the original circuit, but i'm checking that all the sub-division works
O = (4 / 8) * E + (3 / 8) * copy.deepcopy(E) + (
1 / 8) * copy.deepcopy(E) + tq.Variable('a') - tq.Variable('a')
initial_values = {"a": 0.432, "b": -0.123, 'c': 0.543, 'd': 0.233}
result = tq.optimizer_scipy.minimize(objective=-O,
qng=True,
backend=simulator,
method=method,
tol=1.e-4,
method_options={
"gtol": 1.e-4,
"eps": 1.e-4
},
initial_values=initial_values,
silent=False)
assert (numpy.isclose(result.energy, -0.612, atol=1.e-1))
def test_gradient_based_methods(simulator, method, use_gradient):
wfn = tq.QubitWaveFunction.from_string(string="1.0*|00> + 1.0*|11>")
H = tq.paulis.Projector(wfn=wfn.normalize())
U = tq.gates.Ry(angle=tq.assign_variable("a") * numpy.pi, target=0)
U += tq.gates.Ry(angle=tq.assign_variable("b") * numpy.pi,
target=1,
control=0)
E = tq.ExpectationValue(H=H, U=U)
# need to improve starting points for some of the optimizations
initial_values = {"a": 0.002, "b": 0.01}
if method in ["L-BFGS-B", "TNC"]:
initial_values = {"a": 0.1, "b": 0.8}
if use_gradient is False:
initial_values = {"a": 0.3, "b": 0.8}
result = tq.optimizer_scipy.minimize(objective=-E,
backend=simulator,
gradient=use_gradient,
method=method,
tol=1.e-4,
method_options={
"gtol": 1.e-4,
"eps": 1.e-4
},
initial_values=initial_values,
silent=True)
assert (numpy.isclose(result.energy, -1.0, atol=1.e-1))
def test_methods_qng(simulator, method):
### please note! I am finely tuned to always pass! don't get cocky and change lr, maxiter, etc.
H = tq.paulis.Y(0)
U = tq.gates.Ry(numpy.pi / 4, 0) + tq.gates.Ry(
numpy.pi / 3, 1) + tq.gates.Ry(numpy.pi / 7, 2)
U += tq.gates.Rz('a', 0) + tq.gates.Rz('b', 1)
U += tq.gates.CNOT(control=0, target=1) + tq.gates.CNOT(control=1,
target=2)
U += tq.gates.Ry('c', 1) + tq.gates.Rx('d', 2)
U += tq.gates.CNOT(control=0, target=1) + tq.gates.CNOT(control=1,
target=2)
E = tq.ExpectationValue(H=H, U=U)
# just equal to the original circuit, but i'm checking that all the sub-division works
O = E
initial_values = {"a": 0.432, "b": -0.123, 'c': 0.543, 'd': 0.233}
lr = 0.1
result = minimize(objective=-O,
gradient='qng',
backend=simulator,
method=method,
maxiter=200,
lr=lr,
initial_values=initial_values,
silent=False)
assert (numpy.isclose(result.energy, -0.612, atol=2.e-2))
def test_hcb(trafo):
geomstring = "Be 0.0 0.0 0.0\n H 0.0 0.0 1.6\n H 0.0 0.0 -1.6"
mol1 = tq.Molecule(geometry=geomstring, active_orbitals=[1,2,3,4,5,6], basis_set="sto-3g", transformation="ReorderedJordanWigner")
H = mol1.make_hardcore_boson_hamiltonian()
U = mol1.make_upccgsd_ansatz(name="HCB-UpCCGD")
E = tq.ExpectationValue(H=H, U=U)
energy1 = tq.minimize(E).energy
assert numpy.isclose(energy1, -15.527740838656282, atol=1.e-3)
mol2 = tq.Molecule(geometry=geomstring, active_orbitals=[1,2,3,4,5,6], basis_set="sto-3g", transformation=trafo)
H = mol2.make_hamiltonian()
U = mol2.make_upccgsd_ansatz(name="UpCCGD", use_hcb=False)
E = tq.ExpectationValue(H=H, U=U)
energy2 = tq.minimize(E).energy
assert numpy.isclose(energy1, energy2)
def test_sampling_accumulation(backend):
# minimal test that was added after a bug was discovered
# just needs to asssure that it runs through and no errors are thrown within the process
U = tq.gates.Ry(angle=numpy.pi / 2, target=0) + tq.gates.CNOT(1, 3)
H = tq.paulis.Qm(1)
E = tq.ExpectationValue(H=H, U=U)
result = tq.simulate(E, backend=backend, samples=100)
assert result == 0.0
def test_method_convergence(simulator,method):
U = tq.gates.Trotterized(angles=["a"], steps=1, generators=[tq.paulis.Y(0)])
H = tq.paulis.X(0)
O = tq.ExpectationValue(U=U, H=H)
samples=None
angles={'a':numpy.pi/3}
result = tq.minimize(objective=O, method=method,initial_values=angles, samples=samples, lr=0.1,stop_count=40, maxiter=200, backend=simulator)
assert (numpy.isclose(result.energy, -1.0,atol=3.e-2))
def test_active_spaces(active):
mol = tq.chemistry.Molecule(geometry="data/h2o.xyz", basis_set="sto-3g", active_orbitals=active)
H = mol.make_hamiltonian()
Uhf = mol.prepare_reference()
hf = tequila.simulators.simulator_api.simulate(tq.ExpectationValue(U=Uhf, H=H))
assert (tq.numpy.isclose(hf, mol.energies["hf"], atol=1.e-4))
qubits = 2*sum([len(v) for v in active.values()])
assert (H.n_qubits == qubits)
def test_fermionic_gates(assume_real, trafo):
mol = tq.chemistry.Molecule(geometry="H 0.0 0.0 0.7\nLi 0.0 0.0 0.0",
basis_set="sto-3g")
U1 = mol.prepare_reference()
U2 = mol.prepare_reference()
variable_count = {}
for i in [0, 1, 0]:
for a in numpy.random.randint(2, 5, 3):
idx = [(2 * i, 2 * a), (2 * i + 1, 2 * a + 1)]
U1 += mol.make_excitation_gate(indices=idx,
angle=(i, a),
assume_real=assume_real)
g = mol.make_excitation_generator(indices=idx)
U2 += tq.gates.Trotterized(generators=[g],
angles=[(i, a)],
steps=1)
if (i, a) in variable_count:
variable_count[(i, a)] += 1
else:
variable_count[(i, a)] = 1
a = numpy.random.choice(U1.extract_variables(), 1)[0]
H = mol.make_hamiltonian()
E = tq.ExpectationValue(H=H, U=U1)
dE = tq.grad(E, a)
if not assume_real:
assert dE.count_expectationvalues() == 4 * variable_count[a.name]
else:
assert dE.count_expectationvalues() == 2 * variable_count[a.name]
E2 = tq.ExpectationValue(H=H, U=U2)
dE2 = tq.grad(E2, a)
variables = {
k: numpy.random.uniform(0.0, 2.0 * numpy.pi, 1)[0]
for k in E.extract_variables()
}
test1 = tq.simulate(E, variables=variables)
test1x = tq.simulate(E2, variables=variables)
test2 = tq.simulate(dE, variables=variables)
test2x = tq.simulate(dE2, variables=variables)
assert numpy.isclose(test1, test1x, atol=1.e-6)
assert numpy.isclose(test2, test2x, atol=1.e-6)
def test_one_qubit_shot(simulator):
U = tq.gates.Trotterized(angles=["a"], steps=1, generators=[tq.paulis.Y(0)])
H = tq.paulis.X(0)
O = tq.ExpectationValue(U=U, H=H)
samples=10000
if simulator in ['qulacs','pyquil']:
## qulacs sampling is hellishly slow, this test can take 8 minutes to run
samples=100
result = tq.optimizer_scipy.minimize(objective=O, maxiter=15, backend=simulator, samples=samples, silent=True)
assert (numpy.isclose(result.energy, -1.0, atol=1.e-1))
def test_one_qubit_wfn(simulator):
U = tq.gates.Trotterized(angles=["a"],
steps=1,
generators=[tq.paulis.Y(0)])
H = tq.paulis.X(0)
O = tq.ExpectationValue(U=U, H=H)
result = tq.optimizer_scipy.minimize(objective=O,
maxiter=15,
backend=simulator,
silent=True)
assert (numpy.isclose(result.energy, -1.0))
def test_array_computation(backend):
U = tq.gates.X(target=0)
hamiltonians = [
tq.paulis.I(),
tq.paulis.X(0),
tq.paulis.Y(0),
tq.paulis.Z(0)
]
E = tq.ExpectationValue(H=hamiltonians, U=U, shape=[4])
result = tq.simulate(E, backend=backend)
assert all(result == numpy.asarray([1.0, 0.0, 0.0, -1.0]))
def test_one_qubit_wfn(simulator, method):
U = tq.gates.Trotterized(angles=["a"],
steps=1,
generators=[tq.paulis.Y(0)])
H = tq.paulis.X(0)
O = tq.ExpectationValue(U=U, H=H)
result = tq.minimize(objective=O,
maxiter=8,
backend=simulator,
method=method)
assert (numpy.isclose(result.energy, -1.0, atol=1.e-2))
