ket-lang 0.10.4.2.dev0__tar.gz → 0.10.4.2.dev1__tar.gz

{ket_lang-0.10.4.2.dev0/src/ket_lang.egg-info → ket_lang-0.10.4.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ket-lang
-Version: 0.10.4.2.dev0
+Version: 0.10.4.2.dev1
 Summary: Ket quantum programming language interpreter and library
 Home-page: https://quantumket.org
 Author: Evandro Chagas Ribeiro da Rosa

{ket_lang-0.10.4.2.dev0 → ket_lang-0.10.4.2.dev1}/src/ket/__init__.py

@@ -83,7 +83,7 @@ from .fermion import *
 from .fermion import __all__ as all_fermion
 from . import qulib
 
-__version__ = "0.10.4.2.dev0"
+__version__ = "0.10.4.2.dev1"
 
 __all__ = (
     all_base

{ket_lang-0.10.4.2.dev0 → ket_lang-0.10.4.2.dev1}/src/ket/amazon.py

@@ -62,6 +62,7 @@ from __future__ import annotations
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from collections import Counter
 from functools import reduce
 from json import loads
 from operator import add
@@ -256,10 +257,9 @@ class AmazonBraket(BatchExecution):  # pylint: disable=too-many-instance-attribu
         result = self.device.run(circuit, shots=shots).result()
         aws_map = {q: i for i, q in enumerate(result.measured_qubits)}
 
-        counts = {
-            self._from_braket_to_ket(k, qubits_to_sample, aws_map): v
-            for k, v in result.measurement_counts.items()
-        }
+        counts = Counter()
+        for k, v in result.measurement_counts.items():
+            counts[self._from_braket_to_ket(k, qubits_to_sample, aws_map)] += v
 
         mask_64bit = (1 << 64) - 1
         num_chunks = (len(qubits_to_sample) + 63) // 64

{ket_lang-0.10.4.2.dev0 → ket_lang-0.10.4.2.dev1}/src/ket/base/__init__.py

@@ -185,6 +185,21 @@ class Process(LibketProcess):  # pylint: disable=too-many-instance-attributes
             if self._blocked_qubits[q] == 0:
                 del self._blocked_qubits[q]
 
+    def _check_not_in_block(self, operation: str):
+        """Raise if ``operation`` is called inside a gate-building block.
+
+        Blocks (``with around``, ``with control``, ``with inverse``, gate
+        functions) are only added to the circuit when they close. Measuring
+        or inspecting the state inside one would run before the block's
+        gates, giving silently wrong results.
+        """
+        if self._blocks:
+            raise RuntimeError(
+                f"Cannot call {operation} inside a gate-building block "
+                "(e.g., 'with around', 'with control', 'with inverse', or a "
+                "function used as a gate). Call it outside the block."
+            )
+
     def _get_exp_value_index(self) -> int:
         index = self._exp_value_count
         self._exp_value_count += 1

{ket_lang-0.10.4.2.dev0 → ket_lang-0.10.4.2.dev1}/src/ket/clib/libs/kbw/.gitlab-ci.yml

@@ -18,7 +18,7 @@ variables:
 # ---------------------------------------------------------------------------
 
 cargo-clippy:
-  image: registry.gitlab.com/quantum-ket/ket-building-images:linux-1.97
+  image: registry.gitlab.com/quantum-ket/ket-building-images:linux-2.34-1.97
   stage: lint
   cache:
     - key: cargo-registry-v1
@@ -46,7 +46,7 @@ reuse:
 # ---------------------------------------------------------------------------
 
 cargo-test:
-  image: registry.gitlab.com/quantum-ket/ket-building-images:linux-1.97
+  image: registry.gitlab.com/quantum-ket/ket-building-images:linux-2.34-1.97
   stage: test
   cache:
     - key: cargo-registry-v1
@@ -67,8 +67,9 @@ cargo-test:
 # Build stage
 # ---------------------------------------------------------------------------
 
+# glibc >= 2.28, default features (dense + sparse).
 linux-build:
-  image: registry.gitlab.com/quantum-ket/ket-building-images:linux-1.97
+  image: registry.gitlab.com/quantum-ket/ket-building-images:linux-2.28-1.97
   stage: build
   cache:
     - key: cargo-registry-v1
@@ -76,7 +77,7 @@ linux-build:
         - .cargo/registry/index/
         - .cargo/registry/cache/
       policy: pull
-    - key: cargo-release-linux-$CI_COMMIT_REF_SLUG
+    - key: cargo-release-linux-2.28-$CI_COMMIT_REF_SLUG
       paths:
         - target/release/
         - target/.rustc_info.json
@@ -84,9 +85,35 @@ linux-build:
       policy: pull-push
   script:
     - cargo build --release
+    - cp target/release/libkbw.so libkbw.so
   artifacts:
     paths:
-      - target/release/libkbw.so
+      - libkbw.so
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "main"'
+
+# glibc >= 2.34, default features + GPU (wgpu) and CUDA.
+linux-gpu-build:
+  image: registry.gitlab.com/quantum-ket/ket-building-images:linux-2.34-1.97
+  stage: build
+  cache:
+    - key: cargo-registry-v1
+      paths:
+        - .cargo/registry/index/
+        - .cargo/registry/cache/
+      policy: pull
+    - key: cargo-release-linux-2.34-gpu-$CI_COMMIT_REF_SLUG
+      paths:
+        - target/release/
+        - target/.rustc_info.json
+        - target/CACHEDIR.TAG
+      policy: pull-push
+  script:
+    - cargo build --release -F gpu,cuda
+    - cp target/release/libkbw.so libkbw.gpu.so
+  artifacts:
+    paths:
+      - libkbw.gpu.so
   rules:
     - if: '$CI_COMMIT_BRANCH == "main"'
 
@@ -151,8 +178,12 @@ publish:
   script:
     - |
       curl --location --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
-           --upload-file target/release/libkbw.so \
+           --upload-file libkbw.so \
            "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/kbw/${CI_COMMIT_SHORT_SHA}/libkbw.so"
+    - |
+      curl --location --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
+           --upload-file libkbw.gpu.so \
+           "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/kbw/${CI_COMMIT_SHORT_SHA}/libkbw.gpu.so"
     - |
       curl --location --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
            --upload-file target/x86_64-pc-windows-gnu/release/kbw.dll \

{ket_lang-0.10.4.2.dev0 → ket_lang-0.10.4.2.dev1}/src/ket/clib/libs/kbw/Cargo.toml

@@ -28,7 +28,11 @@ build-info = { version = "0.0.45", default-features = false, features = [] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.150"
 num-traits = "0.2"
-cubecl = { version = "0.10.0", features = ["wgpu"], optional = true }
+cubecl = { version = "0.11.1", optional = true }
+cudarc = { version = "0.19.10", default-features = false, features = [
+    "cuda-13040",
+    "dynamic-loading",
+], optional = true }
 bimap = { version = "0.6.3", optional = true }
 pollster = { version = "1.0.1", optional = true }
 smallvec = "1.15.2"
@@ -44,8 +48,9 @@ crate-type = ["cdylib", "rlib"]
 strip = true
 
 [features]
-default = ["dense", "sparse", "gpu"]
-gpu = ["block", "cubecl", "pollster"]
+default = ["dense", "sparse"]
+gpu = ["block", "cubecl/wgpu", "pollster"]
+cuda = ["block", "cubecl/cuda", "dep:cudarc", "pollster"]
 dense = []
 sparse = ["rustc-hash"]
 block = ["bimap"]

ket_lang-0.10.4.2.dev1/src/ket/clib/libs/kbw/build.rs

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2024 Evandro Chagas Ribeiro da Rosa <evandro@quantuloop.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+fn main() {
+    build_info_build::build_script();
+
+    let mut accelerators = Vec::new();
+
+    if std::env::var("CARGO_FEATURE_GPU").is_ok() {
+        accelerators.push("GPU");
+    }
+
+    if std::env::var("CARGO_FEATURE_CUDA").is_ok() {
+        accelerators.push("CUDA");
+    }
+
+    if accelerators.is_empty() {
+        println!("cargo:rustc-env=KBW_ACCELERATORS=", );
+    } else {
+        println!(
+            "cargo:rustc-env=KBW_ACCELERATORS=[{}]",
+            accelerators.join(", ")
+        );
+    }
+}

{ket_lang-0.10.4.2.dev0 → ket_lang-0.10.4.2.dev1}/src/ket/clib/libs/kbw/kbw.h

@@ -25,7 +25,7 @@ extern "C" {
  * * `num_qubits`: number of qubits to allocate.
  * * `simulator`: NUL-terminated C string naming the backend.  Recognised
  *   values (case-insensitive, whitespace ignored): `"dense"`, `"densev2"`,
- *   `"densegpu"`, `"sparse"`, `"sparsev2"`.
+ *   `"densegpu"`, `"densecuda"`, `"sparse"`, `"sparsev2"`.
  * * `use_live`: `true` for live (gate-by-gate) mode; `false` for batch mode.
  * * `gradient`: enable the parameter-shift-rule gradient strategy (batch
  *   mode only).

{ket_lang-0.10.4.2.dev0 → ket_lang-0.10.4.2.dev1}/src/ket/clib/libs/kbw/src/c_api.rs

@@ -23,6 +23,9 @@ use crate::{Dense, DenseV2};
 #[cfg(feature = "gpu")]
 use crate::{DenseGPU, DenseGPUBlock};
 
+#[cfg(feature = "cuda")]
+use crate::DenseCUDA;
+
 #[cfg(feature = "sparse")]
 use crate::{Sparse, SparseV2};
 use ket::{error::KetError, process::QPUConfig};
@@ -37,7 +40,7 @@ use crate::quantum_execution::QubitManager;
 /// * `num_qubits`: number of qubits to allocate.
 /// * `simulator`: NUL-terminated C string naming the backend.  Recognised
 ///   values (case-insensitive, whitespace ignored): `"dense"`, `"densev2"`,
-///   `"densegpu"`, `"sparse"`, `"sparsev2"`.
+///   `"densegpu"`, `"densecuda"`, `"sparse"`, `"sparsev2"`.
 /// * `use_live`: `true` for live (gate-by-gate) mode; `false` for batch mode.
 /// * `gradient`: enable the parameter-shift-rule gradient strategy (batch
 ///   mode only).
@@ -108,6 +111,10 @@ pub unsafe extern "C" fn kbw_make_configuration(
                 )
             }
         }
+        #[cfg(feature = "cuda")]
+        "densecuda" => {
+            make_config::<DenseCUDA>(num_qubits, use_live, decompose, coupling_graph, gradient)
+        }
         #[cfg(feature = "sparse")]
         "sparse" => {
             make_config::<Sparse>(num_qubits, use_live, decompose, coupling_graph, gradient)
@@ -146,7 +153,7 @@ where
     }
 }
 
-const BUILD_INFO: &str = build_info::format!("{} v{} [{} {}]", $.crate_info.name, $.crate_info.version, $.compiler, $.target);
+const BUILD_INFO: &str = build_info::format!("{} v{} {} [{} {}]", $.crate_info.name, $.crate_info.version, env!("KBW_ACCELERATORS"), $.compiler, $.target);
 
 /// Return a static string describing the KBW build.
 ///

{ket_lang-0.10.4.2.dev0 → ket_lang-0.10.4.2.dev1}/src/ket/clib/libs/kbw/src/dense_gpu/kernel.rs

@@ -84,8 +84,8 @@ pub(super) const fn compute_ket(
 
 #[cube(launch_unchecked)]
 pub(super) fn gate_x<F: Float>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     control_mask: u32,
     half_block_size: u32,
@@ -103,20 +103,22 @@ pub(super) fn gate_x<F: Float>(
     );
 
     if ket.2 {
-        let old0 = state_real[ket.0];
-        state_real[ket.0] = state_real[ket.1];
-        state_real[ket.1] = old0;
+        let r0 = state_real[ket.0];
+        let i0 = state_imag[ket.0];
+        let r1 = state_real[ket.1];
+        let i1 = state_imag[ket.1];
 
-        let old0 = state_imag[ket.0];
-        state_imag[ket.0] = state_imag[ket.1];
-        state_imag[ket.1] = old0;
+        state_real[ket.0] = r1;
+        state_imag[ket.0] = i1;
+        state_real[ket.1] = r0;
+        state_imag[ket.1] = i0;
     }
 }
 
 #[cube(launch_unchecked)]
 pub(super) fn gate_y<F: Float>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     control_mask: u32,
     half_block_size: u32,
@@ -150,8 +152,8 @@ pub(super) fn gate_y<F: Float>(
 
 #[cube(launch_unchecked)]
 pub(super) fn gate_z<F: Float>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     control_mask: u32,
     half_block_size: u32,
@@ -176,8 +178,8 @@ pub(super) fn gate_z<F: Float>(
 
 #[cube(launch_unchecked)]
 pub(super) fn gate_h<F: Float + LaunchArg + ConstantFloat>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     control_mask: u32,
     half_block_size: u32,
@@ -226,8 +228,8 @@ fn complex_mul<F: Float>(a_r: F, a_i: F, b_r: F, b_i: F) -> (F, F) {
 
 #[cube(launch_unchecked)]
 pub(super) fn gate_p<F: Float + LaunchArg>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     control_mask: u32,
     half_block_size: u32,
@@ -255,8 +257,8 @@ pub(super) fn gate_p<F: Float + LaunchArg>(
 
 #[cube(launch_unchecked)]
 pub(super) fn gate_rx<F: Float + LaunchArg + ConstantFloat>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     control_mask: u32,
     half_block_size: u32,
@@ -291,8 +293,8 @@ pub(super) fn gate_rx<F: Float + LaunchArg + ConstantFloat>(
 
 #[cube(launch_unchecked)]
 pub(super) fn gate_ry<F: Float + LaunchArg + ConstantFloat>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     control_mask: u32,
     half_block_size: u32,
@@ -327,8 +329,8 @@ pub(super) fn gate_ry<F: Float + LaunchArg + ConstantFloat>(
 
 #[cube(launch_unchecked)]
 pub(super) fn gate_rz<F: Float + LaunchArg>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     control_mask: u32,
     half_block_size: u32,
@@ -365,11 +367,11 @@ pub(super) fn gate_rz<F: Float + LaunchArg>(
 
 #[cube(launch_unchecked)]
 pub(super) fn measure_p1<F: Float>(
-    state_real: &Array<F>,
-    state_imag: &Array<F>,
+    state_real: &[F],
+    state_imag: &[F],
     iter_offset: usize,
     block_offset: usize,
-    prob: &mut Array<F>,
+    prob: &mut [F],
     target: u32,
     mask: u32,
 ) {
@@ -387,8 +389,8 @@ pub(super) fn measure_p1<F: Float>(
 
 #[cube(launch_unchecked)]
 pub(super) fn measure_collapse<F: Float + LaunchArg + ConstantFloat>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: usize,
     target_mask: u32,
     result: u32,
@@ -398,8 +400,8 @@ pub(super) fn measure_collapse<F: Float + LaunchArg + ConstantFloat>(
     let state_index = state as usize;
 
     if (state & target_mask) == result {
-        state_real[state_index] = state_real[state_index] * p;
-        state_imag[state_index] = state_imag[state_index] * p;
+        state_real[state_index] *= p;
+        state_imag[state_index] *= p;
     } else {
         state_real[state_index] = F::ZERO;
         state_imag[state_index] = F::ZERO;
@@ -419,10 +421,10 @@ pub(super) const fn parity_u32(x: u32) -> u32 {
 
 #[cube(launch_unchecked)]
 pub(super) fn exp_value<F: Float + ConstantFloat>(
-    state_real: &Array<F>,
-    state_imag: &Array<F>,
+    state_real: &[F],
+    state_imag: &[F],
     offset: usize,
-    prob: &mut Array<F>,
+    prob: &mut [F],
     target_mask: u32,
 ) {
     let state = ABSOLUTE_POS_X + offset as u32;
@@ -436,8 +438,8 @@ pub(super) fn exp_value<F: Float + ConstantFloat>(
 
 #[cube(launch_unchecked)]
 pub(super) fn in_place_swap<F: Float>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: u32,
     global_index: u32,
     local_index: u32,
@@ -467,8 +469,8 @@ pub(super) fn in_place_swap<F: Float>(
 
 #[cube(launch_unchecked)]
 pub(super) fn init_state<F: Float + ConstantFloat>(
-    state_real: &mut Array<F>,
-    state_imag: &mut Array<F>,
+    state_real: &mut [F],
+    state_imag: &mut [F],
     offset: u32,
 ) {
     let state = (offset + ABSOLUTE_POS_X) as usize;