Update auto_rebase_pass to take optional allow_swaps argument

pytket/binders/circuit/library.cpp

@@ -41,6 +41,12 @@ void init_library(py::module &m) {
       "Given expressions α, β and γ, return circuit equivalent to "
       "TK2(α, β, γ) using up to 3 CX and single-qubit gates.\n\n"
       "The decomposition minimizes the number of CX gates.");
+  library_m.def(
+      "_TK2_using_CX_and_swap", &CircPool::TK2_using_CX_and_swap,
+      "Given expressions α, β and γ, return circuit equivalent to "
+      "TK2(α, β, γ), up to a wire swap, using up to 3 CX and single-qubit "
+      "gates.\n\n"
+      "The decomposition minimizes the number of CX gates.");
   library_m.def(
       "_approx_TK2_using_1xCX", &CircPool::approx_TK2_using_1xCX,
       "Best approximation of TK2 using 1 CX gate and single-qubit gates, using "
@@ -227,6 +233,9 @@ void init_library(py::module &m) {
   library_m.def(
       "_TK2_using_ZZMax", &CircPool::TK2_using_ZZMax,
       "Equivalent to TK2, using up to 3 ZZMax gates.");
+  library_m.def(
+      "_TK2_using_ZZMax_and_swap", &CircPool::TK2_using_ZZMax_and_swap,
+      "Equivalent to TK2, up to a wire swap, using up to 3 ZZMax gates.");
   library_m.def(
       "_XXPhase3_using_TK2", &CircPool::XXPhase3_using_TK2,
       "Equivalent to XXPhase3, using three TK2 gates");

pytket/conanfile.py

@@ -32,7 +32,7 @@ def package(self):
         cmake.install()
 
     def requirements(self):
-        self.requires("tket/1.2.28@tket/stable")
+        self.requires("tket/1.2.29@tket/stable")
         self.requires("tklog/0.3.3@tket/stable")
         self.requires("tkrng/0.3.3@tket/stable")
         self.requires("tkassert/0.3.3@tket/stable")

pytket/pytket/passes/auto_rebase.py

@@ -44,6 +44,13 @@ def _TK2_using_TK2(a: Param, b: Param, c: Param) -> Circuit:
     OpType.ZZMax: _library._TK2_using_ZZMax,
 }
 
+_TK2_CIRCS_WIRE_SWAP: Dict[OpType, Callable[[Param, Param, Param], "Circuit"]] = {
+    OpType.TK2: _TK2_using_TK2,
+    OpType.ZZPhase: _library._TK2_using_ZZPhase,
+    OpType.CX: _library._TK2_using_CX_and_swap,
+    OpType.ZZMax: _library._TK2_using_ZZMax_and_swap,
+}
+
 
 def get_cx_decomposition(gateset: Set[OpType]) -> Circuit:
     """Return a Circuit expressing a CX in terms of a two qubit gate in the
@@ -62,6 +69,7 @@ def get_cx_decomposition(gateset: Set[OpType]) -> Circuit:
 
 def get_tk2_decomposition(
     gateset: Set[OpType],
+    allow_swaps: bool,
 ) -> Callable[[Param, Param, Param], "Circuit"]:
     """Return a function to construct a circuit expressing a TK2 in terms of gates in
     the given gateset, if such a function is available.
@@ -70,9 +78,15 @@ def get_tk2_decomposition(
     :raises NoAutoRebase: no suitable TK2 decomposition found
     :return: function to decompose TK2 gates
     """
-    for k, fn in _TK2_CIRCS.items():
-        if k in gateset:
-            return fn
+    if allow_swaps:
+        for k, fn in _TK2_CIRCS_WIRE_SWAP.items():
+            if k in gateset:
+                return fn
+    else:
+        for k, fn in _TK2_CIRCS.items():
+            if k in gateset:
+                return fn
+
     raise NoAutoRebase("No known decomposition from TK2 to given gateset")
 
 
@@ -109,7 +123,7 @@ def get_TK1_decomposition_function(
     raise NoAutoRebase("No known decomposition from TK1 to available gateset.")
 
 
-def auto_rebase_pass(gateset: Set[OpType]) -> RebaseCustom:
+def auto_rebase_pass(gateset: Set[OpType], allow_swaps: bool = False) -> RebaseCustom:
     """Attempt to generate a rebase pass automatically for the given target
     gateset.
 
@@ -127,12 +141,19 @@ def auto_rebase_pass(gateset: Set[OpType]) -> RebaseCustom:
     """
     tk1 = get_TK1_decomposition_function(gateset)
 
+    if allow_swaps:
+        try:
+            return RebaseCustom(
+                gateset, get_tk2_decomposition(gateset, allow_swaps), tk1
+            )
+        except NoAutoRebase:
+            pass
     # if the gateset has CX but not TK2, rebase via CX
     if OpType.CX in gateset and OpType.TK2 not in gateset:
         return RebaseCustom(gateset, _library._CX(), tk1)
     # in other cases, try to rebase via TK2 first
     try:
-        return RebaseCustom(gateset, get_tk2_decomposition(gateset), tk1)
+        return RebaseCustom(gateset, get_tk2_decomposition(gateset, allow_swaps), tk1)
     except NoAutoRebase:
         pass
     try:

pytket/tests/transform_test.py

@@ -436,7 +436,7 @@ def test_pauli_graph_synth() -> None:
         num_cxs = c.n_gates_of_type(OpType.CX)
         cx_counts.append(num_cxs)
 
-    for (i, count) in enumerate(cx_counts):
+    for i, count in enumerate(cx_counts):
         if i == 0:
             continue
         assert count < cx_counts[i - 1]
@@ -1216,6 +1216,139 @@ def test_round_angles() -> None:
     assert circ0 == circ1
 
 
+def test_auto_rebase_with_swap_cx() -> None:
+    swap_pass = auto_rebase_pass({OpType.CX, OpType.PhasedX, OpType.Rz}, True)
+    no_swap_pass = auto_rebase_pass({OpType.CX, OpType.PhasedX, OpType.Rz}, False)
+
+    c_swap = Circuit(2).ISWAPMax(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.CX) == 1
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(1)
+    assert iqp[Qubit(1)] == Qubit(0)
+    c_no_swap = Circuit(2).ISWAPMax(0, 1)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.CX) == 2
+
+    c_swap = Circuit(2).Sycamore(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.CX) == 2
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(1)
+    assert iqp[Qubit(1)] == Qubit(0)
+    c_no_swap = Circuit(2).Sycamore(0, 1)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.CX) == 3
+
+    c_swap = Circuit(2).ISWAP(0.3, 0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.CX) == 2
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(0)
+    assert iqp[Qubit(1)] == Qubit(1)
+    c_no_swap = Circuit(2).ISWAP(0.3, 0, 1)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.CX) == 2
+
+    c_swap = Circuit(2).ISWAPMax(0, 1).ISWAPMax(1, 0)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.CX) == 2
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(0)
+    assert iqp[Qubit(1)] == Qubit(1)
+    c_no_swap = Circuit(2).ISWAPMax(0, 1).ISWAPMax(1, 0)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.CX) == 4
+
+    c_swap = Circuit(2).SWAP(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.CX) == 0
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(1)
+    assert iqp[Qubit(1)] == Qubit(0)
+    c_no_swap = Circuit(2).SWAP(0, 1)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.CX) == 3
+
+    c_swap = Circuit(2).ZZMax(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.CX) == 1
+
+    c_swap = Circuit(2).CX(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates == 1
+
+
+def test_auto_rebase_with_swap_zzmax() -> None:
+    swap_pass = auto_rebase_pass({OpType.ZZMax, OpType.PhasedX, OpType.Rz}, True)
+    no_swap_pass = auto_rebase_pass({OpType.ZZMax, OpType.PhasedX, OpType.Rz}, False)
+
+    c_swap = Circuit(2).ISWAPMax(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.ZZMax) == 1
+    assert c_swap.n_gates == 4
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(1)
+    assert iqp[Qubit(1)] == Qubit(0)
+    c_no_swap = Circuit(2).ISWAPMax(0, 1)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.ZZMax) == 2
+    assert c_no_swap.n_gates == 13
+
+    c_swap = Circuit(2).Sycamore(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.ZZMax) == 2
+    assert c_swap.n_gates == 12
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(1)
+    assert iqp[Qubit(1)] == Qubit(0)
+
+    c_no_swap = Circuit(2).Sycamore(0, 1)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.ZZMax) == 3
+    assert c_no_swap.n_gates == 16
+
+    c_swap = Circuit(2).ISWAP(0.3, 0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.ZZMax) == 2
+    assert c_swap.n_gates == 13
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(0)
+    assert iqp[Qubit(1)] == Qubit(1)
+    c_no_swap = Circuit(2).ISWAP(0.3, 0, 1)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.ZZMax) == 2
+    assert c_no_swap.n_gates == 13
+
+    c_swap = Circuit(2).ISWAPMax(0, 1).ISWAPMax(1, 0)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.ZZMax) == 2
+    assert c_swap.n_gates == 8
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(0)
+    assert iqp[Qubit(1)] == Qubit(1)
+    c_no_swap = Circuit(2).ISWAPMax(0, 1).ISWAPMax(1, 0)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.ZZMax) == 4
+    assert c_no_swap.n_gates == 26
+
+    c_swap = Circuit(2).SWAP(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates_of_type(OpType.ZZMax) == 0
+    assert c_swap.n_gates == 0
+    iqp = c_swap.implicit_qubit_permutation()
+    assert iqp[Qubit(0)] == Qubit(1)
+    assert iqp[Qubit(1)] == Qubit(0)
+    c_no_swap = Circuit(2).SWAP(0, 1)
+    no_swap_pass.apply(c_no_swap)
+    assert c_no_swap.n_gates_of_type(OpType.ZZMax) == 3
+    assert c_no_swap.n_gates == 16
+
+    c_swap = Circuit(2).ZZMax(0, 1)
+    swap_pass.apply(c_swap)
+    assert c_swap.n_gates == 1
+
+
 if __name__ == "__main__":
     test_remove_redundancies()
     test_reduce_singles()
@@ -1242,3 +1375,5 @@ def test_round_angles() -> None:
     test_CXMappingPass_terminates()
     test_FullMappingPass()
     test_KAK_with_ClassicalExpBox()
+    test_auto_rebase_with_swap_cx()
+    test_auto_rebase_with_swap_zzmax()

tket/conanfile.py

@@ -23,7 +23,7 @@
 
 class TketConan(ConanFile):
     name = "tket"
-    version = "1.2.28"
+    version = "1.2.29"
     package_type = "library"
     license = "Apache 2"
     homepage = "https://github.com/CQCL/tket"

tket/include/tket/Circuit/CircPool.hpp

@@ -316,6 +316,17 @@ Circuit normalised_TK2_using_CX(
  */
 Circuit TK2_using_CX(const Expr &alpha, const Expr &beta, const Expr &gamma);
 
+/**
+ * @brief Equivalent to TK2(α, β, γ) up to a wire swap, with minimal number of
+ * CX gates.
+ *
+ * A TK2-equivalent circuit with as few CX gates as possible (0, 1, 2 or 3 CX).
+ *
+ * @return Circuit Equivalent circuit, up to a wire swap, to TK2(α, β, γ).
+ */
+Circuit TK2_using_CX_and_swap(
+    const Expr &alpha, const Expr &beta, const Expr &gamma);
+
 /**
  * @brief Equivalent to TK2(α, 0, 0), using 1 ZZPhase gate.
  *
@@ -367,6 +378,15 @@ Circuit TK2_using_ZZPhase(
  */
 Circuit TK2_using_ZZMax(const Expr &alpha, const Expr &beta, const Expr &gamma);
 
+/**
+ * @brief Equivalent to TK2(α, β, γ), up to a wire swap, using up to 3 ZZMax
+ * gates.
+ *
+ * @return Circuit equivalent to TK2(α, β, γ) up to a wire swap.
+ */
+Circuit TK2_using_ZZMax_and_swap(
+    const Expr &alpha, const Expr &beta, const Expr &gamma);
+
 /** Equivalent to XXPhase3, using three TK2 gates */
 Circuit XXPhase3_using_TK2(const Expr &alpha);