fix: Encoding of opaque subgraphs with no associated qubit/bit

Cargo.toml

@@ -70,7 +70,7 @@ clap = "4.5.53"
 crossbeam-channel = "0.5.15"
 csv = "1.4.0"
 delegate = "0.13.5"
-derive_more = "2.0.1"
+derive_more = "2.1.0"
 fxhash = "0.2.1"
 indexmap = "2.12.1"
 lazy_static = "1.5.0"

tket/src/serialize/pytket/circuit.rs

@@ -75,20 +75,28 @@ pub(super) struct EncodedCircuitInfo {
 /// pytket circuit, as they cannot be attached to a pytket command.
 #[derive(Debug, Clone)]
 pub(super) struct AdditionalNodesAndWires {
-    /// A subgraph of the region that does not contain any operation encodable
-    /// as a pytket command, and has no qubit/bits in its boundary that could be
-    /// used to emit an opaque barrier command in the [`serial_circuit`].
-    pub extra_subgraph: Option<SubgraphId>,
-    /// Parameter expression inputs to the `extra_subgraph`.
-    /// These cannot be encoded either if there's no pytket command to attach them to.
-    pub extra_subgraph_params: Vec<String>,
+    /// Subgraphs of the region that could not be encoded as a pytket commands,
+    /// and have no qubit/bits in their boundary that could be used to emit an
+    /// opaque barrier command in the [`serial_circuit`].
+    pub additional_subgraphs: Vec<AdditionalSubgraph>,
     /// List of wires that directly connected the input node to the output node in the encoded region,
     /// and were not encoded in [`serial_circuit`].
     ///
     /// We just store the input nodes's output port and output node's input port here.
     pub straight_through_wires: Vec<StraightThroughWire>,
 }
 
+/// A subgraph of the encoded circuit that could not be associated to any qubit or bit register in the pytket circuit.
+#[derive(Debug, Clone)]
+pub(super) struct AdditionalSubgraph {
+    /// The subgraph of the region that could not be encoded as a pytket command,
+    /// and has no qubit/bits in its boundary that could be used to emit an opaque
+    /// barrier command in the [`serial_circuit`].
+    pub id: SubgraphId,
+    /// Parameter expression inputs to the `subgraph`.
+    pub params: Vec<String>,
+}
+
 /// A wire stored in the [`EncodedCircuitInfo`] that directly connected the
 /// input node to the output node in the encoded region, and was not encoded in
 /// the pytket circuit.

tket/src/serialize/pytket/decoder.rs

@@ -467,24 +467,17 @@ impl<'h> PytketDecoderContext<'h> {
         commands: &[circuit_json::Command],
         extra_nodes_and_wires: Option<&AdditionalNodesAndWires>,
     ) -> Result<(), PytketDecodeError> {
-        let config = self.config().clone();
-        for com in commands {
-            let op_type = com.op.op_type;
-            self.process_command(com, config.as_ref())
-                .map_err(|e| e.pytket_op(&op_type))?;
-        }
-
         // Add additional subgraphs and wires not encoded in commands.
         let [input_node, output_node] = self.builder.io();
         if let Some(extras) = extra_nodes_and_wires {
-            if let Some(subgraph_id) = extras.extra_subgraph {
-                let params = extras
-                    .extra_subgraph_params
+            for extra_subgraph in &extras.additional_subgraphs {
+                let params = extra_subgraph
+                    .params
                     .iter()
                     .map(|p| self.load_half_turns(p))
                     .collect_vec();
 
-                self.insert_external_subgraph(subgraph_id, &[], &[], &params)
+                self.insert_external_subgraph(extra_subgraph.id, &[], &[], &params)
                     .map_err(|e| e.hugr_op("External subgraph"))?;
             }
 
@@ -502,6 +495,15 @@ impl<'h> PytketDecoderContext<'h> {
                 );
             }
         }
+
+        // Decode the pytket commands.
+        let config = self.config().clone();
+        for com in commands {
+            let op_type = com.op.op_type;
+            self.process_command(com, config.as_ref())
+                .map_err(|e| e.pytket_op(&op_type))?;
+        }
+
         Ok(())
     }
 

tket/src/serialize/pytket/decoder/subgraph.rs

@@ -6,11 +6,13 @@ use std::sync::Arc;
 use hugr::builder::Container;
 use hugr::hugr::hugrmut::{HugrMut, InsertedForest};
 use hugr::ops::{OpTag, OpTrait};
+use hugr::std_extensions::arithmetic::float_types::float64_type;
 use hugr::types::Type;
 use hugr::{Hugr, HugrView, Node, OutgoingPort, PortIndex, Wire};
 use hugr_core::hugr::internal::HugrMutInternals;
 use itertools::Itertools;
 
+use crate::extension::rotation::rotation_type;
 use crate::serialize::pytket::decoder::{
     DecodeStatus, FoundWire, LoadedParameter, PytketDecoderContext, TrackedBit, TrackedQubit,
 };
@@ -81,7 +83,7 @@ impl<'h> PytketDecoderContext<'h> {
             subgraph, qubits, bits, params, old_parent, new_parent,
         )?;
 
-        self.rewire_external_subgraph_outputs(subgraph, qubits, bits, old_parent, new_parent)?;
+        self.rewire_external_subgraph_outputs(id, subgraph, qubits, bits, old_parent, new_parent)?;
 
         Ok(DecodeStatus::Success)
     }
@@ -159,6 +161,7 @@ impl<'h> PytketDecoderContext<'h> {
     /// Helper for [`Self::insert_external_subgraph`].
     fn rewire_external_subgraph_outputs(
         &mut self,
+        id: SubgraphId,
         subgraph: &OpaqueSubgraph<Node>,
         qubits: &[TrackedQubit],
         bits: &[TrackedBit],
@@ -171,19 +174,19 @@ impl<'h> PytketDecoderContext<'h> {
         let mut output_qubits = qubits;
         let mut output_bits = bits;
 
-        for (ty, (src, src_port)) in subgraph
+        for ((out_idx, ty), (src, src_port)) in subgraph
             .signature()
             .output()
             .iter()
+            .enumerate()
             .zip_eq(subgraph.outgoing_ports())
         {
             // Output wire from the subgraph. Depending on the type, we may need
             // to track new qubits and bits, re-connect it to some output, or
             // leave it untouched.
             let wire = Wire::new(*src, *src_port);
             if let Some(counts) = self.config().type_to_pytket(ty).filter(|c| c.params == 0) {
-                // This port declares new outputs to be tracked by the decoder.
-                // Output parameters from a subgraph are always marked as not supported (they don't map to any pytket argument variable).
+                // This port declares new bit/qubit outputs to be tracked by the decoder.
 
                 // Make sure to disconnect the old wire.
                 self.builder.hugr_mut().disconnect(*src, *src_port);
@@ -204,6 +207,15 @@ impl<'h> PytketDecoderContext<'h> {
                     wire_qubits.unwrap().iter().cloned(),
                     wire_bits.unwrap().iter().cloned(),
                 )?;
+            } else if [rotation_type(), float64_type()].contains(ty) {
+                let param_name = id.output_parameter(out_idx);
+                let param = if ty == &rotation_type() {
+                    LoadedParameter::rotation(wire)
+                } else {
+                    LoadedParameter::float_half_turns(wire)
+                };
+                self.wire_tracker
+                    .register_input_parameter(param, param_name)?;
             } else {
                 // This is an unsupported wire. If it was connected to the old
                 // region's output, rewire it to the new region's output.