Add Custom Gates/Instructions in Rust

crates/cext/src/circuit.rs

@@ -851,9 +851,10 @@ pub unsafe extern "C" fn qk_circuit_instruction_kind(
         OperationRef::PauliProductMeasurement(_) => COperationKind::PauliProductMeasurement,
         OperationRef::PauliProductRotation(_) => COperationKind::PauliProductRotation,
         OperationRef::ControlFlow(_) => COperationKind::ControlFlow,
-        OperationRef::Gate(_) | OperationRef::Instruction(_) | OperationRef::Operation(_) => {
-            COperationKind::Unknown
-        }
+        OperationRef::Gate(_)
+        | OperationRef::Instruction(_)
+        | OperationRef::Operation(_)
+        | OperationRef::CustomOperation(_) => COperationKind::Unknown,
     }
 }
 

crates/cext/src/dag.rs

@@ -1021,9 +1021,10 @@ pub unsafe extern "C" fn qk_dag_op_node_kind(dag: *const DAGCircuit, node: u32)
         OperationRef::PauliProductMeasurement(_) => COperationKind::PauliProductMeasurement,
         OperationRef::PauliProductRotation(_) => COperationKind::PauliProductRotation,
         OperationRef::ControlFlow(_) => COperationKind::ControlFlow,
-        OperationRef::Gate(_) | OperationRef::Instruction(_) | OperationRef::Operation(_) => {
-            COperationKind::Unknown
-        }
+        OperationRef::Gate(_)
+        | OperationRef::Instruction(_)
+        | OperationRef::Operation(_)
+        | OperationRef::CustomOperation(_) => COperationKind::Unknown,
     }
 }
 

crates/circuit/src/circuit_data.rs

@@ -31,8 +31,8 @@ use crate::instruction::Parameters;
 use crate::interner::{Interned, InternedMap, Interner};
 use crate::object_registry::{self, ObjectRegistry};
 use crate::operations::{
-    ControlFlow, ControlFlowView, Operation, OperationRef, Param, PauliBased, PyOperationTypes,
-    PythonOperation, StandardGate,
+    ControlFlow, ControlFlowView, CustomOp, CustomOperation, Operation, OperationRef, Param,
+    PauliBased, PyOperationTypes, PythonOperation, StandardGate,
 };
 use crate::packed_instruction::{PackedInstruction, PackedOperation};
 use crate::parameter::parameter_expression::{ParameterError, ParameterExpression};
@@ -1053,6 +1053,25 @@ impl CircuitData {
         ))
     }
 
+    /// Appends a custom operation to this instance of [CircuitData].
+    pub fn push_custom_operation<O>(
+        &mut self,
+        operation: O,
+        params: &[Param],
+        qargs: &[Qubit],
+        cargs: &[Clbit],
+    ) -> Result<(), CircuitDataError>
+    where
+        O: CustomOperation,
+    {
+        let params = (!params.is_empty()).then(|| Box::new(params.iter().cloned().collect()));
+        let qubits = self.qargs_interner.insert(qargs);
+        let clbits = self.cargs_interner.insert(cargs);
+        self.push(PackedInstruction::from_custom_operation(
+            operation, qubits, clbits, params,
+        ))
+    }
+
     /// Append a packed operation to this CircuitData.
     ///
     /// If a [ControlFlow] operation is provided, the blocks given in
@@ -3078,6 +3097,9 @@ impl PyCircuitData {
                     OperationRef::PauliProductRotation(ppr) => {
                         PauliBased::PauliProductRotation(ppr.clone()).into()
                     }
+                    OperationRef::CustomOperation(custom_operation) => {
+                        CustomOp::from(custom_operation.clone_dyn()).into()
+                    }
                 };
                 res.data.push(PackedInstruction {
                     op: new_op,
@@ -3109,6 +3131,9 @@ impl PyCircuitData {
                     OperationRef::PauliProductRotation(ppr) => {
                         PauliBased::PauliProductRotation(ppr.clone()).into()
                     }
+                    OperationRef::CustomOperation(custom_operation) => {
+                        CustomOp::from(custom_operation.clone_dyn()).into()
+                    }
                 };
                 res.data.push(PackedInstruction {
                     op: new_op,
@@ -4000,6 +4025,7 @@ impl PyCircuitData {
                 OperationRef::Operation(op) => {
                     PyOperationTypes::Operation(op.py_deepcopy(py, None)?).into()
                 }
+                OperationRef::CustomOperation(custom) => CustomOp::from(custom.clone_dyn()).into(),
             };
             out.push(PackedInstruction { op, ..inst.clone() })?;
         }

crates/circuit/src/circuit_instruction.rs

@@ -1032,7 +1032,10 @@ pub fn extract_params<T: CircuitBlock>(
             }
         }
         OperationRef::Unitary(_) | OperationRef::PauliProductMeasurement(_) => None,
-        OperationRef::Gate(_) | OperationRef::Instruction(_) | OperationRef::Operation(_) => {
+        OperationRef::CustomOperation(_)
+        | OperationRef::Gate(_)
+        | OperationRef::Instruction(_)
+        | OperationRef::Operation(_) => {
             let params: SmallVec<[Param; 3]> = params.extract()?;
             (!params.is_empty()).then(|| Parameters::Params(params))
         }

crates/circuit/src/dag_circuit.rs

@@ -7891,6 +7891,7 @@ impl DAGCircuit {
                         OperationRef::StandardGate(gate) => gate.into(),
                         OperationRef::StandardInstruction(instruction) => instruction.into(),
                         OperationRef::Unitary(unitary) => unitary.clone().into(),
+                        OperationRef::CustomOperation(_) => instr.op.clone(),
                         OperationRef::PauliProductMeasurement(ppm) => {
                             PauliBased::PauliProductMeasurement(ppm.clone()).into()
                         }

crates/circuit/src/dag_node.rs

@@ -269,6 +269,7 @@ impl DAGOpNode {
                 OperationRef::StandardGate(gate) => gate.into(),
                 OperationRef::StandardInstruction(instruction) => instruction.into(),
                 OperationRef::Unitary(unitary) => unitary.clone().into(),
+                OperationRef::CustomOperation(_) => instruction.operation.clone(),
                 OperationRef::PauliProductMeasurement(ppm) => {
                     PauliBased::PauliProductMeasurement(ppm.clone()).into()
                 }
@@ -327,6 +328,7 @@ impl DAGOpNode {
                     OperationRef::StandardGate(gate) => gate.into(),
                     OperationRef::StandardInstruction(instruction) => instruction.into(),
                     OperationRef::Unitary(unitary) => unitary.clone().into(),
+                    OperationRef::CustomOperation(_) => self.instruction.operation.clone(),
                     OperationRef::PauliProductMeasurement(ppm) => {
                         PauliBased::PauliProductMeasurement(ppm.clone()).into()
                     }

crates/circuit/src/instruction.rs

@@ -191,5 +191,8 @@ pub fn create_py_op(
         OperationRef::Instruction(instruction) => Ok(instruction.instruction.clone_ref(py)),
         OperationRef::Operation(operation) => Ok(operation.instruction.clone_ref(py)),
         OperationRef::Unitary(unitary) => unitary.create_py_op(py, label),
+        OperationRef::CustomOperation(custom_gate) => custom_gate
+            .create_py_op(py, params.map(|p| p.unwrap_params()))
+            .map(|op| op.unbind()),
     }
 }