Address executor and observable incompatibility

docs/source/guide/executors.md

@@ -30,7 +30,9 @@ To instantiate an `Executor`, provide a function which either:
 1. Inputs a `mitiq.QPROGRAM` and outputs a `mitiq.QuantumResult`.
 2. Inputs a sequence of `mitiq.QPROGRAM`s and outputs a sequence of `mitiq.QuantumResult`s.
 
-**The function must be [annotated](https://peps.python.org/pep-3107/) to tell Mitiq which type of `QuantumResult` it returns. Functions with no annotations are assumed to return `float`s.**
+```{warning}
+To avoid confusion and invalid results, the executor function must be [annotated](https://peps.python.org/pep-3107/) to tell Mitiq which type of `QuantumResult` it returns. Functions without annotations are assumed to return `float`s.
+```
 
 A `QPROGRAM` is "something which a quantum computer inputs" and a `QuantumResult` is "something which a quantum computer outputs." The latter is canonically a bitstring for real quantum hardware, but can be other objects for testing, e.g. a density matrix.
 

docs/source/guide/observables.md

@@ -128,8 +128,8 @@ obs.expectation(circuit, execute=mitiq_cirq.sample_bitstrings)
 
 In error mitigation techniques, you can provide an observable to specify the expectation value to mitigate.
 
-```{admonition} Note:
-When specifying an `Observable`, you must ensure that the return type of the executor function is `MeasurementResultLike` or `DensityMatrixLike`.
+```{warning}
+As note in the [executor documentation](./executors.md#the-input-function), the executor must be annotated with the appropriate type hinting for the return type. Additionally, when specifying an `Observable`, you must ensure that the return type of the executor function is `MeasurementResultLike` or `DensityMatrixLike`.
 ```
 
 ```{code-cell} ipython3

mitiq/executor/executor.py

@@ -23,6 +23,7 @@
 
 import numpy as np
 import numpy.typing as npt
+from cirq import MeasurementGate
 
 from mitiq import QPROGRAM, MeasurementResult, QuantumResult
 from mitiq.interface import convert_from_mitiq, convert_to_mitiq
@@ -149,6 +150,59 @@ def evaluate(
  "Expected observable to be hermitian. Continue with caution."
  )
 
+ # Check executor and observable compatability with type hinting
+ if self._executor_return_type in FloatLike and observable is not None:
+ if self._executor_return_type is None:
+ raise ValueError(
+ "Please use type hinting with the executor. Without a "
+ "return type defined, it is assumed a float is returned. "
+ "When returning a float, an observable should not be used."
+ )
+ else:
+ raise ValueError(
+ "When using a float like result, measurements should be "
+ "included in the circuit and an observable should not be "
+ "used."
+ )
+ elif observable is None:
+ if self._executor_return_type in DensityMatrixLike:
+ raise ValueError(
+ "When using a density matrix like result, an observable "
+ "is required."
+ )
+ elif self._executor_return_type in MeasurementResultLike:
+ raise ValueError(
+ "When using a measurement, or bitstring, like result, an "
+ "observable is required."
+ )
+ else:
+ for circuit in circuits:
+ if (
+ len(
+ list(
+ convert_to_mitiq(circuit)[
+ 0
+ ].findall_operations_with_gate_type(
+ MeasurementGate
+ )
+ )
+ )
+ == 0
+ ):
+ if self._executor_return_type is None:
+ raise ValueError(
+ "Please use type hinting with the executor. "
+ "Without a return type defined, it is assumed "
+ "a float is returned. When returning a float, "
+ "the circuit is expected to include "
+ "measurements."
+ )
+ else:
+ raise ValueError(
+ "When using a float like result, measurements "
+ "should be included in the circuit."
+ )
+
  # Get all required circuits to run.
  if (
  observable is not None
@@ -160,16 +214,6 @@ def evaluate(
  for circuit_with_measurements in observable.measure_in(circuit)
  ]
  result_step = observable.ngroups
- elif (
- observable is not None
- and self._executor_return_type not in MeasurementResultLike
- and self._executor_return_type not in DensityMatrixLike
- ):
- raise ValueError(
- """Executor and observable are not compatible. Executors
- returning expectation values as float must be used with
- observable=None"""
- )
  else:
  all_circuits = circuits
  result_step = 1

mitiq/executor/tests/test_executor.py

@@ -12,6 +12,7 @@
 import numpy as np
 import pyquil
 import pytest
+from qiskit import QuantumCircuit
 
 from mitiq import MeasurementResult
 from mitiq.executor.executor import Executor
@@ -37,7 +38,7 @@ def executor_batched_unique(circuits) -> List[float]:
  return [executor_serial_unique(circuit) for circuit in circuits]
 
 
-def executor_serial_unique(circuit):
+def executor_serial_unique(circuit) -> float:
  return float(len(circuit))
 
 
@@ -58,21 +59,29 @@ def executor_pyquil_batched(programs) -> List[float]:
 
 
 # Serial / batched executors which return measurements.
-def executor_measurements(circuit) -> MeasurementResult:
+def executor_measurements(circuit):
+ return sample_bitstrings(circuit, noise_level=(0,))
+
+
+def executor_measurements_typed(circuit) -> MeasurementResult:
  return sample_bitstrings(circuit, noise_level=(0,))
 
 
 def executor_measurements_batched(circuits) -> List[MeasurementResult]:
- return [executor_measurements(circuit) for circuit in circuits]
+ return [executor_measurements_typed(circuit) for circuit in circuits]
 
 
 # Serial / batched executors which return density matrices.
-def executor_density_matrix(circuit) -> np.ndarray:
+def executor_density_matrix(circuit):
+ return compute_density_matrix(circuit, noise_level=(0,))
+
+
+def executor_density_matrix_typed(circuit) -> np.ndarray:
  return compute_density_matrix(circuit, noise_level=(0,))
 
 
 def executor_density_matrix_batched(circuits) -> List[np.ndarray]:
- return [executor_density_matrix(circuit) for circuit in circuits]
+ return [executor_density_matrix_typed(circuit) for circuit in circuits]
 
 
 def test_executor_simple():
@@ -86,7 +95,7 @@ def test_executor_is_batched_executor():
  assert Executor.is_batched_executor(executor_batched)
  assert not Executor.is_batched_executor(executor_serial_typed)
  assert not Executor.is_batched_executor(executor_serial)
- assert not Executor.is_batched_executor(executor_measurements)
+ assert not Executor.is_batched_executor(executor_measurements_typed)
  assert Executor.is_batched_executor(executor_measurements_batched)
 
 
@@ -96,7 +105,7 @@ def test_executor_non_hermitian_observable():
  q = cirq.LineQubit(0)
  circuits = [cirq.Circuit(cirq.I.on(q)), cirq.Circuit(cirq.X.on(q))]
 
- executor = Executor(executor_measurements)
+ executor = Executor(executor_measurements_typed)
 
  with pytest.warns(UserWarning, match="hermitian"):
  executor.evaluate(circuits, obs)
@@ -199,53 +208,27 @@ def test_run_executor_preserves_order(s, b):
 )
 def test_executor_evaluate_float(execute):
  q = cirq.LineQubit(0)
- circuits = [cirq.Circuit(cirq.X(q)), cirq.Circuit(cirq.H(q), cirq.Z(q))]
+ circuits = [
+ cirq.Circuit(cirq.X(q), cirq.M(q)),
+ cirq.Circuit(cirq.H(q), cirq.Z(q), cirq.M(q)),
+ ]
 
  executor = Executor(execute)
 
  results = executor.evaluate(circuits)
- assert np.allclose(results, [1, 2])
+ assert np.allclose(results, [2, 3])
 
  if execute is executor_serial_unique:
  assert executor.calls_to_executor == 2
  else:
  assert executor.calls_to_executor == 1
 
  assert executor.executed_circuits == circuits
- assert executor.quantum_results == [1, 2]
-
-
-@pytest.mark.parametrize(
- "execute",
- [
- executor_batched,
- executor_batched_unique,
- executor_serial_unique,
- executor_serial_typed,
- executor_serial,
- executor_pyquil_batched,
- ],
-)
-@pytest.mark.parametrize(
- "obs",
- [
- PauliString("X"),
- PauliString("XZ"),
- PauliString("Z"),
- ],
-)
-def test_executor_observable_compatibility_check(execute, obs):
- q = cirq.LineQubit(0)
- circuits = [cirq.Circuit(cirq.X(q)), cirq.Circuit(cirq.H(q), cirq.Z(q))]
-
- executor = Executor(execute)
-
- with pytest.raises(ValueError, match="are not compatible"):
- executor.evaluate(circuits, obs)
+ assert executor.quantum_results == [2, 3]
 
 
 @pytest.mark.parametrize(
- "execute", [executor_measurements, executor_measurements_batched]
+ "execute", [executor_measurements_typed, executor_measurements_batched]
 )
 def test_executor_evaluate_measurements(execute):
  obs = Observable(PauliString("Z"))
@@ -258,24 +241,24 @@ def test_executor_evaluate_measurements(execute):
  results = executor.evaluate(circuits, obs)
  assert np.allclose(results, [1, -1])
 
- if execute is executor_measurements:
+ if execute is executor_measurements_typed:
  assert executor.calls_to_executor == 2
  else:
  assert executor.calls_to_executor == 1
 
  assert executor.executed_circuits[0] == circuits[0] + cirq.measure(q)
  assert executor.executed_circuits[1] == circuits[1] + cirq.measure(q)
- assert executor.quantum_results[0] == executor_measurements(
+ assert executor.quantum_results[0] == executor_measurements_typed(
  circuits[0] + cirq.measure(q)
  )
- assert executor.quantum_results[1] == executor_measurements(
+ assert executor.quantum_results[1] == executor_measurements_typed(
  circuits[1] + cirq.measure(q)
  )
  assert len(executor.quantum_results) == len(circuits)
 
 
 @pytest.mark.parametrize(
- "execute", [executor_density_matrix, executor_density_matrix_batched]
+ "execute", [executor_density_matrix_typed, executor_density_matrix_batched]
 )
 def test_executor_evaluate_density_matrix(execute):
  obs = Observable(PauliString("Z"))
@@ -288,16 +271,85 @@ def test_executor_evaluate_density_matrix(execute):
  results = executor.evaluate(circuits, obs)
  assert np.allclose(results, [1, -1])
 
- if execute is executor_density_matrix:
+ if execute is executor_density_matrix_typed:
  assert executor.calls_to_executor == 2
  else:
  assert executor.calls_to_executor == 1
 
  assert executor.executed_circuits == circuits
  assert np.allclose(
- executor.quantum_results[0], executor_density_matrix(circuits[0])
+ executor.quantum_results[0], executor_density_matrix_typed(circuits[0])
  )
  assert np.allclose(
- executor.quantum_results[1], executor_density_matrix(circuits[1])
+ executor.quantum_results[1], executor_density_matrix_typed(circuits[1])
  )
  assert len(executor.quantum_results) == len(circuits)
+
+
+def test_executor_float_with_observable_typed():
+ obs = Observable(PauliString("Z"))
+ q = cirq.LineQubit(0)
+ circuit = cirq.Circuit(cirq.X.on(q))
+ executor = Executor(executor_serial_typed)
+ with pytest.raises(
+ ValueError,
+ match="When using a float like result",
+ ):
+ executor.evaluate(circuit, obs)
+
+
+def test_executor_measurements_without_observable_typed():
+ q = cirq.LineQubit(0)
+ circuit = cirq.Circuit(cirq.X.on(q))
+ executor = Executor(executor_measurements_typed)
+ with pytest.raises(
+ ValueError,
+ match="When using a measurement, or bitstring, like result",
+ ):
+ executor.evaluate(circuit)
+
+
+def test_executor_density_matrix_without_observable_typed():
+ q = cirq.LineQubit(0)
+ circuit = cirq.Circuit(cirq.X.on(q))
+ executor = Executor(executor_density_matrix_typed)
+ with pytest.raises(
+ ValueError,
+ match="When using a density matrix like result",
+ ):
+ executor.evaluate(circuit)
+
+
+def test_executor_float_no_typehint():
+ obs = Observable(PauliString("Z"))
+ q = cirq.LineQubit(0)
+ circuit = cirq.Circuit(cirq.X.on(q))
+ executor = Executor(executor_serial)
+
+ with pytest.raises(
+ ValueError,
+ match="Please use type hinting with",
+ ):
+ executor.evaluate(circuit, obs)
+
+ with pytest.raises(
+ ValueError,
+ match="Please use type hinting with the executor",
+ ):
+ executor.evaluate(circuit)
+
+
+@pytest.mark.parametrize(
+ "execute",
+ [executor_density_matrix, executor_measurements],
+)
+def test_executor_non_float_no_typehint(execute):
+ executor = Executor(execute)
+
+ qcirc = QuantumCircuit(1)
+ qcirc.h(0)
+
+ with pytest.raises(
+ ValueError, match="Please use type hinting with the executor"
+ ):
+ executor.evaluate(qcirc)

mitiq/observable/pauli.py

@@ -282,8 +282,27 @@ def _measure_in(
 
  basis_rotations = set()
  support = set()
+
+ # Find any existing measurement gates in the circuit
+ existing_measurements = []
+ measurement_tuples = list(
+ circuit.findall_operations_with_gate_type(cirq.MeasurementGate)
+ )
+ if measurement_tuples:
+ existing_measurements = [
+ measurement_tuple[1].qubits[0]
+ for measurement_tuple in measurement_tuples
+ ]
+
  for pauli in paulis.elements:
  basis_rotations.update(pauli._basis_rotations())
+ for qubit in pauli._qubits_to_measure():
+ if qubit in existing_measurements:
+ raise ValueError(
+ f"""More than one measaurement found for qubit: """
+ f"""{qubit}. Only a single measurement is allowed """
+ f"""per qubit."""
+ )
  support.update(pauli._qubits_to_measure())
  measured = circuit + basis_rotations + cirq.measure(*sorted(support))
 

mitiq/observable/tests/test_pauli.py

@@ -137,6 +137,16 @@ def test_pauli_measure_in_bad_qubits_error():
  pauli.measure_in(circuit)
 
 
+def test_pauli_measure_in_multi_measurements_per_qubit():
+ n = 4
+ pauli = PauliString(spec="Z" * n)
+ circuit = cirq.Circuit(cirq.H.on_each(cirq.LineQubit.range(n)))
+ # add a measurement to qubit 0
+ circuit = circuit + cirq.measure(cirq.LineQubit(0))
+ with pytest.raises(ValueError, match="More than one measaurement"):
+ pauli.measure_in(circuit)
+
+
 def test_can_be_measured_with_single_qubit():
  pauli = PauliString(spec="Z")