Use qubit pauli tensor in from_pauli_list

qermit/noise_model/noise_model.py

@@ -99,8 +99,8 @@ def to_ptm(self) -> Tuple[NDArray, Dict[Tuple[Pauli, ...], int]]:
         # PTM entry as a sum pf error weights multiplied by +/-1
         # Depending on commutation relations.
         for pauli_tuple, index in pauli_index.items():
-            pauli = QermitPauli.from_pauli_iterable(
-                pauli_iterable=pauli_tuple,
+            pauli = QermitPauli.from_pauli_list(
+                pauli_list=list(pauli_tuple),
                 qubit_list=[Qubit(i) for i in range(self.n_qubits)],
             )
 
@@ -111,8 +111,8 @@ def to_ptm(self) -> Tuple[NDArray, Dict[Tuple[Pauli, ...], int]]:
             ptm[index][index] += self.identity_error_rate
 
             for error, error_rate in self.distribution.items():
-                error_pauli = QermitPauli.from_pauli_iterable(
-                    pauli_iterable=error,
+                error_pauli = QermitPauli.from_pauli_list(
+                    pauli_list=list(error),
                     qubit_list=[Qubit(i) for i in range(self.n_qubits)],
                 )
                 commute_coeff = (
@@ -185,13 +185,13 @@ def from_ptm(
         # is the matrix of commutation values.
         commutation_matrix = np.zeros(ptm.shape)
         for pauli_one_tuple, index_one in pauli_index.items():
-            pauli_one = QermitPauli.from_pauli_iterable(
-                pauli_iterable=pauli_one_tuple,
+            pauli_one = QermitPauli.from_pauli_list(
+                pauli_list=list(pauli_one_tuple),
                 qubit_list=[Qubit(i) for i in range(len(pauli_one_tuple))],
             )
             for pauli_two_tuple, index_two in pauli_index.items():
-                pauli_two = QermitPauli.from_pauli_iterable(
-                    pauli_iterable=pauli_two_tuple,
+                pauli_two = QermitPauli.from_pauli_list(
+                    pauli_list=list(pauli_two_tuple),
                     qubit_list=[Qubit(i) for i in range(len(pauli_two_tuple))],
                 )
                 commutation_matrix[index_one][index_two] = (

qermit/noise_model/qermit_pauli.py

@@ -472,18 +472,21 @@ def qubit_pauli_tensor(self) -> QubitPauliTensor:
         )
 
     @classmethod
-    def from_pauli_iterable(
-        cls, pauli_iterable: Iterable[Pauli], qubit_list: List[Qubit]
+    def from_pauli_list(
+        cls, pauli_list: List[Pauli], qubit_list: List[Qubit]
     ) -> QermitPauli:
         """Create a QermitPauli from a Pauli iterable.
 
         :param pauli_iterable: The Pauli iterable to convert.
         :param qubit_list: The qubits on which the resulting pauli will act.
         :return: The pauli corresponding to the given iterable.
         """
-        return cls(
-            Z_list=[int(pauli in (Pauli.Z, Pauli.Y)) for pauli in pauli_iterable],
-            X_list=[int(pauli in (Pauli.X, Pauli.Y)) for pauli in pauli_iterable],
-            qubit_list=qubit_list,
-            phase=sum(int(pauli == Pauli.Y) for pauli in pauli_iterable) % 4,
+        return cls.from_qubit_pauli_tensor(
+            qpt=QubitPauliTensor(
+                string=QubitPauliString(
+                    qubits=qubit_list,
+                    paulis=pauli_list,
+                ),
+                coeff=1,
+            ),
         )

tests/noise_model_test.py

@@ -104,8 +104,8 @@ def test_qermit_pauli_from_iterable() -> None:
         qubits=[Qubit(i) for i in range(5)],
         paulis=[Pauli.X, Pauli.Y, Pauli.Z, Pauli.Y, Pauli.Z],
     )
-    pauli = QermitPauli.from_pauli_iterable(
-        pauli_iterable=qubit_pauli_string.map.values(),
+    pauli = QermitPauli.from_pauli_list(
+        pauli_list=list(qubit_pauli_string.map.values()),
         qubit_list=list(qubit_pauli_string.map.keys()),
     )
     pauli.qubit_pauli_tensor.string == qubit_pauli_string