ket-lang 0.10.2.dev3__tar.gz → 0.10.3.dev1__tar.gz

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

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

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.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.2.dev3"
+__version__ = "0.10.3.dev1"
 
 __all__ = (
     all_base

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/kbw/Cargo.toml

@@ -28,11 +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"] }
-bimap = "0.6.3"
-pollster = "1.0.1"
+cubecl = { version = "0.10.0", features = ["wgpu"], optional = true }
+bimap = { version = "0.6.3", optional = true }
+pollster = { version = "1.0.1", optional = true }
 smallvec = "1.15.2"
-rustc-hash = "2.1.3"
+rustc-hash = { version = "2.1.3", optional = true }
 
 [build-dependencies]
 build-info-build = "0.0.45"
@@ -44,3 +44,8 @@ crate-type = ["cdylib", "rlib"]
 strip = true
 
 [features]
+default = ["dense", "sparse", "gpu"]
+gpu = ["block", "cubecl", "pollster"]
+dense = []
+sparse = ["rustc-hash"]
+block = ["bimap"]

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/kbw/src/c_api.rs

@@ -17,7 +17,14 @@
 
 use std::ffi::{c_char, CStr};
 
-use crate::{Dense, DenseGPU, DenseGPUBlock, DenseV2, Sparse, SparseV2};
+#[cfg(feature = "dense")]
+use crate::{Dense, DenseV2};
+
+#[cfg(feature = "gpu")]
+use crate::{DenseGPU, DenseGPUBlock};
+
+#[cfg(feature = "sparse")]
+use crate::{Sparse, SparseV2};
 use ket::{error::KetError, process::QPUConfig};
 
 use crate::quantum_execution::QubitManager;
@@ -68,18 +75,21 @@ pub unsafe extern "C" fn kbw_make_configuration(
 
     let Ok(Ok(coupling_graph)) = unsafe { CStr::from_ptr(coupling_graph_json) }
         .to_str()
-        .map(serde_json::from_str)
+        .map(serde_json::from_str::<Option<Vec<(usize, usize)>>>)
     else {
         return KetError::SerdeError.error_code();
     };
 
     let config = match simulator.as_str() {
+        #[cfg(feature = "dense")]
         "densev1" => {
             make_config::<Dense>(num_qubits, use_live, decompose, coupling_graph, gradient)
         }
+        #[cfg(feature = "dense")]
         "dense" | "densev2" => {
             make_config::<DenseV2>(num_qubits, use_live, decompose, coupling_graph, gradient)
         }
+        #[cfg(feature = "gpu")]
         "densegpu" => {
             if num_qubits
                 < std::env::var("KBW_BLOCK_SIZE")
@@ -98,9 +108,11 @@ pub unsafe extern "C" fn kbw_make_configuration(
                 )
             }
         }
+        #[cfg(feature = "sparse")]
         "sparse" => {
             make_config::<Sparse>(num_qubits, use_live, decompose, coupling_graph, gradient)
         }
+        #[cfg(feature = "sparse")]
         "sparsev2" => {
             make_config::<SparseV2>(num_qubits, use_live, decompose, coupling_graph, gradient)
         }

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/kbw/src/dense_v2.rs

@@ -21,6 +21,7 @@
 
 use std::fmt::Display;
 
+#[cfg(feature = "block")]
 use crate::block::BlockSimulator;
 use crate::quantum_execution::QuantumExecution;
 use crate::{
@@ -340,6 +341,7 @@ impl<F: FloatOps> QuantumExecution for DenseV2<F> {
     }
 }
 
+#[cfg(feature = "block")]
 impl<F: FloatOps + Display> BlockSimulator<Self, ()> for DenseV2<F> {
     fn new_blocks(
         num_local_qubits: usize,

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/kbw/src/lib.rs

@@ -69,14 +69,20 @@ use std::{
 };
 
 pub mod bitwise;
+#[cfg(feature = "block")]
 pub mod block;
 pub mod c_api;
 pub mod convert;
+#[cfg(feature = "dense")]
 pub mod dense;
+#[cfg(feature = "gpu")]
 pub mod dense_gpu;
+#[cfg(feature = "dense")]
 pub mod dense_v2;
 pub mod quantum_execution;
+#[cfg(feature = "sparse")]
 pub mod sparse;
+#[cfg(feature = "sparse")]
 pub mod sparse_v2;
 
 /// Extension trait that adds simulator-specific helpers on top of the standard
@@ -118,36 +124,45 @@ impl FloatOps for f64 {
     }
 }
 
+#[cfg(feature = "dense")]
 /// Double-buffered, dense state-vector simulator using `f32` amplitudes.
 /// Supports up to 32 qubits.
 pub type Dense = dense::Dense<f32>;
 
+#[cfg(feature = "dense")]
 /// [`QubitManager`](quantum_execution::QubitManager) wrapping the [`Dense`] backend.
 /// The recommended entry point for single-process dense simulation.
 pub type DenseSimulator = quantum_execution::QubitManager<Dense>;
 
+#[cfg(feature = "dense")]
 /// In-place dense state-vector simulator using `f32` amplitudes.
 /// Slightly lower memory overhead than [`Dense`] due to the single-buffer design.
 pub type DenseV2 = dense_v2::DenseV2<f32>;
 
+#[cfg(feature = "dense")]
 /// [`QubitManager`](quantum_execution::QubitManager) wrapping the [`DenseV2`] backend.
 pub type DenseV2Simulator = quantum_execution::QubitManager<DenseV2>;
 
+#[cfg(all(feature = "block", feature = "dense"))]
 /// Blocked [`DenseV2`] simulator that partitions the qubit register into
 /// *local* (simulated) and *global* (index) portions, enabling circuits
 /// with more qubits than fit in a single state-vector.
 pub type DenseV2Block = block::Block<(), DenseV2>;
 
+#[cfg(all(feature = "block", feature = "dense"))]
 /// [`QubitManager`](quantum_execution::QubitManager) wrapping the [`DenseV2Block`] backend.
 pub type DenseV2BlockSimulator = quantum_execution::QubitManager<DenseV2Block>;
 
+#[cfg(feature = "gpu")]
 /// GPU-accelerated dense state-vector simulator using the WGPU runtime and `f32` amplitudes.
 /// Requires a compatible GPU and the `wgpu` feature of `CubeCL`.
 pub type DenseGPU = dense_gpu::DenseGPU<cubecl::wgpu::WgpuRuntime, f32>;
 
+#[cfg(feature = "gpu")]
 /// [`QubitManager`](quantum_execution::QubitManager) wrapping the [`DenseGPU`] backend.
 pub type DenseGPUSimulator = quantum_execution::QubitManager<DenseGPU>;
 
+#[cfg(feature = "gpu")]
 /// Blocked GPU dense state-vector; combines the WGPU backend with the block
 /// partitioning scheme for circuits exceeding on-device memory.
 pub type DenseGPUBlock = block::Block<
@@ -161,21 +176,26 @@ pub type DenseGPUBlock = block::Block<
     dense_gpu::DenseGPU<cubecl::wgpu::WgpuRuntime, f32>,
 >;
 
+#[cfg(feature = "gpu")]
 /// [`QubitManager`](quantum_execution::QubitManager) wrapping the [`DenseGPUBlock`] backend.
 /// Note: the typo `DenseGPUS` is preserved for backwards compatibility.
 pub type DenseGPUBlockSimulator = quantum_execution::QubitManager<DenseGPUBlock>;
 
+#[cfg(feature = "sparse")]
 /// Sparse state-vector simulator backed by a [`HashMap`](std::collections::HashMap),
 /// using `f32` amplitudes. Efficient for circuits that remain in a low-entanglement
 /// regime (e.g. few non-zero amplitudes).
 pub type Sparse = sparse::Sparse<f32>;
 
+#[cfg(feature = "sparse")]
 /// [`QubitManager`](quantum_execution::QubitManager) wrapping the [`Sparse`] backend.
 pub type SparseSimulator = quantum_execution::QubitManager<Sparse>;
 
+#[cfg(feature = "sparse")]
 /// Sparse state-vector simulator backed by a sorted `Vec`, providing better
 /// cache locality than [`Sparse`] at the cost of periodic sort-and-reduce passes.
 pub type SparseV2 = sparse_v2::SparseV2<f32>;
 
+#[cfg(feature = "sparse")]
 /// [`QubitManager`](quantum_execution::QubitManager) wrapping the [`SparseV2`] backend.
 pub type SparseV2Simulator = quantum_execution::QubitManager<SparseV2>;

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/examples/qft.rs

@@ -26,20 +26,17 @@ fn qft(qubits: &[usize], do_swap: bool) -> Result<BasicBlock, KetError> {
     let last = qubits[qubits.len() - 1];
     quantum_code.append_gate(QuantumGate::Hadamard, last);
     for (i, c) in init.iter().enumerate() {
-        quantum_code.append_block(
-            controlled_gate(
-                QuantumGate::Phase(Param::Value(PI / 2.0_f64.powi(i as i32 + 1))),
-                &[*c],
-                last,
-            )?,
-            None,
-        );
+        quantum_code.append_block(controlled_gate(
+            QuantumGate::Phase(Param::Value(PI / 2.0_f64.powi(i as i32 + 1))),
+            &[*c],
+            last,
+        )?);
     }
-    quantum_code.append_block(qft(init, false)?, None);
+    quantum_code.append_block(qft(init, false)?);
 
     if do_swap {
         for i in 0..qubits.len() / 2 {
-            quantum_code.append_block(swap_gate(qubits[i], qubits[qubits.len() - i - 1])?, None);
+            quantum_code.append_block(swap_gate(qubits[i], qubits[qubits.len() - i - 1])?);
         }
     }
 

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/src/c_api/block.rs

@@ -86,7 +86,7 @@ pub extern "C" fn ket_block_lock_control(block: &mut BasicBlock) -> i32 {
 #[no_mangle]
 pub extern "C" fn ket_block_append_block(block: &mut BasicBlock, other: *mut BasicBlock) -> i32 {
     let other = unsafe { Box::from_raw(other) };
-    block.append_block(*other, None);
+    block.append_block(*other);
     c_ok()
 }
 

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/src/ir/block.rs

@@ -126,6 +126,7 @@ impl BasicBlock {
         new_inst: GateInstruction,
         epsilon: Option<f64>,
         check_propiety: bool,
+        min_index: usize,
     ) {
         let epsilon = epsilon.unwrap_or(1e-10);
 
@@ -134,6 +135,9 @@ impl BasicBlock {
         }
 
         for (index, inst) in self.gates.iter().enumerate().rev() {
+            if index < min_index {
+                break;
+            }
             let shares_qubits = inst.target == new_inst.target
                 || inst.control.contains(&new_inst.target)
                 || new_inst.control.contains(&inst.target)
@@ -165,7 +169,7 @@ impl BasicBlock {
 
     /// Appends an uncontrolled gate to the block.
     pub fn append_gate(&mut self, gate: QuantumGate, target: usize) {
-        self.append_instruction(GateInstruction::new(gate, target), None, true);
+        self.append_instruction(GateInstruction::new(gate, target), None, true, 0);
     }
 
     /// Return a new basic block with the inverse of the circuit.
@@ -229,6 +233,7 @@ impl BasicBlock {
                 },
                 None,
                 true,
+                0,
             );
         }
 
@@ -255,9 +260,18 @@ impl BasicBlock {
     /// After draining `block.gates`, the global phases are summed and the
     /// `qubits_op` dependency maps are merged (restricting propriety to the
     /// more-general of the two).
-    pub fn append_block(&mut self, mut block: Self, epsilon: Option<f64>) {
+    pub fn append_block(&mut self, block: Self) {
+        self.append_block_with_epsilon_and_min_index(block, None, 0);
+    }
+
+    pub fn append_block_with_epsilon_and_min_index(
+        &mut self,
+        mut block: Self,
+        epsilon: Option<f64>,
+        min_index: usize,
+    ) {
         for inst in block.gates {
-            self.append_instruction(inst, epsilon, false);
+            self.append_instruction(inst, epsilon, false, min_index);
         }
 
         self.global = match (self.global, block.global) {

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/src/lib.rs

@@ -58,9 +58,9 @@ pub fn controlled_gate(
 /// Propagates any [`KetError`] that occurs during the `controlled_gate` operation.
 pub fn swap_gate(a: usize, b: usize) -> Result<BasicBlock, KetError> {
     let mut quantum_code = BasicBlock::new();
-    quantum_code.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?, None);
-    quantum_code.append_block(controlled_gate(QuantumGate::PauliX, &[b], a)?, None);
-    quantum_code.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?, None);
+    quantum_code.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?);
+    quantum_code.append_block(controlled_gate(QuantumGate::PauliX, &[b], a)?);
+    quantum_code.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?);
     Ok(quantum_code)
 }
 
@@ -84,9 +84,9 @@ where
 
     let action = action(BasicBlock::new())?;
 
-    quantum_code.append_block(compute, None);
-    quantum_code.append_block(action, None);
-    quantum_code.append_block(uncompute, None);
+    quantum_code.append_block(compute);
+    quantum_code.append_block(action);
+    quantum_code.append_block(uncompute);
 
     Ok(quantum_code)
 }

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/src/mapping/dynamic_look_ahead.rs

@@ -192,8 +192,12 @@ pub(super) fn map(
                 let mut next_state = physical_to_logical.clone();
                 let log_a = next_state.remove(&phys_a);
                 let log_b = next_state.remove(&phys_b);
-                if let Some(la) = log_a { next_state.insert(phys_b, la); }
-                if let Some(lb) = log_b { next_state.insert(phys_a, lb); }
+                if let Some(la) = log_a {
+                    next_state.insert(phys_b, la);
+                }
+                if let Some(lb) = log_b {
+                    next_state.insert(phys_a, lb);
+                }
 
                 if visited_states.contains(&next_state) {
                     total_score - 1000000

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/src/process/mod.rs

@@ -234,7 +234,11 @@ impl Process {
             });
         }
 
-        self.main_block.append_block(block, Some(self.epsilon));
+        self.main_block.append_block_with_epsilon_and_min_index(
+            block,
+            Some(self.epsilon),
+            self.live_pc,
+        );
         Ok(())
     }
 

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/src/qasm/executor.rs

@@ -360,7 +360,7 @@ fn apply_gate_call(
                 } else {
                     let mut inner = BasicBlock::new();
                     append_u3(&mut inner, theta, phi, lambda, q);
-                    block.append_block(inner.control(extra_controls)?, None);
+                    block.append_block(inner.control(extra_controls)?);
                 }
             }
         }
@@ -388,7 +388,7 @@ fn apply_gate_call(
                 };
                 let mut controls: Vec<usize> = extra_controls.to_vec();
                 controls.push(c);
-                block.append_block(controlled_gate(QuantumGate::PauliX, &controls, t)?, None);
+                block.append_block(controlled_gate(QuantumGate::PauliX, &controls, t)?);
             }
         }
 
@@ -522,7 +522,7 @@ fn apply_gate_call_body(
             } else {
                 let mut inner = BasicBlock::new();
                 append_u3(&mut inner, theta, phi, lambda, qubits[0]);
-                block.append_block(inner.control(extra_controls)?, None);
+                block.append_block(inner.control(extra_controls)?);
             }
         }
         "CX" => {
@@ -531,10 +531,7 @@ fn apply_gate_call_body(
             }
             let mut controls: Vec<usize> = extra_controls.to_vec();
             controls.push(qubits[0]);
-            block.append_block(
-                controlled_gate(QuantumGate::PauliX, &controls, qubits[1])?,
-                None,
-            );
+            block.append_block(controlled_gate(QuantumGate::PauliX, &controls, qubits[1])?);
         }
         name if is_qelib1_gate(name) => {
             apply_qelib1_gate_raw(
@@ -816,7 +813,7 @@ fn apply_qelib1_gate_raw(
     } else {
         let mut inner = BasicBlock::new();
         append_qelib1_gate(&mut inner, gate)?;
-        block.append_block(inner.control(extra_controls)?, None);
+        block.append_block(inner.control(extra_controls)?);
     }
     Ok(())
 }

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/src/qasm/gates.rs

@@ -69,7 +69,7 @@ pub fn append_controlled_u3(
     let mut u3_block = BasicBlock::new();
     append_u3(&mut u3_block, theta, phi, lambda, target);
     let controlled = u3_block.control(controls)?;
-    block.append_block(controlled, None);
+    block.append_block(controlled);
     Ok(())
 }
 
@@ -261,101 +261,75 @@ pub fn append_qelib1_gate(block: &mut BasicBlock, gate: Qelib1Gate) -> Result<()
 
         // ── Two-qubit ─────────────────────────────────────────────────────
         Qelib1Gate::Cx { control, target } => {
-            block.append_block(
-                controlled_gate(QuantumGate::PauliX, &[control], target)?,
-                None,
-            );
+            block.append_block(controlled_gate(QuantumGate::PauliX, &[control], target)?);
         }
         Qelib1Gate::Cy { control, target } => {
-            block.append_block(
-                controlled_gate(QuantumGate::PauliY, &[control], target)?,
-                None,
-            );
+            block.append_block(controlled_gate(QuantumGate::PauliY, &[control], target)?);
         }
         Qelib1Gate::Cz { control, target } => {
-            block.append_block(
-                controlled_gate(QuantumGate::PauliZ, &[control], target)?,
-                None,
-            );
+            block.append_block(controlled_gate(QuantumGate::PauliZ, &[control], target)?);
         }
         Qelib1Gate::Ch { control, target } => {
-            block.append_block(
-                controlled_gate(QuantumGate::Hadamard, &[control], target)?,
-                None,
-            );
+            block.append_block(controlled_gate(QuantumGate::Hadamard, &[control], target)?);
         }
         Qelib1Gate::Cs { control, target } => {
-            block.append_block(controlled_gate(QuantumGate::s(), &[control], target)?, None);
+            block.append_block(controlled_gate(QuantumGate::s(), &[control], target)?);
         }
         Qelib1Gate::Csdg { control, target } => {
-            block.append_block(
-                controlled_gate(QuantumGate::sd(), &[control], target)?,
-                None,
-            );
+            block.append_block(controlled_gate(QuantumGate::sd(), &[control], target)?);
         }
         Qelib1Gate::Ct { control, target } => {
-            block.append_block(controlled_gate(QuantumGate::t(), &[control], target)?, None);
+            block.append_block(controlled_gate(QuantumGate::t(), &[control], target)?);
         }
         Qelib1Gate::Ctdg { control, target } => {
-            block.append_block(
-                controlled_gate(QuantumGate::td(), &[control], target)?,
-                None,
-            );
+            block.append_block(controlled_gate(QuantumGate::td(), &[control], target)?);
         }
         Qelib1Gate::Swap { a, b } => {
-            block.append_block(swap_gate(a, b)?, None);
+            block.append_block(swap_gate(a, b)?);
         }
         Qelib1Gate::Crx {
             theta,
             control,
             target,
         } => {
-            block.append_block(
-                controlled_gate(
-                    QuantumGate::RotationX(Param::Value(theta)),
-                    &[control],
-                    target,
-                )?,
-                None,
-            );
+            block.append_block(controlled_gate(
+                QuantumGate::RotationX(Param::Value(theta)),
+                &[control],
+                target,
+            )?);
         }
         Qelib1Gate::Cry {
             theta,
             control,
             target,
         } => {
-            block.append_block(
-                controlled_gate(
-                    QuantumGate::RotationY(Param::Value(theta)),
-                    &[control],
-                    target,
-                )?,
-                None,
-            );
+            block.append_block(controlled_gate(
+                QuantumGate::RotationY(Param::Value(theta)),
+                &[control],
+                target,
+            )?);
         }
         Qelib1Gate::Crz {
             phi,
             control,
             target,
         } => {
-            block.append_block(
-                controlled_gate(
-                    QuantumGate::RotationZ(Param::Value(phi)),
-                    &[control],
-                    target,
-                )?,
-                None,
-            );
+            block.append_block(controlled_gate(
+                QuantumGate::RotationZ(Param::Value(phi)),
+                &[control],
+                target,
+            )?);
         }
         Qelib1Gate::Cu1 {
             lambda,
             control,
             target,
         } => {
-            block.append_block(
-                controlled_gate(QuantumGate::Phase(Param::Value(lambda)), &[control], target)?,
-                None,
-            );
+            block.append_block(controlled_gate(
+                QuantumGate::Phase(Param::Value(lambda)),
+                &[control],
+                target,
+            )?);
         }
         Qelib1Gate::Cu3 {
             theta,
@@ -370,17 +344,14 @@ pub fn append_qelib1_gate(block: &mut BasicBlock, gate: Qelib1Gate) -> Result<()
         // ── Three-qubit ───────────────────────────────────────────────────
         Qelib1Gate::Ccx { c0, c1, target } => {
             // Toffoli = CCX
-            block.append_block(
-                controlled_gate(QuantumGate::PauliX, &[c0, c1], target)?,
-                None,
-            );
+            block.append_block(controlled_gate(QuantumGate::PauliX, &[c0, c1], target)?);
         }
         Qelib1Gate::Cswap { control, a, b } => {
             // Fredkin = controlled SWAP (3 CNOTs controlled)
             let mut cswap_block = BasicBlock::new();
-            cswap_block.append_block(swap_gate(a, b)?, None);
+            cswap_block.append_block(swap_gate(a, b)?);
             let controlled = cswap_block.control(&[control])?;
-            block.append_block(controlled, None);
+            block.append_block(controlled);
         }
 
         // ── Two-qubit parametric (Ising-type) ────────────────────────────
@@ -389,18 +360,18 @@ pub fn append_qelib1_gate(block: &mut BasicBlock, gate: Qelib1Gate) -> Result<()
             // Decomposition: H⊗H → CX(a,b) → Rz(θ) on b → CX(a,b) → H⊗H
             block.append_gate(QuantumGate::Hadamard, a);
             block.append_gate(QuantumGate::Hadamard, b);
-            block.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?, None);
+            block.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?);
             block.append_gate(QuantumGate::RotationZ(Param::Value(theta)), b);
-            block.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?, None);
+            block.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?);
             block.append_gate(QuantumGate::Hadamard, a);
             block.append_gate(QuantumGate::Hadamard, b);
         }
         Qelib1Gate::Rzz { theta, a, b } => {
             // Rzz(θ) = exp(-i θ/2 · Z⊗Z)
             // Decomposition: CX(a,b) → Rz(θ) on b → CX(a,b)
-            block.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?, None);
+            block.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?);
             block.append_gate(QuantumGate::RotationZ(Param::Value(theta)), b);
-            block.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?, None);
+            block.append_block(controlled_gate(QuantumGate::PauliX, &[a], b)?);
         }
     }
 

{ket_lang-0.10.2.dev3 → ket_lang-0.10.3.dev1}/src/ket/clib/libs/libket/src/tests.rs

@@ -605,7 +605,7 @@ mod basic_block_tests {
         a.append_gate(QuantumGate::PauliX, 0);
         let mut b = BasicBlock::new();
         b.append_gate(QuantumGate::PauliX, 0);
-        a.append_block(b, None);
+        a.append_block(b);
         assert_eq!(
             a.gates.len(),
             0,

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

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