feat: Exhaustive greedy rewrite strategy (#151)

This is a straight combination of the greedy and exhaustive strategies.
Instead of applying each strategy separately, apply each one once but
also include all the following strategies that do not modify the same
nodes.

This is a draft, since for some reason combining multiple strategies at
once is invalidating the hugr.
They may not be correctly reporting their modified nodes ?

Cargo.toml

@@ -73,7 +73,7 @@ members = ["pyrs", "compile-rewriter", "taso-optimiser"]
 
 [workspace.dependencies]
 
-quantinuum-hugr = { git = "https://github.com/CQCL-DEV/hugr", rev = "09494f1" }
+quantinuum-hugr = { git = "https://github.com/CQCL-DEV/hugr", rev = "9254ac7" }
 portgraph = { version = "0.9", features = ["serde"] }
 pyo3 = { version = "0.19" }
 itertools = { version = "0.11.0" }

src/circuit/cost.rs

@@ -5,7 +5,7 @@ use hugr::ops::OpType;
 use std::fmt::{Debug, Display};
 use std::iter::Sum;
 use std::num::NonZeroUsize;
-use std::ops::Add;
+use std::ops::{Add, AddAssign};
 
 use crate::ops::op_matches;
 use crate::T2Op;
@@ -29,7 +29,9 @@ pub trait CircuitCost: Add<Output = Self> + Sum<Self> + Debug + Default + Clone
 }
 
 /// The cost for a group of operations in a circuit, each with cost `OpCost`.
-pub trait CostDelta: Sum<Self> + Debug + Default + Clone + Ord {
+pub trait CostDelta:
+    AddAssign + Add<Output = Self> + Sum<Self> + Debug + Default + Clone + Ord
+{
     /// Return the delta as a `isize`. This may discard some of the cost delta information.
     fn as_isize(&self) -> isize;
 }
@@ -62,14 +64,21 @@ impl<T: Display> Debug for MajorMinorCost<T> {
     }
 }
 
-impl Add for MajorMinorCost {
-    type Output = MajorMinorCost;
+impl<T: Add<Output = T>> Add for MajorMinorCost<T> {
+    type Output = MajorMinorCost<T>;
 
-    fn add(self, rhs: MajorMinorCost) -> Self::Output {
+    fn add(self, rhs: MajorMinorCost<T>) -> Self::Output {
         (self.major + rhs.major, self.minor + rhs.minor).into()
     }
 }
 
+impl<T: AddAssign> AddAssign for MajorMinorCost<T> {
+    fn add_assign(&mut self, rhs: Self) {
+        self.major += rhs.major;
+        self.minor += rhs.minor;
+    }
+}
+
 impl<T: Add<Output = T> + Default> Sum for MajorMinorCost<T> {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
         iter.reduce(|a, b| (a.major + b.major, a.minor + b.minor).into())

src/optimiser/taso.rs

@@ -169,7 +169,6 @@ where
                     // Ignore this circuit: we've already seen it
                     continue;
                 }
-                circ_cnt += 1;
                 logger.log_progress(circ_cnt, Some(pq.len()), seen_hashes.len());
                 let new_circ_cost = cost.add_delta(&cost_delta);
                 pq.push_unchecked(new_circ, new_circ_hash, new_circ_cost);
@@ -390,22 +389,22 @@ mod taso_default {
     use hugr::ops::OpType;
 
     use crate::rewrite::ecc_rewriter::RewriterSerialisationError;
-    use crate::rewrite::strategy::NonIncreasingGateCountStrategy;
+    use crate::rewrite::strategy::{ExhaustiveGreedyStrategy, NonIncreasingGateCountCost};
     use crate::rewrite::ECCRewriter;
 
     use super::*;
 
+    pub type StrategyCost = NonIncreasingGateCountCost<fn(&OpType) -> usize, fn(&OpType) -> usize>;
+
     /// The default TASO optimiser using ECC sets.
-    pub type DefaultTasoOptimiser = TasoOptimiser<
-        ECCRewriter,
-        NonIncreasingGateCountStrategy<fn(&OpType) -> usize, fn(&OpType) -> usize>,
-    >;
+    pub type DefaultTasoOptimiser =
+        TasoOptimiser<ECCRewriter, ExhaustiveGreedyStrategy<StrategyCost>>;
 
     impl DefaultTasoOptimiser {
         /// A sane default optimiser using the given ECC sets.
         pub fn default_with_eccs_json_file(eccs_path: impl AsRef<Path>) -> io::Result<Self> {
             let rewriter = ECCRewriter::try_from_eccs_json_file(eccs_path)?;
-            let strategy = NonIncreasingGateCountStrategy::default_cx();
+            let strategy = NonIncreasingGateCountCost::default_cx();
             Ok(TasoOptimiser::new(rewriter, strategy))
         }
 
@@ -414,7 +413,7 @@ mod taso_default {
             rewriter_path: impl AsRef<Path>,
         ) -> Result<Self, RewriterSerialisationError> {
             let rewriter = ECCRewriter::load_binary(rewriter_path)?;
-            let strategy = NonIncreasingGateCountStrategy::default_cx();
+            let strategy = NonIncreasingGateCountCost::default_cx();
             Ok(TasoOptimiser::new(rewriter, strategy))
         }
     }

src/rewrite.rs

@@ -101,6 +101,16 @@ impl CircuitRewrite {
         self.0.replacement()
     }
 
+    /// Returns a set of nodes referenced by the rewrite. Modifying any these
+    /// nodes will invalidate it.
+    ///
+    /// Two `CircuitRewrite`s can be composed if their invalidation sets are
+    /// disjoint.
+    #[inline]
+    pub fn invalidation_set(&self) -> impl Iterator<Item = Node> + '_ {
+        self.0.invalidation_set()
+    }
+
     delegate! {
         to self.0 {
             /// Apply the rewrite rule to a circuit.