feat(pytket encoding): Support prelude barriers (#919)

Author: aborgna-q

tket2/src/serialize/pytket/decoder/op.rs

@@ -36,7 +36,9 @@ impl Tk1Op {
         num_qubits: usize,
         num_bits: usize,
     ) -> Self {
-        let op = if let Some(native) = NativeOp::try_from_serial_optype(serial_op.op_type.clone()) {
+        let op = if let Some(native) =
+            NativeOp::try_from_serial_optype(serial_op.op_type.clone(), num_qubits, num_bits)
+        {
             Tk1Op::Native(native)
         } else {
             Tk1Op::Opaque(OpaqueTk1Op::new_from_op(serial_op, num_qubits, num_bits))

tket2/src/serialize/pytket/decoder/op/tk2op.rs

@@ -9,6 +9,7 @@ use hugr::std_extensions::arithmetic::float_types::float64_type;
 use hugr::types::Signature;
 
 use hugr::IncomingPort;
+use itertools::Itertools;
 use tket_json_rs::optype::OpType as Tk1OpType;
 
 use crate::extension::rotation::rotation_type;
@@ -51,7 +52,11 @@ impl NativeOp {
     }
 
     /// Returns the translated tket2 optype for this operation, if it exists.
-    pub fn try_from_serial_optype(serial_op: Tk1OpType) -> Option<Self> {
+    pub fn try_from_serial_optype(
+        serial_op: Tk1OpType,
+        num_qubits: usize,
+        num_bits: usize,
+    ) -> Option<Self> {
         let op = match serial_op {
             Tk1OpType::H => Tk2Op::H.into(),
             Tk1OpType::CX => Tk2Op::CX.into(),
@@ -74,6 +79,12 @@ impl NativeOp {
             Tk1OpType::Reset => Tk2Op::Reset.into(),
             Tk1OpType::Measure => Tk2Op::Measure.into(),
             Tk1OpType::noop => Noop::new(qb_t()).into(),
+            Tk1OpType::Barrier => {
+                let qbs = std::iter::repeat_n(qb_t(), num_qubits);
+                let bs = std::iter::repeat_n(bool_t(), num_bits);
+                let types = qbs.chain(bs).collect_vec();
+                hugr::extension::prelude::Barrier::new(types).into()
+            }
             _ => {
                 return None;
             }

tket2/src/serialize/pytket/extension/prelude.rs

@@ -4,12 +4,13 @@ use super::PytketEmitter;
 use crate::serialize::pytket::encoder::{EncodeStatus, RegisterCount, Tk1EncoderContext};
 use crate::serialize::pytket::Tk1ConvertError;
 use crate::Circuit;
-use hugr::extension::prelude::{TupleOpDef, PRELUDE_ID};
+use hugr::extension::prelude::{BarrierDef, TupleOpDef, PRELUDE_ID};
 use hugr::extension::simple_op::MakeExtensionOp;
 use hugr::extension::ExtensionId;
 use hugr::ops::ExtensionOp;
 use hugr::types::TypeArg;
 use hugr::HugrView;
+use tket_json_rs::optype::OpType as Tk1OpType;
 
 /// Encoder for [prelude](hugr::extension::prelude) operations.
 #[derive(Debug, Clone, Default)]
@@ -30,6 +31,10 @@ impl<H: HugrView> PytketEmitter<H> for PreludeEmitter {
         if let Ok(tuple_op) = TupleOpDef::from_extension_op(op) {
             return self.tuple_op_to_pytket(node, op, &tuple_op, circ, encoder);
         };
+        if let Ok(_barrier) = BarrierDef::from_extension_op(op) {
+            encoder.emit_node(Tk1OpType::Barrier, node, circ)?;
+            return Ok(EncodeStatus::Success);
+        };
         Ok(EncodeStatus::Unsupported)
     }
 

tket2/src/serialize/pytket/tests.rs

@@ -74,6 +74,20 @@ const PARAMETERIZED: &str = r#"{
         "implicit_permutation": [[["q", [0]], ["q", [0]]], [["q", [1]], ["q", [1]]]]
     }"#;
 
+const BARRIER: &str = r#"{
+        "phase": "0.0",
+        "bits": [["c", [0]], ["c", [1]]],
+        "qubits": [["q", [0]], ["q", [1]], ["q", [2]]],
+        "commands": [
+            {"args": [["q", [0]], ["q", [1]]], "op": {"type": "CX"}},
+            {"args": [["q", [1]], ["q", [2]]], "op": {"type": "Barrier"}},
+            {"args": [["q", [2]], ["c", [1]]], "op": {"type": "Measure"}}
+        ],
+        "created_qubits": [],
+        "discarded_qubits": [],
+        "implicit_permutation": [[["q", [0]], ["q", [0]]], [["q", [1]], ["q", [1]]], [["q", [2]], ["q", [2]]]]
+    }"#;
+
 /// Check some properties of the serial circuit.
 fn validate_serial_circ(circ: &SerialCircuit) {
     // Check that all commands have valid arguments.
@@ -357,6 +371,7 @@ fn circ_complex_angle_computation() -> (Circuit, String) {
 #[case::simple(MULTI_REGISTER, 2, 3)]
 #[case::unknown_op(UNKNOWN_OP, 2, 3)]
 #[case::parametrized(PARAMETERIZED, 4, 2)]
+#[case::barrier(BARRIER, 3, 3)]
 fn json_roundtrip(#[case] circ_s: &str, #[case] num_commands: usize, #[case] num_qubits: usize) {
     let ser: circuit_json::SerialCircuit = serde_json::from_str(circ_s).unwrap();
     assert_eq!(ser.commands.len(), num_commands);