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_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_compilation(backend):
U = gates.X(target=[0, 1, 2, 3, 4, 5])
for i in range(10):
U += gates.Ry(angle=(i, ), target=numpy.random.randint(0, 5, 1)[0])
U += gates.CZ(0, 1) + gates.CNOT(1, 2) + gates.CZ(2, 3) + gates.CNOT(
3, 4) + gates.CZ(5, 6)
H = paulis.X(0) + paulis.X(1) + paulis.X(2) + paulis.X(3) + paulis.X(
4) + paulis.X(5)
H += paulis.Z(0) + paulis.Z(1) + paulis.Z(2) + paulis.Z(3) + paulis.Z(
4) + paulis.Z(5)
E = ExpectationValue(H=H, U=U)
randvals = numpy.random.uniform(0.0, 2.0, 10)
variables = {(i, ): randvals[i] for i in range(10)}
e0 = simulate(E, variables=variables, backend=backend)
E2 = E * E
for i in range(99):
E2 += E * E
compiled = tq.compile(E2, variables=variables, backend=backend)
e2 = compiled(variables=variables)
assert (E2.count_expectationvalues(unique=True) == 1)
assert (compiled.count_expectationvalues(unique=True) == 1)
assert numpy.isclose(100 * e0**2, 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_interface(backend):
H = tq.paulis.X(0)
U = tq.gates.X(target=0)
CU = tq.compile(objective=U, backend=backend)
a = tq.simulate(objective=U, backend=backend)
aa = CU()
aaa = tq.compile_to_function(objective=U, backend=backend)()
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)
a = tq.simulate(objective=E, backend=backend)
aa = CE()
aaa = tq.compile_to_function(objective=E, backend=backend)()
assert (isinstance(a, numbers.Number))
assert (aa == a)
assert (aaa == a)
def test_sampling(backend):
U = tq.gates.Ry(angle=0.0, target=0)
H = tq.paulis.X(0)
E = tq.ExpectationValue(H=H, U=U)
for i in range(10):
e = tq.simulate(E, samples=1000, backend=backend)
assert numpy.isclose(e, 0.0, atol=2.e-1)
E = tq.compile(E, backend=backend, samples=1000)
for i in range(10):
e = E(samples=1000)
assert numpy.isclose(e, 0.0, atol=2.e-1)
def test_qubit_excitations(backend):
if backend == "symbolic":
return
U1 = tq.gates.X(0) + tq.gates.QubitExcitation(angle=numpy.pi / 2, target=[0, 1])
U2 = tq.gates.H(0) + tq.gates.X(1) + tq.gates.CNOT(0, 1)
wfn1 = tq.simulate(U1, backend=backend)
wfn2 = tq.simulate(U2, backend=backend)
F = numpy.abs(wfn1.inner(wfn2)) ** 2
assert numpy.isclose(F, 1.0, 1.e-4)
U1 = tq.gates.X([0, 1]) + tq.gates.QubitExcitation(angle=numpy.pi / 2, target=[0, 2, 1, 3])
U2 = tq.gates.H(0) + tq.gates.X([2, 3]) + tq.gates.CNOT(0, 1) + tq.gates.CNOT(0, 2) + tq.gates.CNOT(0, 3)
wfn1 = tq.simulate(U1, backend=backend)
wfn2 = tq.simulate(U2, backend=backend)
F = numpy.abs(wfn1.inner(wfn2)) ** 2
assert numpy.isclose(F, 1.0, 1.e-4)
U1 = tq.gates.X([0, 1, 2, 3]) + tq.gates.QubitExcitation(angle=numpy.pi / 2, target=[0, 4, 1, 5, 2, 6, 3, 7])
U2 = tq.gates.H(0) + tq.gates.X([4, 5, 6, 7]) + tq.gates.X([1, 2, 3], 0) + tq.gates.X([4, 5, 6, 7], 0)
wfn1 = tq.simulate(U1, backend=backend)
wfn2 = tq.simulate(U2, backend=backend)
F = numpy.abs(wfn1.inner(wfn2)) ** 2
print(wfn1)
print(wfn2)
print(tq.compile(U1, backend=backend).abstract_circuit)
assert numpy.isclose(F, 1.0, 1.e-4)
q = [5, 3, 7, 8, 2, 9, 2, 4]
U1 = tq.gates.X([q[0], q[1], q[2]]) + tq.gates.QubitExcitation(angle=numpy.pi / 2,
target=[q[0], q[3], q[1], q[4], q[2], q[5]])
U2 = tq.gates.H(q[0]) + tq.gates.X([q[3], q[4], q[5]]) + tq.gates.X([q[1], q[2]], q[0]) + tq.gates.X(
[q[3], q[4], q[5]], q[0])
wfn1 = tq.simulate(U1, backend=backend)
wfn2 = tq.simulate(U2, backend=backend)
F = numpy.abs(wfn1.inner(wfn2)) ** 2
assert numpy.isclose(F, 1.0, 1.e-4)
H = tq.paulis.Projector("1.0*|000000000000>")
P1 = tq.paulis.Qp(ancillaries)
# Normalized Fidelity
E1 = tq.ExpectationValue(U=U0+U1+U2, H=H)
# CountRate
E2 = tq.ExpectationValue(U=U0+U1,H=P1)
1
# print out the circuit
# abstract tequila
# compile level on trotterization to ExpPaulis (qulacs)
# compile level up to primitive gates (cirq)
print(U0+U1+U2)
U = tq.compile(U0+U1+U2, backend="cirq").abstract_circuit
tq.circuit.export_to(U,"full_circuit_compiled_to_cirq.pdf")
U = tq.compile(U0+U1+U2, backend="qulacs").abstract_circuit
tq.circuit.export_to(U,"full_circuit_compiled_to_qulacs.pdf")
# Simulate with optimized variables
# testing
print("Simulate with variables ", variables)
print("non-normalized Fidelity: ", tq.simulate(E1, variables=variables))
print("count rate : ", tq.simulate(E2, variables=variables))
print("normalized Fidelity :", tq.simulate(E1/E2, variables=variables))
# Demonstration what happens without post selection
# i.e. no encoder used
Ex = tq.ExpectationValue(U=setup.setup+U2, H=H)
print("Fidelity without post-selection:", tq.simulate(Ex, variables=variables))
