def test_exception_convert_observable(qubit_op, tol): r"""Test that an error is raised if the QubitOperator contains complex coefficients. Currently the vqe.Hamiltonian class does not support complex coefficients. """ with pytest.raises( TypeError, match="The coefficients entering the QubitOperator must be real"): qchem.convert_observable(qubit_op, tol=tol)
def test_exception_convert_observable(): r"""Test that an error is raised if the QubitOperator contains complex coefficients. Currently the vqe.Hamiltonian class does not support complex coefficients. """ qubit_op = (QubitOperator("Y0 Y1", 1 + 0j) + QubitOperator("Z0 X1", 4.5 + 1.5j) + QubitOperator("Y0 X1", 2)) with pytest.raises( TypeError, match="The coefficients entering the QubitOperator must be real"): qchem.convert_observable(qubit_op)
def test_integration_observable_to_vqe_cost(monkeypatch, mol_name, terms_ref, expected_cost, tol): r"""Test if `convert_observable()` in qchem integrates with `VQECost()` in pennylane""" qOp = QubitOperator() if terms_ref is not None: monkeypatch.setattr(qOp, "terms", terms_ref) vqe_observable = qchem.convert_observable(qOp) # maybe make num_qubits a @property of the Hamiltonian class? num_qubits = max( 1, len(set([w for op in vqe_observable.ops for w in op.wires]))) dev = qml.device("default.qubit", wires=num_qubits) print(vqe_observable.terms) # can replace the ansatz with more suitable ones later. def dummy_ansatz(phis, wires): for phi, w in zip(phis, wires): qml.RX(phi, wires=w) dummy_cost = qml.VQECost(dummy_ansatz, vqe_observable, dev) params = [0.1 * i for i in range(num_qubits)] res = dummy_cost(params) assert np.allclose(res, expected_cost, **tol)
def test_integration_observable_to_vqe_cost(monkeypatch, mol_name, terms_ref, expected_cost, custom_wires, tol): r"""Test if `convert_observable()` in qchem integrates with `ExpvalCost()` in pennylane""" qOp = QubitOperator() if terms_ref is not None: monkeypatch.setattr(qOp, "terms", terms_ref) vqe_observable = qchem.convert_observable(qOp, custom_wires) num_qubits = len(vqe_observable.wires) assert vqe_observable.terms.__repr__() # just to satisfy codecov if custom_wires is None: wires = num_qubits elif isinstance(custom_wires, dict): wires = qchem.structure._process_wires(custom_wires) else: wires = custom_wires[:num_qubits] dev = qml.device("default.qubit", wires=wires) # can replace the ansatz with more suitable ones later. def dummy_ansatz(phis, wires): for phi, w in zip(phis, wires): qml.RX(phi, wires=w) dummy_cost = qml.ExpvalCost(dummy_ansatz, vqe_observable, dev) params = [0.1 * i for i in range(num_qubits)] res = dummy_cost(params) assert np.allclose(res, expected_cost, **tol)
def test_observable_conversion(mol_name, terms_ref, monkeypatch): r"""Test the correctness of the QubitOperator observable conversion from OpenFermion to Pennylane. The parametrized inputs are `.terms` attribute of the output `QubitOperator`s based on the same set of test molecules as `test_gen_hamiltonian_pauli_basis`. The equality checking is implemented in the `qchem` module itself as it could be something useful to the users as well. """ qOp = QubitOperator() if terms_ref is not None: monkeypatch.setattr(qOp, "terms", terms_ref) vqe_observable = qchem.convert_observable(qOp) assert qchem._qubit_operators_equivalent(qOp, vqe_observable)
def test_types_consistency(): r"""Test the type consistency of the qubit Hamiltonian constructed by 'convert_observable' from an OpenFermion QubitOperator with respect to the same observable built directly using PennyLane operations""" # Reference PL operator pl_ref = 1 * qml.Identity(0) + 2 * qml.PauliZ(0) @ qml.PauliX(1) # Corresponding OpenFermion QubitOperator of = QubitOperator("", 1) + QubitOperator("Z0 X1", 2) # Build PL operator using 'convert_observable' pl = qchem.convert_observable(of) ops = pl.terms[1] ops_ref = pl_ref.terms[1] for i, op in enumerate(ops): assert op.name == ops_ref[i].name assert type(op) == type(ops_ref[i])
def test_integration_mol_file_to_vqe_cost(name, core, active, mapping, expected_cost, custom_wires, tol): r"""Test if the output of `decompose()` works with `convert_observable()` to generate `ExpvalCost()`""" ref_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "test_ref_files") hf_file = os.path.join(ref_dir, name) qubit_hamiltonian = qchem.decompose( hf_file, mapping=mapping, core=core, active=active, ) vqe_hamiltonian = qchem.convert_observable(qubit_hamiltonian, custom_wires) assert len(vqe_hamiltonian.ops) > 1 # just to check if this runs num_qubits = len(vqe_hamiltonian.wires) assert num_qubits == 2 * len(active) if custom_wires is None: wires = num_qubits elif isinstance(custom_wires, dict): wires = qchem.structure._process_wires(custom_wires) else: wires = custom_wires[:num_qubits] dev = qml.device("default.qubit", wires=wires) # can replace the ansatz with more suitable ones later. def dummy_ansatz(phis, wires): for phi, w in zip(phis, wires): qml.RX(phi, wires=w) phis = np.load(os.path.join(ref_dir, "dummy_ansatz_parameters.npy")) dummy_cost = qml.ExpvalCost(dummy_ansatz, vqe_hamiltonian, dev) res = dummy_cost(phis) assert np.abs(res - expected_cost) < tol["atol"]
def test_integration_mol_file_to_vqe_cost(hf_filename, docc_mo, act_mo, type_of_transformation, expected_cost, tol): r"""Test if the output of `decompose_hamiltonian()` works with `convert_observable()` to generate `VQECost()`""" ref_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "test_ref_files") transformed_hamiltonian = qchem.decompose_hamiltonian( hf_filename, ref_dir, mapping=type_of_transformation, docc_mo_indices=docc_mo, active_mo_indices=act_mo, ) vqe_hamiltonian = qchem.convert_observable(transformed_hamiltonian) assert len(vqe_hamiltonian.ops) > 1 # just to check if this runs num_qubits = max( 1, len(set([w for op in vqe_hamiltonian.ops for w in op.wires]))) assert num_qubits == 2 * len(act_mo) dev = qml.device("default.qubit", wires=num_qubits) # can replace the ansatz with more suitable ones later. def dummy_ansatz(phis, wires): for phi, w in zip(phis, wires): qml.RX(phi, wires=w) phis = np.load(os.path.join(ref_dir, "dummy_ansatz_parameters.npy")) dummy_cost = qml.VQECost(dummy_ansatz, vqe_hamiltonian, dev) res = dummy_cost(phis) assert np.abs(res - expected_cost) < tol["atol"]