✨ Collect clifford blocks

include/mqt-core/circuit_optimizer/CircuitOptimizer.hpp

@@ -90,8 +90,11 @@ 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 collect only Clifford operations
+   * within a block, non-Clifford operations are a single block
    */
-  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

@@ -58,6 +58,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 @@ struct DSU {
 };
 
 void CircuitOptimizer::collectBlocks(QuantumComputation& qc,
-                                     const std::size_t maxBlockSize) {
+                                     const std::size_t maxBlockSize,
+                                     bool onlyCollectCliffords) {
   if (qc.size() <= 1) {
     return;
   }
@@ -1434,8 +1435,8 @@ void CircuitOptimizer::collectBlocks(QuantumComputation& qc,
     bool canProcess = true;
     bool makesTooBig = false;
 
-    // check if the operation can be processed
-    if (!op->isUnitary()) {
+    // check whether the operation is a Clifford operation
+    if (!op->isUnitary() || (onlyCollectCliffords && !op->isClifford())) {
       canProcess = false;
     }
 

src/ir/operations/CompoundOperation.cpp

@@ -87,6 +87,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,31 @@ 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:
+    return (getControls().empty());
+  case DCX:
+  case SWAP:
+  case iSWAP:
+  case ECR:
+    return (getControls().size() == 1);
+  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,85 @@ TEST(CollectBlocks, collectMultipleSingleQubitGates) {
   EXPECT_TRUE(qc.back()->isCompoundOperation());
 }
 
+TEST(CollectBlocks, nonCliffordOnAll) {
+  QuantumComputation qc(2);
+  qc.sx(0);
+  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(), 4);
+}
+
+TEST(CollectBlocks, nonCliffordonTop) {
+  QuantumComputation qc(2);
+  qc.sdg(0);
+  qc.h(1);
+  qc.t(0);
+  qc.x(0);
+  qc.z(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, 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(), 3);
+  EXPECT_TRUE(qc.front()->isCompoundOperation());
+}
+
+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, nonCliffordBeginning) {
+  QuantumComputation qc(2);
+  qc.t(0);
+  qc.t(1);
+  qc.ecr(0, 1);
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 2, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 2);
+}
+
+TEST(CollectBlocks, threeQubitnonClifford) {
+  QuantumComputation qc(3);
+  qc.mcx({0, 1}, 2);
+  qc.mcz({0, 2}, 1);
+  qc.dcx(0, 1);
+  std::cout << qc << "\n";
+  qc::CircuitOptimizer::collectBlocks(qc, 2, true);
+  std::cout << qc << "\n";
+  EXPECT_EQ(qc.size(), 2);
+}
+
 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"
@@ -148,6 +149,44 @@ 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 y(0, 1, qc::Y);
+  EXPECT_TRUE(y.isClifford());
+  const qc::StandardOperation z(0, 1, qc::Z);
+  EXPECT_TRUE(z.isClifford());
+  const qc::StandardOperation t(0, qc::T);
+  EXPECT_FALSE(t.isClifford());
+  const qc::Controls controls = {qc::Control(0), qc::Control(1)};
+  const qc::StandardOperation ccx(controls, 2, qc::X);
+  EXPECT_FALSE(ccx.isClifford());
+  const qc::StandardOperation ccy(controls, 2, qc::Y);
+  EXPECT_FALSE(ccy.isClifford());
+  const qc::StandardOperation ccz(controls, 2, qc::Z);
+  EXPECT_FALSE(ccz.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());