feat!: Use qsystem encoder/decoders in tket-py (#1041)

Depends on #1039

- Adds an optional config parameter to all the `load_tk1` / `save_tk1`
utilities, so we don't use the default by mistake.
- Uses the new qsystem encoder/decoders in `tket-py`, so now we can load
`ZZMax`/`ZZPhase`/`PhasedX`

BREAKING CHANGE: Added encode/decode config arguments to pytket
load/store utilities

This is not a breaking change for the python lib, so I'll override the
flag for release-please:

BEGIN_COMMIT_OVERRIDE

feat: Support qsystem native operations when loading pytket circuits 

END_COMMIT_OVERRIDE

Author: aborgna-q

Cargo.lock

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

badger-optimiser/Cargo.toml

@@ -143,7 +143,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let badger_logger = BadgerLogger::new(circ_candidates_csv);
 
-    let mut circ = load_tk1_json_file(input_path)?;
+    let mut circ = load_tk1_json_file(
+        input_path,
+        Some(tket_qsystem::pytket::qsystem_decoder_config()),
+    )?;
     if opts.rewrite_tracing {
         circ.enable_rewrite_tracing();
     }
@@ -181,7 +184,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     );
 
     println!("Saving result");
-    save_tk1_json_file(&opt_circ, output_path)?;
+    save_tk1_json_file(
+        &opt_circ,
+        output_path,
+        Some(tket_qsystem::pytket::qsystem_encoder_config()),
+    )?;
 
     #[cfg(feature = "peak_alloc")]
     println!("Peak memory usage: {} GB", PEAK_ALLOC.peak_usage_as_gb());

badger-optimiser/src/main.rs

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

tket-py/Cargo.toml

@@ -43,7 +43,12 @@ impl CircuitType {
     /// Converts a circuit into the format indicated by the flag.
     pub fn convert(self, py: Python, circ: Circuit) -> PyResult<Bound<PyAny>> {
         match self {
-            CircuitType::Tket1 => SerialCircuit::encode(&circ).convert_pyerrs()?.to_tket1(py),
+            CircuitType::Tket1 => SerialCircuit::encode_with_config(
+                &circ,
+                tket_qsystem::pytket::qsystem_encoder_config(),
+            )
+            .convert_pyerrs()?
+            .to_tket1(py),
             CircuitType::Tket => Ok(Bound::new(py, Tk2Circuit { circ })?.into_any()),
         }
     }
@@ -62,7 +67,9 @@ where
         Ok(t2circ) => (t2circ.circ, CircuitType::Tket),
         // tket1 circuit
         Err(_) => (
-            SerialCircuit::from_tket1(circ)?.decode().convert_pyerrs()?,
+            SerialCircuit::from_tket1(circ)?
+                .decode_with_config(tket_qsystem::pytket::qsystem_decoder_config())
+                .convert_pyerrs()?,
             CircuitType::Tket1,
         ),
     };

tket-py/src/circuit/convert.rs

@@ -81,7 +81,9 @@ impl Tk2Circuit {
     /// Convert the [`Tk2Circuit`] to a tket1 circuit.
     pub fn to_tket1<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         let circ = lower_to_pytket(&self.circ).convert_pyerrs()?;
-        SerialCircuit::encode(&circ).convert_pyerrs()?.to_tket1(py)
+        SerialCircuit::encode_with_config(&circ, tket_qsystem::pytket::qsystem_encoder_config())
+            .convert_pyerrs()?
+            .to_tket1(py)
     }
 
     /// Apply a rewrite on the circuit.
@@ -151,15 +153,26 @@ impl Tk2Circuit {
     pub fn to_tket1_json(&self) -> PyResult<String> {
         // Try to simplify tuple pack-unpack pairs, and other operations not supported by pytket.
         let circ = lower_to_pytket(&self.circ).convert_pyerrs()?;
-        serde_json::to_string(&SerialCircuit::encode(&circ).convert_pyerrs()?).map_err(|e| {
+        serde_json::to_string(
+            &SerialCircuit::encode_with_config(
+                &circ,
+                tket_qsystem::pytket::qsystem_encoder_config(),
+            )
+            .convert_pyerrs()?,
+        )
+        .map_err(|e| {
             PyErr::new::<PyValueError, _>(format!("Could not encode pytket circuit to str: {e}"))
         })
     }
 
     /// Decode a tket1 json string to a circuit.
     #[staticmethod]
     pub fn from_tket1_json(json: &str) -> PyResult<Self> {
-        let circ = tket::serialize::load_tk1_json_str(json).map_err(|e| {
+        let circ = tket::serialize::load_tk1_json_str(
+            json,
+            Some(tket_qsystem::pytket::qsystem_decoder_config()),
+        )
+        .map_err(|e| {
             PyErr::new::<PyAttributeError, _>(format!("Could not load pytket circuit: {e}"))
         })?;
         Ok(Tk2Circuit { circ })
@@ -169,15 +182,26 @@ impl Tk2Circuit {
     pub fn to_tket1_json_bytes(&self) -> PyResult<Vec<u8>> {
         // Try to simplify tuple pack-unpack pairs, and other operations not supported by pytket.
         let circ = lower_to_pytket(&self.circ).convert_pyerrs()?;
-        serde_json::to_vec(&SerialCircuit::encode(&circ).convert_pyerrs()?).map_err(|e| {
+        serde_json::to_vec(
+            &SerialCircuit::encode_with_config(
+                &circ,
+                tket_qsystem::pytket::qsystem_encoder_config(),
+            )
+            .convert_pyerrs()?,
+        )
+        .map_err(|e| {
             PyErr::new::<PyValueError, _>(format!("Could not encode pytket circuit to bytes: {e}"))
         })
     }
 
     /// Decode a tket1 json utf8 bytes to a circuit.
     #[staticmethod]
     pub fn from_tket1_json_bytes(json: &[u8]) -> PyResult<Self> {
-        let circ = tket::serialize::load_tk1_json_reader(json).map_err(|e| {
+        let circ = tket::serialize::load_tk1_json_reader(
+            json,
+            Some(tket_qsystem::pytket::qsystem_decoder_config()),
+        )
+        .map_err(|e| {
             PyErr::new::<PyAttributeError, _>(format!("Could not load pytket circuit: {e}"))
         })?;
         Ok(Tk2Circuit { circ })

tket-py/src/circuit/tk2circuit.rs

@@ -54,3 +54,25 @@ def test_conversion():
 
     assert tk1_back == tk1
     assert type(tk1_back) is Circuit
+
+
+def test_conversion_qsystem():
+    tk1 = Circuit(2).ZZPhase(0.75, 0, 1).PhasedX(0.25, 0.33, 1)
+    tk1_dot = render_circuit_dot(tk1)
+
+    tk2 = Tk2Circuit(tk1)
+    tk2_dot = render_circuit_dot(tk2)
+
+    assert type(tk2) is Tk2Circuit
+    assert tk1_dot == tk2_dot
+
+    # Check that we didn't use the opaque tk1 op fallback.
+    # TODO: There's no way to traverse the circuit nodes??
+    assert "TKET1.tk1op" not in tk1_dot
+    assert "tket.qsystem.PhasedX" in tk1_dot
+    assert "tket.qsystem.ZZPhase" in tk1_dot
+
+    tk1_back = tk2.to_tket1()
+
+    assert tk1_back == tk1
+    assert type(tk1_back) is Circuit

tket-py/test/test_circuit.py

@@ -674,6 +674,7 @@ mod tests {
             ],
             "implicit_permutation": [[["q", [0]], ["q", [0]]], [["q", [1]], ["q", [1]]]]
         }"#,
+            None,
         )
         .unwrap()
     }

tket/src/circuit.rs

@@ -24,7 +24,7 @@
 //! use hugr::HugrView;
 //!
 //! // Load a tket1 circuit.
-//! let mut circ: Circuit = tket::serialize::load_tk1_json_file("../test_files/barenco_tof_5.json").unwrap();
+//! let mut circ: Circuit = tket::serialize::load_tk1_json_file("../test_files/barenco_tof_5.json", None).unwrap();
 //!
 //! assert_eq!(circ.qubit_count(), 9);
 //! assert_eq!(circ.num_operations(), 170);

tket/src/lib.rs

@@ -641,7 +641,7 @@ mod tests {
     /// A circuit that would trigger non-composable rewrites, if we applied them blindly from nam_6_3 matches.
     #[fixture]
     fn non_composable_rw_hugr() -> Circuit {
-        load_tk1_json_str(NON_COMPOSABLE).unwrap()
+        load_tk1_json_str(NON_COMPOSABLE, None).unwrap()
     }
 
     /// A badger optimiser using a reduced set of rewrite rules.