Merge remote-tracking branch 'origin/main' into ab/tket-exts-exports

Author: aborgna-q

Cargo.lock

@@ -16,7 +16,7 @@ tket = { path = "../tket", features = [
     "rewrite-tracing",
     "binary-eccs",
 ] }
-tket-qsystem = { path = "../tket-qsystem", version = "0.19.0" }
+tket-qsystem = { path = "../tket-qsystem", version = "0.20.0" }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tracing-appender = { workspace = true }

badger-optimiser/Cargo.toml

@@ -23,7 +23,7 @@ tket = { path = "../tket", version = "0.14.0", features = [
     "portmatching",
     "binary-eccs",
 ] }
-tket-qsystem = { path = "../tket-qsystem", version = "0.19.0" }
+tket-qsystem = { path = "../tket-qsystem", version = "0.20.0" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 tket-json-rs = { workspace = true, features = ["pyo3"] }

tket-py/Cargo.toml

@@ -217,7 +217,7 @@ impl PyPauliIter {
 //
 // TODO: These can no longer be constructed from Python. Since `hugr-rs 0.14`
 // we need an extension and `OpDef` to defines these.
-// If fixing this, make sure to fix `PyHugrType` too.
+// When fixing this, make sure to fix `PyHugrType` too.
 #[pyclass]
 #[pyo3(name = "CustomOp")]
 #[repr(transparent)]

tket-py/src/ops.rs

@@ -1,6 +1,13 @@
 # Changelog
 
 
+## [0.20.0](https://github.com/CQCL/tket2/compare/tket-qsystem-v0.19.0...tket-qsystem-v0.20.0) - 2025-08-21
+
+### New Features
+
+- [**breaking**] Update WASM extension ([#1047](https://github.com/CQCL/tket2/pull/1047))
+- *(qsystem)* native gateset decomposition improvements ([#1059](https://github.com/CQCL/tket2/pull/1059))
+
 ## [0.19.0](https://github.com/CQCL/tket2/compare/tket-qsystem-v0.18.1...tket-qsystem-v0.19.0) - 2025-08-18
 
 ### New Features

tket-qsystem/CHANGELOG.md

@@ -1,6 +1,6 @@
 [package]
 name = "tket-qsystem"
-version = "0.19.0"
+version = "0.20.0"
 edition.workspace = true
 rust-version.workspace = true
 

tket-qsystem/Cargo.toml

@@ -394,27 +394,25 @@ pub trait QSystemOpBuilder: Dataflow + UnwrapBuilder + ArrayOpBuilder {
 
     /// Build a CY gate in terms of QSystem primitives.
     fn build_cy(&mut self, a: Wire, b: Wire) -> Result<[Wire; 2], BuildError> {
+        let pi = pi_mul_f64(self, 1.0);
         let pi_2 = pi_mul_f64(self, 0.5);
         let pi_minus_2 = pi_mul_f64(self, -0.5);
-        let zero = pi_mul_f64(self, 0.0);
 
-        let a = self.add_phased_x(a, pi_minus_2, zero)?;
+        let a = self.add_phased_x(a, pi, pi)?;
+        let b = self.add_phased_x(b, pi_minus_2, pi)?;
         let [a, b] = self.build_zz_max(a, b)?;
-        let a = self.add_rz(a, pi_2)?;
-        let b = self.add_phased_x(b, pi_2, pi_2)?;
-        let b = self.add_rz(b, pi_minus_2)?;
+        let a = self.add_phased_x(a, pi, pi_2)?;
+        let b = self.add_phased_x(b, pi_minus_2, pi_minus_2)?;
+        let a = self.add_rz(a, pi_minus_2)?;
+        let b = self.add_rz(b, pi_2)?;
         Ok([a, b])
     }
 
     /// Build a CZ gate in terms of QSystem primitives.
     fn build_cz(&mut self, a: Wire, b: Wire) -> Result<[Wire; 2], BuildError> {
-        let pi = pi_mul_f64(self, 1.0);
         let pi_2 = pi_mul_f64(self, 0.5);
-        let pi_minus_2 = pi_mul_f64(self, -0.5);
 
-        let a = self.add_phased_x(a, pi, pi_2)?;
         let [a, b] = self.build_zz_max(a, b)?;
-        let a = self.add_phased_x(a, pi, pi_minus_2)?;
         let b = self.add_rz(b, pi_2)?;
         let a = self.add_rz(a, pi_2)?;
 

tket-qsystem/src/extension/qsystem.rs

@@ -6,10 +6,11 @@ use hugr::extension::simple_op::MakeExtensionOp;
 use hugr::extension::ExtensionId;
 use hugr::ops::ExtensionOp;
 use hugr::HugrView;
+use itertools::Itertools as _;
 use tket::serialize::pytket::decoder::{
-    DecodeStatus, LoadedParameter, PytketDecoderContext, TrackedBit, TrackedQubit,
+    DecodeStatus, LoadedParameter, ParameterType, PytketDecoderContext, TrackedBit, TrackedQubit,
 };
-use tket::serialize::pytket::encoder::EncodeStatus;
+use tket::serialize::pytket::encoder::{make_tk1_operation, EncodeStatus};
 use tket::serialize::pytket::extension::PytketDecoder;
 use tket::serialize::pytket::{
     PytketDecodeError, PytketEmitter, PytketEncodeError, PytketEncoderContext,
@@ -83,8 +84,22 @@ impl QSystemEmitter {
             }
         };
 
-        // Most operations map directly to a pytket one.
-        encoder.emit_node(serial_op, node, circ)?;
+        // pytket parameters are always in half-turns.
+        // Since the `tket.qsystem` op inputs are in radians, we have to convert them here.
+        encoder.emit_node_command(
+            node,
+            circ,
+            |_| Vec::new(),
+            move |mut inputs| {
+                for param in inputs.params.to_mut() {
+                    *param = match param.strip_suffix(") * (pi)") {
+                        Some(s) if s.starts_with("(") => s[1..].to_string(),
+                        _ => format!("{param} / (pi)"),
+                    };
+                }
+                make_tk1_operation(serial_op, inputs)
+            },
+        )?;
 
         Ok(EncodeStatus::Success)
     }
@@ -126,15 +141,23 @@ impl PytketDecoder for QSystemEmitter {
             PytketOptype::ZZPhase => QSystemOp::ZZPhase,
             PytketOptype::ZZMax => {
                 // This is a ZZPhase with a 1/2 angle.
-                let param = decoder.load_parameter("pi/2");
+                let param =
+                    Arc::new(decoder.load_parameter_with_type("pi/2", ParameterType::FloatRadians));
                 decoder.add_node_with_wires(QSystemOp::ZZPhase, qubits, bits, &[param])?;
                 return Ok(DecodeStatus::Success);
             }
             _ => {
                 return Ok(DecodeStatus::Unsupported);
             }
         };
-        decoder.add_node_with_wires(op, qubits, bits, params)?;
+
+        // We expect all parameters to be floats in radians.
+        let params = params
+            .iter()
+            .map(|p| Arc::new(p.as_float_radians(&mut decoder.builder)))
+            .collect_vec();
+
+        decoder.add_node_with_wires(op, qubits, bits, &params)?;
 
         Ok(DecodeStatus::Success)
     }

tket-qsystem/src/pytket/qsystem.rs

@@ -128,7 +128,7 @@ fn compare_serial_circs(a: &SerialCircuit, b: &SerialCircuit) {
         let count_b = b_command_count.get(a).copied().unwrap_or_default();
         assert_eq!(
             count_a, count_b,
-            "command {a:?} appears {count_a} times in rhs and {count_b} times in lhs"
+            "command {a:?} appears {count_a} times in rhs and {count_b} times in lhs.\ncounts for a: {a_command_count:#?}\ncounts for b: {b_command_count:#?}"
         );
     }
     assert_eq!(a_command_count.len(), b_command_count.len());

tket-qsystem/src/pytket/tests.rs

@@ -4,7 +4,7 @@ mod param;
 mod tracked_elem;
 mod wires;
 
-pub use param::{LoadedParameter, LoadedParameterType};
+pub use param::{LoadedParameter, ParameterType};
 pub use tracked_elem::{TrackedBit, TrackedQubit};
 pub use wires::TrackedWires;
 
@@ -420,8 +420,13 @@ impl<'h> PytketDecoderContext<'h> {
     /// the first registers in `wires` for the bit inputs and the remaining
     /// registers for the outputs.
     ///
-    /// The input wire types must match the operation's input signature,
-    /// no type conversion is performed.
+    /// The input wire types must match the operation's input signature, no type
+    /// conversion is performed.
+    ///
+    /// The caller must take care of converting the parameter wires to the
+    /// required types and units expected by the operation. An error will be
+    /// returned if the parameter does not match the expected wire type, but the
+    /// unit (radians or half-turns) cannot be checked automatically.
     ///
     /// # Arguments
     ///
@@ -435,6 +440,8 @@ impl<'h> PytketDecoderContext<'h> {
     ///   input ports.
     /// - Returns an error if the node's output ports cannot be assigned to
     ///   arguments from the input wire set.
+    /// - Returns an error if the parameter wires do not match the expected
+    ///   types.
     pub fn add_node_with_wires(
         &mut self,
         op: impl Into<OpType>,
@@ -593,7 +600,18 @@ impl<'h> PytketDecoderContext<'h> {
     /// - If the parameter is a variable, adds a new `rotation` input to the region.
     /// - If the parameter is a sympy expressions, adds it as a [`SympyOpDef`][crate::extension::sympy::SympyOpDef] black box.
     pub fn load_parameter(&mut self, param: &str) -> Arc<LoadedParameter> {
-        self.wire_tracker.load_parameter(&mut self.builder, param)
+        Arc::new(
+            self.wire_tracker
+                .load_parameter(&mut self.builder, param, None),
+        )
+    }
+
+    /// Loads the given parameter expression as a [`LoadedParameter`] in the hugr, and converts it to the requested type and unit.
+    ///
+    /// See [`PytketDecoderContext::load_parameter`] for more details.
+    pub fn load_parameter_with_type(&mut self, param: &str, typ: ParameterType) -> LoadedParameter {
+        self.wire_tracker
+            .load_parameter(&mut self.builder, param, Some(typ))
     }
 }