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

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

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

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

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

{ket_lang-0.10.2.dev1/src/ket/clib/libs/libket → ket_lang-0.10.2.dev2/src/ket/clib/libs/kbw}/cbindgen.toml

@@ -4,4 +4,11 @@ header = """
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-"""
+"""
+
+language = "C"
+pragma_once = true
+cpp_compat = true
+
+[export.rename]
+"QPUConfig" = "void"

ket_lang-0.10.2.dev2/src/ket/clib/libs/kbw/kbw.h

@@ -0,0 +1,68 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Evandro Chagas Ribeiro da Rosa<evandro@quantuloop.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+#pragma once
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Create a [`QPUConfig`] for the requested simulator and write the heap
+ * pointer into `*qpu_config`.
+ *
+ * # Parameters
+ *
+ * * `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"`.
+ * * `use_live`: `true` for live (gate-by-gate) mode; `false` for batch mode.
+ * * `gradient`: enable the parameter-shift-rule gradient strategy (batch
+ *   mode only).
+ * * `coupling_graph_json`: JSON-encoded `Vec<[usize; 2]>` describing allowed
+ *   two-qubit pairs, or a JSON `null` for all-to-all connectivity.
+ * * `qpu_config`: out-parameter; set to the newly allocated config on
+ *   success.
+ *
+ * # Returns
+ *
+ * A `KetError` integer code: `0` on success, non-zero on failure.
+ *
+ * # Safety
+ *
+ * * `simulator` must be a valid, NUL-terminated C string.
+ * * `coupling_graph_json` must be a valid, NUL-terminated C string containing
+ *   either a JSON array of two-element integer arrays or `null`.
+ * * `qpu_config` must be a non-null, aligned, writable pointer.
+ */
+int32_t kbw_make_configuration(uintptr_t num_qubits,
+                               const char *simulator,
+                               bool use_live,
+                               bool decompose,
+                               bool gradient,
+                               const char *coupling_graph_json,
+                               void **qpu_config);
+
+/**
+ * Return a static string describing the KBW build.
+ *
+ * Sets `*msg` to the UTF-8 bytes of the build-info string and `*size` to
+ * its byte length.  The pointer is valid for the lifetime of the process.
+ *
+ * Returns a `KetError` integer code (always `0` = success).
+ */
+int32_t kbw_build_info(const uint8_t **msg, uintptr_t *size);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus

ket_lang-0.10.2.dev2/src/ket/clib/libs/libket/cbindgen.toml

@@ -0,0 +1,14 @@
+header = """
+/*
+ * SPDX-FileCopyrightText: 2026 Evandro Chagas Ribeiro da Rosa<evandro@quantuloop.com>
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+"""
+
+language = "C"
+pragma_once = true
+cpp_compat = true
+
+[defines]
+"feature = qasm" = "FEATURE_QASM"

{ket_lang-0.10.2.dev1 → ket_lang-0.10.2.dev2}/src/ket/clib/libs/libket/libket.h

@@ -5,6 +5,8 @@
  */
 
 
+#pragma once
+
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -184,6 +186,10 @@ typedef struct CBatchExecution {
                       const char **grad_json);
 } CBatchExecution;
 
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
 /**
  * Retrieves the human-readable error message for a given integer error code.
  *
@@ -345,7 +351,7 @@ int32_t ket_quantum_execution_batch(uintptr_t num_qubits,
                                     const struct CBatchExecution *batch,
                                     const struct CNativeGateSet *native_gate_set,
                                     bool decompose,
-                                    bool gradient,
+                                    const char *gradient_strategy_json,
                                     const char *coupling_graph_json,
                                     const char *exp_value_strategy_json,
                                     struct QPUConfig **qpu_config);
@@ -672,3 +678,39 @@ int32_t ket_process_status(const struct Process *process, const char **status);
  * `0` on success, non-zero error code on failure.
  */
 int32_t ket_process_set_parameter(struct Process *process, double value, uintptr_t *index);
+
+#if defined(FEATURE_QASM)
+/**
+ * Parses an `OpenQASM` 2.0 source string and returns a heap-allocated
+ * [`BasicBlock`] containing the resulting gate sequence.
+ *
+ * Physical qubit indices are mapped to the `qreg` declarations in the source
+ * in order. The total number of entries in `qubits` must be ≥ the sum of all
+ * `qreg` sizes declared in `qasm`.
+ *
+ * `measure` statements are **not** executed. Their qubit-to-cbit mapping is
+ * recorded so that subsequent `if` statements are converted to controlled
+ * quantum gates instead of classical branches.
+ *
+ * On success, a newly heap-allocated `BasicBlock` is written to `*block_out`.
+ * The caller takes ownership and must eventually free it with
+ * [`ket_block_delete`].
+ *
+ * # Parameters
+ * - `qubits`     : Pointer to an array of `size_t` physical qubit indices.
+ * - `qubits_len` : Number of entries in `qubits`.
+ * - `qasm`       : Null-terminated C string with the `OpenQASM` 2.0 source.
+ * - `block_out`  : Output: on success, set to a pointer to the new `BasicBlock`.
+ *
+ * # Returns
+ * `0` on success, non-zero error code on failure.
+ */
+int32_t ket_parse_openqasm(const uintptr_t *qubits,
+                           uintptr_t qubits_len,
+                           const char *qasm,
+                           struct BasicBlock **block_out);
+#endif
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus

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

@@ -14,9 +14,10 @@ from functools import reduce
 from operator import add
 import os
 import random
-from typing import Callable, Literal
+from typing import Callable
 from math import sqrt, exp
 from collections.abc import Iterable
+from collections import Counter
 from inspect import signature
 from itertools import starmap
 
@@ -28,7 +29,7 @@ except ImportError:
     _MULTIPROCESS_AVAILABLE = False
 
 
-from ..clib.libket.execution import BatchExecution, LiveExecution
+from ..clib.libket.execution import LiveExecution
 from ..base import Process, Quant
 from ..operations import dump, exp_value
 from ..gates import H, CNOT, X, Z, obs
@@ -678,3 +679,116 @@ def exact_solver(
         ),
         key=lambda se: se[1],
     )
+
+
+class GateCount(LiveExecution):
+    """Live Execution simulator that counts the quantum gates and CNOT depth.
+
+    Example:
+        .. code-block:: python
+
+
+            from ket import *
+            from ket.qulib import GateCount
+
+            gc = GateCount(3)
+            p = Process(gc)
+            q = p.alloc(3)
+            H(q[0])
+            CNOT(q[0], q[1])
+            X(q[2])
+            CNOT(q[1], q[2])
+            H(q)
+
+            # Trigger execution
+            m = measure(q)
+
+            print("Gate Counts:", gc.counts)
+            print("CNOT Depth:", gc.cnot_depth)
+
+
+    Args:
+        num_qubits: number of qubits.
+    """
+
+    def __init__(self, num_qubits: int):
+        super().__init__()
+        self.num_qubits = num_qubits
+        self.counts = Counter()
+        self.depths = [0] * num_qubits
+        self.cnot_depth = 0
+
+    def connect(self):
+        return self.configure(self.num_qubits, decompose=True)
+
+    def _update_cnot_depth(self, control: list[int], target: int):
+        new_depth = max(self.depths[target], *(self.depths[c] for c in control)) + 1
+        for c in control:
+            self.depths[c] = new_depth
+        self.depths[target] = new_depth
+        self.cnot_depth = max(self.cnot_depth, new_depth)
+
+    def pauli_x(self, target: int, control: list[int]):
+        if control:
+            if len(control) == 1:
+                self.counts["cnot"] += 1
+            else:
+                self.counts[f"c{len(control)}x"] += 1
+            self._update_cnot_depth(control, target)
+        else:
+            self.counts["x"] += 1
+
+    def pauli_y(self, target: int, control: list[int]):
+        if control:
+            self.counts[f"c{len(control)}y"] += 1
+            self._update_cnot_depth(control, target)
+        else:
+            self.counts["y"] += 1
+
+    def pauli_z(self, target: int, control: list[int]):
+        if control:
+            if len(control) == 1:
+                self.counts["cz"] += 1
+            else:
+                self.counts[f"c{len(control)}z"] += 1
+            self._update_cnot_depth(control, target)
+        else:
+            self.counts["z"] += 1
+
+    def hadamard(self, target: int, control: list[int]):
+        if control:
+            self.counts[f"c{len(control)}h"] += 1
+            self._update_cnot_depth(control, target)
+        else:
+            self.counts["h"] += 1
+
+    def rotation_x(self, target: int, control: list[int], angle: float):
+        if control:
+            self.counts[f"c{len(control)}rx"] += 1
+            self._update_cnot_depth(control, target)
+        else:
+            self.counts["rx"] += 1
+
+    def rotation_y(self, target: int, control: list[int], angle: float):
+        if control:
+            self.counts[f"c{len(control)}ry"] += 1
+            self._update_cnot_depth(control, target)
+        else:
+            self.counts["ry"] += 1
+
+    def rotation_z(self, target: int, control: list[int], angle: float):
+        if control:
+            self.counts[f"c{len(control)}rz"] += 1
+            self._update_cnot_depth(control, target)
+        else:
+            self.counts["rz"] += 1
+
+    def phase(self, target: int, control: list[int], angle: float):
+        if control:
+            self.counts[f"c{len(control)}p"] += 1
+            self._update_cnot_depth(control, target)
+        else:
+            self.counts["p"] += 1
+
+    def measure(self, qubits: list[int]) -> int:
+        return 0

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

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

{ket_lang-0.10.2.dev1 → ket_lang-0.10.2.dev2}/src/ket_lang.egg-info/SOURCES.txt

@@ -33,6 +33,8 @@ src/ket/clib/libs/kbw/LICENSE
 src/ket/clib/libs/kbw/README.md
 src/ket/clib/libs/kbw/REUSE.toml
 src/ket/clib/libs/kbw/build.rs
+src/ket/clib/libs/kbw/cbindgen.toml
+src/ket/clib/libs/kbw/kbw.h
 src/ket/clib/libs/kbw/LICENSES/Apache-2.0.txt
 src/ket/clib/libs/kbw/examples/grover_batch.rs
 src/ket/clib/libs/kbw/examples/grover_live.rs