✨ Collect clifford blocks

CHANGELOG.md

@@ -11,6 +11,7 @@ This project adheres to [Semantic Versioning], with the exception that minor rel
 
 ### Added
 
+- ✨ Add Clifford block collection pass to `CircuitOptimizer` module ([#885]) ([**jannikpflieger**], [**@burgholzer**])
 - ✨ Add `isControlled()` method to the `UnitaryInterface` MLIR class ([#1157]) ([**@taminob**], [**@burgholzer**])
 - 📝 Integrate generated MLIR documentation ([#1147]) ([**@denialhaag**], [**@burgholzer**])
 - ✨ Add `IfElseOperation` to C++ library and Python package to support Qiskit's `IfElseOp` ([#1117]) ([**@denialhaag**], [**@burgholzer**], [**@lavanya-m-k**])
@@ -221,6 +222,7 @@ _📚 Refer to the [GitHub Release Notes](https://github.com/munich-quantum-tool
 [#893]: https://github.com/munich-quantum-toolkit/core/pull/893
 [#892]: https://github.com/munich-quantum-toolkit/core/pull/892
 [#886]: https://github.com/munich-quantum-toolkit/core/pull/886
+[#885]: https://github.com/munich-quantum-toolkit/core/pull/885
 [#883]: https://github.com/munich-quantum-toolkit/core/pull/883
 [#882]: https://github.com/munich-quantum-toolkit/core/pull/882
 [#879]: https://github.com/munich-quantum-toolkit/core/pull/879
@@ -270,6 +272,7 @@ _📚 Refer to the [GitHub Release Notes](https://github.com/munich-quantum-tool
 [**@li-mingbao**]: https://github.com/li-mingbao
 [**@lavanya-m-k**]: https://github.com/lavanya-m-k
 [**@taminob**]: https://github.com/taminob
+[**@jannikpflieger**]: https://github.com/jannikpflieger
 
 <!-- General links -->
 

include/mqt-core/circuit_optimizer/CircuitOptimizer.hpp

@@ -93,6 +93,19 @@ class CircuitOptimizer {
    */
   static void collectBlocks(QuantumComputation& qc, std::size_t maxBlockSize);
 
+  /**
+   * @brief Collects all Clifford blocks in the circuit.
+   * @details The circuit is traversed and all operations that are part of a
+   * Clifford block are collected into a compound operation with a certain
+   * maximum block size. All non-Clifford operations remain untouched.
+   * Light optimizations are applied to the blocks, such as removing identity
+   * gates.
+   * @param qc the quantum circuit
+   * @param maxBlockSize the maximum size of a block
+   */
+  static void collectCliffordBlocks(QuantumComputation& qc,
+                                    std::size_t maxBlockSize);
+
   /**
    * @brief Elide permutations by propagating them through the circuit.
    * @details The circuit is traversed and any SWAP gate is eliminated by

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

@@ -1625,6 +1625,241 @@ void CircuitOptimizer::collectBlocks(QuantumComputation& qc,
   removeIdentities(qc);
 }
 
+/**
+ * @brief Block of Clifford operations
+ * @details This structure is used to collect Clifford operations that can be
+ * grouped together. It maintains the qubits that are part of the block
+ * and the qubits that are blocked by non-Clifford operations.
+ */
+struct CliffordBlock {
+  std::unordered_set<Qubit> blockQubits;
+  std::unordered_set<Qubit> blocked;
+  std::unique_ptr<CompoundOperation> operations;
+  std::unique_ptr<Operation>* position = nullptr;
+  std::size_t logicalStep = 0;
+
+  [[nodiscard]] bool empty() const noexcept {
+    return !operations || operations->empty();
+  }
+
+  /**
+   * @brief Check if this block is fully disabled by non-Clifford operations
+   *
+   */
+  [[nodiscard]] bool fullyDisabled() const noexcept {
+    return std::ranges::all_of(
+        blockQubits, [this](const Qubit q) { return blocked.contains(q); });
+  }
+
+  /**
+   * @brief Check if adding qubits used by gate would exceed maxBlockSize
+   * @param used Qubits used by the gate
+   * @param maxBlockSize Maximum allowed block size
+   */
+  [[nodiscard]] bool
+  checkExceedsMaxBlockSize(const std::set<Qubit>& used,
+                           const std::size_t maxBlockSize) const noexcept {
+    std::size_t extra = 0;
+    for (const auto q : used) {
+      if (!blockQubits.contains(q)) {
+        ++extra;
+        if (blockQubits.size() + extra > maxBlockSize) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  /**
+   * @brief Check if qubits used by gate are blocked in this block
+   * @param used Qubits used by the gate
+   */
+  [[nodiscard]] bool checkBlocked(const std::set<Qubit>& used) const noexcept {
+    return std::ranges::all_of(
+        used, [this](const Qubit q) { return !blocked.contains(q); });
+  }
+
+  /**
+   * @brief Check if repostion is needed to keep block valid
+   * @param used Qubits used by the gate
+   * @param lastNonClifford Map of qubits to last non-Clifford operation
+   */
+  [[nodiscard]] bool
+  checkRepositionNeeded(const std::set<Qubit>& used,
+                        const std::unordered_map<Qubit, std::size_t>&
+                            lastNonClifford) const noexcept {
+    std::size_t required = 0;
+    for (const auto q : used) {
+      if (const auto it = lastNonClifford.find(q);
+          it != lastNonClifford.end()) {
+        required = std::max(required, it->second);
+      }
+    }
+    return required > logicalStep;
+  }
+
+  /**
+   * @brief Append operation into block
+   * @details Append operation into block. If movePosition is true, re-position
+   * here otherwise we erase the current slot.
+   * @param op Operation to add
+   * @param used Qubits used by the gate
+   * @param qc Quantum computation
+   * @param it Current iterator in quantum computation
+   * @param movePosition Whether to move the position of the block
+   * @param step Current logical step in the quantum computation
+   */
+  void addOp(std::unique_ptr<Operation>& op, const std::set<Qubit>& used,
+             QuantumComputation& qc, QuantumComputation::iterator& it,
+             const bool movePosition, const std::size_t step) {
+    operations->emplace_back(std::move(op));
+
+    if (movePosition) {
+      // we move block into the right position with identities because they are
+      // removed later
+      *position = std::make_unique<StandardOperation>(0, I);
+      position = &(*it);
+      logicalStep = step;
+    } else {
+      // operations is moved into compound operation so we can delete it
+      it = qc.erase(it);
+      --it;
+    }
+
+    for (const auto q : used) {
+      blockQubits.insert(q);
+    }
+  }
+
+  /**
+   * @brief Collapse operation and reset block
+   */
+  void finalize() {
+    if (position == nullptr || empty()) {
+      return;
+    }
+    if (operations->isConvertibleToSingleOperation()) {
+      *position = operations->collapseToSingleOperation();
+    } else {
+      *position = std::move(operations);
+    }
+    // reset
+    operations = std::make_unique<CompoundOperation>();
+    blockQubits.clear();
+    blocked.clear();
+    position = nullptr;
+    logicalStep = 0;
+  }
+};
+
+void CircuitOptimizer::collectCliffordBlocks(QuantumComputation& qc,
+                                             const std::size_t maxBlockSize) {
+  if (qc.size() <= 1) {
+    return;
+  }
+
+  qc.reorderOperations();
+  deferMeasurements(qc);
+
+  std::vector<CliffordBlock> blocks;
+  std::unordered_map<Qubit, std::size_t> lastNonClifford;
+  std::size_t step = 0;
+
+  for (auto it = qc.begin(); it != qc.end(); ++it, ++step) {
+    auto& op = *it;
+    const bool isClif = op->isClifford();
+    const std::set<Qubit> used = op->getUsedQubits();
+
+    if (!isClif) {
+      // track nonClifford and block qubits for any block
+      for (const auto q : used) {
+        lastNonClifford[q] = step;
+      }
+      for (auto& block : blocks) {
+        bool touched = false;
+        for (const auto q : used) {
+          if (block.blockQubits.contains(q)) {
+            block.blocked.insert(q);
+            touched = true;
+          }
+        }
+        if (touched && block.fullyDisabled()) {
+          block.finalize();
+        }
+      }
+      // keep this non-Clifford gate in place
+      continue;
+    }
+
+    // Gate itself is too big
+    if (used.size() > maxBlockSize) {
+      continue;
+    }
+
+    // Try to place into newest block
+    auto chosen = static_cast<std::size_t>(0);
+    bool movePosition = false;
+    bool found = false;
+    for (std::size_t i = blocks.size(); i-- > static_cast<std::size_t>(0);) {
+      auto& block = blocks[i];
+      if (block.position == nullptr) {
+        continue;
+      }
+      if (!block.checkBlocked(used)) {
+        continue;
+      }
+      if (!block.checkExceedsMaxBlockSize(used, maxBlockSize)) {
+        continue;
+      }
+
+      chosen = i;
+      movePosition = block.checkRepositionNeeded(used, lastNonClifford);
+      found = true;
+      break;
+    }
+
+    if (found) {
+      // Disable these qubits in all older blocks
+      for (std::size_t t = 0; t < chosen; ++t) {
+        auto& block = blocks[t];
+        if (block.position == nullptr) {
+          continue;
+        }
+        bool touches = false;
+        for (const auto q : used) {
+          if (block.blockQubits.contains(q)) {
+            block.blocked.insert(q);
+            touches = true;
+          }
+        }
+        if (touches && block.fullyDisabled()) {
+          block.finalize();
+        }
+      }
+
+      blocks[chosen].addOp(op, used, qc, it, movePosition, step);
+      continue;
+    }
+
+    // Otherwise open a new block at this slot
+    CliffordBlock block{};
+    block.operations = std::make_unique<CompoundOperation>();
+    block.position = &(*it);
+    block.logicalStep = step;
+    block.operations->emplace_back(std::move(op));
+    for (const auto q : used) {
+      block.blockQubits.insert(q);
+    }
+    blocks.emplace_back(std::move(block));
+  }
+
+  for (auto& block : blocks) {
+    block.finalize();
+  }
+  removeIdentities(qc);
+}
+
 namespace {
 void elidePermutations(Iterator begin, const std::function<Iterator()>& end,
                        const std::function<Iterator(Iterator)>& erase,

src/ir/operations/CompoundOperation.cpp

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

src/ir/operations/StandardOperation.cpp

@@ -250,6 +250,29 @@ bool StandardOperation::isGlobal(const size_t nQubits) const {
 /***
  * Public Methods
  ***/
+bool StandardOperation::isClifford() const {
+  switch (type) {
+  case I:
+    return true;
+  case X:
+  case Y:
+  case Z:
+    return (controls.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,