ket-lang 0.9.2.dev1__tar.gz → 0.9.2.dev2__tar.gz

{ket_lang-0.9.2.dev1/src/ket_lang.egg-info → ket_lang-0.9.2.dev2}/PKG-INFO

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

{ket_lang-0.9.2.dev1 → ket_lang-0.9.2.dev2}/src/ket/__init__.py

@@ -91,7 +91,7 @@ from .quantumstate import *
 from .quantumstate import __all__ as all_state
 from . import qulib
 
-__version__ = "0.9.2dev1"
+__version__ = "0.9.2dev2"
 
 __all__ = all_base + all_func + all_gate + all_expv + all_state + ["qulib"]
 

{ket_lang-0.9.2.dev1 → ket_lang-0.9.2.dev2}/src/ket/base.py

@@ -127,7 +127,9 @@ class Process(LibketProcess):
         self,
         execution_target: BatchExecution | LiveExecution | None = None,
         num_qubits: Optional[int] = None,
-        simulator: Optional[Literal["sparse", "dense", "dense v2", "dense gpu"]] = None,
+        simulator: Optional[
+            Literal["sparse", "dense", "dense v2", "dense gpu", "dense cuda"]
+        ] = None,
         execution: Optional[Literal["live", "batch"]] = None,
         gradient: bool = False,
         **kwargs,

{ket_lang-0.9.2.dev1 → ket_lang-0.9.2.dev2}/src/ket/clib/kbw.py

@@ -60,6 +60,7 @@ _SIMULATOR = {
     "sparse": 1,
     "dense v2": 2,
     "dense gpu": 3,
+    "dense cuda": 4,
 }
 
 
@@ -69,7 +70,13 @@ _CLASSICAL_SHADOWS = {"bias": (1, 1, 1), "samples": 1_000, "shots": 2048}
 def get_simulator(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     num_qubits: int,
     execution: Literal["live", "batch"] = "live",
-    simulator: Literal["sparse", "dense", "dense v2", "dense gpu"] = "sparse",
+    simulator: Literal[
+        "sparse",
+        "dense",
+        "dense v2",
+        "dense gpu",
+        "dense cuda",
+    ] = "sparse",
     coupling_graph: list[tuple[int, int]] | None = None,
     gradient: bool = False,
     classical_shadows=None,

{ket_lang-0.9.2.dev1 → ket_lang-0.9.2.dev2}/src/ket/clib/libs/kbw/Cargo.toml

@@ -32,8 +32,9 @@ build-info = { version = "0.0.42", default-features = false, features = [] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.145"
 indexmap = "2.12.1"
+num-traits = "0.2"
 
-cubecl = { version = "0.8.1", features = ["wgpu"] }
+cubecl = { version = "0.8.1", features = ["wgpu", "cuda"] }
 
 [build-dependencies]
 build-info-build = "0.0.42"

{ket_lang-0.9.2.dev1 → ket_lang-0.9.2.dev2}/src/ket/clib/libs/kbw/examples/grover.rs

@@ -4,12 +4,12 @@
 
 use std::f64::consts::{FRAC_PI_2, FRAC_PI_4};
 
-use kbw::DenseSimulator;
+use kbw::DenseV2Simulator;
 use ket::prelude::*;
 
 fn main() -> Result<(), KetError> {
     let size = 12;
-    let (target, execution) = DenseSimulator::configuration(size, false, None, None, None, false);
+    let (target, execution) = DenseV2Simulator::configuration(size, false, None, None, None, false);
 
     let mut process = Process::new(target, execution);
 

{ket_lang-0.9.2.dev1 → ket_lang-0.9.2.dev2}/src/ket/clib/libs/kbw/src/bitwise.rs

@@ -3,8 +3,20 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
+use std::ops::{BitOrAssign, Shl};
+
 use num::Integer;
 
+pub(crate) fn get_ctrl_mask<T: Integer + BitOrAssign + Shl<usize, Output = T>>(
+    control: &[usize],
+) -> T {
+    let mut control_mask = T::zero();
+    for c in control {
+        control_mask |= T::one() << *c;
+    }
+    control_mask
+}
+
 pub(crate) fn bit_flip(state: usize, index: usize) -> usize {
     state ^ (1 << index)
 }
@@ -24,10 +36,6 @@ pub(crate) fn is_one_at_vec(state: &[u64], target: usize) -> bool {
     state[outer_index] & (1 << inner_index) != 0
 }
 
-pub(crate) fn ctrl_check(state: usize, control: &[usize]) -> bool {
-    control.iter().all(|control| is_one_at(state, *control))
-}
-
 pub(crate) fn ctrl_check_vec(state: &[u64], control: &[usize]) -> bool {
     control.iter().all(|control| is_one_at_vec(state, *control))
 }

{ket_lang-0.9.2.dev1 → ket_lang-0.9.2.dev2}/src/ket/clib/libs/kbw/src/c_api.rs

@@ -4,7 +4,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    error::KBWError, DenseGPUSimulator, DenseSimulator, DenseV2Simulator, SparseSimulator,
+    error::KBWError, DenseCUDASimulator, DenseGPUSimulator, DenseSimulator, DenseV2Simulator,
+    SparseSimulator,
 };
 use env_logger::Builder;
 use ket::prelude::ExecutionTarget;
@@ -129,6 +130,14 @@ pub unsafe extern "C" fn kbw_make_configuration(
             classical_shadows,
             gradient,
         ),
+        4 => DenseCUDASimulator::configuration(
+            num_qubits,
+            use_live,
+            coupling_graph,
+            sample_base,
+            classical_shadows,
+            gradient,
+        ),
         _ => return KBWError::InvalidSimulator.error_code(),
     }));
 

{ket_lang-0.9.2.dev1 → ket_lang-0.9.2.dev2}/src/ket/clib/libs/kbw/src/dense.rs

@@ -3,30 +3,30 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::bitwise::*;
 use crate::error::{KBWError, Result};
 use crate::quantum_execution::{ExecutionFeatures, QuantumExecution};
+use crate::{bitwise::*, FloatOps};
 use itertools::Itertools;
 use ket::execution::*;
 use ket::process::DumpData;
 use log::error;
-use num::{complex::Complex64, Zero};
+use num::complex::Complex;
+use num::{One, Zero};
 use rand::distr::weighted::WeightedIndex;
 use rand::prelude::*;
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::f64::consts::FRAC_1_SQRT_2;
 
 #[derive(Serialize, Deserialize)]
-pub struct Dense {
-    state_0: Vec<Complex64>,
-    state_1: Vec<Complex64>,
+pub struct Dense<F: FloatOps> {
+    state_0: Vec<Complex<F>>,
+    state_1: Vec<Complex<F>>,
     state: bool,
     num_states: usize,
 }
 
-impl Dense {
-    fn get_states(&mut self) -> (&mut [Complex64], &mut [Complex64]) {
+impl<F: FloatOps> Dense<F> {
+    fn get_states(&mut self) -> (&mut [Complex<F>], &mut [Complex<F>]) {
         self.state = !self.state;
         if self.state {
             (&mut self.state_1, &mut self.state_0)
@@ -35,7 +35,7 @@ impl Dense {
         }
     }
 
-    fn get_current_state(&self) -> &[Complex64] {
+    fn get_current_state(&self) -> &[Complex<F>] {
         if self.state {
             &self.state_0
         } else {
@@ -44,7 +44,7 @@ impl Dense {
     }
 }
 
-impl QuantumExecution for Dense {
+impl<F: FloatOps> QuantumExecution for Dense<F> {
     fn new(num_qubits: usize) -> Result<Self> {
         if num_qubits > 32 {
             error!("dense implementation supports up to 32 qubits");
@@ -54,10 +54,10 @@ impl QuantumExecution for Dense {
         let num_states = 1 << num_qubits;
         let mut state_0 = Vec::new();
         let mut state_1 = Vec::new();
-        state_0.resize(num_states, Complex64::zero());
-        state_1.resize(num_states, Complex64::zero());
+        state_0.resize(num_states, Complex::<F>::zero());
+        state_1.resize(num_states, Complex::<F>::zero());
 
-        state_0[0] = Complex64::new(1.0, 0.0);
+        state_0[0] = Complex::<F>::one();
 
         Ok(Dense {
             state: true,
@@ -70,11 +70,13 @@ impl QuantumExecution for Dense {
     fn pauli_x(&mut self, target: usize, control: &[usize]) {
         let (current_state, next_state) = self.get_states();
 
+        let ctrl_mask: usize = get_ctrl_mask(control);
+
         next_state
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                *amp = current_state[if ctrl_check(state, control) {
+                *amp = current_state[if (state & ctrl_mask) == ctrl_mask {
                     bit_flip(state, target)
                 } else {
                     state
@@ -85,16 +87,18 @@ impl QuantumExecution for Dense {
     fn pauli_y(&mut self, target: usize, control: &[usize]) {
         let (current_state, next_state) = self.get_states();
 
+        let ctrl_mask: usize = get_ctrl_mask(control);
+
         next_state
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) {
+                if (state & ctrl_mask) == ctrl_mask {
                     *amp = current_state[bit_flip(state, target)]
                         * if is_one_at(state, target) {
-                            Complex64::i()
+                            Complex::<F>::i()
                         } else {
-                            -Complex64::i()
+                            -Complex::<F>::i()
                         };
                 } else {
                     *amp = current_state[state];
@@ -105,11 +109,13 @@ impl QuantumExecution for Dense {
     fn pauli_z(&mut self, target: usize, control: &[usize]) {
         let (current_state, next_state) = self.get_states();
 
+        let ctrl_mask: usize = get_ctrl_mask(control);
+
         next_state
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) && is_one_at(state, target) {
+                if (state & ctrl_mask) == ctrl_mask && is_one_at(state, target) {
                     *amp = -current_state[state];
                 } else {
                     *amp = current_state[state];
@@ -120,14 +126,16 @@ impl QuantumExecution for Dense {
     fn hadamard(&mut self, target: usize, control: &[usize]) {
         let (current_state, next_state) = self.get_states();
 
+        let ctrl_mask: usize = get_ctrl_mask(control);
+
         next_state
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) {
-                    *amp = current_state[bit_flip(state, target)] * FRAC_1_SQRT_2;
+                if (state & ctrl_mask) == ctrl_mask {
+                    *amp = current_state[bit_flip(state, target)] * F::FRAC_1_SQRT_2();
                 } else {
-                    *amp = Complex64::zero();
+                    *amp = Complex::<F>::zero();
                 }
             });
 
@@ -135,11 +143,11 @@ impl QuantumExecution for Dense {
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) {
+                if (state & ctrl_mask) == ctrl_mask {
                     *amp *= if is_one_at(state, target) {
-                        -FRAC_1_SQRT_2
+                        -F::FRAC_1_SQRT_2()
                     } else {
-                        FRAC_1_SQRT_2
+                        F::FRAC_1_SQRT_2()
                     };
                 }
             });
@@ -155,13 +163,15 @@ impl QuantumExecution for Dense {
     fn phase(&mut self, lambda: f64, target: usize, control: &[usize]) {
         let (current_state, next_state) = self.get_states();
 
-        let phase = Complex64::exp(lambda * Complex64::i());
+        let phase = Complex::<F>::exp(Complex::<F>::i() * F::from(lambda).unwrap());
+
+        let ctrl_mask: usize = get_ctrl_mask(control);
 
         next_state
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) && is_one_at(state, target) {
+                if (state & ctrl_mask) == ctrl_mask && is_one_at(state, target) {
                     *amp = current_state[state] * phase;
                 } else {
                     *amp = current_state[state];
@@ -172,17 +182,19 @@ impl QuantumExecution for Dense {
     fn rx(&mut self, theta: f64, target: usize, control: &[usize]) {
         let (current_state, next_state) = self.get_states();
 
-        let cons_theta_2 = Complex64::from(f64::cos(theta / 2.0));
-        let sin_theta_2 = -Complex64::i() * f64::sin(theta / 2.0);
+        let cons_theta_2 = Complex::<F>::from(F::cos(F::from(theta / 2.0).unwrap()));
+        let sin_theta_2 = -Complex::<F>::i() * F::sin(F::from(theta / 2.0).unwrap());
+
+        let ctrl_mask: usize = get_ctrl_mask(control);
 
         next_state
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) {
+                if (state & ctrl_mask) == ctrl_mask {
                     *amp = current_state[bit_flip(state, target)] * sin_theta_2;
                 } else {
-                    *amp = Complex64::zero();
+                    *amp = Complex::<F>::zero();
                 }
             });
 
@@ -190,7 +202,7 @@ impl QuantumExecution for Dense {
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) {
+                if (state & ctrl_mask) == ctrl_mask {
                     *amp *= cons_theta_2;
                 }
             });
@@ -206,15 +218,17 @@ impl QuantumExecution for Dense {
     fn ry(&mut self, theta: f64, target: usize, control: &[usize]) {
         let (current_state, next_state) = self.get_states();
 
-        let cons_theta_2 = Complex64::from(f64::cos(theta / 2.0));
-        let p_sin_theta_2 = Complex64::from(f64::sin(theta / 2.0));
+        let cons_theta_2 = Complex::<F>::from(F::cos(F::from(theta / 2.0).unwrap()));
+        let p_sin_theta_2 = Complex::<F>::from(F::sin(F::from(theta / 2.0).unwrap()));
         let m_sin_theta_2 = -p_sin_theta_2;
 
+        let ctrl_mask: usize = get_ctrl_mask(control);
+
         next_state
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) {
+                if (state & ctrl_mask) == ctrl_mask {
                     *amp = current_state[bit_flip(state, target)]
                         * if is_one_at(state, target) {
                             p_sin_theta_2
@@ -222,7 +236,7 @@ impl QuantumExecution for Dense {
                             m_sin_theta_2
                         };
                 } else {
-                    *amp = Complex64::zero();
+                    *amp = Complex::<F>::zero();
                 }
             });
 
@@ -230,7 +244,7 @@ impl QuantumExecution for Dense {
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) {
+                if (state & ctrl_mask) == ctrl_mask {
                     *amp *= cons_theta_2;
                 }
             });
@@ -246,14 +260,16 @@ impl QuantumExecution for Dense {
     fn rz(&mut self, theta: f64, target: usize, control: &[usize]) {
         let (current_state, next_state) = self.get_states();
 
-        let phase_0 = Complex64::exp(-theta / 2.0 * Complex64::i());
-        let phase_1 = Complex64::exp(theta / 2.0 * Complex64::i());
+        let phase_0 = Complex::<F>::exp(Complex::<F>::i() * F::from(-theta / 2.0).unwrap());
+        let phase_1 = Complex::<F>::exp(Complex::<F>::i() * F::from(theta / 2.0).unwrap());
+
+        let ctrl_mask: usize = get_ctrl_mask(control);
 
         next_state
             .par_iter_mut()
             .enumerate()
             .for_each(|(state, amp)| {
-                if ctrl_check(state, control) {
+                if (state & ctrl_mask) == ctrl_mask {
                     *amp = current_state[state]
                         * if is_one_at(state, target) {
                             phase_1
@@ -269,26 +285,29 @@ impl QuantumExecution for Dense {
     fn measure<R: Rng>(&mut self, target: usize, rng: &mut R) -> bool {
         let (current_state, next_state) = self.get_states();
 
-        let p1: f64 = current_state
+        let p1: F = current_state
             .par_iter()
             .enumerate()
             .map(|(state, amp)| {
                 if is_one_at(state, target) {
                     amp.norm().powi(2)
                 } else {
-                    0.0
+                    F::zero()
                 }
             })
             .sum();
 
-        let p0 = match 1.0 - p1 {
-            p0 if p0 >= 0.0 => p0,
-            _ => 0.0,
+        let p0 = match F::one() - p1 {
+            p0 if p0 >= F::zero() => p0,
+            _ => F::zero(),
         };
 
-        let result = WeightedIndex::new([p0, p1]).unwrap().sample(rng) == 1;
+        let result = WeightedIndex::new([p0.to_f64().unwrap(), p1.to_f64().unwrap()])
+            .unwrap()
+            .sample(rng)
+            == 1;
 
-        let p = 1.0 / f64::sqrt(if result { p1 } else { p0 });
+        let p = F::one() / F::sqrt(if result { p1 } else { p0 });
 
         next_state
             .par_iter_mut()
@@ -297,7 +316,7 @@ impl QuantumExecution for Dense {
                 *amp = if is_one_at(state, target) == result {
                     current_state[state] * p
                 } else {
-                    Complex64::zero()
+                    Complex::<F>::zero()
                 };
             });
 
@@ -306,10 +325,10 @@ impl QuantumExecution for Dense {
 
     fn dump(&mut self, qubits: &[usize]) -> DumpData {
         let state = self.get_current_state();
-        let (basis_states, amplitudes_real, amplitudes_imag): (Vec<_>, Vec<_>, Vec<_>) = state
+        let (basis_states, amplitudes_real, amplitudes_imag): (Vec<_>, Vec<f64>, Vec<f64>) = state
             .iter()
             .enumerate()
-            .filter(|(_state, amp)| amp.norm() > 1e-15)
+            .filter(|(_state, amp)| amp.norm() > F::from(1e-15).unwrap())
             .map(|(state, amp)| {
                 let state = qubits
                     .iter()
@@ -319,7 +338,11 @@ impl QuantumExecution for Dense {
                     .reduce(|a, b| a | b)
                     .unwrap_or(0);
 
-                (Vec::from([state as u64]), amp.re, amp.im)
+                (
+                    Vec::from([state as u64]),
+                    amp.re.to_f64().unwrap(),
+                    amp.im.to_f64().unwrap(),
+                )
             })
             .multiunzip();
 
@@ -333,24 +356,22 @@ impl QuantumExecution for Dense {
     fn clear(&mut self) {
         self.state_0.clear();
         self.state_1.clear();
-        self.state_0.resize(self.num_states, Complex64::zero());
-        self.state_1.resize(self.num_states, Complex64::zero());
-        self.state_0[0] = Complex64::new(1.0, 0.0);
+        self.state_0.resize(self.num_states, Complex::<F>::zero());
+        self.state_1.resize(self.num_states, Complex::<F>::zero());
+        self.state_0[0] = Complex::<F>::one();
         self.state = true;
     }
 
     fn save(&self) -> Vec<u8> {
-        serde_json::to_vec(&self).unwrap()
+        unimplemented!()
     }
 
-    fn load(&mut self, data: &[u8]) {
-        if let Ok(simulator) = serde_json::from_slice::<Self>(data) {
-            *self = simulator;
-        }
+    fn load(&mut self, _data: &[u8]) {
+        unimplemented!()
     }
 }
 
-impl ExecutionFeatures for Dense {
+impl<F: FloatOps> ExecutionFeatures for Dense<F> {
     fn feature_measure() -> Capability {
         Capability::Advanced
     }