Merge pull request #32 from ColibrITD-SAS/feat-pauli-string

Feat pauli string

Author: Henri-ColibrITD

examples/scripts/observable_job.py

@@ -6,6 +6,7 @@
 from mpqp.execution import run
 from mpqp.measures import ExpectationMeasure, Observable
 from mpqp.execution.devices import ATOSDevice, IBMDevice, AWSDevice
+from mpqp.core.instruction.measurement.pauli_string import I, Z
 
 obs = Observable(
     np.array(
@@ -19,18 +20,12 @@
     )
 )
 
-obs2 = Observable(
-    np.array(
-        [
-            [3.0, 0.0, 0.0, 0.0],
-            [0.0, 1.0, 0.0, 0.0],
-            [0.0, 0.0, -1.0, 0.0],
-            [0.0, 0.0, 0.0, 0.0],
-        ],
-        dtype=float,
-    )
-)
+obs2 = Observable(1 * I @ Z + 1 * I @ I)
 
+# Observable can be constructed from a Pauli string or a matrix
+print("Observable2:")
+print(obs2.pauli_string)
+print(obs2.matrix)
 
 # Declaration of the circuit with the right size
 circuit = QCircuit(2, label="Observable test")
@@ -42,10 +37,15 @@
 print(circuit)
 
 # Running the computation on myQLM and on Aer simulator, then retrieving the results
-results = run(circuit, [ATOSDevice.MYQLM_PYLINALG,
-                        IBMDevice.AER_SIMULATOR,
-                        ATOSDevice.MYQLM_CLINALG,
-                        AWSDevice.BRAKET_LOCAL_SIMULATOR])
+results = run(
+    circuit,
+    [
+        ATOSDevice.MYQLM_PYLINALG,
+        IBMDevice.AER_SIMULATOR,
+        ATOSDevice.MYQLM_CLINALG,
+        AWSDevice.BRAKET_LOCAL_SIMULATOR,
+    ],
+)
 print(results)
 
 
@@ -59,8 +59,13 @@
 print(circuit)
 
 # Running the computation on myQLM and on Aer simulator, then retrieving the results
-results = run(circuit, [ATOSDevice.MYQLM_PYLINALG,
-                        ATOSDevice.MYQLM_CLINALG,
-                        IBMDevice.AER_SIMULATOR,
-                        AWSDevice.BRAKET_LOCAL_SIMULATOR])
+results = run(
+    circuit,
+    [
+        ATOSDevice.MYQLM_PYLINALG,
+        ATOSDevice.MYQLM_CLINALG,
+        IBMDevice.AER_SIMULATOR,
+        AWSDevice.BRAKET_LOCAL_SIMULATOR,
+    ],
+)
 print(results)

mpqp/core/circuit.py

@@ -7,6 +7,7 @@
 import numpy as np
 import numpy.typing as npt
 from braket.circuits import Circuit as braket_Circuit
+from cirq import Circuit as cirq_Circuit
 from matplotlib.figure import Figure
 from qat.core.wrappers.circuit import Circuit as myQLM_Circuit
 from qiskit.circuit import Operation, QuantumCircuit
@@ -27,6 +28,7 @@
 from mpqp.qasm import qasm2_to_myqlm_Circuit
 from mpqp.qasm.open_qasm_2_and_3 import open_qasm_2_to_3
 from mpqp.qasm.qasm_to_braket import qasm3_to_braket_Circuit
+from mpqp.qasm.qasm_to_cirq import qasm2_to_cirq_Circuit
 from mpqp.tools.errors import NumberQubitsError
 from mpqp.tools.maths import matrix_eq
 
@@ -595,7 +597,7 @@ def without_measurements(self) -> QCircuit:
 
     def to_other_language(
         self, language: Language = Language.QISKIT
-    ) -> Union[QuantumCircuit, myQLM_Circuit, braket_Circuit]:
+    ) -> Union[QuantumCircuit, myQLM_Circuit, braket_Circuit, cirq_Circuit,]:
         """Transforms this circuit into the corresponding circuit in the language
         specified in the ``language`` arg.
 
@@ -697,7 +699,10 @@ def to_other_language(
             )
 
             return qasm3_to_braket_Circuit(circuit.to_qasm3())
-
+        elif language == Language.CIRQ:
+            cirq_circuit = qasm2_to_cirq_Circuit(self.to_qasm2())
+            return cirq_circuit
+        
         else:
             raise NotImplementedError(f"Error: {language} is not supported")
 

mpqp/core/instruction/measurement/expectation_value.py

@@ -7,61 +7,112 @@ class to define your observable, and a :class:`ExpectationMeasure` to perform
 
 import copy
 from numbers import Complex
+from typing import Optional, TYPE_CHECKING
 from warnings import warn
-from typing import Optional
 
 import numpy as np
-import numpy.typing as npt
 from qiskit.circuit import Parameter
 from sympy import Expr
 from typeguard import typechecked
 
+if TYPE_CHECKING:
+    from cirq.circuits.circuit import Circuit as Cirq_Circuit
+
 from mpqp.core.instruction.gates.native_gates import SWAP
 from mpqp.core.instruction.measurement.measure import Measure
+from mpqp.core.instruction.measurement.pauli_string import PauliString
 from mpqp.core.languages import Language
 from mpqp.tools.errors import NumberQubitsError
+from mpqp.tools.generics import Matrix, one_lined_repr
 from mpqp.tools.maths import is_hermitian
-from mpqp.tools.generics import one_lined_repr
 
 
 @typechecked
 class Observable:
     """Class defining an observable, used for evaluating expectation values.
 
-    An observable can be defined by using a hermitian matrix, or using a combination of operators in a specific
-    basis (Kraus, Pauli, ...).
-
-    For the moment, on can only define the observable using a matrix.
+    An observable can be defined by using a Hermitian matrix, or using a combination of operators in a specific
+    basis Pauli.
 
     Example:
         >>> matrix = np.array([[1, 0], [0, -1]])
+        >>> pauli_string = 3 * I @ Z + 4 * X @ Y
         >>> obs = Observable(matrix)
+        >>> obs2 = Observable(pauli_string)
 
     Args:
-        matrix: Hermitian matrix representing the observable.
+        observable : can be either a Hermitian matrix representing the observable or PauliString representing the observable.
+
+    Raises:
+        ValueError: If the input matrix is not Hermitian or does not have a square shape.
+        NumberQubitsError: If the number of qubits in the input observable does
+            not match the number of target qubits.
+
     """
 
-    def __init__(self, matrix: npt.NDArray[np.complex64] | list[list[Complex]]):
-        self.nb_qubits = int(np.log2(len(matrix)))
-        """Number of qubits of this observable."""
-        self.matrix = np.array(matrix)
-        """See parameter description."""
+    def __init__(self, observable: Matrix | PauliString):
+        self._matrix = None
+        self._pauli_string = None
 
-        basis_states = 2**self.nb_qubits
-        if self.matrix.shape != (basis_states, basis_states):
-            raise ValueError(
-                f"The size of the matrix {self.matrix.shape} doesn't neatly fit on a"
-                " quantum register. It should be a square matrix of size a power"
-                " of two."
-            )
+        if isinstance(observable, PauliString):
+            self.nb_qubits = observable.nb_qubits
+            self._pauli_string = observable.simplify()
+        else:
+            self.nb_qubits = int(np.log2(len(observable)))
+            """Number of qubits of this observable."""
+            self._matrix = np.array(observable)
+            
+            basis_states = 2**self.nb_qubits
+            if self.matrix.shape != (basis_states, basis_states):
+                raise ValueError(
+                    f"The size of the matrix {self.matrix.shape} doesn't neatly fit on a"
+                    " quantum register. It should be a square matrix of size a power"
+                    " of two."
+                )
 
-        if not is_hermitian(self.matrix):
-            raise ValueError(
-                "The matrix in parameter is not hermitian (cannot define an observable)"
-            )
+            if not is_hermitian(self.matrix):
+                raise ValueError(
+                    "The matrix in parameter is not hermitian (cannot define an observable)"
+                )
+
+    @property
+    def matrix(self) -> Matrix:
+        """
+        Returns the matrix representation of the observable.
+
+        Returns:
+            np.ndarray: The matrix representation of the observable.
+        """
+        if self._matrix is None:
+            self._matrix = self.pauli_string.to_matrix()
+        matrix = copy.deepcopy(self._matrix).astype(np.complex64)
+        return matrix
+
+    @property
+    def pauli_string(self) -> PauliString:
+        """
+        Returns the PauliString representation of the observable.
+
+        Returns:
+            PauliString: The PauliString representation of the observable.
+        """
+        if self._pauli_string is None:
+            self._pauli_string = PauliString.from_matrix(self.matrix)
+        pauli_string = copy.deepcopy(self._pauli_string)
+        return pauli_string
+    
+    @pauli_string.setter
+    def pauli_string(self, pauli_string: PauliString):
+        self._pauli_string = pauli_string
+        self._matrix = None
+    
+    @matrix.setter
+    def matrix(self, matrix: Matrix):
+        self._matrix = matrix
+        self._pauli_string = None
 
     def __repr__(self) -> str:
-        return f"Observable({one_lined_repr(self.matrix)})"
+        return f"{type(self).__name__}({one_lined_repr(self.matrix)})"
 
     def __mult__(self, other: Expr | Complex) -> Observable:
         """3M-TODO"""
@@ -73,6 +124,70 @@ def subs(
         """3M-TODO"""
         ...
 
+    def to_other_language(
+        self, language: Language, circuit: Optional[Cirq_Circuit] = None
+    ):
+        """
+        Converts the observable to the representation of another quantum programming language.
+
+        Example:
+            >>> obs = Observable(np.diag([0.7, -1, 1, 1]))
+            >>> obs_qiskit = obs.to_other_language(Language.QISKIT)
+            >>> print(obs_qiskit)
+            <bound method Observable.to_qiskit_observable of Observable(array([[ 0.7, 0. , 0. , 0. ], [ 0. , -1. , 0. , 0. ], [ 0. , 0. , 1. , 0. ], [ 0. , 0. , 0. , 1. ]]))>
+
+        Args:
+            language (str): The target programming language ('qiskit', 'pyquil', 'braket', 'cirq').
+            circuit: The Cirq circuit associated with the observable (required for 'cirq' language).
+
+        Returns:
+            Depends on the target language.
+        """
+        if language == Language.QISKIT:
+            from qiskit.quantum_info import Operator
+
+            return Operator(self.matrix)
+        elif language == Language.MY_QLM:
+            from qat.core.wrappers.observable import Observable as QLM_Observable
+
+            return QLM_Observable(self.nb_qubits, matrix=self.matrix)
+        elif language == Language.BRAKET:
+            from braket.circuits.observables import Hermitian
+
+            return Hermitian(self.matrix)
+        elif language == Language.CIRQ:
+            if circuit is None:
+                raise ValueError("Circuit must be specified for cirq_observable.")
+            from cirq.ops.identity import I as Cirq_I
+            from cirq.ops.pauli_gates import X as Cirq_X, Y as Cirq_Y, Z as Cirq_Z
+
+            all_qubits = set(
+                q for moment in circuit for op in moment.operations for q in op.qubits
+            )
+            all_qubits_list = sorted(all_qubits)
+
+            cirq_pauli_string = None
+            pauli_gate_map = {"I": Cirq_I, "X": Cirq_X, "Y": Cirq_Y, "Z": Cirq_Z}
+            for monomial in self.pauli_string.monomials:
+                cirq_monomial = None
+                for index, atom in enumerate(monomial.atoms):
+                    cirq_atom = pauli_gate_map[atom.label](all_qubits_list[index])
+                    cirq_monomial = (
+                        cirq_atom
+                        if cirq_monomial is None
+                        else cirq_monomial * cirq_atom
+                    )
+                cirq_monomial *= monomial.coef
+                cirq_pauli_string = (
+                    cirq_monomial
+                    if cirq_pauli_string is None
+                    else cirq_pauli_string + cirq_monomial
+                )
+
+            return cirq_pauli_string
+        else:
+            raise ValueError(f"Unsupported language: {language}")
+
 
 @typechecked
 class ExpectationMeasure(Measure):
@@ -120,6 +235,7 @@ def __init__(
         super().__init__(targets, shots, label)
         self.observable = observable
         """See parameter description."""
+        # Raise an error if the number of target qubits does not match the size of the observable.
         if self.nb_qubits != observable.nb_qubits:
             raise NumberQubitsError(
                 f"{self.nb_qubits}, the number of target qubit(s) doesn't match"
@@ -172,6 +288,8 @@ def to_other_language(
     ) -> None:
         if qiskit_parameters is None:
             qiskit_parameters = set()
+        #TODO : incoherence here, if the language is Qiskit we raise a NotImplementedError, and otherwise we say that
+        # only qiskit is supported
         if language == Language.QISKIT:
             raise NotImplementedError(
                 "Qiskit does not implement these kind of measures"