fix(encoded-circ): Track unsupported wires between input and output (#1224)

Depends on #1211

These are not represented in the pytket circuit, and cannot be encoded
into a SiblingSubgraph.

We just track them as an additional item in the `EncodedCircuit`'s
`EncodedCircuitInfo`.

Note that the info is only store for circuits we encode directly, and
not for nested regions inside circuit boxes.
This means that the info is lost when encoding those.
I added a commented-out test with a TODO to fix that (we'll need some
extra plumbing to match circ boxes to external metadata).

drive-by: Make sure the encoder's WireTracker stores the input parameter
names, and passes it along.

I'm ignoring breaking changes since they only affect unpublished code.

Author: aborgna-q

tket/src/serialize/pytket.rs

@@ -133,8 +133,8 @@ impl TKETDecode for SerialCircuit {
         options: DecodeOptions,
     ) -> Result<Node, Self::DecodeError> {
         let mut decoder = PytketDecoderContext::new(self, hugr, target, options, None)?;
-        decoder.run_decoder(&self.commands, None)?;
-        Ok(decoder.finish()?.node())
+        decoder.run_decoder(&self.commands, None, &[])?;
+        Ok(decoder.finish(&[])?.node())
     }
 
     fn encode(circuit: &Circuit, options: EncodeOptions) -> Result<Self, Self::EncodeError> {

tket/src/serialize/pytket/circuit.rs

@@ -4,7 +4,7 @@ use std::collections::{HashMap, VecDeque};
 use std::ops::{Index, IndexMut};
 use std::sync::Arc;
 
-use hugr::core::HugrNode;
+use hugr::core::{HugrNode, IncomingPort, OutgoingPort};
 use hugr::hugr::hugrmut::HugrMut;
 use hugr::ops::handle::NodeHandle;
 use hugr::ops::{OpParent, OpTag, OpTrait};
@@ -59,6 +59,11 @@ pub(super) struct EncodedCircuitInfo {
     /// 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>,
+    /// 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>,
     /// List of parameters in the pytket circuit in the order they appear in the
     /// hugr input.
     ///
@@ -67,10 +72,22 @@ pub(super) struct EncodedCircuitInfo {
     pub input_params: Vec<String>,
     /// List of output parameter expressions found at the end of the encoded region.
     //
-    // TODO: The decoder does not currently connect these.
+    // TODO: The decoder does not currently connect these, everything that
+    // _produces_ a parameter gets included in unsupported subgraphs instead.
     pub output_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.
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub(super) struct StraightThroughWire {
+    /// Source port of the wire in the input node.
+    pub input_source: OutgoingPort,
+    /// Target port of the wire in the output node.
+    pub output_target: IncomingPort,
+}
+
 impl EncodedCircuit<Node> {
     /// Encode a HugrView into a [`EncodedCircuit`].
     ///
@@ -162,8 +179,12 @@ impl EncodedCircuit<Node> {
                 options,
                 Some(&self.opaque_subgraphs),
             )?;
-            decoder.run_decoder(&encoded.serial_circuit.commands, encoded.extra_subgraph)?;
-            let decoded_node = decoder.finish()?.node();
+            decoder.run_decoder(
+                &encoded.serial_circuit.commands,
+                encoded.extra_subgraph,
+                &encoded.straight_through_wires,
+            )?;
+            let decoded_node = decoder.finish(&encoded.output_params)?.node();
 
             // Replace the region with the decoded function.
             //
@@ -312,8 +333,8 @@ impl<Node: HugrNode> EncodedCircuit<Node> {
 
         let mut decoder =
             PytketDecoderContext::new(serial_circuit, &mut hugr, target, options, None)?;
-        decoder.run_decoder(&serial_circuit.commands, None)?;
-        decoder.finish()?;
+        decoder.run_decoder(&serial_circuit.commands, None, &[])?;
+        decoder.finish(&[])?;
         Ok(hugr)
     }
 

tket/src/serialize/pytket/decoder.rs

@@ -33,6 +33,7 @@ use super::{
     METADATA_Q_REGISTERS,
 };
 use crate::extension::rotation::rotation_type;
+use crate::serialize::pytket::circuit::StraightThroughWire;
 use crate::serialize::pytket::config::PytketDecoderConfig;
 use crate::serialize::pytket::decoder::wires::WireTracker;
 use crate::serialize::pytket::extension::{build_opaque_tket_op, RegisterCount};
@@ -293,7 +294,12 @@ impl<'h> PytketDecoderContext<'h> {
     ///
     /// The original Hugr entrypoint is _not_ modified, it must be set by the
     /// caller if required.
-    pub(super) fn finish(mut self) -> Result<Node, PytketDecodeError> {
+    ///
+    /// # Arguments
+    ///
+    /// - `output_params`: A list of output parameter expressions to associate
+    ///   with the region's outputs.
+    pub(super) fn finish(mut self, output_params: &[String]) -> Result<Node, PytketDecodeError> {
         // Order the final wires according to the serial circuit register order.
         let known_qubits = self
             .wire_tracker
@@ -304,27 +310,34 @@ impl<'h> PytketDecoderContext<'h> {
         let mut qubits = known_qubits.as_slice();
         let mut bits = known_bits.as_slice();
 
+        // Load the output parameter expressions.
+        let output_params = output_params
+            .iter()
+            .map(|p| self.load_half_turns(p))
+            .collect_vec();
+        let mut params: &[LoadedParameter] = &output_params;
+
         let function_type = self
             .builder
             .hugr()
             .get_optype(self.builder.container_node())
             .inner_function_type()
             .unwrap();
         let expected_output_types = function_type.output_types().iter().cloned().collect_vec();
-        let output_node = self.builder.output().node();
+        let [_, output_node] = self.builder.io();
 
         for (ty, port) in expected_output_types
             .iter()
             .zip(self.builder.hugr().node_inputs(output_node).collect_vec())
         {
             // If the region's output is already connected, leave it alone.
-            // (It's a wire from an unsupported operation)
+            // (It's a wire from an unsupported operation, or was a connected
+            // straight through wire)
             if self.builder.hugr().is_linked(output_node, port) {
                 continue;
             }
 
             // Otherwise, get the tracked wire.
-            let mut params: &[LoadedParameter] = &[];
             let found_wire = self
                 .wire_tracker
                 .find_typed_wire(
@@ -428,21 +441,40 @@ impl<'h> PytketDecoderContext<'h> {
     /// - `commands`: The list of pytket commands to decode.
     /// - `extra_subgraph`: An additional subgraph of the original Hugr that was
     ///   not encoded as a pytket command, and must be decoded independently.
+    /// - `straight_through_wires`: A list of wires that directly connected the
+    ///   input node to the output node in the original region, and were not
+    ///   encoded in the pytket circuit or unsupported graphs.
+    ///   (They cannot be encoded in `extra_subgraph`).
     pub(super) fn run_decoder(
         &mut self,
         commands: &[circuit_json::Command],
         extra_subgraph: Option<SubgraphId>,
+        straight_through_wires: &[StraightThroughWire],
     ) -> 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 if not encoded in commands.
         if let Some(subgraph_id) = extra_subgraph {
             self.insert_external_subgraph(subgraph_id, &[], &[], &[])
                 .map_err(|e| e.hugr_op("External subgraph"))?;
         }
+
+        // Add wires from the input node to the output node that didn't get encoded in commands.
+        let [input_node, output_node] = self.builder.io();
+        for StraightThroughWire {
+            input_source,
+            output_target,
+        } in straight_through_wires
+        {
+            self.builder
+                .hugr_mut()
+                .connect(input_node, *input_source, output_node, *output_target);
+        }
         Ok(())
     }
 

tket/src/serialize/pytket/encoder.rs

@@ -225,9 +225,6 @@ impl<H: HugrView> PytketEncoderContext<H> {
         region: H::Node,
     ) -> Result<(EncodedCircuitInfo, OpaqueSubgraphs<H::Node>), PytketEncodeError<H::Node>> {
         // Add any remaining unsupported nodes
-        //
-        // TODO: Test that opaque subgraphs that don't affect any qubit/bit registers
-        // are correctly encoded in pytket commands.
         let mut extra_subgraph: Option<BTreeSet<H::Node>> = None;
         while !self.unsupported.is_empty() {
             let node = self.unsupported.iter().next().unwrap();
@@ -251,21 +248,22 @@ impl<H: HugrView> PytketEncoderContext<H> {
             self.opaque_subgraphs.register_opaque_subgraph(subgraph)
         });
 
-        let final_values = self.values.finish(circ, region)?;
+        let tracker_result = self.values.finish(circ, region)?;
 
         let mut ser = SerialCircuit::new(self.name, self.phase);
 
         ser.commands = self.commands;
-        ser.qubits = final_values.qubits.into_iter().map_into().collect();
-        ser.bits = final_values.bits.into_iter().map_into().collect();
-        ser.implicit_permutation = final_values.qubit_permutation;
+        ser.qubits = tracker_result.qubits.into_iter().map_into().collect();
+        ser.bits = tracker_result.bits.into_iter().map_into().collect();
+        ser.implicit_permutation = tracker_result.qubit_permutation;
         ser.number_of_ws = None;
 
         let info = EncodedCircuitInfo {
             serial_circuit: ser,
-            input_params: final_values.params,
-            output_params: vec![],
+            input_params: tracker_result.input_params,
+            output_params: tracker_result.params,
             extra_subgraph,
+            straight_through_wires: tracker_result.straight_through_wires,
         };
 
         Ok((info, self.opaque_subgraphs))
@@ -601,6 +599,7 @@ impl<H: HugrView> PytketEncoderContext<H> {
         });
         let subgraph_incoming_ports: IncomingPorts<H::Node> = subgraph.incoming_ports().clone();
         let subgraph_outgoing_ports: OutgoingPorts<H::Node> = subgraph.outgoing_ports().clone();
+        let subgraph_signature = subgraph.signature(circ.hugr());
 
         // Encode a payload referencing the subgraph in the Hugr.
         let subgraph_id = self.opaque_subgraphs.register_opaque_subgraph(subgraph);
@@ -641,7 +640,14 @@ impl<H: HugrView> PytketEncoderContext<H> {
         // Output parameters are mapped to a fresh variable, that can be tracked
         // back to the encoded subcircuit's function name.
         let mut out_param_count = 0;
-        for (out_node, out_port) in &subgraph_outgoing_ports {
+        for ((out_node, out_port), ty) in subgraph_outgoing_ports
+            .iter()
+            .zip(subgraph_signature.output().iter())
+        {
+            if self.config().type_to_pytket(ty).is_none() {
+                // Do not try to register ports with unsupported types.
+                continue;
+            }
             let new_outputs = self.register_port_output(
                 *out_node,
                 *out_port,
@@ -734,6 +740,7 @@ impl<H: HugrView> PytketEncoderContext<H> {
     ///
     // TODO: Support output parameters in subcircuits. This may require
     // substituting variables in the parameter expressions.
+    #[expect(unused)]
     fn emit_subcircuit(
         &mut self,
         node: H::Node,
@@ -767,6 +774,7 @@ impl<H: HugrView> PytketEncoderContext<H> {
     ///
     // TODO: Support output parameters in subcircuits. This may require
     // substituting variables in the parameter expressions.
+    #[expect(unused)]
     fn emit_function_call(
         &mut self,
         node: H::Node,
@@ -902,6 +910,15 @@ impl<H: HugrView> PytketEncoderContext<H> {
                     return Ok(EncodeStatus::Success);
                 }
             }
+            // TODO: DFG and function call emissions are temporarily disabled,
+            // since we cannot track additional metadata associated with the
+            // nested circuit in a `CircuitBox` as we'd do for the root one in
+            // [`EncodedCircuitInfo`].
+            //
+            // See the `unsupported_extras_in_circ_box` case in
+            // `tests::encoded_circuit_roundtrip` for a failing case when this
+            // is enabled.
+            /*
             OpType::DFG(_) => return self.emit_subcircuit(node, circ),
             OpType::Call(call) => {
                 let (fn_node, _) = circ
@@ -914,6 +931,7 @@ impl<H: HugrView> PytketEncoderContext<H> {
                     return Ok(EncodeStatus::Success);
                 }
             }
+            */
             OpType::Input(_) | OpType::Output(_) => {
                 // I/O nodes are handled by the container's encoder.
                 return Ok(EncodeStatus::Success);