use hugr lowering functions

and can't lower rz directly any more (mismatched angle types)

Cargo.toml

@@ -26,8 +26,8 @@ missing_docs = "warn"
 [workspace.dependencies]
 
 # Make sure to run `just recompile-eccs` if the hugr serialisation format changes.
-hugr = "0.12.0"
-hugr-core = "0.9.0"
+hugr = "0.12.1"
+hugr-core = "0.9.1"
 portgraph = "0.12"
 pyo3 = "0.21.2"
 itertools = "0.13.0"

tket2-hseries/src/extension/hseries.rs

@@ -206,24 +206,27 @@ impl<D: Dataflow> HSeriesOpBuilder for D {}
 /// Lower `Tk2Op` operations to `HSeriesOp` operations.
 pub fn lower_tk2_op(
     mut hugr: impl hugr::hugr::hugrmut::HugrMut,
-) -> Result<(), Box<dyn std::error::Error>> {
-    tket2::passes::replace_ops(&mut hugr, |op| {
+) -> Result<Vec<hugr::Node>, Box<dyn std::error::Error>> {
+    let replaced_nodes = hugr::algorithms::replace_many_ops(&mut hugr, |op| {
         let op: Tk2Op = op.cast()?;
         Some(match op {
             Tk2Op::QAlloc => HSeriesOp::QAlloc,
             Tk2Op::QFree => HSeriesOp::QFree,
             Tk2Op::Reset => HSeriesOp::Reset,
             Tk2Op::Measure => HSeriesOp::Measure,
-            Tk2Op::Rz => HSeriesOp::Rz,
             _ => return None,
         })
-    })?;
+    })?
+    .into_iter()
+    .map(|(node, _)| node)
+    .collect::<Vec<_>>();
     fn pi_mul(builder: &mut impl Dataflow, multiplier: f64) -> Wire {
         builder.add_load_const(ops::Const::new(
             ConstF64::new(multiplier * std::f64::consts::PI).into(),
         ))
     }
-    tket2::passes::lower_ops(&mut hugr, |op| {
+
+    let lowered_nodes = hugr::algorithms::lower_ops(&mut hugr, |op| {
         let sig = op.dataflow_signature()?;
         let sig = Signature::new(sig.input, sig.output); // ignore extension delta
         let op = op.cast()?;
@@ -245,7 +248,7 @@ pub fn lower_tk2_op(
         })
     })?;
 
-    Ok(())
+    Ok([replaced_nodes, lowered_nodes].concat())
 }
 
 #[cfg(test)]
@@ -318,26 +321,19 @@ mod test {
 
     #[test]
     fn test_lower_direct() {
-        let mut b = FunctionBuilder::new(
-            "circuit",
-            Signature::new(type_row![FLOAT64_TYPE], type_row![]),
-        )
-        .unwrap();
-        let [angle] = b.input_wires_arr();
+        let mut b = FunctionBuilder::new("circuit", Signature::new_endo(type_row![])).unwrap();
         let [q] = b.add_dataflow_op(Tk2Op::QAlloc, []).unwrap().outputs_arr();
         let [q] = b.add_dataflow_op(Tk2Op::Reset, [q]).unwrap().outputs_arr();
-        let [q] = b
-            .add_dataflow_op(Tk2Op::Rz, [q, angle])
-            .unwrap()
-            .outputs_arr();
         let [q, _] = b
             .add_dataflow_op(Tk2Op::Measure, [q])
             .unwrap()
             .outputs_arr();
         b.add_dataflow_op(Tk2Op::QFree, [q]).unwrap();
         // TODO remaining ops
         let mut h = b.finish_hugr_with_outputs([], &REGISTRY).unwrap();
-        lower_tk2_op(&mut h).unwrap();
+
+        let lowered = lower_tk2_op(&mut h).unwrap();
+        assert_eq!(lowered.len(), 4);
         let circ = Circuit::new(&h, h.root());
         let ops: Vec<HSeriesOp> = circ
             .commands()
@@ -348,7 +344,6 @@ mod test {
             vec![
                 HSeriesOp::QAlloc,
                 HSeriesOp::Reset,
-                HSeriesOp::Rz,
                 HSeriesOp::Measure,
                 HSeriesOp::QFree
             ]

tket2/src/passes.rs

@@ -1,64 +1,14 @@
 //! Optimisation passes and related utilities for circuits.
 
 mod commutation;
-use std::error::Error;
 
 pub use commutation::{apply_greedy_commutation, PullForwardError};
 
 pub mod chunks;
 pub use chunks::CircuitChunks;
 
 pub mod pytket;
-use hugr::{
-    hugr::{hugrmut::HugrMut, views::SiblingSubgraph, HugrError},
-    ops::OpType,
-    Hugr,
-};
 pub use pytket::lower_to_pytket;
 
 pub mod tuple_unpack;
 pub use tuple_unpack::find_tuple_unpack_rewrites;
-
-// TODO use HUGR versions once they are available
-
-/// Replace all operations in a HUGR according to a mapping.
-pub fn replace_ops<S: Into<OpType>>(
-    hugr: &mut impl HugrMut,
-    mapping: impl Fn(&OpType) -> Option<S>,
-) -> Result<(), HugrError> {
-    let replacements = hugr
-        .nodes()
-        .filter_map(|node| {
-            let new_op = mapping(hugr.get_optype(node))?;
-            Some((node, new_op))
-        })
-        .collect::<Vec<_>>();
-
-    for (node, new_op) in replacements {
-        hugr.replace_op(node, new_op)?;
-    }
-
-    Ok(())
-}
-
-/// Lower operations in a circuit according to a mapping to a new HUGR.
-pub fn lower_ops(
-    hugr: &mut impl HugrMut,
-    lowering: impl Fn(&OpType) -> Option<Hugr>,
-) -> Result<(), Box<dyn Error>> {
-    let replacements = hugr
-        .nodes()
-        .filter_map(|node| {
-            let hugr = lowering(hugr.get_optype(node))?;
-            Some((node, hugr))
-        })
-        .collect::<Vec<_>>();
-
-    for (node, replacement) in replacements {
-        let subcirc = SiblingSubgraph::try_from_nodes([node], hugr)?;
-        let rw = subcirc.create_simple_replacement(hugr, replacement)?;
-        hugr.apply_rewrite(rw)?;
-    }
-
-    Ok(())
-}