feat!: Add original circuit/subgraphs in pytket DecoderCtx

Author: aborgna-q

tket-py/src/circuit/convert.rs

@@ -70,7 +70,7 @@ where
         Err(_) => (
             SerialCircuit::from_tket1(circ)?
                 .decode(
-                    DecodeOptions::new()
+                    DecodeOptions::new_any()
                         .with_config(tket_qsystem::pytket::qsystem_decoder_config()),
                 )
                 .convert_pyerrs()?,

tket-qsystem/src/pytket.rs

@@ -15,7 +15,7 @@ use tket::serialize::pytket::{
 ///
 /// Contains a list of custom decoders that define translations of legacy tket
 /// primitives into HUGR operations.
-pub fn qsystem_decoder_config() -> PytketDecoderConfig {
+pub fn qsystem_decoder_config<H: HugrView>() -> PytketDecoderConfig<H> {
     let mut config = default_decoder_config();
     config.add_decoder(QSystemEmitter);
 

tket-qsystem/src/pytket/qsystem.rs

@@ -115,7 +115,7 @@ impl QSystemEmitter {
     }
 }
 
-impl PytketDecoder for QSystemEmitter {
+impl<H: HugrView> PytketDecoder<H> for QSystemEmitter {
     fn op_types(&self) -> Vec<PytketOptype> {
         // Process native optypes that are not supported by the `TketOp` emitter.
         vec![
@@ -132,7 +132,7 @@ impl PytketDecoder for QSystemEmitter {
         bits: &[TrackedBit],
         params: &[LoadedParameter],
         _opgroup: Option<&str>,
-        decoder: &mut PytketDecoderContext<'h>,
+        decoder: &mut PytketDecoderContext<'h, H>,
     ) -> Result<DecodeStatus, PytketDecodeError> {
         let op = match op.op_type {
             PytketOptype::PhasedX => QSystemOp::PhasedX,

tket-qsystem/src/pytket/tests.rs

@@ -198,7 +198,7 @@ fn json_roundtrip(
     assert_eq!(ser.commands.len(), num_commands);
 
     let circ: Circuit = ser
-        .decode(DecodeOptions::new().with_config(qsystem_decoder_config()))
+        .decode(DecodeOptions::new_any().with_config(qsystem_decoder_config()))
         .unwrap();
     assert_eq!(circ.qubit_count(), num_qubits);
 
@@ -229,7 +229,7 @@ fn circuit_roundtrip(#[case] circ: Circuit, #[case] decoded_sig: Signature) {
     )
     .unwrap();
     let deser: Circuit = ser
-        .decode(DecodeOptions::new().with_config(qsystem_decoder_config()))
+        .decode(DecodeOptions::new_any().with_config(qsystem_decoder_config()))
         .unwrap();
 
     let deser_sig = deser.circuit_signature();

tket/src/circuit/hash.rs

@@ -208,7 +208,7 @@ mod test {
     fn hash_constants() {
         let c_str = r#"{"bits": [], "commands": [{"args": [["q", [0]]], "op": {"params": ["0.5"], "type": "Rz"}}], "created_qubits": [], "discarded_qubits": [], "implicit_permutation": [[["q", [0]], ["q", [0]]]], "phase": "0.0", "qubits": [["q", [0]]]}"#;
         let ser: circuit_json::SerialCircuit = serde_json::from_str(c_str).unwrap();
-        let circ: Circuit = ser.decode(DecodeOptions::new()).unwrap();
+        let circ: Circuit = ser.decode(DecodeOptions::new_any()).unwrap();
         circ.circuit_hash(circ.parent()).unwrap();
     }
 
@@ -220,7 +220,7 @@ mod test {
         let mut all_hashes = Vec::with_capacity(2);
         for c_str in [c_str1, c_str2] {
             let ser: circuit_json::SerialCircuit = serde_json::from_str(c_str).unwrap();
-            let circ: Circuit = ser.decode(DecodeOptions::new()).unwrap();
+            let circ: Circuit = ser.decode(DecodeOptions::new_any()).unwrap();
             all_hashes.push(circ.circuit_hash(circ.parent()).unwrap());
         }
         assert_ne!(all_hashes[0], all_hashes[1]);

tket/src/serialize/pytket.rs

@@ -21,7 +21,7 @@ pub use options::{DecodeInsertionTarget, DecodeOptions, EncodeOptions};
 
 use hugr::hugr::hugrmut::HugrMut;
 use hugr::ops::handle::NodeHandle;
-use hugr::{Hugr, Node};
+use hugr::{Hugr, HugrView, Node};
 #[cfg(test)]
 mod tests;
 
@@ -70,7 +70,7 @@ pub trait TKETDecode: Sized {
     /// # Returns
     ///
     /// The encoded circuit.
-    fn decode(&self, options: DecodeOptions) -> Result<Circuit, Self::DecodeError>;
+    fn decode(&self, options: DecodeOptions<impl HugrView>) -> Result<Circuit, Self::DecodeError>;
     /// Convert the serialized circuit into a function definition in an existing HUGR.
     ///
     /// Does **not** modify the HUGR's entrypoint.
@@ -92,7 +92,7 @@ pub trait TKETDecode: Sized {
         // (so that the extension decoder traits are dyn-compatible).
         hugr: &mut Hugr,
         target: DecodeInsertionTarget,
-        options: DecodeOptions,
+        options: DecodeOptions<impl HugrView>,
     ) -> Result<Node, Self::DecodeError>;
     /// Convert a circuit to a serialized pytket circuit.
     ///
@@ -113,9 +113,13 @@ impl TKETDecode for SerialCircuit {
     type DecodeError = PytketDecodeError;
     type EncodeError = PytketEncodeError;
 
-    fn decode(&self, options: DecodeOptions) -> Result<Circuit, Self::DecodeError> {
+    fn decode(&self, options: DecodeOptions<impl HugrView>) -> Result<Circuit, Self::DecodeError> {
         let mut hugr = Hugr::new();
-        let main_func = self.decode_inplace(&mut hugr, DecodeInsertionTarget::Function, options)?;
+        let main_func = self.decode_inplace(
+            &mut hugr,
+            DecodeInsertionTarget::Function { fn_name: None },
+            options,
+        )?;
         hugr.set_entrypoint(main_func);
         Ok(hugr.into())
     }
@@ -124,7 +128,7 @@ impl TKETDecode for SerialCircuit {
         &self,
         hugr: &mut Hugr,
         target: DecodeInsertionTarget,
-        options: DecodeOptions,
+        options: DecodeOptions<impl HugrView>,
     ) -> Result<Node, Self::DecodeError> {
         let config = options
             .config
@@ -134,7 +138,6 @@ impl TKETDecode for SerialCircuit {
             self,
             hugr,
             target,
-            options.fn_name,
             options.signature,
             options.input_params,
             config,

tket/src/serialize/pytket/config.rs

@@ -18,7 +18,7 @@ use hugr::HugrView;
 ///
 /// Contains a list of custom decoders that define translations of legacy tket
 /// primitives into HUGR operations.
-pub fn default_decoder_config() -> PytketDecoderConfig {
+pub fn default_decoder_config<H: HugrView>() -> PytketDecoderConfig<H> {
     let mut config = PytketDecoderConfig::new();
     config.add_decoder(CoreDecoder);
     config.add_decoder(PreludeEmitter);

tket/src/serialize/pytket/config/decoder_config.rs

@@ -5,6 +5,7 @@
 //! translations of legacy tket primitives into HUGR operations.
 
 use hugr::types::Type;
+use hugr::HugrView;
 use itertools::Itertools;
 use std::collections::HashMap;
 
@@ -22,10 +23,10 @@ use super::TypeTranslatorSet;
 /// Contains custom decoders that define translations for HUGR operations,
 /// types, and consts into pytket primitives.
 #[derive(Default, derive_more::Debug)]
-pub struct PytketDecoderConfig {
+pub struct PytketDecoderConfig<H: HugrView> {
     /// Operation emitters
     #[debug(skip)]
-    pub(super) decoders: Vec<Box<dyn PytketDecoder + Send + Sync>>,
+    pub(super) decoders: Vec<Box<dyn PytketDecoder<H> + Send + Sync>>,
     /// Pre-computed map from pytket optypes to corresponding decoders in
     /// `decoders`, identified by their index.
     #[debug("{:?}", optype_decoders.keys().collect_vec())]
@@ -34,7 +35,7 @@ pub struct PytketDecoderConfig {
     type_translators: TypeTranslatorSet,
 }
 
-impl PytketDecoderConfig {
+impl<H: HugrView> PytketDecoderConfig<H> {
     /// Create a new [`PytketDecoderConfig`] with no decoders.
     pub fn new() -> Self {
         Self {
@@ -45,7 +46,7 @@ impl PytketDecoderConfig {
     }
 
     /// Add a decoder to the configuration.
-    pub fn add_decoder(&mut self, decoder: impl PytketDecoder + Send + Sync + 'static) {
+    pub fn add_decoder(&mut self, decoder: impl PytketDecoder<H> + Send + Sync + 'static) {
         let idx = self.decoders.len();
 
         for optype in decoder.op_types() {
@@ -74,7 +75,7 @@ impl PytketDecoderConfig {
         bits: &[TrackedBit],
         params: &[LoadedParameter],
         opgroup: &Option<String>,
-        decoder: &mut PytketDecoderContext<'a>,
+        decoder: &mut PytketDecoderContext<'a, H>,
     ) -> Result<DecodeStatus, PytketDecodeError> {
         let mut result = DecodeStatus::Unsupported;
         let opgroup = opgroup.as_deref();
@@ -91,7 +92,7 @@ impl PytketDecoderConfig {
     fn decoders_for_optype(
         &self,
         optype: &tket_json_rs::OpType,
-    ) -> impl Iterator<Item = &Box<dyn PytketDecoder + Send + Sync>> {
+    ) -> impl Iterator<Item = &Box<dyn PytketDecoder<H> + Send + Sync>> {
         self.optype_decoders
             .get(optype)
             .into_iter()

tket/src/serialize/pytket/decoder.rs

@@ -34,14 +34,22 @@ use crate::extension::rotation::rotation_type;
 use crate::serialize::pytket::config::PytketDecoderConfig;
 use crate::serialize::pytket::decoder::wires::WireTracker;
 use crate::serialize::pytket::extension::{build_opaque_tket_op, RegisterCount};
+use crate::serialize::pytket::opaque::OpaqueSubgraphs;
 use crate::serialize::pytket::{DecodeInsertionTarget, PytketDecodeErrorInner};
 use crate::TketOp;
 
 /// State of the tket circuit being decoded.
 ///
-/// The state of an in-progress [`FunctionBuilder`] being built from a [`SerialCircuit`].
+/// The state of an in-progress [`FunctionBuilder`] being built from a
+/// [`SerialCircuit`].
+///
+/// The generic parameter `H` is the HugrView type of the Hugr that was encoded
+/// into the circuit, if any. This is required when the encoded pytket circuit
+/// contains opaque barriers that reference subgraphs in the original HUGR. See
+/// [`UnsupportedSubgraphPayload`][super::unsupported::UnsupportedSubgraphPayload]
+/// for more details.
 #[derive(Debug)]
-pub struct PytketDecoderContext<'h> {
+pub struct PytketDecoderContext<'h, H: HugrView> {
     /// The Hugr being built.
     pub builder: DFGBuilder<&'h mut Hugr>,
     /// A tracker keeping track of the generated wires and their corresponding types.
@@ -50,10 +58,15 @@ pub struct PytketDecoderContext<'h> {
     ///
     /// Contains custom operation decoders, that define translation of legacy tket
     /// commands into HUGR operations.
-    config: Arc<PytketDecoderConfig>,
+    config: Arc<PytketDecoderConfig<H>>,
+    /// The HugrView type of the Hugr that originated the circuit, if any.
+    original_hugr: Option<&'h H>,
+    /// A registry of unsupported subgraphs from `original_hugr`, that are referenced by opaque barriers in the pytket circuit
+    /// via their [`SubgraphId`].
+    opaque_subgraphs: Option<&'h OpaqueSubgraphs<H::Node>>,
 }
 
-impl<'h> PytketDecoderContext<'h> {
+impl<'h, H: HugrView> PytketDecoderContext<'h, H> {
     /// Initialize a new [`PytketDecoderContext`], using the metadata from a
     /// [`SerialCircuit`].
     ///
@@ -94,12 +107,11 @@ impl<'h> PytketDecoderContext<'h> {
         serialcirc: &SerialCircuit,
         hugr: &'h mut Hugr,
         target: DecodeInsertionTarget,
-        fn_name: Option<String>,
         signature: Option<Signature>,
         input_params: impl IntoIterator<Item = String>,
-        config: impl Into<Arc<PytketDecoderConfig>>,
+        config: impl Into<Arc<PytketDecoderConfig<H>>>,
     ) -> Result<Self, PytketDecodeError> {
-        let config: Arc<PytketDecoderConfig> = config.into();
+        let config: Arc<PytketDecoderConfig<H>> = config.into();
         let signature = signature.unwrap_or_else(|| {
             let num_qubits = serialcirc.qubits.len();
             let num_bits = serialcirc.bits.len();
@@ -108,11 +120,11 @@ impl<'h> PytketDecoderContext<'h> {
                 .into();
             Signature::new(types.clone(), types)
         });
-        let name = fn_name
-            .or_else(|| serialcirc.name.clone())
-            .unwrap_or_default();
         let mut dfg: DFGBuilder<&mut Hugr> = match target {
-            DecodeInsertionTarget::Function => {
+            DecodeInsertionTarget::Function { fn_name } => {
+                let name = fn_name
+                    .or_else(|| serialcirc.name.clone())
+                    .unwrap_or_default();
                 FunctionBuilder::with_hugr(hugr, name, signature.clone())
                     .unwrap()
                     .into_dfg_builder()
@@ -146,6 +158,8 @@ impl<'h> PytketDecoderContext<'h> {
             builder: dfg,
             wire_tracker,
             config,
+            original_hugr: None,
+            opaque_subgraphs: None,
         })
     }
 
@@ -177,7 +191,7 @@ impl<'h> PytketDecoderContext<'h> {
         dfg: &mut DFGBuilder<&mut Hugr>,
         input_types: &TypeRow,
         input_params: impl IntoIterator<Item = String>,
-        config: &PytketDecoderConfig,
+        config: &PytketDecoderConfig<H>,
     ) -> Result<WireTracker, PytketDecodeError> {
         let num_qubits = serialcirc.qubits.len();
         let num_bits = serialcirc.bits.len();
@@ -332,6 +346,24 @@ impl<'h> PytketDecoderContext<'h> {
             .node())
     }
 
+    /// Register the set of unsupported subgraphs that were present in the original HUGR,
+    /// along with a reference to the original HugrView.
+    ///
+    /// # Arguments
+    /// - `opaque_subgraphs`: A registry of opaque subgraphs from
+    ///   `original_hugr`, that are referenced by opaque barriers in the pytket
+    ///   circuit via their [`SubgraphId`].
+    /// - `original_hugr`: The [`Hugr`] that originated the circuit, if any.
+    #[expect(unused)]
+    pub(super) fn register_unsupported_subgraphs(
+        &mut self,
+        opaque_subgraphs: &'h OpaqueSubgraphs<H::Node>,
+        original_hugr: &'h H,
+    ) {
+        self.opaque_subgraphs = Some(opaque_subgraphs);
+        self.original_hugr = Some(original_hugr);
+    }
+
     /// Decode a list of pytket commands.
     pub(super) fn run_decoder(
         &mut self,
@@ -351,7 +383,7 @@ impl<'h> PytketDecoderContext<'h> {
     pub(super) fn process_command(
         &mut self,
         command: &circuit_json::Command,
-        config: &PytketDecoderConfig,
+        config: &PytketDecoderConfig<H>,
     ) -> Result<(), PytketDecodeError> {
         let circuit_json::Command { op, args, opgroup } = command;
 
@@ -380,13 +412,13 @@ impl<'h> PytketDecoderContext<'h> {
     }
 
     /// Returns the configuration used by the decoder.
-    pub fn config(&self) -> &Arc<PytketDecoderConfig> {
+    pub fn config(&self) -> &Arc<PytketDecoderConfig<H>> {
         &self.config
     }
 }
 
 /// Public API, used by the [`PytketDecoder`][super::extension::PytketDecoder] implementers.
-impl<'h> PytketDecoderContext<'h> {
+impl<'h, H: HugrView> PytketDecoderContext<'h, H> {
     /// Returns a new set of [TrackedWires] for a list of [`TrackedQubit`]s,
     /// [`TrackedBit`]s, and [`LoadedParameter`]s following the required types.
     ///
@@ -723,7 +755,7 @@ pub enum DecodeStatus {
 
 /// Helper to continue exhausting the iterators in [`PytketDecoderContext::register_node_outputs`] until we have the total number of elements to report.
 fn make_unexpected_node_out_error<'ty>(
-    config: &PytketDecoderConfig,
+    config: &PytketDecoderConfig<impl HugrView>,
     port_types: impl IntoIterator<Item = (OutgoingPort, &'ty Type)>,
     mut partial_count: RegisterCount,
     expected_qubits: usize,