ket-lang 0.10.4.dev1__tar.gz → 0.10.4.1.dev1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ket-lang
-Version: 0.10.4.dev1
+Version: 0.10.4.1.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.dev1 → ket_lang-0.10.4.1.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.dev1"
+__version__ = "0.10.4.1.dev1"
 
 __all__ = (
     all_base

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

@@ -15,6 +15,7 @@ from ctypes import (
     POINTER,
     c_uint64,
     c_double,
+    pointer,
 )
 import json
 from abc import ABC, abstractmethod
@@ -426,6 +427,13 @@ class NativeGateSet(ABC):
     """
 
     def __init__(self):
+        # Accumulate every JSON result buffer in a list so that raw C pointers
+        # returned by the callbacks remain valid for the lifetime of this object.
+        # Using a single overwritten instance variable causes a use-after-free
+        # segfault because the old bytes object is GC'd while Rust still holds
+        # a pointer into it.
+        self._result_buffers: list[bytes] = []
+
         @CFUNCTYPE(
             c_int32,
             c_char_p,  # gate_json
@@ -439,12 +447,11 @@ class NativeGateSet(ABC):
                 for row in flat
             ]
             result = self.translate(matrix, target)
-            self._translate_result = json.dumps(result).encode("utf-8")
-            native_gate_json[0] = self._translate_result
+            buf = json.dumps(result).encode("utf-8")
+            self._result_buffers.append(buf)
+            native_gate_json[0] = buf
             return 0
 
-        self._translate_result = None
-
         @CFUNCTYPE(
             c_int32,
             c_size_t,  # control
@@ -453,12 +460,11 @@ class NativeGateSet(ABC):
         )
         def cnot(control, target, native_gate_json):
             result = self.cnot(control, target)
-            self._cnot_result = json.dumps(result).encode("utf-8")
-            native_gate_json[0] = self._cnot_result
+            buf = json.dumps(result).encode("utf-8")
+            self._result_buffers.append(buf)
+            native_gate_json[0] = buf
             return 0
 
-        self._cnot_result = None
-
         # Keep references alive for the duration of the object's lifetime.
         self._cb_translate = translate
         self._cb_cnot = cnot
@@ -526,7 +532,7 @@ def make_live_configuration(
     """
 
     if native_gate_set is not None:
-        native_gate_set_ptr = native_gate_set.c_struct
+        native_gate_set_ptr = pointer(native_gate_set.c_struct)
     else:
         native_gate_set_ptr = None
 
@@ -582,7 +588,7 @@ def make_batch_configuration(  # pylint: disable=too-many-arguments,too-many-pos
         exp_value_strategy_json = json.dumps("Native").encode("utf-8")
 
     if native_gate_set is not None:
-        native_gate_set_ptr = native_gate_set.c_struct
+        native_gate_set_ptr = pointer(native_gate_set.c_struct)
     else:
         native_gate_set_ptr = None
 

{ket_lang-0.10.4.dev1 → ket_lang-0.10.4.1.dev1}/src/ket/clib/libs/libket/src/process/mod.rs

@@ -715,7 +715,20 @@ impl Process {
                         }
                     }
                 }
+            } else if gate.control.len() == 1 && matches!(gate.gate, QuantumGate::PauliX) {
+                let control = *gate.control.iter().next().unwrap();
+                let target = gate.target;
+                flush_sq!(control);
+                flush_sq!(target);
+                physical_circuit.append(&mut native_gate_set.cnot(control, target)?);
             } else {
+                if !gate.control.is_empty() {
+                    println!(
+                        "PANIC! gate: {:?}, control len: {}",
+                        gate.gate,
+                        gate.control.len()
+                    );
+                }
                 assert!(
                     gate.control.is_empty(),
                     "controlled gates should be decomposed at this pont"

ket_lang-0.10.4.1.dev1/src/ket/gateset.py

@@ -0,0 +1,176 @@
+"""Native gate set decompositions for Ket."""
+
+# SPDX-FileCopyrightText: 2026 Evandro Chagas Ribeiro da Rosa <evandro@quantuloop.com>
+# SPDX-FileCopyrightText: 2026 Ruan Luiz Molgero Lopes <ruan.molgero@grad.ufsc.br>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+import cmath
+import math
+from .clib.libket.execution import NativeGateSet
+
+
+def _extract_u3(matrix):
+    """
+    Extracts U3 angles (theta, phi, lambda) from a 2x2 unitary matrix.
+    Ignores global phase.
+    """
+    u00, u01 = matrix[0]
+    u10, u11 = matrix[1]
+
+    if abs(u00) > 1e-10:
+        phase_g = cmath.phase(u00)
+        u00 *= cmath.exp(-1j * phase_g)
+        u01 *= cmath.exp(-1j * phase_g)
+        u10 *= cmath.exp(-1j * phase_g)
+        u11 *= cmath.exp(-1j * phase_g)
+
+        val = max(-1.0, min(1.0, u00.real))
+        theta = 2 * math.acos(val)
+
+        phi = cmath.phase(u10) if abs(u10) > 1e-10 else 0.0
+        lam = cmath.phase(-u01) if abs(u01) > 1e-10 else cmath.phase(u11) - phi
+    else:
+        theta = math.pi
+        phase_g = cmath.phase(u10)
+        u10 *= cmath.exp(-1j * phase_g)
+        u01 *= cmath.exp(-1j * phase_g)
+        phi = 0.0
+        lam = cmath.phase(-u01) if abs(u01) > 1e-10 else 0.0
+
+    return theta, phi, lam
+
+
+class RzSXCZ(NativeGateSet):
+    """Gate set using CZ for CNOT decomposition."""
+
+    def translate(self, matrix: list[list[complex]], target: int) -> list:
+        theta, phi, lam = _extract_u3(matrix)
+        return [
+            ["rz", [lam], [target]],
+            ["sxdg", [], [target]],
+            ["rz", [-theta], [target]],
+            ["sx", [], [target]],
+            ["rz", [phi], [target]],
+        ]
+
+    def cnot(self, control: int, target: int) -> list:
+        return [
+            ["rz", [math.pi / 2], [target]],
+            ["sx", [], [target]],
+            ["rz", [math.pi / 2], [target]],
+            ["cz", [], [control, target]],
+            ["rz", [math.pi / 2], [target]],
+            ["sx", [], [target]],
+            ["rz", [math.pi / 2], [target]],
+        ]
+
+
+class RzSXXRzz(NativeGateSet):
+    """Gate set using Rzz for CNOT decomposition."""
+
+    def translate(self, matrix: list[list[complex]], target: int) -> list:
+        theta, phi, lam = _extract_u3(matrix)
+        return [
+            ["rz", [lam], [target]],
+            ["sxdg", [], [target]],
+            ["rz", [-theta], [target]],
+            ["sx", [], [target]],
+            ["rz", [phi], [target]],
+        ]
+
+    def cnot(self, control: int, target: int) -> list:
+        return [
+            ["rz", [math.pi / 2], [target]],
+            ["sx", [], [target]],
+            ["rz", [math.pi / 2], [target]],
+            ["rzz", [math.pi / 2], [control, target]],
+            ["rz", [math.pi / 2], [target]],
+            ["sx", [], [target]],
+            ["rz", [math.pi / 2], [target]],
+            ["sx", [], [target]],
+            ["x", [], [target]],
+            ["rz", [-math.pi / 2], [control]],
+        ]
+
+
+class RzSXECR(NativeGateSet):
+    """Gate set using ECR for CNOT decomposition."""
+
+    def translate(self, matrix: list[list[complex]], target: int) -> list:
+        theta, phi, lam = _extract_u3(matrix)
+        return [
+            ["rz", [lam], [target]],
+            ["sxdg", [], [target]],
+            ["rz", [-theta], [target]],
+            ["sx", [], [target]],
+            ["rz", [phi], [target]],
+        ]
+
+    def cnot(self, control: int, target: int) -> list:
+        return [
+            ["rz", [-math.pi / 2], [control]],
+            ["rz", [-math.pi], [target]],
+            ["sx", [], [target]],
+            ["rz", [-math.pi], [target]],
+            ["ecr", [], [control, target]],
+            ["sx", [], [control]],
+            ["sx", [], [control]],
+        ]
+
+
+class RzRxISWAP(NativeGateSet):
+    """Gate set using iSWAP for CNOT decomposition."""
+
+    def translate(self, matrix: list[list[complex]], target: int) -> list:
+        theta, phi, lam = _extract_u3(matrix)
+        return [
+            ["rz", [lam], [target]],
+            ["rx", [math.pi / 2], [target]],
+            ["rz", [theta], [target]],
+            ["rx", [-math.pi / 2], [target]],
+            ["rz", [phi], [target]],
+        ]
+
+    def cnot(self, control: int, target: int) -> list:
+        return [
+            ["rz", [-math.pi / 2], [control]],
+            ["rz", [math.pi / 2], [target]],
+            ["iswap", [], [control, target]],
+            ["rx", [math.pi / 2], [control]],
+            ["iswap", [], [control, target]],
+            ["rx", [-math.pi / 2], [target]],
+            ["rz", [math.pi / 2], [target]],
+            ["rx", [math.pi / 2], [target]],
+            ["rz", [math.pi / 2], [target]],
+        ]
+
+
+class RzGPiGPi2MS(NativeGateSet):
+    """Gate set using MS and GPi for CNOT decomposition."""
+
+    def translate(self, matrix: list[list[complex]], target: int) -> list:
+        theta, phi, lam = _extract_u3(matrix)
+        return [
+            ["rz", [lam], [target]],
+            ["gpi2", [0.0], [target]],
+            ["rz", [theta], [target]],
+            ["gpi2", [math.pi], [target]],
+            ["rz", [phi], [target]],
+        ]
+
+    def cnot(self, control: int, target: int) -> list:
+        return [
+            ["h", [], [target]],
+            ["gpi", [0.0], [control]],
+            ["h", [], [control]],
+            ["h", [], [target]],
+            ["ms", [], [control, target]],
+            ["h", [], [control]],
+            ["gpi", [0.0], [control]],
+            ["rz", [math.pi / 2], [control]],
+            ["h", [], [target]],
+            ["rz", [math.pi / 2], [target]],
+            ["h", [], [target]],
+        ]

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

@@ -153,8 +153,6 @@ class MPS(BatchExecution, LiveExecution):
 
     Args:
         num_qubits: Total number of qubits to simulate.
-        backend: Target hardware for execution, either ``"cpu"`` or ``"gpu"``.
-            Defaults to ``"cpu"``.
         max_bond: Maximum bond dimension for SVD truncations during the simulation.
             If specified, it restricts entanglement and keeps the MPS strictly 1D, enabling
             the simulation of large numbers of qubits. However, this dynamically changes tensor
@@ -168,7 +166,6 @@ class MPS(BatchExecution, LiveExecution):
     def __init__(
         self,
         num_qubits: int,
-        backend: Literal["cpu", "gpu"] = "cpu",
         max_bond: int = None,
         double_precision: bool = False,
         execution: Optional[Literal["live", "batch"]] = None,
@@ -179,10 +176,7 @@ class MPS(BatchExecution, LiveExecution):
         self._live_psi = None
         self.num_qubits = num_qubits
         self.max_bond = max_bond
-        if backend not in ["cpu", "gpu"]:
-            raise ValueError("backend must be 'cpu' or 'gpu'")
         jax.config.update("jax_enable_x64", double_precision)
-        jax.config.update("jax_platform_name", backend)
 
         self.last_grad = None
 

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

@@ -29,7 +29,7 @@ except ImportError:
     _MULTIPROCESS_AVAILABLE = False
 
 
-from ..clib.libket.execution import LiveExecution
+from ..clib.libket.execution import LiveExecution, BatchExecution
 from ..base import Process, Quant
 from ..operations import dump, exp_value, measure
 from ..gates import H, CNOT, X, Z, obs
@@ -52,6 +52,7 @@ except ImportError:
 try:
     from qiskit import QuantumCircuit, QuantumRegister
     from qiskit.circuit import library, Gate
+    from qiskit.circuit.gate import Gate as QiskitGate
 
     QISKIT_AVAILABLE = True
 except ImportError:
@@ -162,131 +163,228 @@ DRAW_STYLE = {
 }
 
 
-class _IBMDeviceForDraw(LiveExecution):
+class _IBMDeviceForDraw(BatchExecution):
     """IBMDevice use for qulib.draw"""
 
     def __init__(
+        # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
         num_qubits: list[int],
         names: list[str],
         decompose: bool = False,
         keep_order: bool = True,
+        coupling_graph: list[tuple[int, int]] | None = None,
+        native_gate_set=None,
     ):
         super().__init__()
-        qubits = [QuantumRegister(n, l) for n, l in zip(num_qubits, names)]
+        if coupling_graph is not None:
+            qubits = [QuantumRegister(sum(num_qubits), "q")]
+        else:
+            qubits = [QuantumRegister(n, l) for n, l in zip(num_qubits, names)]
         self.circuit = QuantumCircuit(*qubits)
         self.num_qubits = sum(num_qubits)
         self.decompose = decompose
         self.keep_order = keep_order
+        self.coupling_graph = coupling_graph
+        self.native_gate_set = native_gate_set
         self.last_gate = None
 
-    def pauli_x(self, target, control):
-        if self.keep_order and self.last_gate != "X":
-            self.circuit.barrier()
-        gate = library.XGate()
-        if len(control) >= 1:
-            gate = gate.control(len(control))
-        self.circuit.append(gate, control + [target])
-        self.last_gate = "X"
-
-    def pauli_y(self, target, control):
-        if self.keep_order and self.last_gate != "Y":
-            self.circuit.barrier()
-        gate = library.YGate()
-        if len(control) >= 1:
-            gate = gate.control(len(control))
-        self.circuit.append(gate, control + [target])
-        self.last_gate = "Y"
-
-    def pauli_z(self, target, control):
-        if self.keep_order and self.last_gate != "Z":
-            self.circuit.barrier()
-        gate = library.ZGate()
-        if len(control) >= 1:
-            gate = gate.control(len(control))
-        self.circuit.append(gate, control + [target])
-        self.last_gate = "Z"
-
-    def hadamard(self, target, control):
-        if self.keep_order and self.last_gate != "H":
-            self.circuit.barrier()
-        gate = library.HGate()
-        if len(control) >= 1:
-            gate = gate.control(len(control))
-        self.circuit.append(gate, control + [target])
-        self.last_gate = "H"
-
-    def rotation_x(self, target, control, angle):
-        if self.keep_order and self.last_gate != "RX":
-            self.circuit.barrier()
-        gate = library.RXGate(angle)
-        if len(control) >= 1:
-            gate = gate.control(len(control))
-        self.circuit.append(gate, control + [target])
-        self.last_gate = "RX"
-
-    def rotation_y(self, target, control, angle):
-        if self.keep_order and self.last_gate != "RY":
-            self.circuit.barrier()
-        gate = library.RYGate(angle)
-        if len(control) >= 1:
-            gate = gate.control(len(control))
-        self.circuit.append(gate, control + [target])
-        self.last_gate = "RY"
-
-    def rotation_z(self, target, control, angle):
-        if self.keep_order and self.last_gate != "RZ":
-            self.circuit.barrier()
-        gate = library.RZGate(angle)
-        if len(control) >= 1:
-            gate = gate.control(len(control))
-        self.circuit.append(gate, control + [target])
-        self.last_gate = "RZ"
-
-    def phase(self, target, control, angle):
-        if self.keep_order and self.last_gate != "P":
-            self.circuit.barrier()
-        gate = library.PhaseGate(angle)
-        if len(control) >= 1:
-            gate = gate.control(len(control))
-        self.circuit.append(gate, control + [target])
-        self.last_gate = "P"
-
-    def measure(self, qubits: list[int]) -> int:
-        mea = Gate(name="measure", num_qubits=len(qubits), params=[])
-        if self.keep_order and self.last_gate != "M":
-            self.circuit.barrier()
-        self.circuit.append(mea, qubits)
-        self.last_gate = "M"
-        return 0
-
-    def exp_value(self, _):
-        """Compute the expectation value of the given Hamiltonian."""
-        return 0
-
-    def sample(self, qubits: list[int], shots: int):
-        sample = Gate(name=f"sample({shots=})", num_qubits=len(qubits), params=[])
+    def _add_gate(self, gate_name, target, control, value):
+        # pylint: disable=too-many-branches, too-many-statements
+        if gate_name == "PauliX":
+            if self.keep_order and self.last_gate != "X":
+                self.circuit.barrier()
+            gate = library.XGate()
+            if len(control) >= 1:
+                gate = gate.control(len(control))
+            self.circuit.append(gate, control + [target])
+            self.last_gate = "X"
+        elif gate_name == "PauliY":
+            if self.keep_order and self.last_gate != "Y":
+                self.circuit.barrier()
+            gate = library.YGate()
+            if len(control) >= 1:
+                gate = gate.control(len(control))
+            self.circuit.append(gate, control + [target])
+            self.last_gate = "Y"
+        elif gate_name == "PauliZ":
+            if self.keep_order and self.last_gate != "Z":
+                self.circuit.barrier()
+            gate = library.ZGate()
+            if len(control) >= 1:
+                gate = gate.control(len(control))
+            self.circuit.append(gate, control + [target])
+            self.last_gate = "Z"
+        elif gate_name == "Hadamard":
+            if self.keep_order and self.last_gate != "H":
+                self.circuit.barrier()
+            gate = library.HGate()
+            if len(control) >= 1:
+                gate = gate.control(len(control))
+            self.circuit.append(gate, control + [target])
+            self.last_gate = "H"
+        elif gate_name == "RotationX":
+            if self.keep_order and self.last_gate != "RX":
+                self.circuit.barrier()
+            gate = library.RXGate(value)
+            if len(control) >= 1:
+                gate = gate.control(len(control))
+            self.circuit.append(gate, control + [target])
+            self.last_gate = "RX"
+        elif gate_name == "RotationY":
+            if self.keep_order and self.last_gate != "RY":
+                self.circuit.barrier()
+            gate = library.RYGate(value)
+            if len(control) >= 1:
+                gate = gate.control(len(control))
+            self.circuit.append(gate, control + [target])
+            self.last_gate = "RY"
+        elif gate_name == "RotationZ":
+            if self.keep_order and self.last_gate != "RZ":
+                self.circuit.barrier()
+            gate = library.RZGate(value)
+            if len(control) >= 1:
+                gate = gate.control(len(control))
+            self.circuit.append(gate, control + [target])
+            self.last_gate = "RZ"
+        elif gate_name == "Phase":
+            if self.keep_order and self.last_gate != "P":
+                self.circuit.barrier()
+            gate = library.PhaseGate(value)
+            if len(control) >= 1:
+                gate = gate.control(len(control))
+            self.circuit.append(gate, control + [target])
+            self.last_gate = "P"
+
+    def _build_circuit(self, gate_list):
+        # pylint: disable=too-many-branches, too-many-statements, too-many-nested-blocks
+        # pylint: disable=too-many-branches, too-many-statements
+        for g in gate_list:
+            if g.get("decomposed"):
+                for dec_g in g["decomposed"]:
+                    if "U" in dec_g:
+                        u_info = dec_g["U"]
+                        gate_info = u_info[0]
+                        target = u_info[1]
+                        control = []
+                        if isinstance(gate_info, str):
+                            gate_name = gate_info
+                            value = 0.0
+                        else:
+                            gate_name = list(gate_info.keys())[0]
+                            val_info = gate_info[gate_name]
+                            if isinstance(val_info, dict) and "Ref" in val_info:
+                                value = val_info["Ref"]["value"]
+                            else:
+                                value = val_info.get("Value", 0.0)
+                        self._add_gate(gate_name, target, control, value)
+                    elif "CNOT" in dec_g:
+                        cnot_info = dec_g["CNOT"]
+                        target = cnot_info[1]
+                        control = [cnot_info[0]]
+                        self._add_gate("PauliX", target, control, 0.0)
+            else:
+                gate_info = g["gate"]
+                target = g.get("target", 0)
+                control = sorted(g.get("control", []))
+
+                if isinstance(gate_info, str):
+                    gate_name = gate_info
+                    value = 0.0
+                else:
+                    gate_name = list(gate_info.keys())[0]
+                    val_info = gate_info[gate_name]
+                    if isinstance(val_info, dict) and "Ref" in val_info:
+                        value = val_info["Ref"]["value"]
+                    else:
+                        value = val_info.get("Value", 0.0)
+
+                self._add_gate(gate_name, target, control, value)
+
+        # pylint: disable=too-many-branches, too-many-statements
+
+    def exp_value_native(
+        self, gate_list, hamiltonians
+    ):  # pylint: disable=arguments-renamed, redefined-outer-name
+        for g in gate_list:
+            gate_name = g[0]
+            params = g[1]
+            qubits = g[2]
+
+            if gate_name.lower() in ("x", "paulix"):
+                gate = library.XGate()
+            elif gate_name.lower() in ("y", "pauliy"):
+                gate = library.YGate()
+            elif gate_name.lower() in ("z", "pauliz"):
+                gate = library.ZGate()
+            elif gate_name.lower() in ("h", "hadamard"):
+                gate = library.HGate()
+            elif gate_name.lower() in ("rx", "rotationx"):
+                gate = library.RXGate(params[0])
+            elif gate_name.lower() in ("ry", "rotationy"):
+                gate = library.RYGate(params[0])
+            elif gate_name.lower() in ("rz", "rotationz"):
+                gate = library.RZGate(params[0])
+            elif gate_name.lower() in ("p", "phase"):
+                gate = library.PhaseGate(params[0])
+            elif gate_name.lower() == "sx":
+                gate = library.SXGate()
+            elif gate_name.lower() == "sxdg":
+                gate = library.SXdgGate()
+            elif gate_name.lower() == "cz":
+                gate = library.CZGate()
+            elif gate_name.lower() == "rzz":
+                gate = library.RZZGate(params[0])
+            elif gate_name.lower() == "ecr":
+                gate = library.ECRGate()
+            elif gate_name.lower() == "iswap":
+                gate = library.iSwapGate()
+            elif gate_name.lower() == "ms":
+
+                gate = (
+                    library.XXMinusYYGate(params[0])
+                    if len(params) > 0
+                    else QiskitGate("MS", 2, [])
+                )
+            elif gate_name.lower() == "cnot":
+                gate = library.CXGate()
+            else:
+                gate = QiskitGate(gate_name, len(qubits), params)
+
+            if self.keep_order and self.last_gate != gate_name:
+                self.circuit.barrier()
+            self.circuit.append(gate, qubits)
+            self.last_gate = gate_name
+
+        return [0.0] * len(hamiltonians)
+
+    def exp_value(
+        self, gate_list, hamiltonian_list
+    ):  # pylint: disable=arguments-renamed, redefined-outer-name
+        self._build_circuit(gate_list)
+        return [0.0] * len(hamiltonian_list)
+
+    def sample(
+        self, gate_list, qubits_to_sample, shots: int
+    ):  # pylint: disable=arguments-renamed, redefined-outer-name
+        self._build_circuit(gate_list)
+        sample = Gate(
+            name=f"sample({shots=})", num_qubits=len(qubits_to_sample), params=[]
+        )
         if self.keep_order and self.last_gate != "M":
             self.circuit.barrier()
-        self.circuit.append(sample, qubits)
+        self.circuit.append(sample, qubits_to_sample)
         self.last_gate = "M"
         return ([[0]], [0])
 
-    def dump(self, qubits: list[int]) -> dict:
-        dump_gate = Gate(name="dump", num_qubits=len(qubits), params=[])
-        if self.keep_order and self.last_gate != "M":
-            self.circuit.barrier()
-        self.circuit.append(dump_gate, qubits)
-        self.last_gate = "M"
-        return {
-            "basis_states": [[0]],
-            "amplitudes_real": [0.0],
-            "amplitudes_imag": [0.0],
-        }
-
     def connect(self):
         """Configure process"""
-        return super().configure(self.num_qubits, self.decompose)
+        return super().configure(
+            self.num_qubits,
+            decompose=self.decompose,
+            coupling_graph=self.coupling_graph,
+            native_gate_set=self.native_gate_set,
+        )
 
 
 def draw(  # pylint: disable=too-many-arguments, too-many-locals, too-many-branches
@@ -297,6 +395,8 @@ def draw(  # pylint: disable=too-many-arguments, too-many-locals, too-many-branc
     qubits: int | list[int] | None = None,
     qpu_size: int | None = None,
     decompose: bool = False,
+    coupling_graph: list[tuple[int, int]] | None = None,
+    native_gate_set=None,
     title: str | None = None,
     keep_order: bool = True,
     **kwargs,
@@ -371,14 +471,16 @@ def draw(  # pylint: disable=too-many-arguments, too-many-locals, too-many-branc
         num_qubits.append(qpu_size - total)
         names.append("AUX")
 
-    device = _IBMDeviceForDraw(num_qubits, names, decompose, keep_order)
+    device = _IBMDeviceForDraw(
+        num_qubits, names, decompose, keep_order, coupling_graph, native_gate_set
+    )
 
     p = Process(device)
     q = [p.alloc(n) for n in (num_qubits if qpu_size is None else num_qubits[:-1])]
     gate(*args, *q)
 
     with obs():
-        exp_value(Z(q[0]))
+        exp_value(Z(q[0])).get()
 
     if "output" not in kwargs and _IN_NOTEBOOK:
         kwargs["output"] = "mpl"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ket-lang
-Version: 0.10.4.dev1
+Version: 0.10.4.1.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.dev1 → ket_lang-0.10.4.1.dev1}/src/ket_lang.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/ket/amazon.py
 src/ket/expv.py
 src/ket/fermion.py
 src/ket/gates.py
+src/ket/gateset.py
 src/ket/ibm.py
 src/ket/measurement.py
 src/ket/mps.py