Merge RoutingMethod::check_method and RoutingMethod::routing_method

pytket/binders/mapping.cpp

@@ -40,24 +40,23 @@ PYBIND11_MODULE(mapping, m) {
       "whole circuits.")
       .def(
           py::init<
-              const std::function<std::tuple<Circuit, unit_map_t, unit_map_t>(
-                  const Circuit&, const ArchitecturePtr&)>&,
-              const std::function<bool(const Circuit&, const ArchitecturePtr&)>,
+              const std::function<
+                  std::tuple<bool, Circuit, unit_map_t, unit_map_t>(
+                      const Circuit&, const ArchitecturePtr&)>&,
               unsigned, unsigned>(),
           "Constructor for a routing method defined by partially routing "
           "subcircuits.\n\n:param route_subcircuit: A function declaration "
           "that given a Circuit and Architecture object, returns a tuple "
-          "containing a new modified circuit, the initial logical to physical "
+          "containing a bool informing MappingManager whether to substitue "
+          "the returned circuit into the circuit being routed, "
+          "a new modified circuit, the initial logical to physical "
           "qubit mapping of the modified circuit and the permutation of "
           "logical to physical qubit mapping given operations in the "
-          "modified circuit\n:param check_subcircuit: A function declaration "
-          "that given a Circuit and Architecture object, returns a bool "
-          "stating whether the given method can modify the "
-          "given circuit\n:param max_size: The maximum number of gates "
+          "modified circuit\n:param max_size: The maximum number of gates "
           "permitted in a subcircuit\n:param max_depth: The maximum permitted "
           "depth of a subcircuit.",
-          py::arg("route_subcircuit"), py::arg("check_subcircuit"),
-          py::arg("max_size"), py::arg("max_depth"));
+          py::arg("route_subcircuit"), py::arg("max_size"),
+          py::arg("max_depth"));
 
   py::class_<
       LexiRouteRoutingMethod, std::shared_ptr<LexiRouteRoutingMethod>,

pytket/tests/mapping_test.py

@@ -23,7 +23,7 @@
 # simple deterministic heuristic used for testing purposes
 def route_subcircuit_func(
     circuit: Circuit, architecture: Architecture
-) -> Tuple[Circuit, Dict[Node, Node], Dict[Node, Node]]:
+) -> Tuple[bool, Circuit, Dict[Node, Node], Dict[Node, Node]]:
     #     make a replacement circuit with identical unitds
     replacement_circuit = Circuit()
     for qb in circuit.qubits:
@@ -60,7 +60,7 @@ def route_subcircuit_func(
     for com in circuit.get_commands():
         rp_qubits = [permutation_map[relabelling_map[q]] for q in com.qubits]
         if len(com.qubits) > 2:
-            raise ValueError("Command must have maximum two qubits")
+            return (False, Circuit(), {}, {})
         if len(com.qubits) == 1:
             replacement_circuit.add_gate(com.op.type, rp_qubits)
         if len(com.qubits) == 2:
@@ -90,15 +90,13 @@ def route_subcircuit_func(
 
             replacement_circuit.add_gate(com.op.type, rp_qubits)
 
-    return (replacement_circuit, relabelling_map, permutation_map)
+    return (True, replacement_circuit, relabelling_map, permutation_map)
 
 
-def check_subcircuit_func_true(circuit: Circuit, architecture: Architecture) -> bool:
-    return True
-
-
-def check_subcircuit_func_false(circuit: Circuit, architecture: Architecture) -> bool:
-    return False
+def route_subcircuit_func_false(
+    circuit: Circuit, architecture: Architecture
+) -> Tuple[bool, Circuit, Dict[Node, Node], Dict[Node, Node]]:
+    return (False, Circuit(), {}, {})
 
 
 def test_LexiRouteRoutingMethod() -> None:
@@ -127,7 +125,7 @@ def test_RoutingMethodCircuit_custom() -> None:
     test_mm = MappingManager(test_a)
     test_mm.route_circuit(
         test_c,
-        [RoutingMethodCircuit(route_subcircuit_func, check_subcircuit_func_true, 5, 5)],
+        [RoutingMethodCircuit(route_subcircuit_func, 5, 5)],
     )
     routed_commands = test_c.get_commands()
 
@@ -152,9 +150,7 @@ def test_RoutingMethodCircuit_custom_list() -> None:
     test_mm.route_circuit(
         test_c,
         [
-            RoutingMethodCircuit(
-                route_subcircuit_func, check_subcircuit_func_false, 5, 5
-            ),
+            RoutingMethodCircuit(route_subcircuit_func_false, 5, 5),
             LexiRouteRoutingMethod(),
         ],
     )
@@ -173,9 +169,7 @@ def test_RoutingMethodCircuit_custom_list() -> None:
     test_mm.route_circuit(
         test_c,
         [
-            RoutingMethodCircuit(
-                route_subcircuit_func, check_subcircuit_func_true, 5, 5
-            ),
+            RoutingMethodCircuit(route_subcircuit_func, 5, 5),
             LexiRouteRoutingMethod(),
         ],
     )

tket/src/Mapping/LexiRoute.cpp

@@ -509,18 +509,12 @@ void LexiRoute::solve(unsigned lookahead) {
 LexiRouteRoutingMethod::LexiRouteRoutingMethod(unsigned _max_depth)
     : max_depth_(_max_depth){};
 
-bool LexiRouteRoutingMethod::check_method(
-    const std::shared_ptr<MappingFrontier>& /*mapping_frontier*/,
-    const ArchitecturePtr& /*architecture*/) const {
-  return true;
-}
-
-unit_map_t LexiRouteRoutingMethod::routing_method(
+std::pair<bool, unit_map_t> LexiRouteRoutingMethod::routing_method(
     std::shared_ptr<MappingFrontier>& mapping_frontier,
     const ArchitecturePtr& architecture) const {
   LexiRoute lr(architecture, mapping_frontier);
   lr.solve(this->max_depth_);
-  return {};
+  return {true, {}};
 }
 
 unsigned LexiRouteRoutingMethod::get_max_depth() const {

tket/src/Mapping/MappingManager.cpp

@@ -71,20 +71,19 @@ bool MappingManager::route_circuit_with_maps(
   bool circuit_modified = !check_finish();
   while (!check_finish()) {
     // The order methods are passed in std::vector<RoutingMethod> is
-    // the order they are iterated through to call "check_method"
+    // the order they are run
     // If a method performs better but only on specific subcircuits,
     // rank it earlier in the passed vector
     bool valid_methods = false;
     for (const auto& rm : routing_methods) {
       // true => can use held routing method
-      if (rm->check_method(mapping_frontier, this->architecture_)) {
+      std::pair<bool, unit_map_t> bool_map =
+          rm->routing_method(mapping_frontier, this->architecture_);
+      if (bool_map.first) {
         valid_methods = true;
-        unit_map_t partial_permutation =
-            rm->routing_method(mapping_frontier, this->architecture_);
-
-        if (partial_permutation.size() > 0) {
+        if (bool_map.second.size() > 0) {
           std::map<Node, Node> node_map;
-          for (const auto& x : partial_permutation) {
+          for (const auto& x : bool_map.second) {
             node_map.insert({Node(x.first), Node(x.second)});
           }
           for (const std::pair<Node, Node>& swap :

tket/src/Mapping/MultiGateReorder.cpp

@@ -185,7 +185,7 @@ static void partial_rewire(
   }
 }
 
-void MultiGateReorder::solve(unsigned max_depth, unsigned max_size) {
+bool MultiGateReorder::solve(unsigned max_depth, unsigned max_size) {
   // Assume the frontier has been advanced
 
   // store a copy of the original this->mapping_frontier_->quantum_boundray
@@ -199,6 +199,9 @@ void MultiGateReorder::solve(unsigned max_depth, unsigned max_size) {
   // Get a subcircuit only for iterating vertices
   Subcircuit circ =
       this->mapping_frontier_->get_frontier_subcircuit(max_depth, max_size);
+
+  // for return value
+  bool modification_made = false;
   // since we assume that the frontier has been advanced
   // we are certain that any multi-q vert lies after the frontier
   for (const Vertex &vert : circ.verts) {
@@ -213,6 +216,7 @@ void MultiGateReorder::solve(unsigned max_depth, unsigned max_size) {
               this->mapping_frontier_->circuit_, this->u_frontier_edges_, vert);
 
       if (commute_pairs != std::nullopt) {
+        modification_made = true;
         partial_rewire(
             vert, this->mapping_frontier_->circuit_, (*commute_pairs).first,
             (*commute_pairs).second);
@@ -227,44 +231,18 @@ void MultiGateReorder::solve(unsigned max_depth, unsigned max_size) {
   }
   // Return the quantum boundary to its original setting
   this->mapping_frontier_->set_quantum_boundary(copy);
+  return modification_made;
 }
 
 MultiGateReorderRoutingMethod::MultiGateReorderRoutingMethod(
     unsigned _max_depth, unsigned _max_size)
     : max_depth_(_max_depth), max_size_(_max_size) {}
 
-bool MultiGateReorderRoutingMethod::check_method(
-    const std::shared_ptr<MappingFrontier> &mapping_frontier,
-    const ArchitecturePtr &architecture) const {
-  const EdgeVec u_frontier_edges =
-      convert_u_frontier_to_edges(*frontier_convert_vertport_to_edge(
-          mapping_frontier->circuit_, mapping_frontier->quantum_boundary));
-
-  Subcircuit circ = mapping_frontier->get_frontier_subcircuit(
-      this->max_depth_, this->max_size_);
-  // since we assume that the frontier has been advanced
-  // we are certain that any multi-q vert lies after the frontier
-  for (const Vertex &vert : circ.verts) {
-    if (is_multiq_quantum_gate(mapping_frontier->circuit_, vert) &&
-        is_physically_permitted(mapping_frontier, architecture, vert)) {
-      std::optional<std::pair<EdgeVec, EdgeVec>> commute_pairs =
-          try_find_commute_edges(
-              mapping_frontier->circuit_, u_frontier_edges, vert);
-
-      if (commute_pairs != std::nullopt) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-unit_map_t MultiGateReorderRoutingMethod::routing_method(
+std::pair<bool, unit_map_t> MultiGateReorderRoutingMethod::routing_method(
     std::shared_ptr<MappingFrontier> &mapping_frontier,
     const ArchitecturePtr &architecture) const {
   MultiGateReorder mr(architecture, mapping_frontier);
-  mr.solve(this->max_depth_, this->max_size_);
-  return {};
+  return {mr.solve(this->max_depth_, this->max_size_), {}};
 }
 
 unsigned MultiGateReorderRoutingMethod::get_max_depth() const {

tket/src/Mapping/RoutingMethodCircuit.cpp

@@ -17,32 +17,15 @@
 namespace tket {
 
 RoutingMethodCircuit::RoutingMethodCircuit(
-    const std::function<std::tuple<Circuit, unit_map_t, unit_map_t>(
+    const std::function<std::tuple<bool, Circuit, unit_map_t, unit_map_t>(
         const Circuit&, const ArchitecturePtr&)>
         _route_subcircuit,
-    const std::function<bool(const Circuit&, const ArchitecturePtr&)>
-        _check_subcircuit,
     unsigned _max_size, unsigned _max_depth)
     : route_subcircuit_(_route_subcircuit),
-      check_subcircuit_(_check_subcircuit),
       max_size_(_max_size),
       max_depth_(_max_depth){};
 
-bool RoutingMethodCircuit::check_method(
-    const std::shared_ptr<MappingFrontier>& mapping_frontier,
-    const ArchitecturePtr& architecture) const {
-  // Get circuit, pass to held check method
-  Subcircuit frontier_subcircuit = mapping_frontier->get_frontier_subcircuit(
-      this->max_depth_, this->max_size_);
-  Circuit frontier_circuit =
-      mapping_frontier->circuit_.subcircuit(frontier_subcircuit);
-  frontier_circuit.rename_units(
-      mapping_frontier->get_default_to_quantum_boundary_unit_map());
-
-  return this->check_subcircuit_(frontier_circuit, architecture);
-}
-
-unit_map_t RoutingMethodCircuit::routing_method(
+std::pair<bool, unit_map_t> RoutingMethodCircuit::routing_method(
     std::shared_ptr<MappingFrontier>& mapping_frontier,
     const ArchitecturePtr& architecture) const {
   // Produce subcircuit and circuit
@@ -54,30 +37,33 @@ unit_map_t RoutingMethodCircuit::routing_method(
       mapping_frontier->get_default_to_quantum_boundary_unit_map());
 
   // get routed subcircuit
-  std::tuple<Circuit, unit_map_t, unit_map_t> routed_subcircuit =
+  std::tuple<bool, Circuit, unit_map_t, unit_map_t> routed_subcircuit =
       this->route_subcircuit_(frontier_circuit, architecture);
-  unit_map_t new_labelling = std::get<1>(routed_subcircuit);
+
+  if (!get<0>(routed_subcircuit)) {
+    return {false, {}};
+  }
 
   // update unit id at boundary in case of relabelling
-  mapping_frontier->update_quantum_boundary_uids(new_labelling);
+  mapping_frontier->update_quantum_boundary_uids(get<2>(routed_subcircuit));
 
   unit_map_t swap_permutation;
-  for (const auto& pair : new_labelling) {
+  for (const auto& pair : get<2>(routed_subcircuit)) {
     if (pair.first != pair.second &&
         architecture->node_exists(Node(pair.first))) {
       swap_permutation.insert(pair);
     }
   }
   // permute edges held by unitid at out boundary due to swaps
   mapping_frontier->permute_subcircuit_q_out_hole(
-      std::get<2>(routed_subcircuit), frontier_subcircuit);
+      get<3>(routed_subcircuit), frontier_subcircuit);
 
   // substitute old boundary with new cirucit
-  std::get<0>(routed_subcircuit).flatten_registers();
+  get<1>(routed_subcircuit).flatten_registers();
   mapping_frontier->circuit_.substitute(
-      std::get<0>(routed_subcircuit), frontier_subcircuit);
+      get<1>(routed_subcircuit), frontier_subcircuit);
   // return initial unit_map_t incase swap network required
-  return swap_permutation;
+  return {true, swap_permutation};
 }
 
 }  // namespace tket

tket/src/Mapping/include/Mapping/LexiRoute.hpp

@@ -169,21 +169,15 @@ class LexiRouteRoutingMethod : public RoutingMethod {
    */
   LexiRouteRoutingMethod(unsigned _max_depth = 100);
 
-  /**
-   * @return true if method can route subcircuit, false if not
-   */
-  bool check_method(
-      const std::shared_ptr<MappingFrontier>& /*mapping_frontier*/,
-      const ArchitecturePtr& /*architecture*/) const override;
-
   /**
    * @param mapping_frontier Contains boundary of routed/unrouted circuit for
    * modifying
    * @param architecture Architecture providing physical constraints
-   * @return Map between relabelled Qubit, always empty.
+   *
+   * @return true bool, map between relabelled Qubit, always empty.
    *
    */
-  unit_map_t routing_method(
+  std::pair<bool, unit_map_t> routing_method(
       std::shared_ptr<MappingFrontier>& mapping_frontier,
       const ArchitecturePtr& architecture) const override;
 

tket/src/Mapping/include/Mapping/MultiGateReorder.hpp

@@ -34,8 +34,10 @@ class MultiGateReorder {
    * Try to commute any multi-qubit gates to the quantum frontier
    * @param max_depth Maximum number of layers of gates checked for commutation.
    * @param max_size Maximum number of gates checked for commutation.
+   *
+   * @return true if modification made
    */
-  void solve(unsigned max_depth, unsigned max_size);
+  bool solve(unsigned max_depth, unsigned max_size);
 
  private:
   // Architecture all new physical operations must respect
@@ -55,21 +57,15 @@ class MultiGateReorderRoutingMethod : public RoutingMethod {
   MultiGateReorderRoutingMethod(
       unsigned _max_depth = 10, unsigned _max_size = 10);
 
-  /**
-   * @return true if method can route subcircuit, false if not
-   */
-  bool check_method(
-      const std::shared_ptr<MappingFrontier>& /*mapping_frontier*/,
-      const ArchitecturePtr& /*architecture*/) const override;
-
   /**
    * @param mapping_frontier Contains boundary of routed/unrouted circuit for
    * modifying
    * @param architecture Architecture providing physical constraints
-   * @return Logical to Physical mapping at boundary due to modification.
+   * @return Whether circuit is modified and Logical to Physical mapping at
+   * boundary due to modification (always empty)
    *
    */
-  unit_map_t routing_method(
+  std::pair<bool, unit_map_t> routing_method(
       std::shared_ptr<MappingFrontier>& mapping_frontier,
       const ArchitecturePtr& architecture) const override;