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))