fix: refactoring and making tests pass

Author: hJaffaliColibritd

mpqp/core/circuit.py

@@ -906,7 +906,7 @@ def measurements(self) -> list[Measure]:
             ... ])
             >>> circuit.measurements  # doctest: +NORMALIZE_WHITESPACE
             [BasisMeasure(shots=1000),
-            ExpectationMeasure(Observable(array([[1.+0.j, 0.+0.j], [0.+0.j, 1.+0.j]], dtype=complex64)), [1], shots=1000)]
+            ExpectationMeasure([Observable(array([[1.+0.j, 0.+0.j], [0.+0.j, 1.+0.j]], dtype=complex64))], [1], shots=1000)]
 
         """
         return [inst for inst in self.instructions if isinstance(inst, Measure)]

mpqp/core/instruction/measurement/expectation_value.py

@@ -125,8 +125,8 @@ def __init__(self, observable: Matrix | list[Real] | PauliString):
     def matrix(self) -> Matrix:
         """The matrix representation of the observable."""
         if self._matrix is None:
-            if self.is_diagonal:
-                self._matrix = np.diag(self.diagonal_elements)
+            if self.is_diagonal and self._diag_elements is not None:
+                self._matrix = np.diag(self._diag_elements)
             else:
                 self._matrix = self.pauli_string.to_matrix()
         matrix = copy.deepcopy(self._matrix).astype(np.complex64)
@@ -301,10 +301,10 @@ def __init__(
 
         super().__init__(targets, shots, label)
         # TODO Do some checks on the observables when they are many (same size because of targets)
-        self.observable: list[Observable]
+        self.observables: list[Observable]
         """See parameter description."""
         if isinstance(observable, Observable):
-            self.observable = [observable]
+            self.observables = [observable]
         else:
             if not all(
                 observable[0].nb_qubits == obs.nb_qubits for obs in observable[1:]
@@ -313,7 +313,7 @@ def __init__(
                     "All observables in ExpectationMeasure must have the same size. Sizes: "
                     + str([o.nb_qubits for o in observable])
                 )
-            self.observable = observable
+            self.observables = observable
         self._check_targets_order()
 
     def _check_targets_order(self):
@@ -324,10 +324,10 @@ def _check_targets_order(self):
             self.pre_measure = QCircuit(0)
             return
 
-        if self.nb_qubits != self.observable[0].nb_qubits:
+        if self.nb_qubits != self.observables[0].nb_qubits:
             raise NumberQubitsError(
                 f"Target size {self.nb_qubits} doesn't match observable size "
-                f"{self.observable[0].nb_qubits}."
+                f"{self.observables[0].nb_qubits}."
             )
 
         self.pre_measure = QCircuit(max(self.targets) + 1)
@@ -384,8 +384,7 @@ def __repr__(self) -> str:
         )
         shots = "" if self.shots == 0 else f", shots={self.shots}"
         label = "" if self.label is None else f", label={self.label}"
-        # TODO: update the repr when self.observable contains a list of observables, with also the number of observables
-        return f"ExpectationMeasure({self.observable}{targets}{shots}{label})"
+        return f"ExpectationMeasure({self.observables}{targets}{shots}{label})"
 
     def to_other_language(
         self,

mpqp/core/instruction/measurement/pauli_string.py

@@ -338,7 +338,11 @@ def commutes_with(self, p: PauliString):
 
         Returns:
 
+        Examples:
+            >>> from mpqp.measures import I, X, Y, Z
+
         """
+        pass
 
     @staticmethod
     def from_matrix(
@@ -807,14 +811,21 @@ def __hash__(self):
         return hash(monomials_as_tuples)
 
     def is_diagonal(self) -> bool:
-        """Checks wether this pauli string has a diagonal representation, by checking if only ``I`` and ``Z`` Pauli
+        """Checks whether this pauli string has a diagonal representation, by checking if only ``I`` and ``Z`` Pauli
         operators appears in the monomials of the string.
-        TODO
 
         Returns:
             True if the observable represented by pauli string is diagonal.
+
+        Examples:
+            >>> from mpqp.measures import I, X, Y, Z
+            >>> (I @ X + Z @ Y - Y @ X).is_diagonal()
+            False
+            >>> (I @ Z @ I - 2* Z @ Z @ Z + I @ I @ I).is_diagonal()
+            True
+
         """
-        pass
+        return all([all([a != X and a != Y for a in m.atoms]) for m in self.monomials])
 
 
 @typechecked
@@ -943,6 +954,7 @@ def commutes_with(self, pm: PauliStringMonomial) -> bool:
             True if this Pauli monomial commutes with the one in parameter.
 
         Examples:
+            >>> from mpqp.measures import I, X, Y, Z
             >>> (I @ X @ Y).commutes_with(Z @ Y @ X)
             True
             >>> (X @ Z @ Z).commutes_with(Y @ Z @ I)
@@ -1169,6 +1181,7 @@ def commutes_with(self, a: PauliStringAtom) -> bool:
             True if the atoms commute, False otherwise.
 
         Examples:
+            >>> from mpqp.measures import I, X, Y, Z
             >>> X.commutes_with(X)
             True
             >>> X.commutes_with(Y)

mpqp/execution/providers/atos.py

@@ -252,7 +252,7 @@ def generate_observable_job(myqlm_circuit: "Circuit", job: Job) -> "JobQLM":
     # TODO: [multi-obs] update this to take into account the case when we have list of Observables
     if TYPE_CHECKING:
         assert job.measure is not None and isinstance(job.measure, ExpectationMeasure)
-    qlm_obs = job.measure.observable.to_other_language(Language.MY_QLM)
+    qlm_obs = job.measure.observables[0].to_other_language(Language.MY_QLM)
     myqlm_job = myqlm_circuit.to_job(
         job_type="OBS",
         observable=qlm_obs,

mpqp/execution/providers/aws.py

@@ -188,7 +188,7 @@ def submit_job_braket(job: Job) -> tuple[str, "QuantumTask"]:
         # TODO : [multi-obs] update this to take into account the case when we have list of Observables
         if TYPE_CHECKING:
             assert isinstance(job.measure, ExpectationMeasure)
-        herm_op = job.measure.observable.to_other_language(Language.BRAKET)
+        herm_op = job.measure.observables[0].to_other_language(Language.BRAKET)
         braket_circuit.expectation(  # pyright: ignore[reportAttributeAccessIssue]
             observable=herm_op, target=job.measure.targets
         )

mpqp/execution/providers/google.py

@@ -164,7 +164,7 @@ def run_local(job: Job) -> Result:
             assert isinstance(job.measure, ExpectationMeasure)
         # TODO: update this to take into account the case when we have list of Observables
         # TODO: check if Cirq allows for a list of observable when computing expectation values (apparently yes)
-        cirq_obs = job.measure.observable.to_other_language(
+        cirq_obs = job.measure.observables[0].to_other_language(
             language=Language.CIRQ, circuit=cirq_circuit
         )
         if TYPE_CHECKING:
@@ -253,7 +253,7 @@ def run_local_processor(job: Job) -> Result:
             assert isinstance(job.measure, ExpectationMeasure)
 
         # TODO: update this to take into account the case when we have list of Observables
-        cirq_obs = job.measure.observable.to_other_language(
+        cirq_obs = job.measure.observables[0].to_other_language(
             language=Language.CIRQ, circuit=cirq_circuit
         )
         if TYPE_CHECKING:

mpqp/execution/providers/ibm.py

@@ -97,18 +97,8 @@ def compute_expectation_value(
         )
 
     nb_shots = job.measure.shots
-    observables = (
-        job.measure.observable
-        if isinstance(job.measure.observable, list)
-        else [job.measure.observable]
-    )
 
-    qiskit_observables = []
-    for obs in observables:
-        if isinstance(obs, Observable):
-            qiskit_observables.append(obs.to_other_language(Language.QISKIT))
-        else:
-            raise ValueError("Unsupported observable")
+    qiskit_observables = [obs.to_other_language(Language.QISKIT) for obs in job.measure.observables]
 
     if TYPE_CHECKING:
         assert all(isinstance(obs, SparsePauliOp) for obs in qiskit_observables)
@@ -546,11 +536,8 @@ def submit_remote_ibm(job: Job) -> tuple[str, "RuntimeJobV2"]:
         if TYPE_CHECKING:
             assert isinstance(meas, ExpectationMeasure)
         estimator = Runtime_Estimator(mode=session)
-        qiskit_observables = (
-            meas.observable if isinstance(meas.observable, list) else [meas.observable]
-        )
         qiskit_observables = [
-            obs.to_other_language(Language.QISKIT) for obs in qiskit_observables
+            obs.to_other_language(Language.QISKIT) for obs in meas.observables
         ]
         if TYPE_CHECKING:
             assert all(isinstance(obs, SparsePauliOp) for obs in qiskit_observables)

mpqp/execution/runner.py

@@ -78,7 +78,7 @@ def adjust_measure(measure: ExpectationMeasure, circuit: QCircuit):
 
     tweaked_observables = [
         Observable(np.kron(np.kron(Id_before, obs.matrix), Id_after))
-        for obs in measure.observable
+        for obs in measure.observables
     ]
 
     tweaked_measure = ExpectationMeasure(
@@ -123,13 +123,11 @@ def generate_job(
             else:
                 job = Job(JobType.SAMPLE, circuit, device, measurement)
         elif isinstance(measurement, ExpectationMeasure):
-            adjusted_m = adjust_measure(measurement, circuit)
-            print(adjusted_m.observable[0].nb_qubits)
             job = Job(
                 JobType.OBSERVABLE,
                 circuit,
                 device,
-                adjusted_m,
+                adjust_measure(measurement, circuit),
             )
         else:
             raise NotImplementedError(

tests/core/test_circuit.py

@@ -191,7 +191,7 @@ def test_count(circuit: QCircuit, filter: tuple[type[Gate]], count: int):
                 ]
             ),
             "[BasisMeasure([0, 1], shots=1000), ExpectationMeasure("
-            "Observable(array([[1.+0.j, 0.+0.j], [0.+0.j, 1.+0.j]], dtype=complex64)), [1], shots=1000)]",
+            "[Observable(array([[1.+0.j, 0.+0.j], [0.+0.j, 1.+0.j]], dtype=complex64))], [1], shots=1000)]",
         )
     ],
 )

tests/execution/test_runner.py

@@ -33,10 +33,10 @@ def test_adjust_measure(
     measure = ExpectationMeasure(Observable(obs_matrix), measure_targets)
     adjusted_observable_matrix = np.kron(
         np.kron(
-            np.eye(2**nb_ids_before, dtype=np.complex64), measure.observable.matrix
+            np.eye(2**nb_ids_before, dtype=np.complex64), measure.observables[0].matrix
         ),
         np.eye(2**nb_ids_after),
     )
     assert matrix_eq(
-        adjust_measure(measure, circuit).observable.matrix, adjusted_observable_matrix
+        adjust_measure(measure, circuit).observables[0].matrix, adjusted_observable_matrix
     )