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

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

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

{ket_lang-0.10.4.1.dev1 → ket_lang-0.10.4.2.dev0}/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.1.dev1"
+__version__ = "0.10.4.2.dev0"
 
 __all__ = (
     all_base

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

@@ -374,8 +374,12 @@ class Process(LibketProcess):  # pylint: disable=too-many-instance-attributes
                 print(type(circuit))
                 # <class 'list'>
         """
-        block_str = self.gates_json()
-        block = json.loads(block_str.value)
+        return json.loads(self.gates_json())
+
+    def gates_json(self) -> str:
+        """Return the JSON representation of the quantum gates in the main block."""
+        block_str = libket["ket_process_gates_json"](self)
+        block = block_str.value.decode("utf-8")
         libket["ket_string_delete"](block_str)
         return block
 

{ket_lang-0.10.4.1.dev1 → ket_lang-0.10.4.2.dev0}/src/ket/clib/libket/execution.py

@@ -28,9 +28,19 @@ from . import (
 )
 
 
+class CallbackNotImplementedError(NotImplementedError):
+    """Raised by an optional execution callback that a target does not support.
+
+    Subclasses override only the callbacks their target supports, so these
+    methods are not abstract.
+    """
+
+
 class BatchExecution(ABC):  # pylint: disable=too-many-instance-attributes
     """Base class for constructing batch target executions."""
 
+    # pylint: disable=unused-argument
+
     def __init__(self):
         @CFUNCTYPE(
             c_int32,
@@ -186,7 +196,7 @@ class BatchExecution(ABC):  # pylint: disable=too-many-instance-attributes
         .. warning::
             This method is called by Libket and should not be called directly.
         """
-        raise NotImplementedError("`sample` method not implemented")
+        raise CallbackNotImplementedError("`sample` method not implemented")
 
     def exp_value(self, gates, hamiltonian_list):
         """Execute the circuit and compute expectation values.
@@ -194,7 +204,7 @@ class BatchExecution(ABC):  # pylint: disable=too-many-instance-attributes
         .. warning::
             This method is called by Libket and should not be called directly.
         """
-        raise NotImplementedError("`exp_value` method not implemented")
+        raise CallbackNotImplementedError("`exp_value` method not implemented")
 
     def sample_native(self, gates, qubits, shots):
         """Execute the circuit with native gates and compute expectation values.
@@ -202,7 +212,7 @@ class BatchExecution(ABC):  # pylint: disable=too-many-instance-attributes
         .. warning::
             This method is called by Libket and should not be called directly.
         """
-        raise NotImplementedError("`sample_native` method not implemented")
+        raise CallbackNotImplementedError("`sample_native` method not implemented")
 
     def exp_value_native(self, gates, hamiltonians):
         """Execute the circuit with native and compute expectation values.
@@ -210,7 +220,7 @@ class BatchExecution(ABC):  # pylint: disable=too-many-instance-attributes
         .. warning::
             This method is called by Libket and should not be called directly.
         """
-        raise NotImplementedError("`exp_value_native` method not implemented")
+        raise CallbackNotImplementedError("`exp_value_native` method not implemented")
 
     def gradient(self, gates, hamiltonian):
         """Execute the circuit, compute expectation values and the parameters gradient.
@@ -218,12 +228,15 @@ class BatchExecution(ABC):  # pylint: disable=too-many-instance-attributes
         .. warning::
             This method is called by Libket and should not be called directly.
         """
-        raise NotImplementedError("`gradient` method not implemented")
+        raise CallbackNotImplementedError("`gradient` method not implemented")
 
 
 class LiveExecution(ABC):  # pylint: disable=too-many-instance-attributes
     """Base class for constructing live target executions."""
 
+    # Optional callbacks below ignore their arguments.
+    # pylint: disable=unused-argument
+
     def __init__(self):  # pylint: disable=too-many-statements
         @CFUNCTYPE(
             c_int32,
@@ -331,55 +344,57 @@ class LiveExecution(ABC):  # pylint: disable=too-many-instance-attributes
 
     def pauli_x(self, target, control):
         """Apply a Pauli-X gate to the target qubit."""
-        raise NotImplementedError("Pauli-X gate not implemented")
+        raise CallbackNotImplementedError("Pauli-X gate not implemented")
 
     def pauli_y(self, target, control):
         """Apply a Pauli-Y gate to the target qubit."""
-        raise NotImplementedError("Pauli-Y gate not implemented")
+        raise CallbackNotImplementedError("Pauli-Y gate not implemented")
 
     def pauli_z(self, target, control):
         """Apply a Pauli-Z gate to the target qubit."""
-        raise NotImplementedError("Pauli-Z gate not implemented")
+        raise CallbackNotImplementedError("Pauli-Z gate not implemented")
 
     def hadamard(self, target, control):
         """Apply a Hadamard gate to the target qubit."""
-        raise NotImplementedError("Hadamard gate not implemented")
+        raise CallbackNotImplementedError("Hadamard gate not implemented")
 
     def rotation_x(self, target, control, angle):
         """Apply a X-Rotation gate to the target qubit."""
-        raise NotImplementedError("X-Rotation gate not implemented")
+        raise CallbackNotImplementedError("X-Rotation gate not implemented")
 
     def rotation_y(self, target, control, angle):
         """Apply a Y-Rotation gate to the target qubit."""
-        raise NotImplementedError("Y-Rotation gate not implemented")
+        raise CallbackNotImplementedError("Y-Rotation gate not implemented")
 
     def rotation_z(self, target, control, angle):
         """Apply a Z-Rotation gate to the target qubit."""
-        raise NotImplementedError("Z-Rotation gate not implemented")
+        raise CallbackNotImplementedError("Z-Rotation gate not implemented")
 
     def phase(self, target, control, angle):
         """Apply a Phase gate to the target qubit."""
-        raise NotImplementedError("Phase gate not implemented")
+        raise CallbackNotImplementedError("Phase gate not implemented")
 
     def measure(self, qubits: list[int]) -> int:
         """Measure the qubits and return the result as an integer."""
-        raise NotImplementedError("`measure` method not implemented")
+        raise CallbackNotImplementedError("`measure` method not implemented")
 
     def exp_value(self, hamiltonian: dict):
         """Compute the expectation value of the given Hamiltonian."""
-        raise NotImplementedError("`exp_value` method not implemented")
+        raise CallbackNotImplementedError("`exp_value` method not implemented")
 
     def sample(self, qubits: list[int], shots: int):
         """Sample the state of the qubits."""
-        raise NotImplementedError("`sample` method not implemented")
+        raise CallbackNotImplementedError("`sample` method not implemented")
 
     def dump(self, qubits: list[int]) -> dict:
         """Dump the state of the qubits."""
-        raise NotImplementedError("`dump` method not implemented")
+        raise CallbackNotImplementedError("`dump` method not implemented")
 
     def compute_native_gates(self, gates) -> dict:
         """Compute native gates."""
-        raise NotImplementedError("`compute_native_gates` method not implemented")
+        raise CallbackNotImplementedError(
+            "`compute_native_gates` method not implemented"
+        )
 
     @abstractmethod
     def connect(self):

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

@@ -114,6 +114,32 @@ windows-build:
   rules:
     - if: '$CI_COMMIT_BRANCH == "main"'
 
+macos-build:
+  image: registry.gitlab.com/quantum-ket/ket-building-images:macos-1.97
+  stage: build
+  cache:
+    - key: cargo-registry-v1
+      paths:
+        - .cargo/registry/index/
+        - .cargo/registry/cache/
+      policy: pull
+    - key: cargo-release-macos-$CI_COMMIT_REF_SLUG
+      paths:
+        - target/universal2-apple-darwin/release/
+        - target/aarch64-apple-darwin/release/
+        - target/x86_64-apple-darwin/release/
+        - target/release/
+        - target/.rustc_info.json
+        - target/CACHEDIR.TAG
+      policy: pull-push
+  script:
+    - cargo zigbuild --release --target universal2-apple-darwin
+  artifacts:
+    paths:
+      - target/universal2-apple-darwin/release/libkbw.dylib
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "main"'
+
 # ---------------------------------------------------------------------------
 # Deploy stage
 # ---------------------------------------------------------------------------
@@ -131,3 +157,7 @@ publish:
       curl --location --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
            --upload-file target/x86_64-pc-windows-gnu/release/kbw.dll \
            "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/kbw/${CI_COMMIT_SHORT_SHA}/kbw.dll"
+    - |
+      curl --location --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
+           --upload-file target/universal2-apple-darwin/release/libkbw.dylib \
+           "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/kbw/${CI_COMMIT_SHORT_SHA}/libkbw.dylib"

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

@@ -114,6 +114,32 @@ windows-build:
   rules:
     - if: '$CI_COMMIT_BRANCH == "main"'
 
+macos-build:
+  image: registry.gitlab.com/quantum-ket/ket-building-images:macos-1.97
+  stage: build
+  cache:
+    - key: cargo-registry-v1
+      paths:
+        - .cargo/registry/index/
+        - .cargo/registry/cache/
+      policy: pull
+    - key: cargo-release-macos-$CI_COMMIT_REF_SLUG
+      paths:
+        - target/universal2-apple-darwin/release/
+        - target/aarch64-apple-darwin/release/
+        - target/x86_64-apple-darwin/release/
+        - target/release/
+        - target/.rustc_info.json
+        - target/CACHEDIR.TAG
+      policy: pull-push
+  script:
+    - cargo zigbuild --release --target universal2-apple-darwin
+  artifacts:
+    paths:
+      - target/universal2-apple-darwin/release/libket.dylib
+  rules:
+    - if: '$CI_COMMIT_BRANCH == "main"'
+
 # ---------------------------------------------------------------------------
 # Deploy stage
 # ---------------------------------------------------------------------------
@@ -129,5 +155,9 @@ publish:
       curl --location --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
            --upload-file target/x86_64-pc-windows-gnu/release/ket.dll \
            "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/libket/${CI_COMMIT_SHORT_SHA}/ket.dll"
+    - |
+      curl --location --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
+           --upload-file target/universal2-apple-darwin/release/libket.dylib \
+           "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/libket/${CI_COMMIT_SHORT_SHA}/libket.dylib"
   rules:
     - if: '$CI_COMMIT_BRANCH == "main"'

{ket_lang-0.10.4.1.dev1 → ket_lang-0.10.4.2.dev0}/src/ket/clib/libs/libket/src/ir/block.rs

@@ -136,10 +136,14 @@ impl BasicBlock {
             return;
         }
 
+        let mut bypass_count = 0;
         for (index, inst) in self.gates.iter().enumerate().rev() {
             if index < min_index {
                 break;
             }
+            if bypass_count > 64 {
+                break;
+            }
             let shares_qubits = inst.target == new_inst.target
                 || inst.control.contains(&new_inst.target)
                 || new_inst.control.contains(&inst.target)
@@ -163,6 +167,7 @@ impl BasicBlock {
                 if !inst.commutes_with(&new_inst) {
                     break;
                 }
+                bypass_count += 1;
             }
         }
 

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

@@ -1,3 +1,4 @@
+# pylint: disable=too-many-lines
 """Quantum gate definitions.
 
 All quantum gates accept one or more :class:`~ket.base.Quant` objects as input
@@ -55,7 +56,7 @@ from __future__ import annotations
 
 from contextlib import contextmanager
 from ctypes import c_size_t
-from math import pi, prod
+from math import pi, prod, isclose
 from functools import reduce, wraps
 from typing import Any, Callable
 import functools
@@ -894,7 +895,11 @@ def evolve(hamiltonian: Hamiltonian):
             simulate. The coefficient of each term serves as the rotation
             angle.
     """
+
     process = hamiltonian.ket_process
+    if isinstance(hamiltonian, Pauli):
+        hamiltonian = Hamiltonian([hamiltonian], process)
+
     for term in hamiltonian.terms:
         gates_qubits = [
             (gate, qubit) for qubit, gate in term.map.items() if gate != "I"
@@ -907,11 +912,17 @@ def evolve(hamiltonian: Hamiltonian):
 
         qubits = Quant(qubits=list(qubits), process=process)
 
+        coef = term.coef
+        if isinstance(coef, complex):
+            if not isclose(coef.imag, 0.0):
+                raise ValueError("Cannot evolve with complex coefficient.")
+            coef = coef.real
+
         if len(gates) == 1:
-            _RGATE[gates[0]](2 * term.coef, qubits)
+            _RGATE[gates[0]](2 * coef, qubits)
         else:
             with around(_rot, gates, qubits):
-                _rzg(2 * term.coef, qubits)
+                _rzg(2 * coef, qubits)
 
 
 def is_diagonal(gate: Callable) -> Callable:

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

@@ -144,7 +144,9 @@ def _build_and_evaluate(
 _jitted_build_and_evaluate = jax.jit(_build_and_evaluate, static_argnums=(1, 2, 3, 4))
 
 
-class MPS(BatchExecution, LiveExecution):
+class MPS(
+    BatchExecution, LiveExecution
+):  # pylint: disable=too-many-instance-attributes
     """Matrix Product State (MPS) backend simulator.
 
     The ``MPS`` backend is specialized for executing quantum circuits with 1D linear topologies.
@@ -169,10 +171,15 @@ class MPS(BatchExecution, LiveExecution):
         max_bond: int = None,
         double_precision: bool = False,
         execution: Optional[Literal["live", "batch"]] = None,
+        gradient: bool = False,
     ):
         BatchExecution.__init__(self)
+        self._batch_c_struct = self.c_struct
         LiveExecution.__init__(self)
+        self._live_c_struct = self.c_struct
+
         self.execution = execution or "batch"
+        self.gradient = gradient
         self._live_psi = None
         self.num_qubits = num_qubits
         self.max_bond = max_bond
@@ -183,6 +190,7 @@ class MPS(BatchExecution, LiveExecution):
     def connect(self):
         """Configure the connection to the MPS simulator."""
         if self.execution == "live":
+            self.c_struct = self._live_c_struct
             return LiveExecution.configure(
                 self,
                 self.num_qubits,
@@ -194,10 +202,11 @@ class MPS(BatchExecution, LiveExecution):
         else:
             coupling_graph = None
 
+        self.c_struct = self._batch_c_struct
         return BatchExecution.configure(
             self,
             self.num_qubits,
-            gradient="Native",
+            gradient="Native" if self.gradient else False,
             coupling_graph=coupling_graph,
             decompose=True,
         )

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

@@ -5,6 +5,8 @@ Utilities for preparing quantum states and building quantum algorithms.
 
 from __future__ import annotations
 
+# pylint: disable=too-many-lines
+
 # SPDX-FileCopyrightText: 2020 Evandro Chagas Ribeiro da Rosa <evandro@quantuloop.com>
 # SPDX-FileCopyrightText: 2020 Rafael de Santiago <r.santiago@ufsc.br>
 #
@@ -785,47 +787,17 @@ def exact_solver(
     )
 
 
-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.
-    """
+class _GateCountBase:
+    """Base class for counting quantum gates and tracking CNOT depth."""
 
     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):
+        """Update CNOT depth for the given control and target qubits."""
         new_depth = max(self.depths[target], *(self.depths[c] for c in control)) + 1
         for c in control:
             self.depths[c] = new_depth
@@ -833,6 +805,7 @@ class GateCount(LiveExecution):
         self.cnot_depth = max(self.cnot_depth, new_depth)
 
     def pauli_x(self, target: int, control: list[int]):
+        """Count Pauli-X or CNOT / multi-controlled X gate."""
         if control:
             if len(control) == 1:
                 self.counts["cnot"] += 1
@@ -843,6 +816,7 @@ class GateCount(LiveExecution):
             self.counts["x"] += 1
 
     def pauli_y(self, target: int, control: list[int]):
+        """Count Pauli-Y or multi-controlled Y gate."""
         if control:
             self.counts[f"c{len(control)}y"] += 1
             self._update_cnot_depth(control, target)
@@ -850,6 +824,7 @@ class GateCount(LiveExecution):
             self.counts["y"] += 1
 
     def pauli_z(self, target: int, control: list[int]):
+        """Count Pauli-Z or multi-controlled Z gate."""
         if control:
             if len(control) == 1:
                 self.counts["cz"] += 1
@@ -860,55 +835,223 @@ class GateCount(LiveExecution):
             self.counts["z"] += 1
 
     def hadamard(self, target: int, control: list[int]):
+        """Count Hadamard or multi-controlled H gate."""
         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):
+    def rotation_x(
+        self,
+        target: int,
+        control: list[int],
+        angle: float,  # pylint: disable=unused-argument
+    ):
+        """Count Rotation-X gate."""
         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):
+    def rotation_y(
+        self,
+        target: int,
+        control: list[int],
+        angle: float,  # pylint: disable=unused-argument
+    ):
+        """Count Rotation-Y gate."""
         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):
+    def rotation_z(
+        self,
+        target: int,
+        control: list[int],
+        angle: float,  # pylint: disable=unused-argument
+    ):
+        """Count Rotation-Z gate."""
         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):
+    def phase(
+        self,
+        target: int,
+        control: list[int],
+        angle: float,  # pylint: disable=unused-argument
+    ):
+        """Count Phase gate."""
         if control:
             self.counts[f"c{len(control)}p"] += 1
             self._update_cnot_depth(control, target)
         else:
             self.counts["p"] += 1
 
+
+class GateCount(_GateCountBase, 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):
+        _GateCountBase.__init__(self, num_qubits)
+        LiveExecution.__init__(self)
+
+    def connect(self):
+        """Connect to the execution target."""
+        return self.configure(self.num_qubits, decompose=True)
+
     def measure(self, qubits: list[int]) -> int:
+        """Measure callback for LiveExecution."""
         return 0
 
 
+class BatchGateCount(_GateCountBase, BatchExecution):
+    """Batch Execution simulator that counts the quantum gates and CNOT depth.
+
+    Similar to :class:`GateCount`, but uses batch execution mode.
+    Note that measurement results will not be available until the process is evaluated
+    (e.g. by requesting an expectation value or sampling).
+
+    Args:
+        num_qubits: number of qubits.
+    """
+
+    def __init__(self, num_qubits: int):
+        _GateCountBase.__init__(self, num_qubits)
+        BatchExecution.__init__(self)
+
+    def connect(self):
+        """Connect to the execution target."""
+        return self.configure(self.num_qubits, decompose=True)
+
+    def _count_gates(self, gate_list):
+        for gate_dict in gate_list:
+            if gate_dict.get("decomposed") is not None:
+                self._count_gates(
+                    [
+                        (
+                            {
+                                "gate": "PauliX",
+                                "target": dec["CNOT"][1],
+                                "control": [dec["CNOT"][0]],
+                            }
+                            if "CNOT" in dec
+                            else {
+                                "gate": dec["U"][0],
+                                "target": dec["U"][1],
+                                "control": [],
+                            }
+                        )
+                        for dec in gate_dict["decomposed"]
+                    ]
+                )
+                continue
+
+            gate_name = gate_dict.get("gate")
+            if gate_name is None:
+                continue
+            target = gate_dict.get("target")
+            ctrl = sorted(gate_dict.get("control", []))
+            val = None
+
+            if isinstance(gate_name, dict):
+                gate_name, val_dict = next(iter(gate_name.items()))
+                val = val_dict.get("Value")
+
+            self._dispatch_gate(gate_name, target, ctrl, val)
+
+    def _dispatch_gate(self, gate_name, target, ctrl, val):
+        """Dispatch a single gate instruction to its counting method."""
+        if gate_name == "Hadamard":
+            self.hadamard(target, ctrl)
+        elif gate_name == "PauliX":
+            self.pauli_x(target, ctrl)
+        elif gate_name == "PauliY":
+            self.pauli_y(target, ctrl)
+        elif gate_name == "PauliZ":
+            self.pauli_z(target, ctrl)
+        elif gate_name == "RotationX":
+            self.rotation_x(target, ctrl, val)
+        elif gate_name == "RotationY":
+            self.rotation_y(target, ctrl, val)
+        elif gate_name == "RotationZ":
+            self.rotation_z(target, ctrl, val)
+        elif gate_name == "Phase":
+            self.phase(target, ctrl, val)
+
+    def sample(
+        self, gates, qubits_to_sample, shots  # pylint: disable=redefined-outer-name
+    ):
+        self._count_gates(gates)
+        return [], []
+
+    def exp_value(
+        self, gates, hamiltonian_list  # pylint: disable=redefined-outer-name
+    ):
+        self._count_gates(gates)
+        return [0.0] * len(hamiltonian_list)
+
+    def sample_native(
+        self, gates, qubits, shots  # pylint: disable=redefined-outer-name
+    ):
+        raise NotImplementedError("BatchGateCount does not support native gates")
+
+    def exp_value_native(
+        self, gates, hamiltonians  # pylint: disable=redefined-outer-name
+    ):
+        raise NotImplementedError("BatchGateCount does not support native gates")
+
+    def gradient(self, gates, hamiltonian):  # pylint: disable=redefined-outer-name
+        raise NotImplementedError(
+            "BatchGateCount does not support gradient calculation"
+        )
+
+
 def gate_count(
     gate: Callable,
     num_qubits: int | list[int] = 1,
     args: tuple = (),
     *,
     qpu_size: int | None = None,
+    batch: bool = False,
 ) -> tuple[Counter, int]:
     """Count the quantum gates and CNOT depth of a quantum gate function.
 
     This function executes the provided quantum gate operation on a live
-    execution environment and tracks the number of times each fundamental
+    or batch execution environment and tracks the number of times each fundamental
     gate is called, as well as the CNOT depth (ignoring single-qubit gates).
     Multi-qubit gates are decomposed before counting.
 
@@ -919,6 +1062,7 @@ def gate_count(
         args: Classical arguments to pass to the gate function.
         qpu_size: Size of the quantum processing unit (QPU). Defaults
             to ``sum(num_qubits)``.
+        batch: If ``True``, use batch execution mode instead of live execution.
 
     Returns:
         A tuple containing:
@@ -961,13 +1105,21 @@ def gate_count(
     if qpu_size <= 0:
         raise ValueError(f"QPU size must be a positive integer, got {qpu_size}.")
 
-    gc = GateCount(qpu_size)
+    if batch:
+        gc = BatchGateCount(qpu_size)
+    else:
+        gc = GateCount(qpu_size)
+
     process = Process(gc)
 
     qubits = [process.alloc(n) for n in num_qubits]
 
     gate(*args, *qubits)
 
-    measure(qubits[0])
+    if batch:
+        with obs():
+            exp_value(Z(qubits[0][0])).get()
+    else:
+        measure(qubits[0][0])
 
     return gc.counts, gc.cnot_depth

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

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