qilisdk 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

qilisdk/digital/gates.py

@@ -20,6 +20,8 @@ import numpy as np
 from scipy.linalg import expm
 from typing_extensions import Self
 
+from qilisdk.common.parameterizable import Parameterizable
+from qilisdk.common.variables import Parameter
 from qilisdk.yaml import yaml
 
 from .exceptions import (
@@ -32,7 +34,7 @@ from .exceptions import (
 TBasicGate = TypeVar("TBasicGate", bound="BasicGate")
 
 
-class Gate(ABC):
+class Gate(Parameterizable, ABC):
     """
     Represents a quantum gate that can be used in quantum circuits.
     """
@@ -103,54 +105,60 @@ class Gate(ABC):
         return len(self.qubits)
 
     @property
-    def parameters(self) -> dict[str, float]:
+    def nparameters(self) -> int:
         """
-        Retrieve a mapping of parameter names to their corresponding values.
+        Retrieve the number of parameters for the gate.
 
         Returns:
-            dict[str, float]: A dictionary mapping each parameter name to its numeric value.
+            int: The count of parameters needed by the gate.
         """
-        return {}
+        return len(self.get_parameters())
 
     @property
-    def parameter_names(self) -> list[str]:
+    def is_parameterized(self) -> bool:
         """
-        Retrieve the symbolic names of the gate's parameters.
+        Determine whether the gate requires parameters.
 
         Returns:
-            list[str]: A list containing the names of the parameters.
+            bool: True if the gate is parameterized; otherwise, False.
         """
-        return list(self.parameters.keys())
+        return self.nparameters != 0
 
     @property
-    def parameter_values(self) -> list[float]:
+    def parameters(self) -> dict[str, Parameter]:
+        """Returns the raw parameter objects stored in the gate.
+
+        Returns:
+            dict[str, Parameter]: A dictionary mapping each Parameter object to its label.
         """
-        Retrieve the numerical values assigned to the gate's parameters.
+        return {}
+
+    def get_parameters(self) -> dict[str, float]:  # noqa: PLR6301
+        """
+        Retrieve a mapping of parameter names to their corresponding values.
 
         Returns:
-            list[float]: A list containing the parameter values.
+            dict[str, float]: A dictionary mapping each parameter name to its numeric value.
         """
-        return list(self.parameters.values())
+        return {}
 
-    @property
-    def nparameters(self) -> int:
+    def get_parameter_names(self) -> list[str]:
         """
-        Retrieve the number of parameters for the gate.
+        Retrieve the symbolic names of the gate's parameters.
 
         Returns:
-            int: The count of parameters needed by the gate.
+            list[str]: A list containing the names of the parameters.
         """
-        return len(self.parameters)
+        return list(self.get_parameters())
 
-    @property
-    def is_parameterized(self) -> bool:
+    def get_parameter_values(self) -> list[float]:
         """
-        Determine whether the gate requires parameters.
+        Retrieve the numerical values assigned to the gate's parameters.
 
         Returns:
-            bool: True if the gate is parameterized; otherwise, False.
+            list[float]: A list containing the parameter values.
         """
-        return self.nparameters != 0
+        return list(self.get_parameters().values())
 
     def set_parameters(self, parameters: dict[str, float]) -> None:
         """
@@ -166,7 +174,7 @@ class Gate(ABC):
         if not self.is_parameterized:
             raise GateNotParameterizedError
 
-        if any(name not in self.parameters for name in parameters):
+        if any(name not in self.get_parameters() for name in parameters):
             raise InvalidParameterNameError
 
     def set_parameter_values(self, values: list[float]) -> None:
@@ -183,26 +191,34 @@ class Gate(ABC):
         if not self.is_parameterized:
             raise GateNotParameterizedError
 
-        if len(values) != len(self.parameters):
+        if len(values) != len(self.get_parameters()):
             raise ParametersNotEqualError
 
+    def get_parameter_bounds(self) -> dict[str, tuple[float, float]]:  # noqa: PLR6301
+        return {}
+
+    def set_parameter_bounds(self, ranges: dict[str, tuple[float, float]]) -> None:
+        if not self.is_parameterized:
+            raise GateNotParameterizedError
+
     def __repr__(self) -> str:
         qubits_str = f"({self.qubits[0]})" if self.nqubits == 1 else str(self.qubits)
         return f"{self.name}{qubits_str}"
 
 
+@yaml.register_class
 class BasicGate(Gate):
     """
     Represents a quantum gate that can be used in quantum circuits.
     """
 
-    def __init__(self, target_qubits: tuple[int, ...], parameters: dict[str, float] = {}) -> None:
+    def __init__(self, target_qubits: tuple[int, ...], parameters: dict[str, Parameter] = {}) -> None:
         # Check for duplicate integers in target_qubits.
         if len(target_qubits) != len(set(target_qubits)):
             raise ValueError("Duplicate target qubits found.")
 
         self._target_qubits: tuple[int, ...] = target_qubits
-        self._parameters: dict[str, float] = parameters
+        self._parameters: dict[str, Parameter] = parameters
         self._matrix: np.ndarray = self._generate_matrix()
 
     @property
@@ -214,22 +230,38 @@ class BasicGate(Gate):
         return self._target_qubits
 
     @property
-    def parameters(self) -> dict[str, float]:
-        return dict(self._parameters)
+    def parameters(self) -> dict[str, Parameter]:
+        return self._parameters
+
+    def get_parameters(self) -> dict[str, float]:
+        return {k: v.value for k, v in self._parameters.items()}
 
     def set_parameters(self, parameters: dict[str, float]) -> None:
         super().set_parameters(parameters=parameters)
-        self._parameters.update(parameters)
+        for k, v in parameters.items():
+            self._parameters[k].set_value(v)
         self._matrix = self._generate_matrix()
 
     def set_parameter_values(self, values: list[float]) -> None:
         super().set_parameter_values(values=values)
 
-        for key, value in zip(self.parameters, values):
-            self._parameters[key] = value
+        for key, value in zip(self.get_parameters(), values):
+            self._parameters[key].set_value(value)
 
         self._matrix = self._generate_matrix()
 
+    def get_parameter_bounds(self) -> dict[str, tuple[float, float]]:
+        return {k: v.bounds for k, v in self._parameters.items()}
+
+    def set_parameter_bounds(self, ranges: dict[str, tuple[float, float]]) -> None:
+        super().set_parameter_bounds(ranges=ranges)
+        for label, bound in ranges.items():
+            if label not in self._parameters:
+                raise ValueError(
+                    f"The provided parameter label {label} is not defined in the list of parameters in this object."
+                )
+            self._parameters[label].set_bounds(bound[0], bound[1])
+
     def controlled(self: Self, *control_qubits: int) -> Controlled[Self]:
         """
         Creates a controlled version of this unitary gate.
@@ -293,18 +325,6 @@ class Modified(Gate, Generic[TBasicGate]):
     def target_qubits(self) -> tuple[int, ...]:
         return self._basic_gate.target_qubits
 
-    @property
-    def parameters(self) -> dict[str, float]:
-        return self._basic_gate.parameters
-
-    @property
-    def parameter_names(self) -> list[str]:
-        return self._basic_gate.parameter_names
-
-    @property
-    def parameter_values(self) -> list[float]:
-        return self._basic_gate.parameter_values
-
     @property
     def nparameters(self) -> int:
         return self._basic_gate.nparameters
@@ -313,6 +333,19 @@ class Modified(Gate, Generic[TBasicGate]):
     def is_parameterized(self) -> bool:
         return self._basic_gate.is_parameterized
 
+    @property
+    def parameters(self) -> dict[str, Parameter]:
+        return self._basic_gate.parameters
+
+    def get_parameters(self) -> dict[str, float]:
+        return self._basic_gate.get_parameters()
+
+    def get_parameter_names(self) -> list[str]:
+        return self._basic_gate.get_parameter_names()
+
+    def get_parameter_values(self) -> list[float]:
+        return self._basic_gate.get_parameter_values()
+
     def set_parameters(self, parameters: dict[str, float]) -> None:
         self._basic_gate.set_parameters(parameters=parameters)
         self._matrix = self._generate_matrix()
@@ -321,6 +354,12 @@ class Modified(Gate, Generic[TBasicGate]):
         self._basic_gate.set_parameter_values(values=values)
         self._matrix = self._generate_matrix()
 
+    def get_parameter_bounds(self) -> dict[str, tuple[float, float]]:
+        return self._basic_gate.get_parameter_bounds()
+
+    def set_parameter_bounds(self, ranges: dict[str, tuple[float, float]]) -> None:
+        self._basic_gate.set_parameter_bounds(ranges)
+
     @abstractmethod
     def _generate_matrix(self) -> np.ndarray: ...
 
@@ -450,14 +489,48 @@ class M(Gate):
         return self._target_qubits
 
 
+@yaml.register_class
+class I(BasicGate):
+    """
+    The Identity gate.
+
+    The associated matrix is:
+
+    .. code-block:: text
+
+       [[1, 0],
+       [0, 1]]
+
+    """
+
+    def __init__(self, qubit: int) -> None:
+        """
+        Initialize a Pauli-X gate.
+
+        Args:
+            qubit (int): The target qubit index for the X gate.
+        """
+        super().__init__(target_qubits=(qubit,))
+
+    @property
+    def name(self) -> str:
+        return "I"
+
+    def _generate_matrix(self) -> np.ndarray:  # noqa: PLR6301
+        return np.array([[1, 0], [0, 1]], dtype=complex)
+
+
 @yaml.register_class
 class X(BasicGate):
     """
     The Pauli-X gate.
 
     The associated matrix is:
-        [[0, 1],
-        [1, 0]]
+
+    .. code-block:: text
+
+       [[0, 1],
+       [1, 0]]
 
     This is a pi radians rotation around the X-axis in the Bloch sphere.
     """
@@ -487,8 +560,9 @@ class Y(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
-        [[0, -i],
-         [i, 0]]
+
+       [[ 0, -i ],
+        [ i,  0 ]]
 
     This is a pi radians rotation around the Y-axis in the Bloch sphere.
     """
@@ -518,8 +592,9 @@ class Z(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         [[1, 0],
-         [0, -1]]
+        [0, -1]]
 
     This is a pi radians rotation around the Z-axis in the Bloch sphere.
     """
@@ -549,8 +624,9 @@ class H(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
-        1/sqrt(2) * [[1, 1],
-                     [1, -1]]
+
+        [[1/sqrt(2),  1/sqrt(2)],
+         [1/sqrt(2), -1/sqrt(2)]]
 
     This is a pi radians rotation around the (X+Z)-axis in the Bloch sphere.
     """
@@ -580,6 +656,7 @@ class S(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         [[1, 0],
          [0, i]]
 
@@ -611,6 +688,7 @@ class T(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         [[1,           0],
          [0, exp(i*pi/4)]]
 
@@ -642,6 +720,7 @@ class RX(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         [[cos(theta/2),     -i*sin(theta/2)],
          [-i*sin(theta/2),     cos(theta/2)]]
 
@@ -651,7 +730,7 @@ class RX(BasicGate):
 
     PARAMETER_NAMES: ClassVar[list[str]] = ["theta"]
 
-    def __init__(self, qubit: int, *, theta: float) -> None:
+    def __init__(self, qubit: int, *, theta: float | Parameter) -> None:
         """
         Initialize an RX gate.
 
@@ -659,7 +738,10 @@ class RX(BasicGate):
             qubit (int): The target qubit index for the rotation.
             theta (float): The rotation angle (polar) in radians.
         """
-        super().__init__(target_qubits=(qubit,), parameters={"theta": theta})
+        super().__init__(
+            target_qubits=(qubit,),
+            parameters={"theta": theta if isinstance(theta, Parameter) else Parameter("theta", theta)},
+        )
 
     @property
     def name(self) -> str:
@@ -667,10 +749,10 @@ class RX(BasicGate):
 
     @property
     def theta(self) -> float:
-        return self.parameters["theta"]
+        return self.get_parameters()["theta"]
 
     def _generate_matrix(self) -> np.ndarray:
-        theta = self.parameters["theta"]
+        theta = self.theta
         cos_half = np.cos(theta / 2)
         sin_half = np.sin(theta / 2)
         return np.array([[cos_half, -1j * sin_half], [-1j * sin_half, cos_half]], dtype=complex)
@@ -684,6 +766,7 @@ class RY(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         [[cos(theta/2), -sin(theta/2)],
          [sin(theta/2),  cos(theta/2)]]
 
@@ -693,7 +776,7 @@ class RY(BasicGate):
 
     PARAMETER_NAMES: ClassVar[list[str]] = ["theta"]
 
-    def __init__(self, qubit: int, *, theta: float) -> None:
+    def __init__(self, qubit: int, *, theta: float | Parameter) -> None:
         """
         Initialize an RY gate.
 
@@ -701,7 +784,10 @@ class RY(BasicGate):
             qubit (int): The target qubit index for the rotation.
             theta (float): The rotation angle (polar) in radians.
         """
-        super().__init__(target_qubits=(qubit,), parameters={"theta": theta})
+        super().__init__(
+            target_qubits=(qubit,),
+            parameters={"theta": theta if isinstance(theta, Parameter) else Parameter("theta", theta)},
+        )
 
     @property
     def name(self) -> str:
@@ -709,10 +795,10 @@ class RY(BasicGate):
 
     @property
     def theta(self) -> float:
-        return self.parameters["theta"]
+        return self.get_parameters()["theta"]
 
     def _generate_matrix(self) -> np.ndarray:
-        theta = self.parameters["theta"]
+        theta = self.theta
         cos_half = np.cos(theta / 2)
         sin_half = np.sin(theta / 2)
         return np.array([[cos_half, -sin_half], [sin_half, cos_half]], dtype=complex)
@@ -726,6 +812,7 @@ class RZ(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         [[exp(-i*phi/2),              0],
          [0,               exp(i*phi/2)]]
 
@@ -743,7 +830,7 @@ class RZ(BasicGate):
 
     PARAMETER_NAMES: ClassVar[list[str]] = ["phi"]
 
-    def __init__(self, qubit: int, *, phi: float) -> None:
+    def __init__(self, qubit: int, *, phi: float | Parameter) -> None:
         """
         Initialize an RZ gate.
 
@@ -751,21 +838,22 @@ class RZ(BasicGate):
             qubit (int): The target qubit index for the rotation.
             phi (float): The rotation angle (azimuthal) in radians.
         """
-        super().__init__(target_qubits=(qubit,), parameters={"phi": phi})
+        super().__init__(
+            target_qubits=(qubit,),
+            parameters={"phi": phi if isinstance(phi, Parameter) else Parameter("phi", phi)},
+        )
 
     @property
     def name(self) -> str:
         return "RZ"
 
     @property
-    def theta(self) -> float:
-        return self.parameters["theta"]
+    def phi(self) -> float:
+        return self.get_parameters()["phi"]
 
     def _generate_matrix(self) -> np.ndarray:
-        phi = self.parameters["phi"]
-        cos_half = np.cos(phi / 2)
-        sin_half = np.sin(phi / 2)
-        return np.array([[cos_half, -sin_half], [sin_half, cos_half]], dtype=complex)
+        phi = self.phi
+        return np.array([[np.exp(-0.5j * phi), 0.0], [0.0, np.exp(0.5j * phi)]], dtype=complex)
 
 
 @yaml.register_class
@@ -776,6 +864,7 @@ class U1(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         [[1,            0],
          [0, exp(i*phi)]]
 
@@ -790,7 +879,7 @@ class U1(BasicGate):
 
     PARAMETER_NAMES: ClassVar[list[str]] = ["phi"]
 
-    def __init__(self, qubit: int, *, phi: float) -> None:
+    def __init__(self, qubit: int, *, phi: float | Parameter) -> None:
         """
         Initialize a U1 gate.
 
@@ -798,7 +887,10 @@ class U1(BasicGate):
             qubit (int): The target qubit index for the U1 gate.
             phi (float): The phase to add, or equivalently the rotation angle (azimuthal) in radians.
         """
-        super().__init__(target_qubits=(qubit,), parameters={"phi": phi})
+        super().__init__(
+            target_qubits=(qubit,),
+            parameters={"phi": phi if isinstance(phi, Parameter) else Parameter("phi", phi)},
+        )
 
     @property
     def name(self) -> str:
@@ -806,10 +898,10 @@ class U1(BasicGate):
 
     @property
     def phi(self) -> float:
-        return self.parameters["phi"]
+        return self.get_parameters()["phi"]
 
     def _generate_matrix(self) -> np.ndarray:
-        phi = self.parameters["phi"]
+        phi = self.phi
         return np.array([[1, 0], [0, np.exp(1j * phi)]], dtype=complex)
 
 
@@ -821,6 +913,7 @@ class U2(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         1/sqrt(2)*[[1,                   -exp(i*gamma)],
                    [exp(i*phi),    exp(i*(phi+gamma))]]
 
@@ -838,7 +931,7 @@ class U2(BasicGate):
 
     PARAMETER_NAMES: ClassVar[list[str]] = ["phi", "gamma"]
 
-    def __init__(self, qubit: int, *, phi: float, gamma: float) -> None:
+    def __init__(self, qubit: int, *, phi: float | Parameter, gamma: float | Parameter) -> None:
         """
         Initialize a U2 gate.
 
@@ -847,7 +940,13 @@ class U2(BasicGate):
             phi (float): The first phase parameter, or equivalently the first rotation angle (azimuthal) in radians.
             gamma (float): The second phase parameter, or equivalently the second rotation angle (azimuthal) in radians..
         """
-        super().__init__(target_qubits=(qubit,), parameters={"phi": phi, "gamma": gamma})
+        super().__init__(
+            target_qubits=(qubit,),
+            parameters={
+                "phi": phi if isinstance(phi, Parameter) else Parameter("phi", phi),
+                "gamma": gamma if isinstance(gamma, Parameter) else Parameter("gamma", gamma),
+            },
+        )
 
     @property
     def name(self) -> str:
@@ -855,15 +954,15 @@ class U2(BasicGate):
 
     @property
     def phi(self) -> float:
-        return self.parameters["phi"]
+        return self.get_parameters()["phi"]
 
     @property
     def gamma(self) -> float:
-        return self.parameters["gamma"]
+        return self.get_parameters()["gamma"]
 
     def _generate_matrix(self) -> np.ndarray:
-        phi = self.parameters["phi"]
-        gamma = self.parameters["gamma"]
+        phi = self.phi
+        gamma = self.gamma
         return (1 / np.sqrt(2)) * np.array(
             [
                 [1, -np.exp(1j * gamma)],
@@ -881,6 +980,7 @@ class U3(BasicGate):
     The associated matrix is:
 
     .. code-block:: text
+
         [[cos(theta/2), -exp(i*gamma/2*sin(theta/2))],
          [exp(i*phi/2)*sin(theta/2),    exp(i*(phi+gamma))*cos(theta/2)]]
 
@@ -899,7 +999,9 @@ class U3(BasicGate):
 
     PARAMETER_NAMES: ClassVar[list[str]] = ["theta", "phi", "gamma"]
 
-    def __init__(self, qubit: int, *, theta: float, phi: float, gamma: float) -> None:
+    def __init__(
+        self, qubit: int, *, theta: float | Parameter, phi: float | Parameter, gamma: float | Parameter
+    ) -> None:
         """
         Initialize a U3 gate.
 
@@ -909,7 +1011,14 @@ class U3(BasicGate):
             phi (float): The first phase parameter, or equivalently the first rotation angle (azimuthal) in radians.
             gamma (float): The second phase parameter, or equivalently the second rotation angle (azimuthal) in radians.
         """
-        super().__init__(target_qubits=(qubit,), parameters={"theta": theta, "phi": phi, "gamma": gamma})
+        super().__init__(
+            target_qubits=(qubit,),
+            parameters={
+                "theta": theta if isinstance(theta, Parameter) else Parameter("theta", theta),
+                "phi": phi if isinstance(phi, Parameter) else Parameter("phi", phi),
+                "gamma": gamma if isinstance(gamma, Parameter) else Parameter("gamma", gamma),
+            },
+        )
 
     @property
     def name(self) -> str:
@@ -917,20 +1026,20 @@ class U3(BasicGate):
 
     @property
     def theta(self) -> float:
-        return self.parameters["theta"]
+        return self.get_parameters()["theta"]
 
     @property
     def phi(self) -> float:
-        return self.parameters["phi"]
+        return self.get_parameters()["phi"]
 
     @property
     def gamma(self) -> float:
-        return self.parameters["gamma"]
+        return self.get_parameters()["gamma"]
 
     def _generate_matrix(self) -> np.ndarray:
-        theta = self.parameters["theta"]
-        phi = self.parameters["phi"]
-        gamma = self.parameters["gamma"]
+        theta = self.theta
+        phi = self.phi
+        gamma = self.gamma
         return np.array(
             [
                 [np.cos(theta / 2), -np.exp(1j * gamma) * np.sin(theta / 2)],
@@ -948,6 +1057,7 @@ class CNOT(Controlled[X]):
     The associated matrix is:
 
     .. code-block:: text
+
         [[1, 0, 0, 0],
          [0, 1, 0, 0],
          [0, 0, 0, 1],
@@ -973,6 +1083,7 @@ class CZ(Controlled[Z]):
     The associated matrix is:
 
     .. code-block:: text
+
         [[1, 0, 0, 0],
          [0, 1, 0, 0],
          [0, 0, 1, 0],
@@ -987,3 +1098,35 @@ class CZ(Controlled[Z]):
 
     def __init__(self, control: int, target: int) -> None:
         super().__init__(control, basic_gate=Z(target))
+
+
+@yaml.register_class
+class SWAP(BasicGate):
+    """
+    The SWAP gate.
+
+    The associated matrix is:
+
+    .. code-block:: text
+
+       [[1, 0, 0, 0],
+        [0, 0, 1, 0],
+        [0, 1, 0, 0],
+        [0, 0, 0, 1]]
+
+    """
+
+    def __init__(self, qubit_a: int, qubit_b: int) -> None:
+        """
+        Args:
+            qubit_a (int): First qubit to swap with.
+            qubit_b (int): Second qubit to swap with.
+        """
+        super().__init__(target_qubits=(qubit_a, qubit_b))
+
+    @property
+    def name(self) -> str:
+        return "SWAP"
+
+    def _generate_matrix(self) -> np.ndarray:  # noqa: PLR6301
+        return np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]], dtype=complex)

qilisdk/{extras/qaas/qaas_analog_result.py → functionals/__init__.py}

@@ -12,9 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from qilisdk.analog.analog_result import AnalogResult
-from qilisdk.yaml import yaml
+from .sampling import Sampling
+from .sampling_result import SamplingResult
+from .time_evolution import TimeEvolution
+from .time_evolution_result import TimeEvolutionResult
+from .variational_program import VariationalProgram
+from .variational_program_result import VariationalProgramResult
 
-
-@yaml.register_class
-class QaaSAnalogResult(AnalogResult): ...
+__all__ = [
+    "Sampling",
+    "SamplingResult",
+    "TimeEvolution",
+    "TimeEvolutionResult",
+    "VariationalProgram",
+    "VariationalProgramResult",
+]