fix: Incorrect matching of pytket parameters to unsupported graph ports (#1561)

Fixes #1516

There was a problem in how we match pytket command parameters that
reference a unsupported subgraph output port.
The encoder generated the name using a sequential id for each port, but
the decoder used the `PortIndex` instead.

Fixed the bug, added the issue repro as a guppy example, and made an LLM
create a reduced rust test case.

Note that while this is a needed bug fix, there's a bigger problem that
I'm not fixing in this PR:
Due to how pytket circuits use parameters, each time we find a new
unknown variable name the decoder adds it as a new angle input to the
region being decoded.
This is useful when decoding user-generated pytket circuits, but in
general if the pytket circuit was encoded from a Hugr region there
shouldn't be any new inputs added. These new inputs end up making the
Hugr invalid instead.
There's different ways we could avoid this, but I'll do that in a follow
up PR.

Author: aborgna-q

test_files/guppy_examples/issue_1516.hugr

@@ -0,0 +1,24 @@
+# /// script
+# requires-python = ">=3.14"
+# dependencies = [
+#     "guppylang==0.21.13",
+# ]
+# ///
+
+from pathlib import Path
+from sys import argv
+
+from guppylang import guppy
+from guppylang.std.builtins import owned
+from guppylang.std.quantum import qubit
+from guppylang.std.quantum.functional import ch
+
+
+@guppy
+def test(q1: qubit @ owned, q2: qubit @ owned) -> tuple[qubit, qubit]:
+    q1, q2 = ch(q1, q2)
+    return (q1, q2)
+
+
+program = test.compile_function()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/guppy_examples/issue_1516.py

@@ -11,6 +11,7 @@
     inline_funcs,
     NormalizeGuppy,
     ModifierResolverPass,
+    GlobalScope,
 )
 from tket._state import CompilationState
 from tket_exts import tket_registry
@@ -21,7 +22,12 @@
 from hypothesis import given, settings
 
 from tket.passes import PytketHugrPass
-from pytket.passes import CliffordSimp, SquashRzPhasedX, SequencePass
+from pytket.passes import (
+    CliffordSimp,
+    SquashRzPhasedX,
+    RemoveRedundancies,
+    SequencePass,
+)
 from hugr.build.base import Hugr
 
 import numpy as np
@@ -297,3 +303,23 @@ def test_inline_functions() -> None:
     all = InlineFunctions(heuristic=inline_funcs.All())(hugr)
 
     assert _count_ops(all, "Call") == 0
+
+
+def test_issue_1516() -> None:
+    """Regression test for issue 1516.
+
+    This was caused by a bug in the decoder that injected new parameter inputs when decoding a modified pytket circuit back into an existing region.
+
+    <https://github.com/quantinuum/tket2/issues/1516>
+    """
+    hugr = _hugr_from_path("test_files/guppy_examples/issue_1516.hugr")
+
+    # Ensure that the hugr is valid before we start.
+    CompilationState.from_python(hugr).validate()
+
+    opt = PytketHugrPass(RemoveRedundancies()).with_scope(
+        GlobalScope.PRESERVE_ENTRYPOINT
+    )
+    opt_hugr = opt(hugr, inplace=False)
+
+    CompilationState.from_python(opt_hugr).validate()

tket-py/test/test_pass.py

@@ -190,12 +190,12 @@ impl<'h> PytketDecoderContext<'h> {
 
         let mut output_qubits = qubits;
         let mut output_bits = bits;
+        let mut output_param_count = 0;
 
-        for ((out_idx, ty), (src, src_port)) in subgraph
+        for (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
@@ -225,7 +225,10 @@ impl<'h> PytketDecoderContext<'h> {
                     wire_bits.unwrap().iter().cloned(),
                 )?;
             } else if PARAMETER_TYPES.contains(ty) {
-                let param_name = id.output_parameter(out_idx);
+                // The encoder names opaque parameter outputs by the number of
+                // parameter values exposed to pytket.
+                let param_name = id.output_parameter(output_param_count);
+                output_param_count += 1;
                 let param = if ty == &rotation_type() {
                     LoadedParameter::rotation(wire)
                 } else {

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

@@ -31,7 +31,7 @@ use hugr::hugr::hugrmut::HugrMut;
 use hugr::ops::handle::FuncID;
 use hugr::ops::{OpParent, OpType, Value};
 use hugr::std_extensions::arithmetic::float_ops::FloatOps;
-use hugr::types::{Signature, SumType};
+use hugr::types::{Signature, SumType, Type};
 use hugr::{Hugr, HugrView};
 use itertools::Itertools;
 use rstest::{fixture, rstest};
@@ -792,6 +792,44 @@ fn circ_complex_param_type() -> Hugr {
     h.finish_hugr_with_outputs([float_tuple]).unwrap()
 }
 
+/// A circuit with an unsupported subgraph whose first output is not exposed as
+/// a pytket parameter, followed by a float output used by a supported gate.
+///
+/// Regression test for <https://github.com/Quantinuum/tket2/issues/1516>
+#[fixture]
+fn circ_unsupported_subgraph_skipped_output_before_param() -> Hugr {
+    let tuple_float_t = Type::from(SumType::new_tuple(vec![float64_type()]));
+    let input_t = vec![qb_t()];
+    let output_t = vec![qb_t(), tuple_float_t.clone()];
+    let mut h = FunctionBuilder::new(
+        "unsupported_subgraph_skipped_output_before_param",
+        Signature::new(input_t, output_t),
+    )
+    .unwrap();
+    let [q] = h.input_wires_arr();
+
+    let func = h
+        .module_root_builder()
+        .declare(
+            "tuple_and_float",
+            Signature::new(vec![], vec![tuple_float_t, float64_type()]).into(),
+        )
+        .unwrap();
+
+    let call = h.call(&func, &[], []).unwrap();
+    let [float_tuple, angle] = call.outputs_arr();
+    let [angle] = h
+        .add_dataflow_op(RotationOp::from_halfturns_unchecked, [angle])
+        .unwrap()
+        .outputs_arr();
+    let [q] = h
+        .add_dataflow_op(TketOp::Ry, [q, angle])
+        .unwrap()
+        .outputs_arr();
+
+    h.finish_hugr_with_outputs([q, float_tuple]).unwrap()
+}
+
 /// A program with two unsupported subgraphs not associated to any qubit or bit.
 /// <https://github.com/CQCL/tket2/issues/1294>
 #[fixture]
@@ -1112,6 +1150,11 @@ fn fail_on_modified_hugr(circ_tk1_ops: Hugr) {
 #[case::order_edge(circ_order_edge(), 1, CircuitRoundtripTestConfig::Default)]
 #[case::bool_conversion(circ_bool_conversion(), 1, CircuitRoundtripTestConfig::Default)]
 #[case::complex_param_type(circ_complex_param_type(), 1, CircuitRoundtripTestConfig::Default)]
+#[case::unsupported_subgraph_skipped_output_before_param(
+    circ_unsupported_subgraph_skipped_output_before_param(),
+    1,
+    CircuitRoundtripTestConfig::Default
+)]
 // TODO: We need to track [`EncodedCircuitInfo`] for nested CircBoxes too. We
 // have temporarily disabled encoding of DFG and function calls as CircBoxes to
 // avoid an error here.