Feat custom basis

mpqp/core/circuit.py

@@ -26,13 +26,6 @@
 from typing import TYPE_CHECKING, Iterable, Optional, Sequence, Type
 from warnings import warn
 
-if TYPE_CHECKING:
-    from qat.core.wrappers.circuit import Circuit as myQLM_Circuit
-    from cirq.circuits.circuit import Circuit as cirq_Circuit
-    from braket.circuits import Circuit as braket_Circuit
-    from qiskit.circuit import QuantumCircuit
-    from sympy import Basic, Expr
-
 import numpy as np
 import numpy.typing as npt
 from typeguard import TypeCheckError, typechecked
@@ -44,18 +37,25 @@
 from mpqp.core.instruction.gates.custom_gate import CustomGate
 from mpqp.core.instruction.gates.gate_definition import UnitaryMatrix
 from mpqp.core.instruction.gates.parametrized_gate import ParametrizedGate
-from mpqp.core.instruction.measurement import BasisMeasure, ComputationalBasis, Measure
+from mpqp.core.instruction.measurement import BasisMeasure, Measure
 from mpqp.core.instruction.measurement.expectation_value import ExpectationMeasure
 from mpqp.core.languages import Language
 from mpqp.noise.noise_model import DimensionalNoiseModel, NoiseModel
 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, NonReversibleWarning
+from mpqp.tools.errors import NonReversibleWarning, NumberQubitsError
 from mpqp.tools.generics import OneOrMany
 from mpqp.tools.maths import matrix_eq
 
+if TYPE_CHECKING:
+    from qat.core.wrappers.circuit import Circuit as myQLM_Circuit
+    from cirq.circuits.circuit import Circuit as cirq_Circuit
+    from braket.circuits import Circuit as braket_Circuit
+    from qiskit.circuit import QuantumCircuit
+    from sympy import Basic, Expr
+
 
 @typechecked
 class QCircuit:
@@ -155,7 +155,7 @@ def __init__(
                     self._nb_qubits = max(connections) + 1
             else:
                 self._nb_qubits = nb_qubits
-            self.add(list(map(deepcopy, data)))
+            self.add(deepcopy(data))
 
     def __eq__(self, value: object) -> bool:
         return dumps(self) == dumps(value)
@@ -256,12 +256,15 @@ def _check_components_targets(self, components: Instruction | NoiseModel):
                     "In noisy circuits, BasisMeasure must span all qubits in the circuit."
                 )
 
-    def _update_targets_components(self, components: Instruction | NoiseModel):
-        """update the targets of the components with the number of qubits in the circuit.
+    def _update_targets_components(self, component: Instruction | NoiseModel):
+        """Update the targets of the component with the number of qubits in the circuit.
+
+        Args:
+            component: Instruction or NoiseModel for which we want to update the `targets` attribute.
 
         Raises:
-            ValueError: If the number of target qubits for a noise source is
-                smaller than the its dimension, or if BasisMeasure does not span
+            ValueError: If the number of target qubits for a NoiseModel is
+                smaller than its dimension, or if BasisMeasure does not span
                 all qubits in a noisy circuit.
 
         Examples:
@@ -285,28 +288,36 @@ def _update_targets_components(self, components: Instruction | NoiseModel):
         """
         targets = list(range(self.nb_qubits))
 
-        components.targets = targets
-        self._check_components_targets(components)
+        component.targets = targets
+        self._check_components_targets(component)
+
+        if isinstance(component, Barrier):
+            component.size = self.nb_qubits
+        elif isinstance(component, ExpectationMeasure):
+            component.check_targets_order()
+        elif isinstance(component, DimensionalNoiseModel):
+            component.check_dimension()
+        elif isinstance(component, BasisMeasure):
+            from mpqp.core.instruction.measurement.basis import VariableSizeBasis
+
+            if not isinstance(component.basis, VariableSizeBasis):
+                raise ValueError(
+                    "A `BasisMeasure` with a non variable sized basis cannot be"
+                    " dynamic."
+                )
+
+            component.basis.set_size(self.nb_qubits)
 
-        if isinstance(components, Barrier):
-            components.size = self.nb_qubits
-        elif isinstance(components, ExpectationMeasure):
-            components.check_targets_order()
-        elif isinstance(components, DimensionalNoiseModel):
-            components.check_dimension()
-        elif isinstance(components, BasisMeasure):
             if self.nb_cbits is None:
                 self.nb_cbits = 0
             unique_cbits = set()
-            for basis_measure in self.instructions:
-                if basis_measure != components and isinstance(
-                    basis_measure, BasisMeasure
-                ):
-                    if basis_measure.c_targets:
-                        unique_cbits.update(basis_measure.c_targets)
+            for instruction in self.instructions:
+                if instruction != component and isinstance(instruction, BasisMeasure):
+                    if instruction.c_targets:
+                        unique_cbits.update(instruction.c_targets)
             c_targets = []
             i = 0
-            for _ in range(len(components.targets)):
+            for _ in range(len(component.targets)):
                 while i in unique_cbits:
                     warn(
                         "Dynamic measurements don't play well with static measurements: "
@@ -315,12 +326,12 @@ def _update_targets_components(self, components: Instruction | NoiseModel):
                     i += 1
                 c_targets.append(i)
                 i += 1
-            components.c_targets = c_targets
+            component.c_targets = c_targets
             self.nb_cbits = max(
                 max(c_targets, default=0) + 1, max(unique_cbits, default=0) + 1
             )
 
-        return components
+        return component
 
     @property
     def nb_qubits(self) -> int:
@@ -955,12 +966,7 @@ def to_other_language(
                     qargs = instruction.controls + instruction.targets
                 elif isinstance(instruction, Gate):
                     qargs = instruction.targets
-                elif isinstance(instruction, BasisMeasure) and isinstance(
-                    instruction.basis, ComputationalBasis
-                ):
-                    # TODO for custom basis, check if something should be
-                    # changed here, e.g. remove the condition to have only
-                    # computational basis
+                elif isinstance(instruction, BasisMeasure):
                     assert instruction.c_targets is not None
                     qargs = [instruction.targets]
                     cargs = [instruction.c_targets]

mpqp/core/instruction/measurement/basis.py

@@ -10,15 +10,17 @@
 
 from __future__ import annotations
 
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from functools import reduce
 from typing import Optional
 
 import numpy as np
 import numpy.typing as npt
 from typeguard import typechecked
 
-from mpqp.tools.display import clean_1D_array
+from mpqp.core.instruction.gates.custom_gate import CustomGate
+from mpqp.core.instruction.gates.gate_definition import UnitaryMatrix
+from mpqp.tools.display import clean_1D_array, one_lined_repr
 from mpqp.tools.maths import atol, matrix_eq
 
 
@@ -33,27 +35,41 @@ class Basis:
             ``basis_vectors``'s dimensions.
 
     Example:
-        >>> Basis([np.array([1,0]), np.array([0,-1])]).pretty_print()
+        >>> custom_basis = Basis([np.array([1,0]), np.array([0,-1])], symbols=("↑", "↓"))
+        >>> custom_basis.pretty_print()
         Basis: [
             [1, 0],
             [0, -1]
         ]
+        >>> circ = QCircuit([X(0), H(1), CNOT(1, 2), Y(2)])
+        >>> circ.add(BasisMeasure([0, 1, 2], basis=custom_basis, shots=10000))
+        >>> print(run(circ, IBMDevice.AER_SIMULATOR)) # doctest: +SKIP
+        Result: None, IBMDevice, AER_SIMULATOR
+         Counts: [0, 0, 0, 0, 0, 4936, 5064, 0]
+         Probabilities: [0, 0, 0, 0, 0, 0.4936, 0.5064, 0]
+         Samples:
+          State: ↓↑↓, Index: 5, Count: 4936, Probability: 0.4936
+          State: ↓↓↑, Index: 6, Count: 5064, Probability: 0.5064
+         Error: None
 
     """
 
     def __init__(
         self,
         basis_vectors: list[npt.NDArray[np.complex64]],
         nb_qubits: Optional[int] = None,
+        symbols: Optional[tuple[str, str]] = None,
     ):
-        # TODO : add the possibility to give the symbols for the '0' and '1' of
-        # the custom basis. This should then appear in the Sample
-        # binary_representation of the basis state. For instance in the Hadamard
-        # basis, the symbols will be '+' and '-'. If the user wants '↑' and '↓'
-        # for his custom basis, when we print samples we would have something
-        # like:
-        # State: ↑↑↓, Index: 1, Count: 512, Probability: 0.512
+        if symbols is None:
+            symbols = ("0", "1")
+        self.symbols = symbols
+
         if len(basis_vectors) == 0:
+            if nb_qubits is None:
+                raise ValueError(
+                    "Empty basis and no number of qubits specified. Please at "
+                    "least specify one of these two."
+                )
             self.nb_qubits = nb_qubits
             self.basis_vectors = basis_vectors
             return
@@ -71,7 +87,7 @@ def __init__(
             raise ValueError("All vectors of the given basis are not normalized")
         m = np.array([vector for vector in basis_vectors])
         if not matrix_eq(
-            m.transpose().dot(m),
+            m.transpose().dot(m),  # fixme
             np.eye(len(basis_vectors)),  # pyright: ignore[reportArgumentType]
         ):
             raise ValueError("The given basis is not orthogonal")
@@ -81,6 +97,24 @@ def __init__(
         self.basis_vectors = basis_vectors
         """See parameter description."""
 
+    def binary_to_custom(self, state: str) -> str:
+        """Converts a binary string to a custom string representation.
+        By default, it uses "0" and "1" but can be customized based on the provided `symbols`.
+
+        Args:
+            state: The binary string (e.g., "01") to be converted.
+
+        Returns:
+            The custom string representation of the binary state.
+
+        Example:
+            >>> basis = Basis([np.array([1,0]), np.array([0,-1])], symbols=("+", "-"))
+            >>> custom_state = basis.binary_to_custom("01")
+            >>> custom_state
+            '+-'
+        """
+        return ''.join(self.symbols[int(bit)] for bit in state)
+
     def pretty_print(self):
         """Nicer print for the basis, with human readable formatting.
 
@@ -96,17 +130,62 @@ def pretty_print(self):
         print(f"Basis: [\n    {joint_vectors}\n]")
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.basis_vectors}, {self.nb_qubits})"
+        joint_vectors = ", ".join(map(one_lined_repr, self.basis_vectors))
+        qubits = "" if isinstance(self, VariableSizeBasis) else f", {self.nb_qubits}"
+        return f"{type(self).__name__}({joint_vectors}{qubits})"
+
+    def to_computational(self):
+        """Converts the custom basis to the computational basis.
+
+        This method creates a quantum circuit with a custom gate represented by
+        a unitary transformation and applies it to all qubits before measurement.
+
+        Returns:
+            A quantum circuit representing the basis change circuit.
+
+        Example:
+            >>> basis = Basis([np.array([1, 0]), np.array([0, -1])])
+            >>> circuit = basis.to_computational()
+            >>> print(circuit)
+               ┌─────────┐
+            q: ┤ Unitary ├
+               └─────────┘
+
+        """
+
+        from mpqp.core.circuit import QCircuit
+
+        basis_change = np.array(self.basis_vectors).T.conjugate()
+        return QCircuit(
+            [
+                CustomGate(
+                    UnitaryMatrix(basis_change), targets=list(range(self.nb_qubits))
+                )
+            ]
+        )
 
 
 @typechecked
-class VariableSizeBasis(Basis):
-    """3M-TODO"""
+class VariableSizeBasis(Basis, ABC):
+    """A variable-size basis with a dynamically adjustable size to different qubit numbers
+    during circuit execution.
+
+    Args:
+        nb_qubits: number of qubits in the basis. If not provided,
+            the basis can be dynamically sized later using the `set_size` method.
+
+        symbols: custom symbols for representing basis states, defaults to ("0", "1").
+    """
 
     @abstractmethod
-    def __init__(self, nb_qubits: Optional[int] = None):
-        super().__init__([], nb_qubits)
-        pass
+    def __init__(
+        self, nb_qubits: Optional[int] = None, symbols: Optional[tuple[str, str]] = None
+    ):
+        if symbols is None:
+            symbols = ("0", "1")
+        super().__init__([], 0, symbols=symbols)
+        if nb_qubits is not None:
+            self.set_size(nb_qubits)
 
     @abstractmethod
     def set_size(self, nb_qubits: int):
@@ -159,10 +238,7 @@ class ComputationalBasis(VariableSizeBasis):
     """
 
     def __init__(self, nb_qubits: Optional[int] = None):
-        basis = []
-        Basis.__init__(self, basis, nb_qubits)
-        if nb_qubits is not None:
-            self.set_size(nb_qubits)
+        super().__init__(nb_qubits)
 
     def set_size(self, nb_qubits: int):
         self.basis_vectors = [
@@ -171,6 +247,11 @@ def set_size(self, nb_qubits: int):
         ]
         self.nb_qubits = nb_qubits
 
+    def to_computational(self):
+        from mpqp.core.circuit import QCircuit
+
+        return QCircuit(self.nb_qubits)
+
 
 class HadamardBasis(VariableSizeBasis):
     """Basis representing the Hadamard basis, also called X-basis or +/- basis.
@@ -186,17 +267,33 @@ class HadamardBasis(VariableSizeBasis):
             [0.5, 0.5, -0.5, -0.5],
             [0.5, -0.5, -0.5, 0.5]
         ]
-
+        >>> circ = QCircuit([X(0), H(1), CNOT(1, 2), Y(2)])
+        >>> circ.add(BasisMeasure(basis=HadamardBasis()))
+        >>> print(run(circ, IBMDevice.AER_SIMULATOR)) # doctest: +SKIP
+        Result: None, IBMDevice, AER_SIMULATOR
+         Counts: [0, 261, 253, 0, 0, 244, 266, 0]
+         Probabilities: [0, 0.25488, 0.24707, 0, 0, 0.23828, 0.25977, 0]
+         Samples:
+          State: ++-, Index: 1, Count: 261, Probability: 0.2548828
+          State: +-+, Index: 2, Count: 253, Probability: 0.2470703
+          State: -+-, Index: 5, Count: 244, Probability: 0.2382812
+          State: --+, Index: 6, Count: 266, Probability: 0.2597656
+         Error: None
     """
 
     def __init__(self, nb_qubits: Optional[int] = None):
-        basis = []
-        Basis.__init__(self, basis, nb_qubits)
-        if nb_qubits is not None:
-            self.set_size(nb_qubits)
+        super().__init__(nb_qubits, symbols=('+', '-'))
 
     def set_size(self, nb_qubits: int):
         H = np.array([[1, 1], [1, -1]], dtype=np.complex64) / np.sqrt(2)
         Hn = reduce(np.kron, [H] * nb_qubits, np.eye(1))
         self.basis_vectors = [line for line in Hn]
         self.nb_qubits = nb_qubits
+
+    def to_computational(self):
+        from mpqp.core.circuit import QCircuit
+        from mpqp.core.instruction.gates.native_gates import H
+
+        if self.nb_qubits == 0:
+            return QCircuit(self.nb_qubits)
+        return QCircuit([H(qb) for qb in range(self.nb_qubits)])