[feature] RV3.1

pytket/binders/architecture.cpp

@@ -19,8 +19,11 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include "Circuit/Circuit.hpp"
 #include "Utils/Json.hpp"
 #include "binder_json.hpp"
+#include "binder_utils.hpp"
+#include "typecast.hpp"
 
 namespace py = pybind11;
 using json = nlohmann::json;
@@ -56,6 +59,12 @@ PYBIND11_MODULE(architecture, m) {
           "given two nodes in Architecture, "
           "returns distance between them",
           py::arg("node_0"), py::arg("node_1"))
+      .def(
+          "valid_operation", &Architecture::valid_operation,
+          "Returns true if the given operation acting on the given ",
+          "nodes can be executed on the Architecture connectivity graph."
+          "\n\n:param uids: UnitID validity is being checked for",
+          py::arg("uids"))
       .def(
           "get_adjacent_nodes", &Architecture::get_neighbour_nodes,
           "given a node, returns adjacent nodes in Architecture.",

pytket/binders/mapping.cpp

@@ -13,12 +13,17 @@
 // limitations under the License.
 
 #include <pybind11/functional.h>
+#include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
+#include <pybind11/stl_bind.h>
 
+#include "Circuit/Circuit.hpp"
+#include "Mapping/LexiLabelling.hpp"
 #include "Mapping/LexiRoute.hpp"
 #include "Mapping/MappingManager.hpp"
 #include "Mapping/RoutingMethodCircuit.hpp"
+#include "binder_utils.hpp"
 
 namespace py = pybind11;
 
@@ -63,14 +68,22 @@ PYBIND11_MODULE(mapping, m) {
       RoutingMethod>(
       m, "LexiRouteRoutingMethod",
       "Defines a RoutingMethod object for mapping circuits that uses the "
-      "Lexicographical Comparison approach outlined in arXiv:1902.08091.")
+      "Lexicographical Comparison approach outlined in arXiv:1902.08091."
+      "Only supports 1-qubit, 2-qubit and barrier gates.")
       .def(
           py::init<unsigned>(),
           "LexiRoute constructor.\n\n:param lookahead: Maximum depth of "
           "lookahead employed when picking SWAP for purpose of logical to "
           "physical mapping.",
           py::arg("lookahead") = 10);
 
+  py::class_<
+      LexiLabellingMethod, std::shared_ptr<LexiLabellingMethod>, RoutingMethod>(
+      m, "LexiLabellingMethod",
+      "Defines a RoutingMethod for labelling Qubits that uses the "
+      "Lexicographical Comparison approach outlined in arXiv:1902.08091.")
+      .def(py::init<>(), "LexiLabellingMethod constructor.");
+
   py::class_<MappingManager>(
       m, "MappingManager",
       "Defined by a pytket Architecture object, maps Circuit logical qubits "

pytket/binders/passes.cpp

@@ -15,6 +15,8 @@
 #include <pybind11/functional.h>
 
 #include "ArchAwareSynth/SteinerForest.hpp"
+#include "Mapping/LexiLabelling.hpp"
+#include "Mapping/LexiRoute.hpp"
 #include "Mapping/RoutingMethod.hpp"
 #include "Predicates/CompilerPass.hpp"
 #include "Predicates/PassGenerators.hpp"
@@ -33,8 +35,9 @@ namespace tket {
 
 static PassPtr gen_cx_mapping_pass_kwargs(
     const Architecture &arc, const PlacementPtr &placer, py::kwargs kwargs) {
-  RoutingMethodPtr method = std::make_shared<LexiRouteRoutingMethod>();
-  std::vector<RoutingMethodPtr> config = {method};
+  std::vector<RoutingMethodPtr> config = {
+      std::make_shared<LexiLabellingMethod>(),
+      std::make_shared<LexiRouteRoutingMethod>()};
   if (kwargs.contains("config")) {
     config = py::cast<std::vector<RoutingMethodPtr>>(kwargs["config"]);
   }
@@ -50,8 +53,9 @@ static PassPtr gen_cx_mapping_pass_kwargs(
 }
 
 static PassPtr gen_default_routing_pass(const Architecture &arc) {
-  RoutingMethodPtr method = std::make_shared<LexiRouteRoutingMethod>();
-  std::vector<RoutingMethodPtr> config = {method};
+  std::vector<RoutingMethodPtr> config = {
+      std::make_shared<LexiLabellingMethod>(),
+      std::make_shared<LexiRouteRoutingMethod>()};
   return gen_routing_pass(arc, config);
 }
 

pytket/docs/changelog.rst

@@ -35,7 +35,11 @@ Minor new features:
 * New ``pytket.passes.NaivePlacementPass`` which completes a basic relabelling of all Circuit Qubit
   not labelled as some Architecture Node to any available Architecture Node
 * Add ``opgroups`` property to ``Circuit``.
-
+* ``Architecture`` has new ``valid_operations`` method which returns true if passed UnitID respect 
+  architecture constraints.
+* New methods for mapping logical to physical circuits for some ``Architecture``: ``LexiRouteRoutingMethod``
+  ``LexiLabellingMethod``, ``MultiGateReorderRoutingMethod``.
+
 0.19.2 (February 2022)
 ----------------------
 

pytket/tests/architecture_test.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from pytket.circuit import Node  # type: ignore
+from pytket.circuit import Node, Op, OpType, Circuit, Qubit, PhasePolyBox  # type: ignore
 from pytket.architecture import Architecture, SquareGrid, FullyConnected  # type: ignore
+import numpy as np
 
 
 def test_architectures() -> None:
@@ -78,8 +79,25 @@ def test_arch_types() -> None:
     assert isinstance(sg, SquareGrid)
 
 
+def test_valid_operation() -> None:
+    edges = [(0, 1), (1, 2), (2, 0), (0, 3), (3, 4), (4, 5), (5, 6)]
+    arc = Architecture(edges)
+
+    assert not arc.valid_operation([Node(1), Node(3)])
+    assert arc.valid_operation([Node(0)])
+    assert arc.valid_operation([Node(0), Node(1)])
+    assert not arc.valid_operation([Node(0), Node(1), Node(2)])
+    assert not arc.valid_operation([Node(10)])
+    assert not arc.valid_operation([Node(10), Node(11), Node(15)])
+    assert not arc.valid_operation([Node(0), Node(1), Node(2), Node(3)])
+    assert not arc.valid_operation([Node(0), Node(4)])
+    assert not arc.valid_operation([Node(0), Node(1), Node(2)])
+    assert not arc.valid_operation([Node(0), Node(1), Node(4)])
+
+
 if __name__ == "__main__":
     test_architectures()
     test_architecture_eq()
     test_fully_connected()
     test_arch_types()
+    test_valid_operation()

pytket/tests/backend_test.py

@@ -24,7 +24,7 @@
 from pytket.circuit import Circuit, OpType, BasisOrder, Qubit, Bit, Node  # type: ignore
 from pytket.predicates import CompilationUnit  # type: ignore
 from pytket.passes import PauliSimp, CliffordSimp, ContextSimp  # type: ignore
-from pytket.mapping import MappingManager, LexiRouteRoutingMethod  # type: ignore
+from pytket.mapping import MappingManager, LexiRouteRoutingMethod, LexiLabellingMethod  # type: ignore
 from pytket.architecture import Architecture  # type: ignore
 from pytket.utils.outcomearray import OutcomeArray, readout_counts
 from pytket.utils.prepare import prepare_circuit
@@ -528,7 +528,7 @@ def test_postprocess_3() -> None:
 
     mm = MappingManager(arc)
     rc = c.copy()
-    mm.route_circuit(rc, [LexiRouteRoutingMethod()])
+    mm.route_circuit(rc, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
     n_shots = 100
     h = b.process_circuit(b.get_compiled_circuit(c), n_shots=n_shots, postprocess=True)
     r = b.get_result(h)

pytket/tests/mapping_test.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from pytket.mapping import MappingManager, RoutingMethodCircuit, LexiRouteRoutingMethod  # type: ignore
+from pytket.mapping import MappingManager, RoutingMethodCircuit, LexiRouteRoutingMethod, LexiLabellingMethod  # type: ignore
 from pytket.architecture import Architecture  # type: ignore
 from pytket import Circuit, OpType
 from pytket.circuit import Node, Qubit  # type: ignore
@@ -104,7 +104,7 @@ def test_LexiRouteRoutingMethod() -> None:
     nodes = [Node("test", 0), Node("test", 1), Node("test", 2)]
     test_a = Architecture([[nodes[0], nodes[1]], [nodes[1], nodes[2]]])
     test_mm = MappingManager(test_a)
-    test_mm.route_circuit(test_c, [LexiRouteRoutingMethod()])
+    test_mm.route_circuit(test_c, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
     routed_commands = test_c.get_commands()
 
     assert routed_commands[0].op.type == OpType.CX
@@ -151,11 +151,11 @@ def test_RoutingMethodCircuit_custom_list() -> None:
         test_c,
         [
             RoutingMethodCircuit(route_subcircuit_func_false, 5, 5),
+            LexiLabellingMethod(),
             LexiRouteRoutingMethod(),
         ],
     )
     routed_commands = test_c.get_commands()
-
     assert routed_commands[0].op.type == OpType.CX
     assert routed_commands[0].qubits == [nodes[1], nodes[0]]
     assert routed_commands[1].op.type == OpType.CX
@@ -170,6 +170,7 @@ def test_RoutingMethodCircuit_custom_list() -> None:
         test_c,
         [
             RoutingMethodCircuit(route_subcircuit_func, 5, 5),
+            LexiLabellingMethod(),
             LexiRouteRoutingMethod(),
         ],
     )

pytket/tests/mitigation_test.py

@@ -17,7 +17,7 @@
 
 from pytket.utils.spam import SpamCorrecter, compress_counts
 from pytket.circuit import Node, Circuit, Qubit  # type: ignore
-from pytket.mapping import MappingManager, LexiRouteRoutingMethod  # type: ignore
+from pytket.mapping import MappingManager, LexiLabellingMethod, LexiRouteRoutingMethod  # type: ignore
 from pytket.architecture import Architecture  # type: ignore
 from pytket.placement import place_with_map  # type: ignore
 from pytket.passes import DelayMeasures  # type: ignore
@@ -112,7 +112,7 @@ def test_spam_integration() -> None:
     place_with_map(bellcc, qmap)
     mm = MappingManager(arc)
     rbell = bellcc.copy()
-    mm.route_circuit(rbell, [LexiRouteRoutingMethod()])
+    mm.route_circuit(rbell, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
 
     def check_correction(
         counts0: Dict[Tuple[int, ...], int], counts1: Dict[Tuple[int, ...], int]
@@ -509,7 +509,7 @@ def test_spam_routing() -> None:
     testc = Circuit(4, 4).H(0).CX(0, 3).CX(1, 2).CX(0, 1).CX(3, 2).measure_all()
     routed = testc.copy()
     mm = MappingManager(arc)
-    mm.route_circuit(routed, [LexiRouteRoutingMethod()])
+    mm.route_circuit(routed, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
     DelayMeasures().apply(routed)
     readout = routed.qubit_readout
 

pytket/tests/placement_test.py

@@ -24,7 +24,7 @@
     place_with_map,
 )
 from pytket.passes import PauliSimp, DefaultMappingPass  # type: ignore
-from pytket.mapping import MappingManager, LexiRouteRoutingMethod  # type: ignore
+from pytket.mapping import MappingManager, LexiRouteRoutingMethod, LexiLabellingMethod  # type: ignore
 from pytket.qasm import circuit_from_qasm  # type: ignore
 
 import json
@@ -73,9 +73,9 @@ def test_placements() -> None:
     assert circ_qbs != graph_placed.qubits
 
     mm = MappingManager(test_architecture)
-    mm.route_circuit(base_placed, [LexiRouteRoutingMethod()])
-    mm.route_circuit(line_placed, [LexiRouteRoutingMethod()])
-    mm.route_circuit(graph_placed, [LexiRouteRoutingMethod()])
+    mm.route_circuit(base_placed, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
+    mm.route_circuit(line_placed, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
+    mm.route_circuit(graph_placed, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
 
     assert base_placed.valid_connectivity(test_architecture, False)
     assert line_placed.valid_connectivity(test_architecture, False)
@@ -121,8 +121,8 @@ def test_placement_config() -> None:
     assert map1 != map2
 
     mm = MappingManager(test_architecture)
-    mm.route_circuit(circ1, [LexiRouteRoutingMethod()])
-    mm.route_circuit(circ2, [LexiRouteRoutingMethod()])
+    mm.route_circuit(circ1, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
+    mm.route_circuit(circ2, [LexiLabellingMethod(), LexiRouteRoutingMethod()])
     assert circ1.n_gates < circ2.n_gates
 
 

pytket/tests/predicates_test.py

@@ -75,7 +75,7 @@
     CompilationUnit,
     UserDefinedPredicate,
 )
-from pytket.mapping import LexiRouteRoutingMethod  # type: ignore
+from pytket.mapping import LexiLabellingMethod, LexiRouteRoutingMethod  # type: ignore
 from pytket.architecture import Architecture  # type: ignore
 from pytket.placement import Placement, GraphPlacement  # type: ignore
 from pytket.transform import Transform, PauliSynthStrat, CXConfigType  # type: ignore
@@ -230,7 +230,9 @@ def test_routing_and_placement_pass() -> None:
     assert seq_pass.apply(cu2)
     assert cu2.initial_map == expected_map
 
-    full_pass = FullMappingPass(arc, pl, config=[LexiRouteRoutingMethod()])
+    full_pass = FullMappingPass(
+        arc, pl, config=[LexiLabellingMethod(), LexiRouteRoutingMethod()]
+    )
     cu3 = CompilationUnit(circ.copy())
     assert full_pass.apply(cu3)
     assert cu3.initial_map == expected_map
@@ -682,7 +684,9 @@ def sq(a: float, b: float, c: float) -> Circuit:
         [k.to_list(), v.to_list()] for k, v in qm.items()
     ]
     # FullMappingPass
-    fm_pass = FullMappingPass(arc, placer, config=[LexiRouteRoutingMethod()])
+    fm_pass = FullMappingPass(
+        arc, placer, config=[LexiLabellingMethod(), LexiRouteRoutingMethod()]
+    )
     assert fm_pass.to_dict()["pass_class"] == "SequencePass"
     p_pass = fm_pass.get_sequence()[0]
     r_pass = fm_pass.get_sequence()[1]

pytket/tests/transform_test.py

@@ -39,7 +39,7 @@
 from pytket.transform import Transform, CXConfigType, PauliSynthStrat  # type: ignore
 from pytket.qasm import circuit_from_qasm
 from pytket.architecture import Architecture  # type: ignore
-from pytket.mapping import MappingManager, LexiRouteRoutingMethod  # type: ignore
+from pytket.mapping import MappingManager, LexiRouteRoutingMethod, LexiLabellingMethod  # type: ignore
 from pytket.placement import Placement, GraphPlacement, LinePlacement, NoiseAwarePlacement  # type: ignore
 
 from sympy import Symbol  # type: ignore
@@ -770,7 +770,9 @@ def test_decompose_swap_to_cx() -> None:
     pl = Placement(arc)
     pl.place_with_map(circ, init_map)
 
-    MappingManager(arc).route_circuit(circ, [LexiRouteRoutingMethod()])
+    MappingManager(arc).route_circuit(
+        circ, [LexiLabellingMethod(), LexiRouteRoutingMethod()]
+    )
     assert circ.valid_connectivity(arc, False)
     Transform.DecomposeSWAPtoCX(arc).apply(circ)
     assert len(circ.get_commands()) == 20
@@ -813,8 +815,12 @@ def test_FullMappingPass() -> None:
     cu_1 = CompilationUnit(circ)
     gp_placer = GraphPlacement(arc)
     lp_placer = LinePlacement(arc)
-    m_pass_0 = FullMappingPass(arc, gp_placer, [LexiRouteRoutingMethod()])
-    m_pass_1 = FullMappingPass(arc, lp_placer, [LexiRouteRoutingMethod()])
+    m_pass_0 = FullMappingPass(
+        arc, gp_placer, [LexiLabellingMethod(), LexiRouteRoutingMethod()]
+    )
+    m_pass_1 = FullMappingPass(
+        arc, lp_placer, [LexiLabellingMethod(), LexiRouteRoutingMethod()]
+    )
     m_pass_0.apply(cu_0)
     m_pass_1.apply(cu_1)
     out_circ_0 = cu_0.circuit

tket/src/Architecture/Architecture.cpp

@@ -24,25 +24,14 @@
 
 namespace tket {
 
-// basic implementation that works off same prior assumptions
-// TODO: Update this for more mature systems of multi-qubit gates
-bool Architecture::valid_operation(
-    const OpType& optype, const std::vector<Node>& uids) const {
+bool Architecture::valid_operation(const std::vector<Node>& uids) const {
+  for (Node n : uids) {
+    if (!this->node_exists(Node(n))) return false;
+  }
   if (uids.size() == 1) {
-    // with current Architecture can assume all single qubit gates valid
-    return true;
-  } else if (optype == OpType::Barrier) {
     return true;
   } else if (uids.size() == 2) {
-    if (this->node_exists(uids[0]) && this->node_exists(uids[1]) &&
-        this->bidirectional_edge_exists(uids[0], uids[1])) {
-      return true;
-    }
-  } else if (uids.size() == 3 && optype == OpType::BRIDGE) {
-    bool con_0_exists = this->bidirectional_edge_exists(uids[0], uids[1]);
-    bool con_1_exists = this->bidirectional_edge_exists(uids[2], uids[1]);
-    if (this->node_exists(uids[0]) && this->node_exists(uids[1]) &&
-        this->node_exists(uids[2]) && con_0_exists && con_1_exists) {
+    if (this->bidirectional_edge_exists(uids[0], uids[1])) {
       return true;
     }
   }

tket/src/Architecture/CMakeLists.txt

@@ -28,10 +28,10 @@ add_library(tket-${COMP}
 
 list(APPEND DEPS_${COMP}
     Graphs
-    OpType
     TokenSwapping
     Utils)
 
+
 foreach(DEP ${DEPS_${COMP}})
     target_include_directories(
         tket-${COMP} PRIVATE ${TKET_${DEP}_INCLUDE_DIR})

tket/src/Architecture/include/Architecture/Architecture.hpp

@@ -23,7 +23,6 @@
 
 #include "Graphs/CompleteGraph.hpp"
 #include "Graphs/DirectedGraph.hpp"
-#include "OpType/OpType.hpp"
 #include "Utils/BiMapHeaders.hpp"
 #include "Utils/EigenConfig.hpp"
 #include "Utils/Json.hpp"
@@ -107,8 +106,7 @@ class Architecture : public ArchitectureBase<graphs::DirectedGraph<Node>> {
    * Returns true if the given operation acting on the given nodes
    * can be executed on the Architecture connectivity graph.
    */
-  bool valid_operation(
-      const OpType &optype, const std::vector<Node> &uids) const;
+  bool valid_operation(const std::vector<Node> &uids) const;
 
   /**
    * Sub-architecture generated by a subset of nodes.