Bring coverage to 100% (#47)

* Bring coverage to 100%

* Make sure ansatz and target have same number of qubits

* Consolidate and improve statevector tests

* Deprecated functions don't need explicit coverage

* Work if possible with a non-circuit tensor network

Author: garrison

qiskit_addon_aqc_tensor/objective.py

@@ -81,7 +81,7 @@ def __init__(
             "instead of calling the instance directly."
         ),
     )
-    def __call__(self, x: np.ndarray) -> tuple[float, np.ndarray]:
+    def __call__(self, x: np.ndarray) -> tuple[float, np.ndarray]:  # pragma: no cover
         """Evaluate ``(objective_value, gradient)`` of function at point ``x``.
 
         This method is DEPRECATED since v0.2.  The
@@ -117,7 +117,7 @@ def __init__(
         target: TensorNetworkState,
         ansatz: QuantumCircuit,
         settings: TensorNetworkSimulationSettings,
-    ):
+    ):  # pragma: no cover
         """Initialize the objective function.
 
         The :class:`.OneMinusFidelity` class is DEPRECATED since v0.2.

qiskit_addon_aqc_tensor/simulation/aer/gradient.py

@@ -35,6 +35,14 @@
 
 @dispatch
 def _preprocess_for_gradient(objective, settings: Union[QiskitAerSimulationSettings, AerSimulator]):
+    if objective._ansatz is not None:
+        ansatz_num_qubits = objective._ansatz.num_qubits
+        target_num_qubits = len(objective._target_tensornetwork.gamma)
+        if ansatz_num_qubits != target_num_qubits:
+            raise ValueError(
+                "Ansatz and target have different numbers of qubits "
+                f"({ansatz_num_qubits} vs. {target_num_qubits})."
+            )
     gate_actions = preprocess_circuit_for_backtracking(objective._ansatz, settings)
     lhs_tensornetwork = tensornetwork_from_circuit(
         QuantumCircuit(objective._ansatz.num_qubits), settings

qiskit_addon_aqc_tensor/simulation/explicit_gradient.py

@@ -112,7 +112,7 @@ def preprocess_circuit_for_backtracking(
         except KeyError as ex:
             raise ValueError(
                 f"Expects a gate from the list of basis ones: "
-                f"'{_basis_gates()}', got '{operation.name}' instead."
+                f"{sorted(_basis_gates())}, got '{operation.name}' instead."
             ) from ex
         action = action_generator(pname2index, operation, qubit_indices, settings)
         if action is not None:

qiskit_addon_aqc_tensor/simulation/quimb/__init__.py

@@ -90,14 +90,18 @@ class QuimbSimulator(TensorNetworkSimulationSettings):
     #: Whether to display a progress bar while applying gates.
     progbar: bool = False
 
-    def _construct_circuit(self, qc: QuantumCircuit, /, **kwargs):
+    def _construct_circuit(
+        self, qc: QuantumCircuit, /, *, out_state: np.ndarray | None = None, **kwargs
+    ):
         import qiskit_quimb
 
         qc = qc.decompose(AnsatzBlock)
         quimb_circuit_factory = self.quimb_circuit_factory
         circ = quimb_circuit_factory(N=qc.num_qubits, **kwargs)
         gates = qiskit_quimb.quimb_gates(qc)
         circ.apply_gates(gates, progbar=self.progbar)
+        if out_state is not None:
+            out_state[:] = np.squeeze(circ.psi.to_dense())
         return circ
 
 
@@ -111,8 +115,10 @@ def tensornetwork_from_circuit(
     qc: QuantumCircuit,
     settings: QuimbSimulator,
     /,
+    *,
+    out_state: Optional[np.ndarray] = None,
 ) -> quimb.tensor.Circuit:
-    return settings._construct_circuit(qc)
+    return settings._construct_circuit(qc, out_state=out_state)
 
 
 @dispatch
@@ -171,10 +177,7 @@ def apply_circuit_to_state(
     Returns:
         The new state.
     """
-    circuit = settings._construct_circuit(qc, psi0=circ0.psi)
-    if out_state is not None:
-        out_state[:] = circuit.psi.to_dense()
-    return circuit
+    return settings._construct_circuit(qc, out_state=out_state, psi0=circ0.psi)
 
 
 class QiskitQuimbConversionContext:
@@ -257,10 +260,18 @@ def qiskit_ansatz_to_quimb(
             quimb_gate_ = quimb_gate(op, qubits)
             if quimb_gate_ is not None:
                 circ.apply_gate(quimb_gate_)
-        else:
+        else:  # pragma: no cover
             raise ValueError("A parameter in the circuit has an unexpected type.")
     for j, _, _ in mapping:
-        if j == -1:
+        if j == -1:  # pragma: no cover
+            # NOTE: There seems to be no obvious way to trigger this error.
+            # Even the following snippet results in the parameter being removed
+            # from the circuit.
+            #
+            # qc = QuantumCircuit(1)
+            # x = Parameter("x")
+            # qc.rx(x, 0)
+            # qc.data[0] = CircuitInstruction(RXGate(np.pi / 3), qubits=[0])
             raise ValueError(
                 "Some parameter(s) in the given Qiskit circuit remain unused. "
                 "This use case is not currently supported by the Quimb conversion code."
@@ -278,7 +289,7 @@ def recover_parameters_from_quimb(
         raise ValueError(
             "The length of the mapping in the provided QiskitQuimbConversionContext "
             "does not match the number of parametrized gates in the circuit "
-            f"({len(mapping)}) vs. ({len(quimb_parametrized_gates)})."
+            f"({len(mapping)} vs. {len(quimb_parametrized_gates)})."
         )
     # `(y - b) / m` is the inversion of the parameter expression, which we
     # assumed above to be in the form mx + b.
@@ -292,6 +303,20 @@ def _preprocess_for_gradient(objective, settings: QuimbSimulator):
             "Gradient method unspecified. Please specify an autodiff_backend "
             "for the QuimbSimulator object."
         )
+    if objective._ansatz is not None:
+        ansatz_num_qubits = objective._ansatz.num_qubits
+        target = objective._target_tensornetwork
+        try:
+            # As implemented by quimb.tensor.Circuit
+            target_num_qubits = target.N
+        except AttributeError:  # pragma: no cover
+            # As implemented by quimb.tensor.TensorNetworkGen
+            target_num_qubits = target.nsites
+        if ansatz_num_qubits != target_num_qubits:
+            raise ValueError(
+                "Ansatz and target have different numbers of qubits "
+                f"({ansatz_num_qubits} vs. {target_num_qubits})."
+            )
     if settings.autodiff_backend == "explicit":
         # FIXME: error if target and/or settings could result in non-MPS, in
         # order to prevent a later MethodError from plum

test/simulation/aer/test_aer_backend.py

@@ -12,7 +12,6 @@
 
 import numpy as np
 import pytest
-from qiskit import QuantumCircuit
 from qiskit.circuit.library import CXGate, XGate
 from qiskit.providers.basic_provider import BasicSimulator
 
@@ -32,23 +31,6 @@
 pytestmark = pytest.mark.skipif(skip_aer_tests, reason="qiskit-aer is not installed")
 
 
-@pytest.fixture
-def bell_qc():
-    qc = QuantumCircuit(2)
-    qc.h(0)
-    qc.cx(0, 1)
-    return qc
-
-
-@pytest.fixture
-def ghz_qc():
-    qc = QuantumCircuit(3)
-    qc.h(0)
-    qc.cx(0, 1)
-    qc.cx(1, 2)
-    return qc
-
-
 class TestQiskitAerBackend:
     def test_bell_circuit(self, bell_qc, AerSimulator):
         simulator = AerSimulator(method="matrix_product_state")
@@ -57,12 +39,6 @@ def test_bell_circuit(self, bell_qc, AerSimulator):
         bell_mps2 = tensornetwork_from_circuit(bell_qc, settings)
         assert compute_overlap(bell_mps1, bell_mps2) == pytest.approx(1)
 
-    def test_bell_circuit_statevector(self, bell_qc, AerSimulator):
-        simulator = AerSimulator(method="matrix_product_state")
-        out_state = np.zeros([4], dtype=complex)
-        tensornetwork_from_circuit(bell_qc, simulator, out_state=out_state)
-        assert out_state == pytest.approx(np.array([1, 0, 0, 1]) / np.sqrt(2))
-
     def test_bell_circuit_log(self, bell_qc, AerSimulator):
         simulator = AerSimulator(method="matrix_product_state", mps_log_data=True)
         all_log_data: list[str] = []

test/simulation/conftest.py

@@ -0,0 +1,30 @@
+# This code is a Qiskit project.
+#
+# (C) Copyright IBM 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+import pytest
+from qiskit import QuantumCircuit
+
+
+@pytest.fixture
+def bell_qc():
+    qc = QuantumCircuit(2)
+    qc.h(0)
+    qc.cx(0, 1)
+    return qc
+
+
+@pytest.fixture
+def ghz_qc():
+    qc = QuantumCircuit(3)
+    qc.h(0)
+    qc.cx(0, 1)
+    qc.cx(1, 2)
+    return qc

test/simulation/quimb/test_quimb_backend.py

@@ -16,6 +16,7 @@
 from qiskit.circuit import Parameter, QuantumCircuit
 from qiskit.circuit.library import CXGate, RXGate, XXPlusYYGate
 
+from qiskit_addon_aqc_tensor.objective import MaximizeStateFidelity
 from qiskit_addon_aqc_tensor.simulation import (
     compute_overlap,
     tensornetwork_from_circuit,
@@ -115,3 +116,32 @@ def test_repeated_parameter(self):
             e_info.value.args[0]
             == "Parameter cannot be repeated in circuit, else quimb will attempt to optimize each instance separately."
         )
+
+    def test_unspecified_gradient_method(self, quimb):
+        settings = QuimbSimulator(quimb.tensor.CircuitMPS)
+        qc = QuantumCircuit(1)
+        x = Parameter("x")
+        qc.rx(x, 0)
+        with pytest.raises(ValueError) as e_info:
+            MaximizeStateFidelity(None, qc, settings)
+        assert (
+            e_info.value.args[0]
+            == "Gradient method unspecified. Please specify an autodiff_backend for the QuimbSimulator object."
+        )
+
+    def test_recovery_num_parameters_mismatch_error(self):
+        x = Parameter("x")
+        y = Parameter("y")
+        qc1 = QuantumCircuit(1)
+        qc1.rx(1 - x, 0)
+        qc2 = QuantumCircuit(1)
+        qc2.rx(1 - x, 0)
+        qc2.ry(1 - 0.5 * y, 0)
+        circ1, _ = qiskit_ansatz_to_quimb(qc1, [0.5])
+        _, ctx2 = qiskit_ansatz_to_quimb(qc2, [0.5, 0.3])
+        with pytest.raises(ValueError) as e_info:
+            recover_parameters_from_quimb(circ1, ctx2)
+        assert (
+            e_info.value.args[0]
+            == "The length of the mapping in the provided QiskitQuimbConversionContext does not match the number of parametrized gates in the circuit (2 vs. 1)."
+        )

test/simulation/test_gradient.py

@@ -28,6 +28,7 @@
     _compute_objective_and_gradient,
     _preprocess_for_gradient,
 )
+from qiskit_addon_aqc_tensor.simulation.aer import is_aer_available
 from qiskit_addon_aqc_tensor.simulation.explicit_gradient import _basis_gates
 
 
@@ -70,7 +71,7 @@ def _generate_random_ansatz(num_qubits: int):
             su2_gates=su2_gates,
             reps=random.randint(1, 2),
             parameter_prefix="c",
-            insert_barriers=_get_random_bool(),
+            insert_barriers=True,
         ),
         inplace=True,
         copy=False,
@@ -129,3 +130,52 @@ def vdagger_rhs(thetas):
     numerical_grad = -2 * np.real(np.conj(f_0) * numerical_grad)
 
     assert grad == pytest.approx(numerical_grad, abs=1e-4)
+
+
+@pytest.mark.skipif(not is_aer_available(), reason="qiskit-aer is not installed")
+class TestExplicitGradient:
+    def test_no_parameters_throws_error(self, AerSimulator):
+        settings = AerSimulator(method="matrix_product_state")
+        tn = tensornetwork_from_circuit(QuantumCircuit(1), settings)
+        qc = QuantumCircuit(1)
+        with pytest.raises(ValueError) as e_info:
+            MaximizeStateFidelity(tn, qc, settings)
+        assert (
+            e_info.value.args[0]
+            == "Expects parametric circuit using ParameterVector object.\nThat is, placeholders are expected rather than concrete\nvalues for the variable parameters. The circuit specified\nhas no variable parameters. Check that the function\nassign_parameters() has not been applied to this circuit."
+        )
+
+    def test_non_basis_gate(self, AerSimulator):
+        settings = AerSimulator(method="matrix_product_state")
+        tn = tensornetwork_from_circuit(QuantumCircuit(2), settings)
+        qc = QuantumCircuit(2)
+        x = Parameter("x")
+        qc.rx(x, 0)
+        qc.cp(np.pi / 5, 0, 1)
+        with pytest.raises(ValueError) as e_info:
+            MaximizeStateFidelity(tn, qc, settings)
+        assert (
+            e_info.value.args[0]
+            == "Expects a gate from the list of basis ones: ['cx', 'cz', 'ecr', 'h', 'rx', 'ry', 'rz', 's', 'sdg', 'x', 'y', 'z'], got 'cp' instead."
+        )
+
+    def test_one_qubit_parametrized_pauli_error_messages(self, subtests, AerSimulator):
+        settings = AerSimulator(method="matrix_product_state")
+        tn = tensornetwork_from_circuit(QuantumCircuit(1), settings)
+        x = Parameter("x")
+        y = Parameter("y")
+        with subtests.test("Expression with multiple parameters"):
+            qc = QuantumCircuit(1)
+            qc.rx(x + y, 0)
+            with pytest.raises(ValueError) as e_info:
+                MaximizeStateFidelity(tn, qc, settings)
+            assert e_info.value.args[0] == "Expression cannot contain more than one Parameter"
+        with subtests.test("Nonlinear expression"):
+            qc = QuantumCircuit(1)
+            qc.rx(x**3, 0)
+            with pytest.raises(ValueError) as e_info:
+                MaximizeStateFidelity(tn, qc, settings)
+            assert (
+                e_info.value.args[0]
+                == "ParameterExpression's derivative must be a floating-point number, i.e., the expression must be in the form ax + b."
+            )

test/simulation/test_statevector.py

@@ -0,0 +1,37 @@
+# This code is a Qiskit project.
+#
+# (C) Copyright IBM 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+import numpy as np
+import pytest
+from qiskit import QuantumCircuit
+from qiskit.quantum_info import Statevector
+
+from qiskit_addon_aqc_tensor.simulation import (
+    tensornetwork_from_circuit,
+)
+
+
+class TestExactStatevector:
+    def test_bell_circuit_statevector(self, bell_qc, available_backend_fixture):
+        out_state = np.zeros([4], dtype=complex)
+        tensornetwork_from_circuit(bell_qc, available_backend_fixture, out_state=out_state)
+        assert out_state == pytest.approx(np.array([1, 0, 0, 1]) / np.sqrt(2))
+
+    def test_random_circuit_statevector(self, available_backend_fixture):
+        qc = QuantumCircuit(3)
+        qc.h(0)
+        qc.cx(0, 1)
+        qc.ryy(0.3, 1, 2)
+        qc.rxx(0.7, 0, 2)
+        out_state = np.zeros([8], dtype=complex)
+        tensornetwork_from_circuit(qc, available_backend_fixture, out_state=out_state)
+        abs(np.vdot(Statevector(qc).data, out_state)) == pytest.approx(1)

test/test_objective.py

@@ -0,0 +1,36 @@
+# This code is a Qiskit project.
+#
+# (C) Copyright IBM 2025.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+
+import pytest
+from qiskit import QuantumCircuit
+from qiskit.circuit import Parameter
+
+from qiskit_addon_aqc_tensor.objective import MaximizeStateFidelity
+from qiskit_addon_aqc_tensor.simulation import (
+    tensornetwork_from_circuit,
+)
+
+
+# pylint: disable=no-self-use
+class TestObjective:
+    def test_ansatz_target_qubit_mismatch(self, available_backend_fixture):
+        settings = available_backend_fixture
+        target = tensornetwork_from_circuit(QuantumCircuit(2), settings)
+        x = Parameter("x")
+        ansatz = QuantumCircuit(1)
+        ansatz.rx(x, 0)
+        with pytest.raises(ValueError) as e_info:
+            MaximizeStateFidelity(target, ansatz, settings)
+        assert (
+            e_info.value.args[0] == "Ansatz and target have different numbers of qubits (1 vs. 2)."
+        )