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