feat: gridsynth pass

Cargo.toml

@@ -104,7 +104,4 @@ cool_asserts = "2.0.4"
 zstd = "0.13.3"
 anyhow = "1.0.100"
 num-rational = "0.4.2"
-
-[profile.release.package.tket-py]
-# Some configurations to reduce the size of tket wheels
-strip = true
+rsgridsynth = "0.2.0"

tket-py/Cargo.toml

@@ -26,7 +26,6 @@ tket = { path = "../tket", version = "0.16.0", features = [
 ] }
 tket-qsystem = { path = "../tket-qsystem", version = "0.22.0" }
 tket1-passes = { path = "../tket1-passes", version = "0.0.0" }
-
 derive_more = { workspace = true, features = ["into", "from"] }
 hugr = { workspace = true }
 itertools = { workspace = true }

tket-py/src/passes.rs

@@ -1,6 +1,7 @@
 //! Passes for optimising circuits.
 
 pub mod chunks;
+pub mod gridsynth;
 pub mod tket1;
 
 use std::{cmp::min, convert::TryInto, fs, num::NonZeroUsize, path::PathBuf};
@@ -29,6 +30,7 @@ pub fn module(py: Python<'_>) -> PyResult<Bound<'_, PyModule>> {
     m.add_function(wrap_pyfunction!(normalize_guppy, &m)?)?;
     m.add_class::<self::chunks::PyCircuitChunks>()?;
     m.add_function(wrap_pyfunction!(self::chunks::chunks, &m)?)?;
+    m.add_function(wrap_pyfunction!(self::gridsynth::gridsynth, &m)?)?;
     m.add_function(wrap_pyfunction!(self::tket1::tket1_pass, &m)?)?;
     m.add("PullForwardError", py.get_type::<PyPullForwardError>())?;
     m.add("TK1PassError", py.get_type::<tket1::PytketPassError>())?;

tket-py/src/passes/gridsynth.rs

@@ -0,0 +1,32 @@
+//! Bindings to allow users to access the gridsynth pass from Python.
+//! The definitions here should be reflected in the
+//! `tket-py/tket/_tket/passes.pyi` type stubs file
+use crate::circuit::CircuitType;
+use crate::circuit::try_with_circ;
+use crate::utils::{ConvertPyErr, create_py_exception};
+use pyo3::prelude::*;
+use tket::passes::gridsynth::apply_gridsynth_pass;
+
+create_py_exception!(
+    tket::passes::gridsynth::GridsynthError,
+    PyGridsynthError,
+    "Errors from the gridsynth pass."
+);
+
+/// Binding to a python function called gridsynth that runs the rust function called
+/// apply_gridsynth pass behind the scenes
+#[pyfunction]
+pub fn gridsynth<'py>(
+    circ: &Bound<'py, PyAny>,
+    epsilon: f64,
+    simplify: bool,
+) -> PyResult<Bound<'py, PyAny>> {
+    let py = circ.py();
+
+    try_with_circ(circ, |mut circ: tket::Circuit, typ: CircuitType| {
+        apply_gridsynth_pass(circ.hugr_mut(), epsilon, simplify).convert_pyerrs()?;
+
+        let circ = typ.convert(py, circ)?;
+        PyResult::Ok(circ)
+    })
+}

tket-py/tket/_tket/passes.pyi

@@ -105,3 +105,15 @@ def tket1_pass(
       circuit-like regions, and optimise them too.
       nested inside other subregions of the circuit.
     """
+
+def gridsynth(hugr: CircuitClass, epsilon: float, simplify: bool) -> CircuitClass:
+    """Runs a pass applying the gridsynth algorithm to all Rz gates in a HUGR,
+    which decomposes them into the Clifford + T basis.
+
+    Parameters:
+    - hugr: the hugr to run the pass on.
+    - epsilon: the precision of the gridsynth decomposition
+    - simplify: if `True`, each sequence of gridsynth gates is compressed into
+      a sequence of H*T and H*Tdg gates, sandwiched by Clifford gates. This sequence
+      always has a smaller number of S and H gates, and the same number of T+Tdg gates.
+    """

tket-py/tket/passes.py

@@ -31,6 +31,7 @@
     tket1_pass,
     normalize_guppy,
     PullForwardError,
+    gridsynth,
 )
 
 __all__ = [
@@ -176,3 +177,48 @@ def _normalize(self, hugr: Hugr, inplace: bool) -> PassResult:
         )
         new_hugr = Hugr.from_str(opt_program.to_str())
         return PassResult.for_pass(self, hugr=new_hugr, inplace=inplace, result=None)
+
+
+@dataclass
+class Gridsynth(ComposablePass):
+    epsilon: float
+    simplify: bool = True
+
+    """Apply the gridsynth algorithm to all Rz gates in the Hugr.
+
+    This includes a NormalizeGuppy pass with all of the constituent passes applied
+    before applying gridsynth to standardise the
+    format.
+
+    Parameters:
+    - epsilon: The allowable error tolerance.
+    - simplify: If `True`, each sequence of gridsynth gates is compressed into
+      a sequence of H*T and H*Tdg gates, sandwiched by Clifford gates. This sequence
+      always has a smaller number of S and H gates, and the same number of T+Tdg gates.
+    """
+
+    # TO DO: make the NormalizeGuppy pass optional, in case it is already run
+    # before Gridsynth. Need to warn users, at least in docs that if NormalizeGuppy
+    # is not run first then Gridsynth is likely to fail. Maybe issue the warning if
+    # the option to run NormalizeGuppy is set to False. The option would be specified
+    # as a field of the dataclass (would also need to add @dataclass decorator)
+    # like for NormalizeGuppy above
+    def run(self, hugr: Hugr, *, inplace: bool = True) -> PassResult:
+        # inplace option does nothing for now but I retain for consistency of
+        # API with other passes
+        return implement_pass_run(
+            self,
+            hugr=hugr,
+            inplace=inplace,
+            copy_call=lambda h: self._apply_gridsynth_pass(
+                hugr, self.epsilon, self.simplify, inplace
+            ),
+        )
+
+    def _apply_gridsynth_pass(
+        self, hugr: Hugr, epsilon: float, simplify: bool, inplace: bool
+    ) -> PassResult:
+        compiler_state: Tk2Circuit = Tk2Circuit.from_bytes(hugr.to_bytes())
+        program = gridsynth(compiler_state, epsilon, simplify)
+        new_hugr = Hugr.from_str(program.to_str())
+        return PassResult.for_pass(self, hugr=new_hugr, inplace=inplace, result=None)

tket/Cargo.toml

@@ -77,6 +77,7 @@ pest_derive = { workspace = true }
 zstd = { workspace = true, optional = true }
 anyhow = { workspace = true, optional = true }
 num-rational = { workspace = true }
+rsgridsynth = { workspace = true }
 
 
 [dev-dependencies]

tket/src/passes.rs

@@ -16,6 +16,8 @@ pub use guppy::NormalizeGuppy;
 pub mod pytket;
 pub use pytket::lower_to_pytket;
 
+pub mod gridsynth;
+
 pub mod tuple_unpack;
 #[expect(deprecated)]
 pub use tuple_unpack::find_tuple_unpack_rewrites;