WIP: Gates in rust

This compiles but has circular import errors because we need to
use the standard gate classes in Python to map from python to rust.

Fixes: Qiskit#12205

Author: mtreinish

Cargo.lock

@@ -16,6 +16,11 @@ license = "Apache-2.0"
 [workspace.dependencies]
 indexmap.version = "2.2.6"
 hashbrown.version = "0.14.0"
+num-complex = "0.4"
+ndarray = "^0.15.6"
+numpy = "0.21.0"
+smallvec = "1.13"
+
 # Most of the crates don't need the feature `extension-module`, since only `qiskit-pyext` builds an
 # actual C extension (the feature disables linking in `libpython`, which is forbidden in Python
 # distributions).  We only activate that feature when building the C extension module; we still need

Cargo.toml

@@ -11,28 +11,28 @@ doctest = false
 
 [dependencies]
 rayon = "1.10"
-numpy = "0.21.0"
+numpy.workspace = true
 rand = "0.8"
 rand_pcg = "0.3"
 rand_distr = "0.4.3"
 ahash = "0.8.11"
 num-traits = "0.2"
-num-complex = "0.4"
+num-complex.workspace = true
 num-bigint = "0.4"
 rustworkx-core = "0.14"
 faer = "0.18.2"
 qiskit-circuit.workspace = true
 
 [dependencies.smallvec]
-version = "1.13"
+workspace = true
 features = ["union"]
 
 [dependencies.pyo3]
 workspace = true
 features = ["hashbrown", "indexmap", "num-complex", "num-bigint", "smallvec"]
 
 [dependencies.ndarray]
-version = "^0.15.6"
+workspace = true
 features = ["rayon", "approx-0_5"]
 
 [dependencies.approx]

crates/accelerate/Cargo.toml

@@ -141,7 +141,9 @@ impl ZXPaulis {
         phases: &Bound<PyArray1<u8>>,
         coeffs: &Bound<PyArray1<Complex64>>,
     ) -> PyResult<Self> {
-        let &[num_ops, num_qubits] = x.shape() else { unreachable!("PyArray2 must be 2D") };
+        let &[num_ops, num_qubits] = x.shape() else {
+            unreachable!("PyArray2 must be 2D")
+        };
         if z.shape() != [num_ops, num_qubits] {
             return Err(PyValueError::new_err(format!(
                 "'x' and 'z' have different shapes: {:?} and {:?}",

crates/accelerate/src/sparse_pauli_op.rs

@@ -11,4 +11,11 @@ doctest = false
 
 [dependencies]
 hashbrown.workspace = true
-pyo3.workspace = true
+num-complex.workspace = true
+ndarray.workspace = true
+numpy.workspace = true
+smallvec.workspace = true
+
+[dependencies.pyo3]
+workspace = true
+features = ["hashbrown", "indexmap", "num-complex", "num-bigint", "smallvec"]

crates/circuit/Cargo.toml

@@ -13,6 +13,9 @@
 use crate::circuit_instruction::CircuitInstruction;
 use crate::intern_context::{BitType, IndexType, InternContext};
 use crate::SliceOrInt;
+use smallvec::SmallVec;
+
+use crate::operations::{OperationType, Param};
 
 use hashbrown::HashMap;
 use pyo3::exceptions::{PyIndexError, PyKeyError, PyRuntimeError, PyValueError};
@@ -25,11 +28,15 @@ use std::hash::{Hash, Hasher};
 #[derive(Clone, Debug)]
 struct PackedInstruction {
     /// The Python-side operation instance.
-    op: PyObject,
+    op: OperationType,
     /// The index under which the interner has stored `qubits`.
     qubits_id: IndexType,
     /// The index under which the interner has stored `clbits`.
     clbits_id: IndexType,
+    params: Option<SmallVec<[Param; 3]>>,
+    label: Option<String>,
+    duration: Option<PyObject>,
+    unit: Option<String>,
 }
 
 /// Private wrapper for Python-side Bit instances that implements
@@ -324,7 +331,7 @@ impl CircuitData {
             0,
         )?;
         res.intern_context = self.intern_context.clone();
-        res.data = self.data.clone();
+        res.data.clone_from(&self.data);
         Ok(res)
     }
 
@@ -366,7 +373,15 @@ impl CircuitData {
     #[pyo3(signature = (func))]
     pub fn foreach_op(&self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
         for inst in self.data.iter() {
-            func.call1((inst.op.bind(py),))?;
+            match &inst.op {
+                OperationType::Standard(op) => {
+                    let op = op.into_py(py);
+                    func.call1((op,))
+                }
+                OperationType::Instruction(op) => func.call1((op.instruction.clone_ref(py),)),
+                OperationType::Gate(op) => func.call1((op.gate.clone_ref(py),)),
+                OperationType::Operation(op) => func.call1((op.operation.clone_ref(py),)),
+            }?;
         }
         Ok(())
     }
@@ -380,7 +395,15 @@ impl CircuitData {
     #[pyo3(signature = (func))]
     pub fn foreach_op_indexed(&self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
         for (index, inst) in self.data.iter().enumerate() {
-            func.call1((index, inst.op.bind(py)))?;
+            match &inst.op {
+                OperationType::Standard(op) => {
+                    let op = op.into_py(py);
+                    func.call1((index, op))
+                }
+                OperationType::Instruction(op) => func.call1((index, op.instruction.clone_ref(py))),
+                OperationType::Gate(op) => func.call1((index, op.gate.clone_ref(py))),
+                OperationType::Operation(op) => func.call1((index, op.operation.clone_ref(py))),
+            }?;
         }
         Ok(())
     }
@@ -395,7 +418,16 @@ impl CircuitData {
     #[pyo3(signature = (func))]
     pub fn map_ops(&mut self, py: Python<'_>, func: &Bound<PyAny>) -> PyResult<()> {
         for inst in self.data.iter_mut() {
-            inst.op = func.call1((inst.op.bind(py),))?.into_py(py);
+            inst.op = match &inst.op {
+                OperationType::Standard(op) => {
+                    let op = op.into_py(py);
+                    func.call1((op,))
+                }
+                OperationType::Instruction(op) => func.call1((op.instruction.clone_ref(py),)),
+                OperationType::Gate(op) => func.call1((op.gate.clone_ref(py),)),
+                OperationType::Operation(op) => func.call1((op.operation.clone_ref(py),)),
+            }?
+            .extract()?;
         }
         Ok(())
     }
@@ -666,9 +698,13 @@ impl CircuitData {
                     .collect::<PyResult<Vec<BitType>>>()?;
 
                 self.data.push(PackedInstruction {
-                    op: inst.op.clone_ref(py),
+                    op: inst.op.clone(),
                     qubits_id: self.intern_context.intern(qubits)?,
                     clbits_id: self.intern_context.intern(clbits)?,
+                    params: inst.params.clone(),
+                    label: inst.label.clone(),
+                    duration: inst.duration.clone(),
+                    unit: inst.unit.clone(),
                 });
             }
             return Ok(());
@@ -720,7 +756,7 @@ impl CircuitData {
 
     fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
         for packed in self.data.iter() {
-            visit.call(&packed.op)?;
+            visit.call(&packed.duration)?;
         }
         for bit in self.qubits_native.iter().chain(self.clbits_native.iter()) {
             visit.call(bit)?;
@@ -820,17 +856,21 @@ impl CircuitData {
                 self.intern_context.intern(args)
             };
         Ok(PackedInstruction {
-            op: inst.operation.clone_ref(py),
+            op: inst.operation.clone(),
             qubits_id: interned_bits(&self.qubit_indices_native, inst.qubits.bind(py))?,
             clbits_id: interned_bits(&self.clbit_indices_native, inst.clbits.bind(py))?,
+            params: inst.params.clone(),
+            label: inst.label.clone(),
+            duration: inst.duration.clone(),
+            unit: inst.unit.clone(),
         })
     }
 
     fn unpack(&self, py: Python<'_>, inst: &PackedInstruction) -> PyResult<Py<CircuitInstruction>> {
         Py::new(
             py,
             CircuitInstruction {
-                operation: inst.op.clone_ref(py),
+                operation: inst.op.clone(),
                 qubits: PyTuple::new_bound(
                     py,
                     self.intern_context
@@ -849,6 +889,10 @@ impl CircuitData {
                         .collect::<Vec<_>>(),
                 )
                 .unbind(),
+                params: inst.params.clone(),
+                label: inst.label.clone(),
+                duration: inst.duration.clone(),
+                unit: inst.unit.clone(),
             },
         )
     }