Diagonalize gates

pennylane_qiskit/converter.py

@@ -35,6 +35,7 @@
 
 import pennylane as qml
 import pennylane.ops as pennylane_ops
+from pennylane.tape.tape import rotations_and_diagonal_measurements
 from pennylane_qiskit.qiskit_device import QISKIT_OPERATION_MAP
 
 inv_map = {v.__name__: k for k, v in QISKIT_OPERATION_MAP.items()}
@@ -652,7 +653,11 @@ def circuit_to_qiskit(circuit, register_size, diagonalize=True, measure=True):
     # rotate the state for measurement in the computational basis
     # ToDo: check this in cases with multiple different bases
     if diagonalize:
-        rotations = circuit.diagonalizing_gates
+        rotations, measurements = rotations_and_diagonal_measurements(circuit)
+        for _, m in enumerate(measurements):
+            if m.obs is not None:
+                rotations.extend(m.obs.diagonalizing_gates())
+
         for rot in rotations:
             qc &= operation_to_qiskit(rot, reg, creg)
 

pennylane_qiskit/qiskit_device2.py

@@ -32,7 +32,7 @@
 
 from pennylane import transform
 from pennylane.transforms.core import TransformProgram
-from pennylane.transforms import broadcast_expand
+from pennylane.transforms import broadcast_expand, split_non_commuting
 from pennylane.tape import QuantumTape, QuantumScript
 from pennylane.typing import Result, ResultBatch
 from pennylane.devices import Device
@@ -129,7 +129,6 @@ def split_execution_types(
     will use the Qiskit Sampler. ExpectationValue and Variance will use the Estimator, except
     when the measured observable does not have a `pauli_rep`. In that case, the Sampler will be
     used, and the raw samples will be processed to give an expectation value."""
-
     estimator = []
     sampler = []
 
@@ -219,6 +218,11 @@ class QiskitDevice2(Device):
         "Hadamard",
         "Hermitian",
         "Projector",
+        "Prod",
+        "Sum",
+        "LinearCombination",
+        "SProd",
+        # TODO Could support SparseHamiltonian
     }
 
     # pylint:disable = too-many-arguments
@@ -365,7 +369,7 @@ def preprocess(
         )
 
         transform_program.add_transform(broadcast_expand)
-        # missing: split non-commuting, sum_expand, etc. [SC-62047]
+        transform_program.add_transform(split_non_commuting)
 
         transform_program.add_transform(split_execution_types)
 
@@ -580,10 +584,8 @@ def _process_estimator_job(measurements, job_result):
         Returns:
             result (tuple): the processed result from EstimatorV2
         """
-
         expvals = job_result[0].data.evs
         variances = (job_result[0].data.stds / job_result[0].metadata["target_precision"]) ** 2
-
         result = []
         for i, mp in enumerate(measurements):
             if isinstance(mp, ExpectationMP):

tests/test_base_device.py

@@ -365,14 +365,75 @@ def test_stopping_conditions(self, op, expected):
         [
             (qml.PauliX(0), True),
             (qml.Hadamard(3), True),
-            (qml.prod(qml.PauliY(1), qml.PauliZ(0)), False),
+            (qml.prod(qml.PauliY(1), qml.PauliZ(0)), True),
         ],
     )
     def test_observable_stopping_condition(self, obs, expected):
         """Test that observable_stopping_condition works"""
         res = test_dev.observable_stopping_condition(obs)
         assert res == expected
 
+    @pytest.mark.parametrize(
+        "measurements, num_tapes",
+        [
+            (
+                [
+                    qml.expval(qml.X(0) + qml.Y(0) + qml.Z(0)),
+                ],
+                3,
+            ),
+            (
+                [qml.var(qml.X(0) + qml.Y(0) + qml.Z(0))],  # Var should not split
+                1,
+            ),
+            (
+                [
+                    qml.expval(qml.X(0)),
+                    qml.expval(qml.Y(1)),
+                    qml.expval(qml.Z(0) @ qml.Z(1)),
+                    qml.expval(qml.X(0) @ qml.Z(1) + 0.5 * qml.Y(1) + qml.Z(0)),
+                ],
+                3,
+            ),
+            (
+                [
+                    qml.expval(
+                        qml.prod(qml.X(0), qml.Z(0), qml.Z(0)) + 0.35 * qml.X(0) - 0.21 * qml.Z(0)
+                    )
+                ],
+                2,
+            ),
+            (
+                [
+                    qml.counts(qml.X(0)),
+                    qml.counts(qml.Y(1)),
+                    qml.counts(qml.Z(0) @ qml.Z(1)),
+                    qml.counts(qml.X(0) @ qml.Z(1) + 0.5 * qml.Y(1) + qml.Z(0)),
+                ],
+                3,
+            ),
+            (
+                [
+                    qml.sample(qml.X(0)),
+                    qml.sample(qml.Y(1)),
+                    qml.sample(qml.Z(0) @ qml.Z(1)),
+                    qml.sample(qml.X(0) @ qml.Z(1) + 0.5 * qml.Y(1) + qml.Z(0)),
+                ],
+                3,
+            ),
+        ],
+    )
+    def test_preprocess_split_non_commuting(self, measurements, num_tapes):
+        """Test that `split_non_commuting` works as expected in the preprocess function."""
+
+        dev = QiskitDevice2(wires=5, backend=backend)
+        qs = QuantumScript([], measurements=measurements, shots=qml.measurements.Shots(1000))
+
+        program, _ = dev.preprocess()
+        tapes, _ = program([qs])
+
+        assert len(tapes) == num_tapes
+
     @pytest.mark.parametrize(
         "measurements,num_types",
         [
@@ -451,7 +512,6 @@ def test_warning_if_shots(self):
             match="default_shots was found in the keyword arguments",
         ):
             dev = QiskitDevice2(wires=2, backend=backend, options={"default_shots": 30})
-
         # resets to default since we reinitialize the device
         assert dev._kwargs["default_shots"] == 1024
 
@@ -1114,3 +1174,166 @@ def qiskit_circuit(x):
         assert np.shape(res[0]) == np.shape(qiskit_res[0])
         assert np.shape(res[1]) == np.shape(qiskit_res[1])
         assert len(res) == len(qiskit_res)
+
+    @pytest.mark.parametrize(
+        "observable",
+        [
+            lambda: [qml.expval(qml.Hadamard(0)), qml.expval(qml.Hadamard(0))],
+            lambda: [
+                qml.var(qml.Hadamard(0)),
+                qml.var(qml.Hadamard(0)),
+            ],
+            lambda: [
+                qml.expval(qml.X(0)),
+                qml.expval(qml.Y(1)),
+                qml.expval(0.5 * qml.Y(1)),
+                qml.expval(qml.Z(0) @ qml.Z(1)),
+                qml.expval(qml.X(0) @ qml.Z(1) + 0.5 * qml.Y(1) + qml.Z(0)),
+                qml.expval(
+                    qml.ops.LinearCombination(
+                        [0.35, 0.46], [qml.X(0) @ qml.Z(1), qml.Z(0) @ qml.X(2)]
+                    )
+                ),
+                qml.expval(
+                    qml.ops.LinearCombination(
+                        [1.0, 2.0, 3.0], [qml.X(0), qml.X(1), qml.Z(0)], grouping_type="qwc"
+                    )
+                ),
+            ],
+            lambda: [
+                qml.expval(
+                    qml.Hamiltonian([0.35, 0.46], [qml.X(0) @ qml.Z(1), qml.Z(0) @ qml.Y(2)])
+                )
+            ],
+            lambda: [qml.expval(qml.X(0) @ qml.Z(1) + qml.Z(0))],
+            pytest.param(
+                [qml.var(qml.X(0) + qml.Z(0))],
+                marks=pytest.mark.xfail(reason="Qiskit itself is bugged when given Sum"),
+            ),
+            lambda: [
+                qml.expval(qml.Hadamard(0)),
+                qml.expval(qml.Hadamard(1)),
+                qml.expval(qml.Hadamard(0) @ qml.Hadamard(1)),
+                qml.expval(
+                    qml.Hadamard(0) @ qml.Hadamard(1) + 0.5 * qml.Hadamard(1) + qml.Hadamard(0)
+                ),
+            ],
+        ],
+    )
+    def test_observables_that_need_split_non_commuting(self, observable):
+        """Tests that observables that have non-commuting measurements are
+        processed correctly when executed by the Estimator or, in the case of
+        qml.Hadamard, executed by the Sampler via expval() or var"""
+        qiskit_dev = QiskitDevice2(wires=3, backend=backend, shots=30000)
+
+        @qml.qnode(qiskit_dev)
+        def qiskit_circuit():
+            qml.RX(np.pi / 3, 0)
+            qml.RZ(np.pi / 3, 0)
+            return observable()
+
+        dev = qml.device("default.qubit", wires=3, shots=30000)
+
+        @qml.qnode(dev)
+        def circuit():
+            qml.RX(np.pi / 3, 0)
+            qml.RZ(np.pi / 3, 0)
+            return observable()
+
+        qiskit_res = qiskit_circuit()
+        res = circuit()
+
+        assert np.allclose(res, qiskit_res, atol=0.05)
+
+    @pytest.mark.parametrize(
+        "observable",
+        [
+            lambda: [qml.counts(qml.X(0) + qml.Y(0)), qml.counts(qml.X(0))],
+            lambda: [
+                qml.counts(qml.X(0) @ qml.Z(1) + 0.5 * qml.Y(1) + qml.Z(0)),
+                qml.counts(0.5 * qml.Y(1)),
+            ],
+        ],
+    )
+    def test_observables_that_need_split_non_commuting_counts(self, observable):
+        """Tests that observables that have non-commuting measurents are processed
+        correctly when executed by the Sampler via counts()"""
+        qiskit_dev = QiskitDevice2(wires=3, backend=backend, shots=30000)
+
+        @qml.qnode(qiskit_dev)
+        def qiskit_circuit():
+            qml.RX(np.pi / 3, 0)
+            qml.RZ(np.pi / 3, 0)
+            return observable()
+
+        dev = qml.device("default.qubit", wires=3, shots=30000)
+
+        @qml.qnode(dev)
+        def circuit():
+            qml.RX(np.pi / 3, 0)
+            qml.RZ(np.pi / 3, 0)
+            return observable()
+
+        qiskit_res = qiskit_circuit()
+        res = circuit()
+
+        assert len(qiskit_res) == len(res)
+        for res1, res2 in zip(qiskit_res, res):
+            assert all(res1[key] - res2.get(key, 0) < 300 for key in res1)
+
+    @pytest.mark.parametrize(
+        "observable",
+        [
+            lambda: [qml.sample(qml.X(0) + qml.Y(0)), qml.sample(qml.X(0))],
+            lambda: [qml.sample(qml.X(0) @ qml.Y(1)), qml.sample(qml.X(0))],
+            lambda: [
+                qml.sample(qml.X(0) @ qml.Z(1) + 0.5 * qml.Y(1) + qml.Z(0)),
+                qml.sample(0.5 * qml.Y(1)),
+            ],
+            lambda: [
+                qml.sample(qml.X(0)),
+                qml.sample(qml.Y(1)),
+                qml.sample(0.5 * qml.Y(1)),
+                qml.sample(qml.Z(0) @ qml.Z(1)),
+                qml.sample(qml.X(0) @ qml.Z(1) + 0.5 * qml.Y(1) + qml.Z(0)),
+                qml.sample(
+                    qml.ops.LinearCombination(
+                        [0.35, 0.46], [qml.X(0) @ qml.Z(1), qml.Z(0) @ qml.X(2)]
+                    )
+                ),
+                qml.sample(
+                    qml.ops.LinearCombination(
+                        [1.0, 2.0, 3.0], [qml.X(0), qml.X(1), qml.Z(0)], grouping_type="qwc"
+                    )
+                ),
+            ],
+            lambda: [
+                qml.sample(
+                    qml.Hamiltonian([0.35, 0.46], [qml.X(0) @ qml.Z(1), qml.Z(0) @ qml.Y(2)])
+                )
+            ],
+        ],
+    )
+    def test_observables_that_need_split_non_commuting_samples(self, observable):
+        """Tests that observables that have non-commuting measurents are processed
+        correctly when executed by the Sampler via sample()"""
+        qiskit_dev = QiskitDevice2(wires=3, backend=backend, shots=30000)
+
+        @qml.qnode(qiskit_dev)
+        def qiskit_circuit():
+            qml.RX(np.pi / 3, 0)
+            qml.RZ(np.pi / 3, 0)
+            return observable()
+
+        dev = qml.device("default.qubit", wires=3, shots=30000)
+
+        @qml.qnode(dev)
+        def circuit():
+            qml.RX(np.pi / 3, 0)
+            qml.RZ(np.pi / 3, 0)
+            return observable()
+
+        qiskit_res = qiskit_circuit()
+        res = circuit()
+
+        assert np.allclose(np.mean(qiskit_res, axis=1), np.mean(res, axis=1), atol=0.05)

tests/test_converter.py

@@ -1723,6 +1723,29 @@ def test_circuit_to_qiskit_diagonalize_kwarg(self, diagonalize):
 
         assert len(instructions) == len(expected_gates)
 
+    def test_circuit_to_qiskit_measurements_with_overlapping_wires(self):
+        """Test that diagonalizing gates work for circuits with
+        measurements on overlapping wires"""
+
+        measurements = [qml.sample(qml.X(0) @ qml.Y(1)), qml.sample(qml.X(0))]
+        tape = qml.tape.QuantumScript(measurements=measurements)
+
+        qc = circuit_to_qiskit(tape, 2, diagonalize=True, measure=True)
+
+        # get list of instruction names up to the barrier (played right before measurements)
+        instructions = []
+        for instruction in qc.data:
+            if instruction.operation.name == "barrier":
+                break
+            instructions.append(instruction.operation.name)
+
+        # manually diagonalized test case since Qiskit transpiles whatever we had before
+        # and that results is different from PL's diagonalization
+        expected_gates = ["ry", "rx"]
+
+        assert len(instructions) == len(expected_gates)
+        assert instructions == expected_gates
+
 
 class TestConverterGatePennyLaneToQiskit:
     def test_non_parameteric_operation_to_qiskit(self):