✨ Collect clifford blocks

include/mqt-core/circuit_optimizer/CircuitOptimizer.hpp

@@ -90,8 +90,10 @@ class CircuitOptimizer {
    * gates and fusing single-qubit gates.
    * @param qc the quantum circuit
    * @param maxBlockSize the maximum size of a block
+   * @param onlyCollectCliffords whether to only group Clifford operations
    */
-  static void collectBlocks(QuantumComputation& qc, std::size_t maxBlockSize);
+  static void collectBlocks(QuantumComputation& qc, std::size_t maxBlockSize,
+                            bool onlyCollectCliffords = false);
 
   /**
    * @brief Elide permutations by propagating them through the circuit.

include/mqt-core/ir/operations/CompoundOperation.hpp

@@ -60,6 +60,8 @@ class CompoundOperation final : public Operation {
 
   [[nodiscard]] bool isGlobal(size_t nQubits) const noexcept override;
 
+  [[nodiscard]] bool isClifford() const override;
+
   void addControl(Control c) override;
 
   void clearControls() override;

include/mqt-core/ir/operations/OpType.hpp

@@ -66,6 +66,9 @@ std::string shortName(OpType opType);
   }
 }
 
+/**
+ * @brief Checks if given OpType is a single qubit gate
+ */
 [[nodiscard]] constexpr bool isSingleQubitGate(const OpType type) {
   switch (type) {
   case I:

include/mqt-core/ir/operations/Operation.hpp

@@ -155,6 +155,8 @@ class Operation {
 
   [[nodiscard]] virtual bool isControlled() const { return !controls.empty(); }
 
+  [[nodiscard]] virtual bool isClifford() const { return false; }
+
   /**
    * @brief Checks whether a gate is global.
    * @details A StandardOperation is global if it acts on all qubits.

include/mqt-core/ir/operations/StandardOperation.hpp

@@ -82,6 +82,8 @@ class StandardOperation : public Operation {
 
   [[nodiscard]] bool isGlobal(size_t nQubits) const override;
 
+  [[nodiscard]] bool isClifford() const override;
+
   void addControl(const Control c) override {
     if (actsOn(c.qubit)) {
       throw std::runtime_error("Cannot add control on qubit " +

src/circuit_optimizer/CircuitOptimizer.cpp

@@ -1418,7 +1418,8 @@
 };
 
 void CircuitOptimizer::collectBlocks(QuantumComputation& qc,
-                                     const std::size_t maxBlockSize) {
+                                     const std::size_t maxBlockSize,
+                                     bool onlyCollectCliffords) {
   if (qc.size() <= 1) {
     return;
   }
@@ -1429,16 +1430,31 @@
 
   // create an empty disjoint set union data structure
   DSU dsu{};
+  DSU nonCliffordDSU{};
   for (auto opIt = qc.begin(); opIt != qc.end(); ++opIt) {
     auto& op = *opIt;
     bool canProcess = true;
     bool makesTooBig = false;
 
-    // check if the operation can be processed
     if (!op->isUnitary()) {
       canProcess = false;
     }
 
+    /*if (onlyCollectCliffords && !op->isClifford()) {
+      const auto usedQubits = op->getUsedQubits();
+      std::int64_t prev = -1;
+      for (const auto& q : usedQubits) {
+        if (prev != -1) {
+          dsu.unionBlock(static_cast<Qubit>(prev), q);
+        }
+        prev = q;
+      }
+      for (auto q : op->getUsedQubits()) {
+        dsu.finalizeBlock(q);
+      }
+      continue;
+    }*/
+
     const auto usedQubits = op->getUsedQubits();
 
     if (canProcess) {
@@ -1546,6 +1562,37 @@
         }
         prev = q;
       }
+
+      if (onlyCollectCliffords && !op->isClifford()) {
+        // check if next operation which acts on other qubits within the same
+        // block fits in the block
+        if (opIt + 1 != qc.end() && (*std::next(opIt))->isUnitary()) {
+          const auto& nextOp = *(opIt + 1);
+          const auto nextUsedQubits = nextOp->getUsedQubits();
+          std::unordered_set<Qubit> nextBlockQubits;
+          for (const auto& q : nextUsedQubits) {
+            nextBlockQubits.emplace(dsu.findBlock(q));
+          }
+          std::size_t nextTotalSize = 0;
+          for (const auto& q : nextBlockQubits) {
+            nextTotalSize += dsu.bitBlocks[q].size();
+          }
+          if (nextTotalSize <= maxBlockSize) {
+            // if the next operation fits in the block, do not finalize the
+            // current block yet
+            for (const auto& q : usedQubits) {
+              dsu.finalizeBlock(q);
+            }
+            continue;
+          }
+        }
+
+        for (auto q : op->getUsedQubits()) {
+          dsu.finalizeBlock(q);
+        }
+        continue;
+      }
+
       const auto block = dsu.findBlock(static_cast<Qubit>(prev));
       const auto empty = dsu.blockEmpty(block);
       if (empty) {

src/ir/operations/CompoundOperation.cpp

@@ -91,6 +91,11 @@ bool CompoundOperation::isGlobal(const size_t nQubits) const noexcept {
          });
 }
 
+bool CompoundOperation::isClifford() const {
+  return std::all_of(ops.begin(), ops.end(),
+                     [](const auto& op) { return op->isClifford(); });
+}
+
 bool CompoundOperation::isSymbolicOperation() const {
   return std::any_of(ops.begin(), ops.end(),
                      [](const auto& op) { return op->isSymbolicOperation(); });

src/ir/operations/StandardOperation.cpp

@@ -250,6 +250,30 @@ bool StandardOperation::isGlobal(const size_t nQubits) const {
 /***
  * Public Methods
  ***/
+bool StandardOperation::isClifford() const {
+  switch (type) {
+  case I:
+  case Barrier:
+    return true;
+  case X:
+  case Y:
+  case Z:
+    return (getControls().size() <= 1);
+  case H:
+  case S:
+  case Sdg:
+  case SX:
+  case SXdg:
+  case DCX:
+  case SWAP:
+  case iSWAP:
+  case ECR:
+    return !isControlled();
+  default:
+    return false;
+  }
+}
+
 void StandardOperation::dumpOpenQASM(
     std::ostream& of, const QubitIndexToRegisterMap& qubitMap,
     [[maybe_unused]] const BitIndexToRegisterMap& bitMap, size_t indent,

test/circuit_optimizer/test_collect_blocks.cpp

@@ -45,6 +45,116 @@ TEST(CollectBlocks, collectMultipleSingleQubitGates) {
   EXPECT_TRUE(qc.back()->isCompoundOperation());
 }
 
+TEST(CollectBlocks, nonCliffordOnAll) {
+  QuantumComputation qc(2);
+  qc.sx(0);
+  qc.cx(0, 1);
+  qc.sxdg(1);
+  qc.t(0);
+  qc.t(1);
+  qc.x(0);
+  qc.x(1);
+
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 2, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 5);
+  EXPECT_TRUE(qc.front()->isCompoundOperation());
+  EXPECT_EQ(dynamic_cast<qc::CompoundOperation&>(*qc.front()).size(), 3);
+}
+
+TEST(CollectBlocks, nonCliffordSingleQubit) {
+  QuantumComputation qc(1);
+  qc.sdg(0);
+  qc.h(0);
+  qc.t(0);
+  qc.x(0);
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 2, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 3);
+  EXPECT_TRUE(qc.front()->isCompoundOperation());
+}
+
+TEST(CollectBlocks, collectTwoQubitCliffordGates) {
+  QuantumComputation qc(2);
+  qc.h(0);
+  qc.s(1);
+  qc.cx(0, 1);
+  qc.rx(0.1, 0);
+  qc.x(0);
+  qc.y(1);
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 2, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 4);
+  EXPECT_TRUE(qc.front()->isCompoundOperation());
+  EXPECT_TRUE(qc.back()->isStandardOperation());
+  EXPECT_EQ(dynamic_cast<qc::CompoundOperation&>(*qc.front()).size(), 3);
+}
+
+TEST(CollectBlocks, TwoQubitnonClifford) {
+  QuantumComputation qc(2);
+  qc.h(0);
+  qc.s(1);
+  qc.rxx(0.1, 0, 1);
+  qc.i(0);
+  qc.y(1);
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 2, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 3);
+  EXPECT_TRUE(qc.front()->isCompoundOperation());
+}
+
+TEST(CollectBlocks, mergeBlocksnonClifford) {
+  QuantumComputation qc(3);
+  qc.h(0);
+  qc.cx(0, 1);
+  qc.cx(1, 2);
+  qc.t(0);
+  qc.t(1);
+  qc.cx(0, 1);
+  qc.cx(1, 2);
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 3, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 4);
+  EXPECT_TRUE(qc.front()->isCompoundOperation());
+  EXPECT_TRUE(qc.back()->isCompoundOperation());
+}
+
+TEST(CollectBlocks, nonCliffordBeginning) {
+  QuantumComputation qc(2);
+  qc.t(0);
+  qc.t(1);
+  qc.ecr(0, 1);
+  qc.x(0);
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 2, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 3);
+  EXPECT_TRUE(qc.front()->isStandardOperation());
+  EXPECT_TRUE(qc.back()->isCompoundOperation());
+}
+
+TEST(CollectBlocks, threeQubitnonClifford) {
+  QuantumComputation qc(3);
+  qc.h(0);
+  qc.h(1);
+  qc.h(2);
+  qc.mcx({0, 1}, 2);
+  qc.mcz({0, 2}, 1);
+  qc.dcx(0, 1);
+  qc.dcx(1, 2);
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 3, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 4);
+  EXPECT_TRUE(qc.front()->isCompoundOperation());
+  EXPECT_TRUE(qc.back()->isCompoundOperation());
+}
+
 TEST(CollectBlocks, mergeBlocks) {
   QuantumComputation qc(2);
   qc.h(0);

test/ir/test_operation.cpp

@@ -14,6 +14,7 @@
 #include "ir/Register.hpp"
 #include "ir/operations/AodOperation.hpp"
 #include "ir/operations/CompoundOperation.hpp"
+#include "ir/operations/Control.hpp"
 #include "ir/operations/Expression.hpp"
 #include "ir/operations/NonUnitaryOperation.hpp"
 #include "ir/operations/OpType.hpp"
@@ -122,6 +123,14 @@ TEST(CompoundOperation, GetNqubits) {
   EXPECT_EQ(op.getNqubits(), 3);
 }
 
+TEST(CompoundOperation, IsClifford) {
+  qc::CompoundOperation op1;
+  op1.emplace_back<qc::StandardOperation>(0, qc::OpType::H);
+  op1.emplace_back<qc::StandardOperation>(1, qc::OpType::RX,
+                                          std::vector{qc::PI_2});
+  EXPECT_FALSE(op1.isClifford());
+}
+
 TEST(OpType, General) {
   EXPECT_EQ(qc::toString(qc::RZ), "rz");
   std::stringstream ss;
@@ -157,6 +166,56 @@ TEST(Operation, IsIndividualGate) {
   EXPECT_FALSE(op3.isSingleQubitGate());
 }
 
+TEST(Operation, IsClifford) {
+  const qc::StandardOperation x(0, qc::X);
+  EXPECT_TRUE(x.isClifford());
+  const qc::StandardOperation cx(0, 1, qc::X);
+  EXPECT_TRUE(cx.isClifford());
+  const qc::StandardOperation ccx({0, 1}, 2, qc::X);
+  EXPECT_FALSE(ccx.isClifford());
+
+  const qc::StandardOperation y(0, qc::Y);
+  EXPECT_TRUE(y.isClifford());
+  const qc::StandardOperation cy(0, 1, qc::Y);
+  EXPECT_TRUE(cy.isClifford());
+  const qc::StandardOperation ccy({0, 1}, 2, qc::Y);
+  EXPECT_FALSE(ccy.isClifford());
+
+  const qc::StandardOperation z(0, qc::Z);
+  EXPECT_TRUE(z.isClifford());
+  const qc::StandardOperation cz(0, 1, qc::Z);
+  EXPECT_TRUE(cz.isClifford());
+  const qc::StandardOperation ccz({0, 1}, 2, qc::Z);
+  EXPECT_FALSE(ccz.isClifford());
+
+  const qc::StandardOperation t(0, qc::T);
+  EXPECT_FALSE(t.isClifford());
+  const qc::StandardOperation tdg(0, qc::Tdg);
+  EXPECT_FALSE(tdg.isClifford());
+
+  const qc::StandardOperation h(0, qc::H);
+  EXPECT_TRUE(h.isClifford());
+
+  const qc::StandardOperation s(0, qc::S);
+  EXPECT_TRUE(s.isClifford());
+  const qc::StandardOperation sdg(0, qc::Sdg);
+  EXPECT_TRUE(sdg.isClifford());
+
+  const qc::StandardOperation sx(0, qc::SX);
+  EXPECT_TRUE(sx.isClifford());
+  const qc::StandardOperation sxdg(0, qc::SXdg);
+  EXPECT_TRUE(sxdg.isClifford());
+
+  const qc::StandardOperation dcx({0, 1}, qc::DCX);
+  EXPECT_TRUE(dcx.isClifford());
+  const qc::StandardOperation swap({0, 1}, qc::SWAP);
+  EXPECT_TRUE(swap.isClifford());
+  const qc::StandardOperation iswap({0, 1}, qc::iSWAP);
+  EXPECT_TRUE(iswap.isClifford());
+  const qc::StandardOperation ecr({0, 1}, qc::ECR);
+  EXPECT_TRUE(ecr.isClifford());
+}
+
 TEST(Operation, IsDiagonalGate) {
   const qc::StandardOperation op1(0, qc::X);
   EXPECT_FALSE(op1.isDiagonalGate());