qilisdk 0.1.1__tar.gz → 0.1.3__tar.gz

{qilisdk-0.1.1 → qilisdk-0.1.3}/.github/workflows/code_quality.yml

@@ -43,6 +43,9 @@ jobs:
       - name: Install the project
         run: uv sync --all-groups --all-extras
 
+      - name: Explicit installation of cudaq
+        run: uv pip install cudaq==0.10.0
+
       - name: Ruff
         run: uv run ruff check --output-format=github .
 

{qilisdk-0.1.1 → qilisdk-0.1.3}/.github/workflows/tests.yml

@@ -43,5 +43,8 @@ jobs:
       - name: Install qilisdk
         run: uv sync --all-groups --all-extras
 
+      - name: Explicit installation of cudaq
+        run: uv pip install cudaq==0.10.0
+
       - name: Run tests
         run: uv run pytest tests

{qilisdk-0.1.1 → qilisdk-0.1.3}/CHANGELOG.md

@@ -1,3 +1,39 @@
+# Qilisdk 0.1.3 (2025-05-07)
+
+### Bugfixes
+
+- Made `pydantic` pass to be a mandatory requirement, and not only for qaas as before. Solving a problem with installation overseen in previous PRs. 
+
+  ([PR #29](https://github.com/qilimanjaro-tech/qilisdk/pulls/29))
+
+- Made several small changes to the `QuantumObject` class and logic. The two main changes are:
+  - The first concerns the trace norm which was incorrectly implemented before.
+  - The second concerns changing the modulus of 2 check for the Hilbert Space size, to a a pow(2) check.
+
+  ([PR #30](https://github.com/qilimanjaro-tech/qilisdk/pulls/30))
+
+- Solved problems with ``Cudaq`` backend:
+  - Updated ``Cudaq`` to version 0.10.0 to fix issues encountered in version 0.9.1
+  - Migrated ``CudaBackend`` to use the new version of ``Cudaq``
+
+  ([PR #31](https://github.com/qilimanjaro-tech/qilisdk/pulls/31))
+
+### Misc
+
+- Transformed hardcoded `PUBLIC URL` into an environment variable lookup that defaults to the hardcoded value
+
+  ([PR #32](https://github.com/qilimanjaro-tech/qilisdk/pulls/32))
+
+
+# Qilisdk 0.1.2 (2025-04-22)
+
+### Misc
+
+- Improved `QaaSBacked` functionality to include methods for executing digital and analog algorithms.
+  
+  [PR #27](https://github.com/qilimanjaro-tech/qilisdk/pulls/27)
+
+
 # Qilisdk 0.1.1 (2025-04-11)
 
 ### Misc
@@ -57,6 +93,7 @@
   ```
 
   ([PR #2](https://github.com/qilimanjaro-tech/qilisdk/pulls/2))
+
 - Introduces the `Hamiltonian` class as a central component for Pauli-based operator arithmetic, with a flyweight pattern for single-qubit operators. Internally stores terms as a dictionary mapping tuples of `PauliOperator` objects to complex coefficients.
 
   **Key Features**
@@ -121,6 +158,7 @@
   This release provides a robust framework for Pauli-operator arithmetic, scalar integration, and canonical simplification, forming a foundation for higher-level quantum analog functionality.
 
   ([PR #3](https://github.com/qilimanjaro-tech/qilisdk/pulls/3))
+
 - Added the `Optimizer` abstract base class and its concrete subclass `SciPyOptimizer`. The `SciPyOptimizer` class wraps `scipy.optimize.minimize` to optimize cost functions while supporting extra keyword arguments such as Jacobian, bounds, etc. This implementation provides a structured way to perform optimization and access optimal parameters via the `optimal_parameters` property.
 
   ### Code Example

{qilisdk-0.1.1 → qilisdk-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.1
+Version: 0.1.3
 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: cudaq==0.10.0; 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

{qilisdk-0.1.1 → qilisdk-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qilisdk"
-version = "0.1.1"
+version = "0.1.3"
 description = "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."
 readme = "README.md"
 authors = [{name = "Qilimanjaro Quantum Tech", email = "info@qilimanjaro.tech"}]
@@ -26,17 +26,17 @@ dependencies = [
     "numpy>=2.2.4",
     "ruamel-yaml>=0.18.10",
     "scipy>=1.15.1",
+    "pydantic>=2.10.6",
+    "pydantic-settings>=2.8.0",
 ]
 
 [project.optional-dependencies]
 cuda = [
-    "cudaq==0.9.1",
+    "cudaq==0.10.0",
 ]
 qaas = [
     "httpx>=0.28.1",
     "keyring>=25.6.0",
-    "pydantic>=2.10.6",
-    "pydantic-settings>=2.8.0",
 ]
 
 [dependency-groups]

{qilisdk-0.1.1 → qilisdk-0.1.3}/src/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-0.1.1 → qilisdk-0.1.3}/src/qilisdk/analog/quantum_objects.py

@@ -24,7 +24,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 +43,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 +54,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 +71,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 +129,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.
 
@@ -141,9 +146,9 @@ class 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,
+        and 'keep' indicates the indices of the subsystems to be retained.
 
         Args:
             dims (list[int]): A list specifying the dimensions of each subsystem.
@@ -162,26 +167,22 @@ class QuantumObject:
         if rho.shape != (total_dim, total_dim):
             raise ValueError("Dimension mismatch between provided dims and QuantumObject shape")
 
-        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)
@@ -209,26 +210,34 @@ class QuantumObject:
         """
         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 +247,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 +259,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 +271,40 @@ 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.
+
+        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_density_matrix():
+            return self
+
+        if self.is_bra():
+            return (self.adjoint() @ self).unit()
+
+        if self.is_ket():
+            return (self @ self.adjoint()).unit()
+
+        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 +312,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 +321,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 +330,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_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_dm(self, tol: float = 1e-8) -> bool:
+    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 +355,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 +370,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 +383,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 +404,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 +420,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 +445,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 +458,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 +480,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 +502,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 +517,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-0.1.1 → qilisdk-0.1.3}/src/qilisdk/digital/ansatz.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from abc import ABC, abstractmethod
-from typing import ClassVar, Literal, Union
+from typing import Any, ClassVar, Literal, Union
 
 from qilisdk.digital.circuit import Circuit
 from qilisdk.digital.gates import CNOT, CZ, U1, U2, U3, M
@@ -103,6 +103,23 @@ class HardwareEfficientAnsatz(Ansatz):
             "grouped": self._construct_layer_grouped,
         }
 
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__.copy()
+        # Exclude the mapping that contains bound methods (not serializable).
+        state.pop("construct_layer_handlers", None)
+        return state
+
+    def __setstate__(self, state) -> None:  # noqa: ANN001
+        """
+        Restore the object's state after deserialization and reinitialize any attributes that were omitted.
+        """
+        self.__dict__.update(state)
+        # Reconstruct the mapping with the proper bound methods.
+        self.construct_layer_handlers = {
+            "interposed": self._construct_layer_interposed,
+            "grouped": self._construct_layer_grouped,
+        }
+
     @property
     def nparameters(self) -> int:
         """

{qilisdk-0.1.1 → qilisdk-0.1.3}/src/qilisdk/digital/vqe.py

@@ -83,6 +83,7 @@ class VQEResult(Result):
         )
 
 
+@yaml.register_class
 class VQE(DigitalAlgorithm):
     """
     Implements the Variational Quantum Eigensolver (VQE) algorithm.

{qilisdk-0.1.1 → qilisdk-0.1.3}/src/qilisdk/extras/__init__.py

@@ -25,7 +25,7 @@ OPTIONAL_FEATURES: list[OptionalFeature] = [
     ),
     OptionalFeature(
         name="qaas",
-        dependencies=["httpx", "keyring", "pydantic", "pydantic-settings"],
+        dependencies=["httpx", "keyring"],
         symbols=[Symbol(path="qilisdk.extras.qaas.qaas_backend", name="QaaSBackend")],
     ),
 ]