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

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

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

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

{ket_lang-0.10.3.dev1 → ket_lang-0.10.4.dev1}/src/ket/amazon.py

@@ -204,15 +204,25 @@ class AmazonBraket(BatchExecution):  # pylint: disable=too-many-instance-attribu
         for gate_inst in gates:
             gate = gate_inst["gate"]
             target = gate_inst["target"]
-            decomposed = gate_inst["decomposed"]
+            controls = gate_inst.get("control", [])
+            decomposed = gate_inst.get("decomposed")
+
+            if len(controls) == 1:
+                control = controls[0]
+                if gate == "PauliX":
+                    circuit.cnot(control, target)
+                    continue
+                if isinstance(gate, dict) and "Phase" in gate:
+                    circuit.cphaseshift(control, target, gate["Phase"]["Value"])
+                    continue
 
             if decomposed is not None:
-                for gate in decomposed:
-                    match gate:
+                for dec_gate in decomposed:
+                    match dec_gate:
                         case {"CNOT": (control, target)}:
                             circuit.cnot(control, target)
-                        case {"U": (gate, target)}:
-                            self._call_gate(circuit, gate, target)
+                        case {"U": (u_gate, target)}:
+                            self._call_gate(circuit, u_gate, target)
             else:
                 self._call_gate(circuit, gate, target)
 

{ket_lang-0.10.3.dev1 → ket_lang-0.10.4.dev1}/src/ket/clib/libket/__init__.py

@@ -311,6 +311,7 @@ api_argtypes = {
     "ket_block_set_as_permutation": ([c_void_p], []),
     "ket_process_set_parameter": ([c_void_p, c_double], [c_size_t]),
     "ket_parse_openqasm": ([POINTER(c_size_t), c_size_t, c_char_p], [c_void_p]),
+    "ket_qft": ([POINTER(c_size_t), c_size_t, c_bool], [c_void_p]),
 }
 
 

{ket_lang-0.10.3.dev1 → ket_lang-0.10.4.dev1}/src/ket/clib/libs/libket/.gitlab-ci.yml

@@ -83,7 +83,7 @@ linux-build:
         - target/CACHEDIR.TAG
       policy: pull-push
   script:
-    - cargo build -F c_api --release
+    - cargo build --release
   artifacts:
     paths:
       - target/release/libket.so
@@ -107,7 +107,7 @@ windows-build:
         - target/CACHEDIR.TAG
       policy: pull-push
   script:
-    - cargo build -F c_api --release --target x86_64-pc-windows-gnu
+    - cargo build --release --target x86_64-pc-windows-gnu
   artifacts:
     paths:
       - target/x86_64-pc-windows-gnu/release/ket.dll

{ket_lang-0.10.3.dev1 → ket_lang-0.10.4.dev1}/src/ket/clib/libs/libket/Cargo.toml

@@ -25,7 +25,8 @@ thiserror = "2.0.19"
 itertools = "0.15.0"
 rand = "0.10.2"
 rayon = "1.5.3"
-build-info = { version = "0.0.45", default-features = false, features = [], optional = true }
+build-info = { version = "0.0.45", default-features = false, features = [
+], optional = true }
 
 [build-dependencies]
 lalrpop = { version = "0.23.1", optional = true }
@@ -39,6 +40,6 @@ crate-type = ["cdylib", "rlib"]
 strip = true
 
 [features]
-default = ["qasm"]
+default = ["qasm", "c_api"]
 c_api = ["build-info"]
 qasm = ["dep:lalrpop-util", "dep:lalrpop"]

ket_lang-0.10.4.dev1/src/ket/clib/libs/libket/examples/grover.rs

@@ -0,0 +1,73 @@
+// SPDX-FileCopyrightText: 2024 Evandro Chagas Ribeiro da Rosa <evandro@quantuloop.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+use std::f64::consts::FRAC_PI_4;
+
+use ket::{
+    compute_action_uncompute_gate,
+    error::KetError,
+    ir::{block::BasicBlock, gate::QuantumGate},
+    process::{Process, QPUConfig},
+};
+
+fn main() -> Result<(), KetError> {
+    let num_qubits = 3;
+
+    let mut process = Process::new(QPUConfig {
+        num_qubits,
+        quantum_execution: None,
+    });
+
+    let qubits: Result<Vec<_>, _> = (0..num_qubits).map(|_| process.alloc()).collect();
+    let qubits = qubits?;
+
+    let mut quantum_code = BasicBlock::new();
+
+    for target in &qubits {
+        quantum_code.append_gate(QuantumGate::Hadamard, *target);
+    }
+
+    process.append_block(quantum_code.into())?;
+
+    let steps = ((FRAC_PI_4) * f64::sqrt((1 << num_qubits) as f64)) as i64;
+
+    for _ in 0..steps {
+        process.append_block(
+            compute_action_uncompute_gate(
+                |mut compute| {
+                    for target in &qubits {
+                        compute.append_gate(QuantumGate::PauliX, *target);
+                    }
+                    Ok(compute)
+                },
+                |mut action| {
+                    action.append_gate(QuantumGate::PauliZ, qubits[0]);
+                    Ok(action.control(&qubits[1..])?)
+                },
+            )?
+            .into(),
+        )?;
+
+        process.append_block(
+            compute_action_uncompute_gate(
+                |mut compute| {
+                    for target in &qubits {
+                        compute.append_gate(QuantumGate::Hadamard, *target);
+                        compute.append_gate(QuantumGate::PauliX, *target);
+                    }
+                    Ok(compute)
+                },
+                |mut action| {
+                    action.append_gate(QuantumGate::PauliZ, qubits[0]);
+                    Ok(action.control(&qubits[1..])?)
+                },
+            )?
+            .into(),
+        )?;
+    }
+
+    println!("{:#?}", process);
+
+    Ok(())
+}

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

@@ -54,7 +54,7 @@ fn main() -> Result<(), KetError> {
     let qubits: Result<Vec<_>, _> = (0..num_qubits).map(|_| process.alloc()).collect();
     let qubits = qubits?;
 
-    process.append_block(qft(&qubits, true)?)?;
+    process.append_block(qft(&qubits, true)?.into())?;
 
     println!("{:#?}", process);
 

{ket_lang-0.10.3.dev1 → ket_lang-0.10.4.dev1}/src/ket/clib/libs/libket/libket.h

@@ -711,6 +711,26 @@ int32_t ket_parse_openqasm(const uintptr_t *qubits,
                            struct BasicBlock **block_out);
 #endif
 
+/**
+ * Creates a BasicBlock that implements the Quantum Fourier Transform (QFT) on the given qubits.
+ *
+ * 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. The MSQ should be at index 0.
+ * - `qubits_len` : Number of entries in `qubits`.
+ * - `do_swap`    : Boolean flag indicating whether to add SWAP gates at the end of the circuit to reverse the qubit order.
+ * - `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_qft(const uintptr_t *qubits,
+                uintptr_t qubits_len,
+                bool do_swap,
+                struct BasicBlock **block_out);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

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

@@ -11,19 +11,19 @@ use std::ffi::{c_char, CString};
 use crate::{
     c_api::c_ok,
     error::KetError,
-    ir::{block::BasicBlock, gate::QuantumGate},
+    ir::{block::Block, gate::QuantumGate},
 };
 
 /// Allocates a new, empty [`BasicBlock`] and writes its pointer to `block`.
 #[no_mangle]
-pub extern "C" fn ket_block_new(block: &mut *mut BasicBlock) -> i32 {
-    *block = Box::into_raw(Box::new(BasicBlock::new()));
+pub extern "C" fn ket_block_new(block: &mut *mut Block) -> i32 {
+    *block = Box::into_raw(Box::new(Block::new()));
     c_ok()
 }
 
 /// Deallocates the memory associated with a [`BasicBlock`].
 #[no_mangle]
-pub extern "C" fn ket_block_delete(block: *mut BasicBlock) -> i32 {
+pub extern "C" fn ket_block_delete(block: *mut Block) -> i32 {
     let _ = unsafe { *Box::from_raw(block) };
     c_ok()
 }
@@ -31,7 +31,7 @@ pub extern "C" fn ket_block_delete(block: *mut BasicBlock) -> i32 {
 /// Appends a new quantum gate (provided as a JSON payload) to a [`BasicBlock`].
 #[no_mangle]
 pub extern "C" fn ket_block_append_gate(
-    block: &mut BasicBlock,
+    block: &mut Block,
     gate_json: *const c_char,
     target: usize,
 ) -> i32 {
@@ -42,10 +42,7 @@ pub extern "C" fn ket_block_append_gate(
 
 /// Creates a new [`BasicBlock`] that is the adjoint (inverse) of the provided block.
 #[no_mangle]
-pub extern "C" fn ket_block_inverse(
-    block: &BasicBlock,
-    inverted_block: &mut *mut BasicBlock,
-) -> i32 {
+pub extern "C" fn ket_block_inverse(block: &Block, inverted_block: &mut *mut Block) -> i32 {
     *inverted_block = Box::into_raw(Box::new(block.inverse()));
     c_ok()
 }
@@ -53,10 +50,10 @@ pub extern "C" fn ket_block_inverse(
 /// Creates a new [`BasicBlock`] resulting from adding control qubits to all gates in the block.
 #[no_mangle]
 pub extern "C" fn ket_block_control(
-    block: &BasicBlock,
+    block: &Block,
     control_qubits: *const usize,
     control_qubits_len: usize,
-    controlled_block: &mut *mut BasicBlock,
+    controlled_block: &mut *mut Block,
 ) -> i32 {
     let qubits = unsafe { std::slice::from_raw_parts(control_qubits, control_qubits_len) };
     match block.control(qubits) {
@@ -70,21 +67,21 @@ pub extern "C" fn ket_block_control(
 
 /// Enables approximate decomposition strategies for all gates in the given [`BasicBlock`].
 #[no_mangle]
-pub extern "C" fn ket_block_enable_approximated_decomposition(block: &mut BasicBlock) -> i32 {
+pub extern "C" fn ket_block_enable_approximated_decomposition(block: &mut Block) -> i32 {
     block.enable_approximated_decomposition();
     c_ok()
 }
 
 /// Locks the control qubits of all gates in the given [`BasicBlock`], preventing further additions.
 #[no_mangle]
-pub extern "C" fn ket_block_lock_control(block: &mut BasicBlock) -> i32 {
+pub extern "C" fn ket_block_lock_control(block: &mut Block) -> i32 {
     block.lock_control();
     c_ok()
 }
 
 /// Appends the contents of `other` block to `block` and consumes `other`.
 #[no_mangle]
-pub extern "C" fn ket_block_append_block(block: &mut BasicBlock, other: *mut BasicBlock) -> i32 {
+pub extern "C" fn ket_block_append_block(block: &mut Block, other: *mut Block) -> i32 {
     let other = unsafe { Box::from_raw(other) };
     block.append_block(*other);
     c_ok()
@@ -92,7 +89,7 @@ pub extern "C" fn ket_block_append_block(block: &mut BasicBlock, other: *mut Bas
 
 /// Adds a global phase to the [`BasicBlock`].
 #[no_mangle]
-pub extern "C" fn ket_block_add_global_phase(block: &mut BasicBlock, phase: f64) -> i32 {
+pub extern "C" fn ket_block_add_global_phase(block: &mut Block, phase: f64) -> i32 {
     block.add_global_phase(phase);
     c_ok()
 }
@@ -100,17 +97,17 @@ pub extern "C" fn ket_block_add_global_phase(block: &mut BasicBlock, phase: f64)
 /// Serializes the properties of the [`BasicBlock`] into a JSON payload and writes it to the buffer.
 #[no_mangle]
 pub extern "C" fn ket_block_proprieties_json(
-    block: &BasicBlock,
+    block: &Block,
     proprieties: &mut *const c_char,
 ) -> i32 {
-    *proprieties = to_json!(&block.qubits_op).into_raw();
+    *proprieties = to_json!(&block.flatten().unwrap().qubits_op).into_raw();
 
     c_ok()
 }
 
 /// Marks the [`BasicBlock`] as implementing a diagonal gate.
 #[no_mangle]
-pub extern "C" fn ket_block_set_as_diagonal(block: &mut BasicBlock) -> i32 {
+pub extern "C" fn ket_block_set_as_diagonal(block: &mut Block) -> i32 {
     block.set_as_diagonal();
 
     c_ok()
@@ -118,7 +115,7 @@ pub extern "C" fn ket_block_set_as_diagonal(block: &mut BasicBlock) -> i32 {
 
 /// Marks the [`BasicBlock`] as implementing a permutation gate.
 #[no_mangle]
-pub extern "C" fn ket_block_set_as_permutation(block: &mut BasicBlock) -> i32 {
+pub extern "C" fn ket_block_set_as_permutation(block: &mut Block) -> i32 {
     block.set_as_permutation();
 
     c_ok()

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

@@ -11,7 +11,7 @@ use std::ffi::{c_char, CStr, CString};
 use crate::{
     c_api::{c_error, c_ok},
     error::KetError,
-    ir::{block::BasicBlock, gate::Param, hamiltonian::Hamiltonian},
+    ir::{block::Block, gate::Param, hamiltonian::Hamiltonian},
     process::{Process, ProcessState, QPUConfig},
 };
 
@@ -92,7 +92,7 @@ pub extern "C" fn ket_process_alloc(process: &mut Process, qubit: &mut usize) ->
     c_ok()
 }
 
-/// Appends a [`BasicBlock`] of gates to the process.
+/// Appends a [`Block`] of gates to the process.
 ///
 /// The `block` is **consumed** by this call and must not be used afterwards.
 /// Returns an error if the process state does not allow gate appending
@@ -107,7 +107,7 @@ pub extern "C" fn ket_process_alloc(process: &mut Process, qubit: &mut usize) ->
 /// `0` on success, non-zero error code on failure (including
 /// `GateAppendForbidden` and `QubitIndexOutOfRange`).
 #[no_mangle]
-pub extern "C" fn ket_process_append_block(process: &mut Process, block: *mut BasicBlock) -> i32 {
+pub extern "C" fn ket_process_append_block(process: &mut Process, block: *mut Block) -> i32 {
     let block = unsafe { *Box::from_raw(block) };
     c_error(process.append_block(block))
 }
@@ -127,7 +127,7 @@ pub extern "C" fn ket_process_append_block(process: &mut Process, block: *mut Ba
 /// `0` on success, non-zero error code on failure.
 #[no_mangle]
 pub extern "C" fn ket_process_gates_json(process: &Process, block: &mut *mut c_char) -> i32 {
-    *block = to_json!(&process.main_block().gates).into_raw();
+    *block = to_json!(&process.main_block().flatten().unwrap().gates).into_raw();
     c_ok()
 }
 
@@ -449,7 +449,7 @@ pub extern "C" fn ket_process_set_parameter(
 }
 
 /// Parses an `OpenQASM` 2.0 source string and returns a heap-allocated
-/// [`BasicBlock`] containing the resulting gate sequence.
+/// [`Block`] 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
@@ -459,7 +459,7 @@ pub extern "C" fn ket_process_set_parameter(
 /// 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`.
+/// On success, a newly heap-allocated `Block` is written to `*block_out`.
 /// The caller takes ownership and must eventually free it with
 /// [`ket_block_delete`].
 ///
@@ -467,7 +467,7 @@ pub extern "C" fn ket_process_set_parameter(
 /// - `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`.
+/// - `block_out`  : Output: on success, set to a pointer to the new `Block`.
 ///
 /// # Returns
 /// `0` on success, non-zero error code on failure.
@@ -477,7 +477,7 @@ pub unsafe extern "C" fn ket_parse_openqasm(
     qubits: *const usize,
     qubits_len: usize,
     qasm: *const c_char,
-    block_out: &mut *mut crate::ir::block::BasicBlock,
+    block_out: &mut *mut Block,
 ) -> i32 {
     if qasm.is_null() || (qubits_len > 0 && qubits.is_null()) {
         return KetError::OpenQasmParseError.error_code();
@@ -495,10 +495,39 @@ pub unsafe extern "C" fn ket_parse_openqasm(
     };
 
     match crate::qasm::parse_openqasm(qubit_slice, qasm_str) {
-        Ok(block) => {
+        Ok(bb) => {
+            let mut block = Block::new();
+            block.append_basic_block(bb);
             *block_out = Box::into_raw(Box::new(block));
             c_ok()
         }
         Err(e) => e.error_code(),
     }
 }
+
+/// Creates a BasicBlock that implements the Quantum Fourier Transform (QFT) on the given qubits.
+///
+/// On success, a newly heap-allocated `Block` 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. The MSQ should be at index 0.
+/// - `qubits_len` : Number of entries in `qubits`.
+/// - `do_swap`    : Boolean flag indicating whether to add SWAP gates at the end of the circuit to reverse the qubit order.
+/// - `block_out`  : Output: on success, set to a pointer to the new `Block`.
+///
+/// # Returns
+/// `0` on success, non-zero error code on failure.
+#[no_mangle]
+pub unsafe extern "C" fn ket_qft(
+    qubits: *const usize,
+    qubits_len: usize,
+    do_swap: bool,
+    block_out: &mut *mut Block,
+) -> i32 {
+    let qubits = unsafe { std::slice::from_raw_parts(qubits, qubits_len) };
+
+    *block_out = Box::into_raw(Box::new(c_error!(crate::qft(qubits, do_swap))));
+
+    c_ok()
+}

{ket_lang-0.10.3.dev1 → ket_lang-0.10.4.dev1}/src/ket/clib/libs/libket/src/error.rs

@@ -179,6 +179,9 @@ pub enum KetError {
     )]
     DumpUnavailableInBatch,
 
+    #[error("unknown macro")]
+    UnknownMacro,
+
     /// `execute` was called on a process that has no pending measurement or
     /// expectation-value request.
     ///
@@ -355,6 +358,7 @@ impl KetError {
             Self::SamplingUnavailable => 8,
             Self::ExpectationValueUnavailable => 9,
             Self::DumpUnavailableInBatch => 10,
+            Self::UnknownMacro => 24,
             Self::NoPendingMeasurement => 11,
             Self::ExplicitExecuteInLiveMode => 12,
             Self::ExecutionFailed => 13,
@@ -397,6 +401,7 @@ impl KetError {
             8 => Self::SamplingUnavailable,
             9 => Self::ExpectationValueUnavailable,
             10 => Self::DumpUnavailableInBatch,
+            24 => Self::UnknownMacro,
             11 => Self::NoPendingMeasurement,
             12 => Self::ExplicitExecuteInLiveMode,
             13 => Self::ExecutionFailed,
@@ -438,6 +443,7 @@ mod tests {
             KetError::SamplingUnavailable,
             KetError::ExpectationValueUnavailable,
             KetError::DumpUnavailableInBatch,
+            KetError::UnknownMacro,
             KetError::NoPendingMeasurement,
             KetError::ExplicitExecuteInLiveMode,
             KetError::ExecutionFailed,
@@ -474,6 +480,7 @@ mod tests {
             KetError::SamplingUnavailable,
             KetError::ExpectationValueUnavailable,
             KetError::DumpUnavailableInBatch,
+            KetError::UnknownMacro,
             KetError::NoPendingMeasurement,
             KetError::ExplicitExecuteInLiveMode,
             KetError::ExpValueNotSupported,