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

qilisdk/analog/__init__.py

@@ -14,7 +14,7 @@
 
 from .algorithms import TimeEvolution
 from .hamiltonian import Hamiltonian, I, X, Y, Z
-from .quantum_objects import QuantumObject, basis, bra, expect, ket, tensor
+from .quantum_objects import QuantumObject, basis_state, bra, expect_val, ket, tensor_prod
 from .schedule import Schedule
 
 __all__ = [
@@ -26,9 +26,9 @@ __all__ = [
     "X",
     "Y",
     "Z",
-    "basis",
+    "basis_state",
     "bra",
-    "expect",
+    "expect_val",
     "ket",
-    "tensor",
+    "tensor_prod",
 ]

qilisdk/analog/quantum_objects.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 from __future__ import annotations
 
+import math
 import string
 from typing import Literal
 
@@ -24,7 +25,11 @@ from scipy.sparse.linalg import norm as scipy_norm
 from qilisdk.yaml import yaml
 
 Complex = int | float | complex
-TWO = 2
+
+
+###############################################################################
+# Main Class Definition
+###############################################################################
 
 
 @yaml.register_class
@@ -39,9 +44,9 @@ class QuantumObject:
 
     The internal data is stored as a SciPy CSR (Compressed Sparse Row) matrix for
     efficient arithmetic and manipulation. The expected shapes for the data are:
-      - (2**N, 2**N) for operators or density matrices,
+      - (2**N, 2**N) for operators or density matrices (or scalars),
       - (2**N, 1) for ket states,
-      - (1, 2**N) for bra states.
+      - (1, 2**N) or (2**N,) for bra states.
     """
 
     def __init__(self, data: np.ndarray | sparray | spmatrix) -> None:
@@ -50,10 +55,12 @@ class QuantumObject:
 
         Converts a NumPy array to a CSR matrix if needed and validates the shape of the input.
         The input must represent a valid quantum state or operator with appropriate dimensions.
+        Notice that 1D arrays of shape (2N,) are considered/transformed to bras with shape (1, 2N).
 
         Args:
             data (np.ndarray | sparray | spmatrix): A dense NumPy array or a SciPy sparse matrix
-                representing a quantum state or operator.
+                representing a quantum state or operator. Should be of shape: (2**N, 2**N) for operators
+                (1, 2**N) for ket states, (2**N, 1) or (2**N,) for bra states, or (1, 1) for scalars.
 
         Raises:
             ValueError: If the input data is not a NumPy array or a SciPy sparse matrix,
@@ -65,21 +72,18 @@ class QuantumObject:
             self._data = data.tocsr()
         else:
             raise ValueError("Input must be a NumPy array or a SciPy sparse matrix")
-        invalid_shape = (
-            len(self._data.shape) > TWO
-            or (self._data.shape[0] == 1 and self._data.shape[1] != 1 and self._data.shape[1] % 2 != 0)
-            or (self._data.shape[1] == 1 and self._data.shape[0] != 1 and self._data.shape[0] % 2 != 0)
-            or (self._data.shape[0] != self._data.shape[1] and self._data.shape[0] != 1 and self._data.shape[1] != 1)
-            or (
-                self._data.shape[1] == self._data.shape[0] and self._data.shape[0] % 2 != 0 and self._data.shape[0] != 1
-            )
-        )
-        if invalid_shape:
+
+        # Valid shapes are operators = (2**N, 2**N) (scalars included), bra's = (1, 2**N) / (2**N,), or ket's =(2**N, 1):
+        valid_shape = self.is_operator() or self.is_ket() or self.is_bra()
+
+        if len(self._data.shape) != 2 or not valid_shape:  # noqa: PLR2004
             raise ValueError(
                 "Dimension of data is wrong. expected data to have shape similar to (2**N, 2**N), (1, 2**N), (2**N, 1)",
                 f"but received {self._data.shape}",
             )
 
+    # ------------- Properties --------------
+
     @property
     def data(self) -> csr_matrix:
         """
@@ -126,7 +130,9 @@ class QuantumObject:
         """
         return self._data.shape
 
-    def dag(self) -> QuantumObject:
+    # ----------- Matrix Logic Operations ------------
+
+    def adjoint(self) -> QuantumObject:
         """
         Compute the adjoint (conjugate transpose) of the QuantumObject.
 
@@ -136,52 +142,112 @@ class QuantumObject:
         out = QuantumObject(self._data.conj().T)
         return out
 
-    def ptrace(self, dims: list[int], keep: list[int]) -> "QuantumObject":
+    def ptrace(self, keep: list[int], dims: list[int] | None = None) -> "QuantumObject":
         """
         Compute the partial trace over subsystems not in 'keep'.
 
         This method calculates the reduced density matrix by tracing out
-        the subsystems that are not specified in the 'keep' parameter. The
-        input 'dims' represents the dimensions of each subsystem, and 'keep'
-        indicates the indices of the subsystems to be retained.
+        the subsystems that are not specified in the 'keep' parameter.
+        The input 'dims' represents the dimensions of each subsystem (optional),
+        and 'keep' indicates the indices of those subsystems to be retained.
+
+        If the QuantumObject is a ket or bra, it will first be converted to a density matrix.
 
         Args:
-            dims (list[int]): A list specifying the dimensions of each subsystem.
             keep (list[int]): A list of indices corresponding to the subsystems to retain.
+                The order of the indices in 'keep' is not important, since dimensions will
+                be returned in the tensor original order, but the indices must be unique.
+            dims (list[int], optional): A list specifying the dimensions of each subsystem.
+                If not specified, a density matrix of qubit states is assumed, and the
+                dimensions are inferred accordingly (i.e. we split the state in dim 2 states).
 
         Raises:
             ValueError: If the product of the dimensions in dims does not match the
-                shape of the QuantumObject's dense representation.
+                shape of the QuantumObject's dense representation or if any dimension is non-positive.
+            ValueError: If the indices in 'keep' are not unique or are out of range.
+            ValueError: If the QuantumObject is not a valid density matrix or state vector.
+            ValueError: If the number of subsystems exceeds the available ASCII letters.
 
         Returns:
             QuantumObject: A new QuantumObject representing the reduced density matrix
                 for the subsystems specified in 'keep'.
         """
-        rho = self.dense
-        total_dim = np.prod(dims)
-        if rho.shape != (total_dim, total_dim):
-            raise ValueError("Dimension mismatch between provided dims and QuantumObject shape")
+        # 1) Get the density matrix representation:
+        rho = self.dense if self.is_operator() else self.to_density_matrix().dense
+
+        # 2.a) If `dims` is not provided, we assume a density matrix of qubit states (we split in subsystems of dim = 2):
+        if dims is None:
+            # The to_density_matrix() should check its a square matrix, with size being a power of 2, so we can do:
+            number_of_qubits_in_state = int(math.log2(rho.shape[0]))
+            dims = [2 for _ in range(number_of_qubits_in_state)]
+        # 2.b) If `dims` is provided, we run checks on it:
+        else:
+            total_dim = int(np.prod(dims))
+            if rho.shape != (total_dim, total_dim):
+                raise ValueError(
+                    f"Dimension mismatch: QuantumObject shape {rho.shape} does not match the expected shape ({total_dim}, {total_dim}), given by the product of all passed `dims`: (np.prod(dims), np.prod(dims))."
+                )
+            if any(d <= 0 for d in dims):
+                raise ValueError("All subsystem dimensions must be positive")
+
+        # 3) Validate & sort `keep`
+        keep_set = set(keep)
+        if any(i < 0 or i >= len(dims) for i in keep_set):
+            raise ValueError("keep indices out of range (0, len(dims))")
+        if len(keep_set) != len(keep):
+            raise ValueError("duplicate indices in keep")
+
+        # 4) Trace out the subsystems not in `keep`.
+        rho_t = self._compute_traced_tensor_via_einstein_summation(rho, keep_set, dims)
+
+        # 5) The resulting tensor has separate indices for each subsystem kept.
+        # Reshape it into a matrix (i.e. combine the row indices and column indices).
+        dims_keep = [dims[i] for i in keep_set]
+        new_dim = int(np.prod(dims_keep)) if dims_keep else 1
+
+        return QuantumObject(rho_t.reshape((new_dim, new_dim)))
+
+    @staticmethod
+    def _compute_traced_tensor_via_einstein_summation(rho: np.ndarray, keep: set[int], dims: list[int]) -> np.ndarray:
+        """Helper function called in `ptrace`, which computes the partial trace over subsystems not in 'keep'.
+
+        This function generates the appropriate einsum subscript strings for the input tensor
+        and performs the summation over the indices corresponding to the subsystems being traced out.
+
+        Args:
+            rho (np.ndarray): The input density matrix to be traced out.
+            keep (set[int]): A list of indices corresponding to the subsystems to retain.
+                The order of the indices in 'keep' is not important, since dimensions will
+                be returned in the tensor original order, but the indices must be unique.
+            dims (list[int]): A list specifying the dimensions of each subsystem.
+
+        Returns:
+            np.ndarray: The resulting tensor after tracing out the specified subsystems.
+
+        Raises:
+            ValueError: If the number of subsystems exceeds the available ASCII letters.
+        """
+        # Check that the number of subsystems is not too large, that we run out of ascii letters.
+        needed, MAX_LABELS = len(dims) + len(keep), len(string.ascii_letters)
+        if needed > MAX_LABELS:
+            raise ValueError(f"Not enough einsum labels (dims + keep): need {needed}, but only {MAX_LABELS} available.")
 
-        n = len(dims)
         # Use letters from the ASCII alphabet (both cases) for einsum indices.
         # For each subsystem, assign two letters: one for the row index and one for the column index.
-        row_letters = []
-        col_letters = []
-        out_row = []  # Letters that will remain in the output for the row part.
-        out_col = []  # Letters for the column part.
+        row_letters, col_letters = [], []
+        out_row, out_col = [], []  # Letters that will remain in the output for the row part and for the column part.
         letters = iter(string.ascii_letters)
 
-        for i in range(n):
+        for i in range(len(dims)):
             if i in keep:
-                # For a subsystem we want to keep, use two different letters
-                r = next(letters)
-                c = next(letters)
+                # For a subsystem we want to keep, use two different letters (r, c)
+                r, c = next(letters), next(letters)
                 row_letters.append(r)
                 col_letters.append(c)
                 out_row.append(r)
                 out_col.append(c)
             else:
-                # For subsystems to be traced out, assign the same letter so that those indices are summed.
+                # For subsystems to be traced out, assign the same letter (r, r) so that those indices are summed.
                 r = next(letters)
                 row_letters.append(r)
                 col_letters.append(r)
@@ -195,40 +261,40 @@ class QuantumObject:
         # Reshape rho into a tensor with shape dims + dims.
         reshaped = rho.reshape(dims + dims)
         # Use einsum to sum over the indices that appear twice (i.e. those being traced out).
-        reduced_tensor = np.einsum(f"{input_subscript}->{output_subscript}", reshaped)
-
-        # The resulting tensor has separate indices for each subsystem kept.
-        # Reshape it into a matrix (i.e. combine the row indices and column indices).
-        dims_keep = [dims[i] for i in keep]
-        new_dim = np.prod(dims_keep)
-        reduced_matrix = reduced_tensor.reshape(new_dim, new_dim)
-
-        return QuantumObject(reduced_matrix)
+        return np.einsum(f"{input_subscript}->{output_subscript}", reshaped)
 
     def norm(self, order: int | Literal["fro", "tr"] = 1) -> float:
         """
         Compute the norm of the QuantumObject.
 
-        For density matrices, the norm order can be specified. For state vectors,
-        the norm is computed accordingly.
+        For density matrices, the norm order can be specified. For state vectors, the norm is computed accordingly.
 
         Args:
             order (int or {"fro", "tr"}, optional): The order of the norm.
-                If the QuantumObject represents a density matrix and 'tr' is specified,
-                the trace norm is returned. Defaults to 1.
+                Only applies if the QuantumObject represents a density matrix. Other than all the
+                orders accepted by scipy, it also accepts 'tr' for the trace norm. Defaults to 1.
+
+        Raises:
+            ValueError: If the QuantumObject is not a valid density matrix or state vector,
 
         Returns:
             float: The computed norm of the QuantumObject.
         """
         if self.is_scalar():
             return self.dense[0][0]
-        if self.is_dm() or self.shape[0] == self.shape[1]:
+
+        if self.is_density_matrix() or self.shape[0] == self.shape[1]:
             if order == "tr":
-                return self._data.trace()
+                return np.sum(np.abs(np.linalg.eigvalsh(self.dense)))
             return scipy_norm(self._data, ord=order)
+
         if self.is_bra():
             return np.sqrt(self._data @ self._data.conj().T).toarray()[0, 0]
-        return np.sqrt(self._data.conj().T @ self._data).toarray()[0, 0]
+
+        if self.is_ket():
+            return np.sqrt(self._data.conj().T @ self._data).toarray()[0, 0]
+
+        raise ValueError("The QuantumObject is not a valid density matrix or state vector. Cannot compute the norm.")
 
     def unit(self, order: int | Literal["fro", "tr"] = "tr") -> QuantumObject:
         """
@@ -238,8 +304,8 @@ class QuantumObject:
 
         Args:
             order (int or {"fro", "tr"}, optional): The order of the norm to use for normalization.
-                If the QuantumObject represents a density matrix and 'tr' is specified,
-                the trace norm is used. Defaults to "tr".
+                Only applies if the QuantumObject represents a density matrix. Other than all the
+                orders accepted by scipy, it also accepts 'tr' for the trace norm. Defaults to "tr".
 
         Raises:
             ValueError: If the norm of the QuantumObject is 0, making normalization impossible.
@@ -250,6 +316,7 @@ class QuantumObject:
         norm = self.norm(order=order)
         if norm == 0:
             raise ValueError("Cannot normalize a zero-norm Quantum Object")
+
         return QuantumObject(self._data / norm)
 
     def expm(self) -> QuantumObject:
@@ -261,6 +328,46 @@ class QuantumObject:
         """
         return QuantumObject(expm(self._data))
 
+    def to_density_matrix(self) -> QuantumObject:
+        """
+        Convert the QuantumObject to a density matrix.
+
+        If the QuantumObject represents a state vector (ket or bra), this method
+        calculates the corresponding density matrix by taking the outer product.
+        If the QuantumObject is already a density matrix, it is returned unchanged.
+        The resulting density matrix is normalized.
+
+        Raises:
+            ValueError: If the QuantumObject is a scalar, as a density matrix cannot be derived.
+            ValueError: If the QuantumObject is an operator that is not a density matrix.
+
+        Returns:
+            QuantumObject: A new QuantumObject representing the density matrix.
+        """
+        if self.is_scalar():
+            raise ValueError("Cannot make a density matrix from scalar.")
+
+        if self.is_bra():
+            return (self.adjoint() @ self).unit()
+
+        if self.is_ket():
+            return (self @ self.adjoint()).unit()
+
+        if self.is_density_matrix():
+            return self
+
+        if self.is_operator():
+            raise ValueError(
+                "Cannot make a density matrix from an operator, which is not a density matrix already (trace=1 and hermitian)."
+            )
+
+        raise ValueError(
+            "Cannot make a density matrix from this QuantumObject. "
+            "It must be either a ket, a bra or already a density matrix."
+        )
+
+    # ----------- Checks for Matrices ------------
+
     def is_ket(self) -> bool:
         """
         Check if the QuantumObject represents a ket (column vector) state.
@@ -268,7 +375,7 @@ class QuantumObject:
         Returns:
             bool: True if the QuantumObject is a ket state, False otherwise.
         """
-        return self.shape[0] % 2 == 0 and self.shape[1] == 1
+        return self.shape[1] == 1 and self.shape[0].bit_count() == 1
 
     def is_bra(self) -> bool:
         """
@@ -277,7 +384,7 @@ class QuantumObject:
         Returns:
             bool: True if the QuantumObject is a bra state, False otherwise.
         """
-        return self.shape[1] % 2 == 0 and self.shape[0] == 1
+        return self.shape[0] == 1 and self.shape[1].bit_count() == 1
 
     def is_scalar(self) -> bool:
         """
@@ -286,14 +393,22 @@ class QuantumObject:
         Returns:
             bool: True if the QuantumObject is a scalar, False otherwise.
         """
-        return self.data.shape == (1, 1)
+        return self.shape == (1, 1)
 
-    def is_dm(self, tol: float = 1e-8) -> bool:
+    def is_operator(self) -> bool:
+        """
+        Check if the QuantumObject is an operator (square matrix).
+
+        Returns:
+            bool: True if the QuantumObject is an operator, False otherwise.
+        """
+        return self._data.shape[1] == self._data.shape[0] and self._data.shape[0].bit_count() == 1
+
+    def is_density_matrix(self, tol: float = 1e-8) -> bool:
         """
         Determine if the QuantumObject is a valid density matrix.
 
-        A valid density matrix must be square, Hermitian, positive semi-definite,
-        and have a trace equal to 1.
+        A valid density matrix must be square, Hermitian, positive semi-definite, and have a trace equal to 1.
 
         Args:
             tol (float, optional): The numerical tolerance for verifying Hermiticity,
@@ -303,11 +418,11 @@ class QuantumObject:
             bool: True if the QuantumObject is a valid density matrix, False otherwise.
         """
         # Check if rho is a square matrix
-        if self.shape[0] != self.shape[1]:
+        if not self.is_operator():
             return False
 
         # Check Hermitian condition: rho should be equal to its conjugate transpose
-        if not np.allclose(self.dense, self._data.conj().T.toarray(), atol=tol):
+        if not self.is_hermitian(tol=tol):
             return False
 
         # Check if eigenvalues are non-negative (positive semi-definite)
@@ -318,7 +433,7 @@ class QuantumObject:
         # Check if the trace is 1
         return np.isclose(self._data.trace(), 1, atol=tol)
 
-    def is_herm(self, tol: float = 1e-8) -> bool:
+    def is_hermitian(self, tol: float = 1e-8) -> bool:
         """
         Check if the QuantumObject is Hermitian.
 
@@ -331,39 +446,20 @@ class QuantumObject:
         """
         return np.allclose(self.dense, self._data.conj().T.toarray(), atol=tol)
 
-    def to_density_matrix(self) -> QuantumObject:
-        """
-        Convert the QuantumObject to a density matrix.
-
-        If the QuantumObject represents a state vector (ket or bra), this method
-        calculates the corresponding density matrix by taking the outer product.
-        If the QuantumObject is already a density matrix, it is returned unchanged.
-        The resulting density matrix is normalized.
-
-        Raises:
-            ValueError: If the QuantumObject is a scalar, as a density matrix cannot be derived.
-
-        Returns:
-            QuantumObject: A new QuantumObject representing the density matrix.
-        """
-        if self.is_scalar():
-            raise ValueError("Cannot make a density matrix from scalar.")
-        if self.is_dm():
-            return self
-        if self.is_bra():
-            return (self.dag() @ self).unit()
-        return (self @ self.dag()).unit()
+    # ----------- Basic Arithmetic Operators ------------
 
     def __add__(self, other: QuantumObject | Complex) -> QuantumObject:
         if isinstance(other, QuantumObject):
             return QuantumObject(self._data + other._data)
         if isinstance(other, Complex) and other == 0:
             return self
+
         raise TypeError("Addition is only supported between QuantumState instances")
 
     def __sub__(self, other: QuantumObject) -> QuantumObject:
         if isinstance(other, QuantumObject):
             return QuantumObject(self._data - other._data)
+
         raise TypeError("Subtraction is only supported between QuantumState instances")
 
     def __mul__(self, other: QuantumObject | Complex) -> QuantumObject:
@@ -371,11 +467,13 @@ class QuantumObject:
             return QuantumObject(self._data * other)
         if isinstance(other, QuantumObject):
             return QuantumObject(self._data * other._data)
+
         raise TypeError("Unsupported multiplication type")
 
     def __matmul__(self, other: QuantumObject) -> QuantumObject:
         if isinstance(other, QuantumObject):
             return QuantumObject(self._data @ other._data)
+
         raise TypeError("Dot product is only supported between QuantumState instances")
 
     def __rmul__(self, other: QuantumObject | Complex) -> QuantumObject:
@@ -385,19 +483,23 @@ class QuantumObject:
         return f"{self.dense}"
 
 
-def basis(N: int, n: int) -> QuantumObject:
+###############################################################################
+# Outside class Function Definitions
+###############################################################################
+
+
+def basis_state(n: int, N: int) -> QuantumObject:
     """
-    Generate the basis vector representation of a Fock state.
+    Generate the n'th basis vector representation, on a N-size Hilbert space (N=2**num_qubits).
 
-    This function creates a column vector (ket) representing the Fock state |n⟩
-    in a Hilbert space of dimension N.
+    This function creates a column vector (ket) representing the Fock state |n⟩ in a Hilbert space of dimension N.
 
     Args:
-        N (int): The dimension of the Hilbert space (number of Fock states).
-        n (int): The desired number state.
+        n (int): The desired number state (from 0 to N-1).
+        N (int): The dimension of the Hilbert space, has a value 2**num_qubits.
 
     Returns:
-        QuantumObject: A QuantumObject representing the Fock state |n⟩.
+        QuantumObject: A QuantumObject representing the |n⟩'th basis state on a N-size Hilbert space (N=2**num_qubits).
     """
     return QuantumObject(csc_array(([1], ([n], [0])), shape=(N, 1)))
 
@@ -406,9 +508,8 @@ def ket(*state: int) -> QuantumObject:
     """
     Generate a ket state for a multi-qubit system.
 
-    This function creates a tensor product of individual qubit states (kets)
-    based on the input values. Each input must be either 0 or 1. For example,
-    ket(0, 1) creates a two-qubit ket state |0⟩ ⊗ |1⟩.
+    This function creates a tensor product of individual qubit states (kets) based on the input values.
+    Each input must be either 0 or 1. For example, ket(0, 1) creates a two-qubit ket state |0⟩ ⊗ |1⟩.
 
     Args:
         *state (int): A sequence of integers representing the state of each qubit (0 or 1).
@@ -420,17 +521,17 @@ def ket(*state: int) -> QuantumObject:
         QuantumObject: A QuantumObject representing the multi-qubit ket state.
     """
     if any(s not in {0, 1} for s in state):
-        raise ValueError("the state can only be 1 or 0.")
-    return tensor([QuantumObject(csc_array(([1], ([s], [0])), shape=(2, 1))) for s in state])
+        raise ValueError(f"the state can only contain 1s or 0s. But received: {state}")
+
+    return tensor_prod([QuantumObject(csc_array(([1], ([s], [0])), shape=(2, 1))) for s in state])
 
 
 def bra(*state: int) -> QuantumObject:
     """
     Generate a bra state for a multi-qubit system.
 
-    This function creates a tensor product of individual qubit states (bras)
-    based on the input values. Each input must be either 0 or 1. For example,
-    bra(0, 1) creates a two-qubit bra state ⟨0| ⊗ ⟨1|.
+    This function creates a tensor product of individual qubit states (bras) based on the input values.
+    Each input must be either 0 or 1. For example, bra(0, 1) creates a two-qubit bra state ⟨0| ⊗ ⟨1|.
 
     Args:
         *state (int): A sequence of integers representing the state of each qubit (0 or 1).
@@ -442,11 +543,12 @@ def bra(*state: int) -> QuantumObject:
         QuantumObject: A QuantumObject representing the multi-qubit bra state.
     """
     if any(s not in {0, 1} for s in state):
-        raise ValueError("the state can only be 1 or 0.")
-    return tensor([QuantumObject(csc_array(([1], ([0], [s])), shape=(1, 2))) for s in state])
+        raise ValueError(f"the state can only contain 1s or 0s. But received:: {state}")
 
+    return tensor_prod([QuantumObject(csc_array(([1], ([0], [s])), shape=(1, 2))) for s in state])
 
-def tensor(operators: list[QuantumObject]) -> QuantumObject:
+
+def tensor_prod(operators: list[QuantumObject]) -> QuantumObject:
     """
     Calculate the tensor product of a list of QuantumObjects.
 
@@ -463,10 +565,11 @@ def tensor(operators: list[QuantumObject]) -> QuantumObject:
     if len(operators) > 1:
         for i in range(1, len(operators)):
             out = kron(out, operators[i].data)
+
     return QuantumObject(out)
 
 
-def expect(operator: QuantumObject, state: QuantumObject) -> Complex:
+def expect_val(operator: QuantumObject, state: QuantumObject) -> Complex:
     """
     Calculate the expectation value of an operator with respect to a quantum state.
 
@@ -477,10 +580,17 @@ def expect(operator: QuantumObject, state: QuantumObject) -> Complex:
         operator (QuantumObject): The quantum operator represented as a QuantumObject.
         state (QuantumObject): The quantum state or density matrix represented as a QuantumObject.
 
+    Raises:
+        ValueError: If the operator is not a square matrix.
+
     Returns:
         Complex: The expectation value. The result is guaranteed to be real if the operator
                  is Hermitian, and may be complex otherwise.
     """
+    if not operator.is_operator():
+        raise ValueError("The operator must be a square matrix.")
+
     if state.data.shape[1] == state.data.shape[0]:
         return (operator @ state).dense.trace()
-    return (state.dag() @ operator @ state).dense[0, 0]
+
+    return (state.adjoint() @ operator @ state).dense[0, 0]

qilisdk/extras/__init__.py

@@ -20,12 +20,12 @@ __all__ = []
 OPTIONAL_FEATURES: list[OptionalFeature] = [
     OptionalFeature(
         name="cuda",
-        dependencies=["cudaq"],
+        dependencies=["cuda-quantum-cu12"],
         symbols=[Symbol(path="qilisdk.extras.cuda.cuda_backend", name="CudaBackend")],
     ),
     OptionalFeature(
         name="qaas",
-        dependencies=["httpx", "keyring", "pydantic", "pydantic-settings"],
+        dependencies=["httpx", "keyring"],
         symbols=[Symbol(path="qilisdk.extras.qaas.qaas_backend", name="QaaSBackend")],
     ),
 ]

qilisdk/extras/cuda/cuda_backend.py

@@ -17,9 +17,8 @@ from typing import TYPE_CHECKING, Callable, Type, TypeVar
 
 import cudaq
 import numpy as np
-from cudaq import State
-from cudaq.operator import ElementaryOperator, OperatorSum, ScalarOperator, evolve, spin
-from cudaq.operator import Schedule as cuda_schedule
+from cudaq import ElementaryOperator, OperatorSum, ScalarOperator, State, evolve, spin
+from cudaq import Schedule as cuda_schedule
 
 from qilisdk.analog.analog_backend import AnalogBackend
 from qilisdk.analog.hamiltonian import Hamiltonian, PauliI, PauliOperator, PauliX, PauliY, PauliZ
@@ -277,7 +276,7 @@ class CudaBackend(DigitalBackend, AnalogBackend):
 
         return CudaAnalogResult(
             final_expected_values=np.array(
-                [exp_val.expectation() for exp_val in evolution_result.final_expectation_values()]
+                [exp_val.expectation() for exp_val in evolution_result.final_expectation_values()[0]]
             ),
             expected_values=(
                 np.array(
@@ -287,12 +286,12 @@ class CudaBackend(DigitalBackend, AnalogBackend):
                 else None
             ),
             final_state=(
-                QuantumObject(np.array(evolution_result.final_state())).dag()
+                QuantumObject(np.array(evolution_result.final_state())).adjoint()
                 if evolution_result.final_state() is not None
                 else None
             ),
             intermediate_states=(
-                [QuantumObject(np.array(state)).dag() for state in evolution_result.intermediate_states()]
+                [QuantumObject(np.array(state)).adjoint() for state in evolution_result.intermediate_states()]
                 if evolution_result.intermediate_states() is not None
                 else None
             ),

qilisdk/extras/qaas/qaas_backend.py

@@ -17,6 +17,7 @@ import json
 import logging
 from base64 import urlsafe_b64encode
 from datetime import datetime, timezone
+from os import environ
 from typing import TYPE_CHECKING, cast
 
 import httpx
@@ -65,7 +66,7 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
       c) keyring (fallback).
     """
 
-    _api_url: str = "https://qilimanjaroqaas.ddns.net:8080/api/v1"
+    _api_url: str = environ.get("PUBLIC_API_URL", "https://qilimanjaroqaas.ddns.net:8080/api/v1")
 
     def __init__(self) -> None:
         """

{qilisdk-0.1.2.dist-info → qilisdk-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.2
+Version: 0.1.4
 Summary: qilisdk is a Python framework for writing digital and analog quantum algorithms and executing them across multiple quantum backends. Its modular design streamlines the development process and enables easy integration with a variety of quantum platforms.
 Author-email: Qilimanjaro Quantum Tech <info@qilimanjaro.tech>
 License-File: LICENCE
@@ -21,15 +21,15 @@ Classifier: Topic :: Scientific/Engineering :: Quantum Computing
 Requires-Python: >=3.10
 Requires-Dist: dill>=0.3.9
 Requires-Dist: numpy>=2.2.4
+Requires-Dist: pydantic-settings>=2.8.0
+Requires-Dist: pydantic>=2.10.6
 Requires-Dist: ruamel-yaml>=0.18.10
 Requires-Dist: scipy>=1.15.1
 Provides-Extra: cuda
-Requires-Dist: cudaq==0.9.1; extra == 'cuda'
+Requires-Dist: cuda-quantum-cu12; extra == 'cuda'
 Provides-Extra: qaas
 Requires-Dist: httpx>=0.28.1; extra == 'qaas'
 Requires-Dist: keyring>=25.6.0; extra == 'qaas'
-Requires-Dist: pydantic-settings>=2.8.0; extra == 'qaas'
-Requires-Dist: pydantic>=2.10.6; extra == 'qaas'
 Description-Content-Type: text/markdown
 
 # QiliSDK
@@ -227,7 +227,7 @@ For analog simulations, the new `TimeEvolution` and `Schedule` classes allow you
 
 ```python
 import numpy as np
-from qilisdk.analog import TimeEvolution, Schedule, tensor, ket, X, Z, Y
+from qilisdk.analog import Schedule, TimeEvolution, ket, X, Z, Y, tensor_prod
 from qilisdk.extras import CudaBackend
 
 T = 10       # Total evolution time
@@ -251,16 +251,15 @@ schedule = Schedule(
 )
 
 # Prepare an initial state (equal superposition)
-state = tensor([(ket(0) + ket(1)).unit() for _ in range(nqubits)]).unit()
+state = tensor_prod([(ket(0) + ket(1)).unit() for _ in range(nqubits)]).unit()
 
 # Perform time evolution on the CUDA backend with observables to monitor
 time_evolution = TimeEvolution(
-    backend=CudaBackend(),
     schedule=schedule,
     initial_state=state,
     observables=[Z(0), X(0), Y(0)],
 )
-results = time_evolution.evolve(store_intermediate_results=True)
+results = time_evolution.evolve(backend=CudaBackend(), store_intermediate_results=True)
 print("Time Evolution Results:", results)
 ```
 

{qilisdk-0.1.2.dist-info → qilisdk-0.1.4.dist-info}/RECORD

@@ -3,13 +3,13 @@ qilisdk/__init__.pyi,sha256=iwacKJYttlh9DgQgNmnAjkU9CyjDQG42X3gr9Dg1kME,710
 qilisdk/_optionals.py,sha256=gl6yZ2sROY-USvNkXy6964OBOrDNKJAIyBU8D2H13z4,3594
 qilisdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qilisdk/yaml.py,sha256=QTDiLB8-3GWOfFKxvKwfEtJjTYXRxGP3ldUAEERB51E,4055
-qilisdk/analog/__init__.py,sha256=ExHaNL6pYH9HPY1ahskbPHqVyN9BnH8_ZxLCBS1HYp0,974
+qilisdk/analog/__init__.py,sha256=0J2XPJKMrvBM8jRa4nhxMKTB0fQ5kt4emb4lp4uv3Qs,1004
 qilisdk/analog/algorithms.py,sha256=OiQma6y5ueNE1buXXbNexme1k1aQaIg1A00C6mX10JQ,4621
 qilisdk/analog/analog_backend.py,sha256=GRCqlCslo8F0iB8N6Mn-_0IFJos6xRbadwVvk3lYilc,1753
 qilisdk/analog/analog_result.py,sha256=aaTGQmKm8-cuFvs_lhCAP0JOaUxsmsNcVbn_M5rvkm4,4705
 qilisdk/analog/exceptions.py,sha256=66nF1b3God6LgJ1IQd0thC3iyr6z1iMcZTfmDsSr4LE,686
 qilisdk/analog/hamiltonian.py,sha256=ELQXIauk_foOQbOChTFIV4fYzTwqHhSP1tMw8PwytaQ,25126
-qilisdk/analog/quantum_objects.py,sha256=_M7hkZOD-NW0FjoTtkrFFDVICxQ2cH7OP0xlfqjtuTE,18833
+qilisdk/analog/quantum_objects.py,sha256=toYJZmgnAq06vHSpJbyl6bXEC1jRLjBrN9tJ2lV_9bc,24478
 qilisdk/analog/schedule.py,sha256=AHpiBPN1YZb9J2WNw6MyRPjRWAyqLVIiGFj5y_rwDmA,12807
 qilisdk/common/__init__.py,sha256=sB9yxB1512KdJuWGSHx7TWvIxLMFBX1m7zm6NVkWEAA,657
 qilisdk/common/algorithm.py,sha256=_MBdMHIJogTPnR8QRCvpf364lxQNDqGWWyZpsgplcyI,636
@@ -27,17 +27,17 @@ qilisdk/digital/digital_result.py,sha256=PmqVOp4W1COZOFYcROxuLG7WAYjBAB6EM5BeY0J
 qilisdk/digital/exceptions.py,sha256=21RnaSBkzZOuQWcIWVB303F4nyU1ABOykhAYow4m7lA,871
 qilisdk/digital/gates.py,sha256=Ylf9iwDNONaatzIrrPpXi6H59C7bMvrq-tWyIK5ZykU,29614
 qilisdk/digital/vqe.py,sha256=HdxueeBO6MQYKyy8xo2_x50hqHd693RPvXaxEFIcEJI,6648
-qilisdk/extras/__init__.py,sha256=kki6xpa5TInawohC_vNacHZ4UAWxrEoK_lpl5eUkRpk,1543
+qilisdk/extras/__init__.py,sha256=MdNUZ8Fd0hYFcRzUQWrhHGGEhdHlldd61fWL8iIPe_Y,1522
 qilisdk/extras/__init__.pyi,sha256=xQ4zOPeSaNM5zGfb07fK4lcbAu4y95YfgSlHs5TkR3Y,717
 qilisdk/extras/cuda/__init__.py,sha256=LDSTo7NstSbHMvvqvx7ZLxh0HFTEXg1O_B76SyEEHk8,588
 qilisdk/extras/cuda/cuda_analog_result.py,sha256=0IoBZpkPfxS5CDps1Z6uRH1ATWG689klYR1RvGyUhBU,737
-qilisdk/extras/cuda/cuda_backend.py,sha256=ew8Dethe1bIFrSRd0rv-cl7joozrHrPNV1IBn7LtOhQ,16403
+qilisdk/extras/cuda/cuda_backend.py,sha256=AuoWuwlFQfloEE6krMP_1ZHsQZJyxwcnB7g56YTW1U0,16379
 qilisdk/extras/cuda/cuda_digital_result.py,sha256=bgHCrmcUVCBngo443PhfLkMxAT8Kk24FRubU3bJsdsQ,742
 qilisdk/extras/qaas/__init__.py,sha256=LDSTo7NstSbHMvvqvx7ZLxh0HFTEXg1O_B76SyEEHk8,588
 qilisdk/extras/qaas/keyring.py,sha256=xjJj6wrRALj31foctYTGZ07wgusVyIGuzeKxU-MNAA0,1774
 qilisdk/extras/qaas/models.py,sha256=Phf_j8LPmBUeUbe_StgM-aSz8o1HecCnfsjFbvMAlTY,3801
 qilisdk/extras/qaas/qaas_analog_result.py,sha256=MLWKtRWLwKZl7Q-tWv615-P_LKFxJIRrK_ni_jQvaP8,738
-qilisdk/extras/qaas/qaas_backend.py,sha256=PvXvuL-c5VtPv0IAt2z8AS8witUbVJbVnmxJMwKFiBw,9976
+qilisdk/extras/qaas/qaas_backend.py,sha256=2S953of7KUZ_JBNuqPBHCGa3uOu6Jve3CQxoppJvZyc,10030
 qilisdk/extras/qaas/qaas_digital_result.py,sha256=9EaZujlXvdmqdfVD-laDJq_I8YO5bc3XHRvEobOYR1U,743
 qilisdk/extras/qaas/qaas_settings.py,sha256=Vl-OPs0ijht7GqxjztY-Id3nEinfE48j_J-d9mJ4Ctk,935
 qilisdk/extras/qaas/qaas_time_evolution_result.py,sha256=sj9-xe1CbuO-yOkG5ac-f49CpIM4-X6tKnd9RBVfRMU,745
@@ -45,7 +45,7 @@ qilisdk/extras/qaas/qaas_vqe_result.py,sha256=tQUJ904aW7BzSzd-Dxi8TvL6AIQAnDsiOG
 qilisdk/utils/__init__.py,sha256=cFdezrFwesp9azZEBG_CWq3_Qp1yH8do_PyJbIIdSkU,920
 qilisdk/utils/openqasm2.py,sha256=QGQi2rrkYB_cqRgCyp3V3uDyfnVvcdMxykIiK0-sqXM,8316
 qilisdk/utils/serialization.py,sha256=vp-q2SZ9cBq3NX-gfT3ZDt0tzF3KnxkhV0cM7imJ2zo,3870
-qilisdk-0.1.2.dist-info/METADATA,sha256=Pr59Q2KtieNfdr9qiOac3B1Bin1bzbbapoajmejEFy0,18039
-qilisdk-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-qilisdk-0.1.2.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-qilisdk-0.1.2.dist-info/RECORD,,
+qilisdk-0.1.4.dist-info/METADATA,sha256=TyXixdKgm05tUHh5HArhbZh5U2cUE63hGTFPY6msU1M,18016
+qilisdk-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qilisdk-0.1.4.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+qilisdk-0.1.4.dist-info/RECORD,,