qilisdk 0.1.3__tar.gz → 0.1.4__tar.gz

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

@@ -42,10 +42,7 @@ 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.3 → qilisdk-0.1.4}/.github/workflows/tests.yml

@@ -43,8 +43,5 @@ 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.3 → qilisdk-0.1.4}/.gitignore

@@ -14,3 +14,7 @@ wheels/
 
 # Folder for storing user files
 .tmp
+
+# development environment files
+.vscode
+.coverage

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

@@ -1,8 +1,15 @@
+# Qilisdk 0.1.4 (2025-06-18)
+
+### Bugfixes
+
+- Removed manual installation of CUDA-Q for the tests and the code quality workflows. ([PR #40](https://github.com/qilimanjaro-tech/qilisdk/pulls/40))
+
+
 # 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. 
+- 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))
 
@@ -30,7 +37,7 @@
 ### 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.3 → qilisdk-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.3
+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
@@ -26,7 +26,7 @@ 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.10.0; 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'
@@ -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.3 → qilisdk-0.1.4}/README.md

@@ -193,7 +193,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
@@ -217,16 +217,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.3 → qilisdk-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qilisdk"
-version = "0.1.3"
+version = "0.1.4"
 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"}]
@@ -32,7 +32,7 @@ dependencies = [
 
 [project.optional-dependencies]
 cuda = [
-    "cudaq==0.10.0",
+    "cuda-quantum-cu12",
 ]
 qaas = [
     "httpx>=0.28.1",
@@ -55,6 +55,9 @@ dev = [
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.uv.sources]
+cudaq = { git = "https://github.com/NVIDIA/cuda-quantum", tag = "0.11.0"}
+
 [tool.ruff]
 line-length = 120
 output-format = "concise"

{qilisdk-0.1.3 → qilisdk-0.1.4}/src/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
 
@@ -141,31 +142,95 @@ 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 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.")
 
         # 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.
@@ -196,15 +261,7 @@ 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:
         """
@@ -282,6 +339,7 @@ class QuantumObject:
 
         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.
@@ -289,15 +347,20 @@ class QuantumObject:
         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()
 
+        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."

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

@@ -20,7 +20,7 @@ __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(

{qilisdk-0.1.3 → qilisdk-0.1.4}/src/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

{qilisdk-0.1.3 → qilisdk-0.1.4}/tests/analog/test_quantum_objects.py

@@ -85,18 +85,49 @@ def test_dag():
 
 
 def test_ptrace_valid():
-    """Test partial trace on a valid 2-qubit density matrix.
-
-    The test creates a 2-qubit state |00⟩, converts it to a density matrix,
-    and then traces out the second qubit.
-    """
-    qket = ket(0, 0)
+    """Test partial trace on a valid 4-qubit density matrices."""
+    qket = ket(0, 1, 1, 0)
     rho = qket.to_density_matrix()
-    # dims for a 2-qubit system are [2, 2]; keep the first qubit (index 0).
-    reduced = rho.ptrace([2, 2], keep=[0])
-    # Expected reduced density matrix is the pure state |0⟩.
-    expected = ket(0).to_density_matrix()
-    np.testing.assert_allclose(reduced.dense, expected.dense, atol=1e-8)
+
+    # Different combinations of partial traces.
+    reduced_single_qubit_ground = rho.ptrace(keep=[0], dims=[2, 2, 4])
+    reduced_single_qubit_excited = rho.ptrace(keep=[1], dims=[2, 2, 4])
+    reduced_double_qubit_1 = rho.ptrace(keep=[2], dims=[2, 2, 4])
+    reduced_double_qubit_2 = rho.ptrace(keep=[2, 3], dims=[2, 2, 2, 2])
+    reduced_double_qubit_3 = rho.ptrace(keep=[3, 2], dims=[2, 2, 2, 2])
+
+    # Expected reduced density matrices:
+    expected_single_qubit_ground = ket(0).to_density_matrix()
+    expected_single_qubit_excited = ket(1).to_density_matrix()
+    expected_double_qubit = ket(1, 0).to_density_matrix()
+
+    # Checks:
+    np.testing.assert_allclose(reduced_single_qubit_ground.dense, expected_single_qubit_ground.dense, atol=1e-8)
+    np.testing.assert_allclose(reduced_single_qubit_excited.dense, expected_single_qubit_excited.dense, atol=1e-8)
+    np.testing.assert_allclose(reduced_double_qubit_1.dense, expected_double_qubit.dense, atol=1e-8)
+    np.testing.assert_allclose(reduced_double_qubit_2.dense, expected_double_qubit.dense, atol=1e-8)
+    np.testing.assert_allclose(reduced_double_qubit_3.dense, expected_double_qubit.dense, atol=1e-8)
+
+
+def test_ptrace_valid_keep_with_automatic_dims_and_density_matrix():
+    qket = ket(0, 0, 1, 0)
+    reduced_single_qubit = qket.ptrace(keep=[2, 3])
+    expected_single_qubit = ket(1, 0).to_density_matrix()
+    np.testing.assert_allclose(reduced_single_qubit.dense, expected_single_qubit.dense, atol=1e-8)
+
+
+def test_ptrace_works_for_operators_which_are_not_density_matrices():
+    # Build a “diagonal” density matrix whose diagonal entries are 0…7. That way each composite basis |i0,i1,i2⟩ ↦
+    # flat index i = 4*i0 + 2*i1 + i2 carries a unique number. And the trace != 1, so not a density operator
+    dims = [2, 2, 2]
+    full_dim = np.prod(dims)
+    rho = np.diag(np.arange(full_dim, dtype=float))
+    q_obj = QuantumObject(rho)
+
+    # Pick an out of order keep list:
+    keep = [0, 2]  # subspace 2 *then* subspace 0
+    expected_result = np.array([[2, 0, 0, 0], [0, 4, 0, 0], [0, 0, 10, 0], [0, 0, 0, 12]])
+    np.testing.assert_allclose(q_obj.ptrace(keep, dims).dense, expected_result, atol=1e-8)
 
 
 def test_ptrace_invalid_dims():
@@ -104,9 +135,22 @@ def test_ptrace_invalid_dims():
     arr = np.eye(2)
     qobj = QuantumObject(arr)
     with pytest.raises(ValueError):  # noqa: PT011
-        qobj.ptrace([2, 2], keep=[0])
+        qobj.ptrace(keep=[0], dims=[2, 2])
+    with pytest.raises(ValueError):  # noqa: PT011
+        qobj.ptrace(keep=[0], dims=[1])  # too few dimensions
 
 
+def test_ptrace_invalid_keep():
+    """Partial trace should raise ValueError if keep indices are out of bounds."""
+    arr = np.eye(2)
+    qobj = QuantumObject(arr)
+    with pytest.raises(ValueError):  # noqa: PT011
+        qobj.ptrace(keep=[1], dims=[2])
+    with pytest.raises(ValueError):  # noqa: PT011
+        qobj.ptrace(keep=[2], dims=[2])  # out of bounds index
+    with pytest.raises(ValueError):  # noqa: PT011
+        qobj.ptrace(keep=[0, 1], dims=[2])  # too many indices
+
 # --- Arithmetic Operator Tests ---