Merge branch 'main' into fix_rust_definition

Author: alexanderivrii

Cargo.lock

@@ -15,10 +15,12 @@ license = "Apache-2.0"
 # Each crate can add on specific features freely as it inherits.
 [workspace.dependencies]
 bytemuck = "1.21"
+bitfield-struct = "0.9.3"
 indexmap.version = "2.7.1"
 hashbrown.version = "0.14.5"
 num-bigint = "0.4"
 num-complex = "0.4"
+nalgebra = "0.33"
 ndarray = "0.15"
 numpy = "0.23"
 smallvec = "1.13"

Cargo.toml

@@ -16,8 +16,7 @@ use rustworkx_core::petgraph::stable_graph::NodeIndex;
 
 use qiskit_circuit::circuit_instruction::ExtraInstructionAttributes;
 use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType};
-use qiskit_circuit::imports::BARRIER;
-use qiskit_circuit::operations::{Operation, PyInstruction};
+use qiskit_circuit::operations::{Operation, StandardInstruction};
 use qiskit_circuit::packed_instruction::{PackedInstruction, PackedOperation};
 use qiskit_circuit::Qubit;
 
@@ -65,45 +64,19 @@ pub fn barrier_before_final_measurements(
             res
         })
         .collect();
-    let new_barrier = BARRIER
-        .get_bound(py)
-        .call1((dag.num_qubits(), label.as_deref()))?;
-
-    let new_barrier_py_inst = PyInstruction {
-        qubits: dag.num_qubits() as u32,
-        clbits: 0,
-        params: 0,
-        op_name: "barrier".to_string(),
-        control_flow: false,
-        #[cfg(feature = "cache_pygates")]
-        instruction: new_barrier.clone().unbind(),
-        #[cfg(not(feature = "cache_pygates"))]
-        instruction: new_barrier.unbind(),
-    };
     let qargs: Vec<Qubit> = (0..dag.num_qubits() as u32).map(Qubit).collect();
-    #[cfg(feature = "cache_pygates")]
-    {
-        dag.apply_operation_back(
-            py,
-            PackedOperation::from_instruction(Box::new(new_barrier_py_inst)),
-            qargs.as_slice(),
-            &[],
-            None,
-            ExtraInstructionAttributes::new(label, None, None, None),
-            Some(new_barrier.unbind()),
-        )?;
-    }
-    #[cfg(not(feature = "cache_pygates"))]
-    {
-        dag.apply_operation_back(
-            py,
-            PackedOperation::from_instruction(Box::new(new_barrier_py_inst)),
-            qargs.as_slice(),
-            &[],
-            None,
-            ExtraInstructionAttributes::new(label, None, None, None),
-        )?;
-    }
+    dag.apply_operation_back(
+        py,
+        PackedOperation::from_standard_instruction(StandardInstruction::Barrier(
+            dag.num_qubits() as u32
+        )),
+        qargs.as_slice(),
+        &[],
+        None,
+        ExtraInstructionAttributes::new(label, None, None, None),
+        #[cfg(feature = "cache_pygates")]
+        None,
+    )?;
     for inst in final_packed_ops {
         dag.push_back(py, inst)?;
     }

crates/accelerate/src/barrier_before_final_measurement.rs

@@ -19,8 +19,8 @@ use qiskit_circuit::packed_instruction::PackedOperation;
 use smallvec::{smallvec, SmallVec};
 
 use qiskit_circuit::circuit_data::CircuitData;
-use qiskit_circuit::operations::{Param, PyInstruction};
-use qiskit_circuit::{imports, Clbit, Qubit};
+use qiskit_circuit::operations::{Param, StandardInstruction};
+use qiskit_circuit::{Clbit, Qubit};
 
 use itertools::izip;
 
@@ -193,7 +193,7 @@ pub fn n_local(
 
     // This struct can be used to yield barrier if insert_barriers is true, otherwise
     // it returns an empty iterator. For conveniently injecting barriers in-between operations.
-    let maybe_barrier = MaybeBarrier::new(py, num_qubits, insert_barriers)?;
+    let maybe_barrier = MaybeBarrier::new(num_qubits, insert_barriers)?;
 
     let packed_insts = (0..reps).flat_map(|layer| {
         rotation_layer(
@@ -280,23 +280,14 @@ struct MaybeBarrier {
 }
 
 impl MaybeBarrier {
-    fn new(py: Python, num_qubits: u32, insert_barriers: bool) -> PyResult<Self> {
+    fn new(num_qubits: u32, insert_barriers: bool) -> PyResult<Self> {
         if !insert_barriers {
             Ok(Self { barrier: None })
         } else {
-            let barrier_cls = imports::BARRIER.get_bound(py);
-            let py_barrier = barrier_cls.call1((num_qubits,))?;
-            let py_inst = PyInstruction {
-                qubits: num_qubits,
-                clbits: 0,
-                params: 0,
-                op_name: "barrier".to_string(),
-                control_flow: false,
-                instruction: py_barrier.into(),
-            };
-
             let inst = (
-                py_inst.into(),
+                PackedOperation::from_standard_instruction(StandardInstruction::Barrier(
+                    num_qubits,
+                )),
                 smallvec![],
                 (0..num_qubits).map(Qubit).collect(),
                 vec![] as Vec<Clbit>,

crates/accelerate/src/circuit_library/multi_local.rs

@@ -13,9 +13,10 @@
 use pyo3::prelude::*;
 use pyo3::types::{PyList, PyString, PyTuple};
 use qiskit_circuit::circuit_data::CircuitData;
-use qiskit_circuit::operations::{multiply_param, radd_param, Param, PyInstruction, StandardGate};
+use qiskit_circuit::operations;
+use qiskit_circuit::operations::{multiply_param, radd_param, Param, StandardGate};
 use qiskit_circuit::packed_instruction::PackedOperation;
-use qiskit_circuit::{imports, Clbit, Qubit};
+use qiskit_circuit::{Clbit, Qubit};
 use smallvec::{smallvec, SmallVec};
 
 // custom types for a more readable code
@@ -248,7 +249,14 @@ pub fn py_pauli_evolution(
         indices.push(tuple.get_item(1)?.extract::<Vec<u32>>()?)
     }
 
-    let barrier = get_barrier(py, num_qubits as u32);
+    let barrier = (
+        PackedOperation::from_standard_instruction(operations::StandardInstruction::Barrier(
+            num_qubits as u32,
+        )),
+        smallvec![],
+        (0..num_qubits as u32).map(Qubit).collect(),
+        vec![],
+    );
 
     let evos = paulis.iter().enumerate().zip(indices).zip(times).flat_map(
         |(((i, pauli), qubits), time)| {
@@ -328,24 +336,3 @@ fn cx_fountain(
         )
     }))
 }
-
-fn get_barrier(py: Python, num_qubits: u32) -> Instruction {
-    let barrier_cls = imports::BARRIER.get_bound(py);
-    let barrier = barrier_cls
-        .call1((num_qubits,))
-        .expect("Could not create Barrier Python-side");
-    let barrier_inst = PyInstruction {
-        qubits: num_qubits,
-        clbits: 0,
-        params: 0,
-        op_name: "barrier".to_string(),
-        control_flow: false,
-        instruction: barrier.into(),
-    };
-    (
-        barrier_inst.into(),
-        smallvec![],
-        (0..num_qubits).map(Qubit).collect(),
-        vec![],
-    )
-}

crates/accelerate/src/circuit_library/pauli_evolution.rs

@@ -14,9 +14,9 @@ use pyo3::prelude::*;
 use pyo3::types::PySequence;
 use pyo3::types::PyString;
 use qiskit_circuit::circuit_data::CircuitData;
-use qiskit_circuit::imports;
-use qiskit_circuit::operations::PyInstruction;
-use qiskit_circuit::operations::{add_param, multiply_param, multiply_params, Param, StandardGate};
+use qiskit_circuit::operations::{
+    add_param, multiply_param, multiply_params, Param, StandardGate, StandardInstruction,
+};
 use qiskit_circuit::packed_instruction::PackedOperation;
 use qiskit_circuit::{Clbit, Qubit};
 use smallvec::{smallvec, SmallVec};
@@ -78,7 +78,14 @@ pub fn pauli_feature_map(
 
     // construct a Barrier object Python side to (possibly) add to the circuit
     let packed_barrier = if insert_barriers {
-        Some(_get_barrier(py, feature_dimension)?)
+        Some((
+            PackedOperation::from_standard_instruction(StandardInstruction::Barrier(
+                feature_dimension,
+            )),
+            smallvec![],
+            (0..feature_dimension).map(Qubit).collect(),
+            vec![] as Vec<Clbit>,
+        ))
     } else {
         None
     };
@@ -244,23 +251,3 @@ fn _get_paulis(
         },
     )
 }
-
-/// Get a barrier object from Python space.
-fn _get_barrier(py: Python, feature_dimension: u32) -> PyResult<Instruction> {
-    let barrier_cls = imports::BARRIER.get_bound(py);
-    let barrier = barrier_cls.call1((feature_dimension,))?;
-    let barrier_inst = PyInstruction {
-        qubits: feature_dimension,
-        clbits: 0,
-        params: 0,
-        op_name: "barrier".to_string(),
-        control_flow: false,
-        instruction: barrier.into(),
-    };
-    Ok((
-        barrier_inst.into(),
-        smallvec![],
-        (0..feature_dimension).map(Qubit).collect(),
-        vec![] as Vec<Clbit>,
-    ))
-}