Check if gateset is Clifford.

include/cliffordsynthesis/encoding/GateEncoder.hpp

@@ -5,18 +5,25 @@
 
 #pragma once
 
+#include "Definitions.hpp"
 #include "LogicBlock/LogicBlock.hpp"
 #include "cliffordsynthesis/Results.hpp"
 #include "cliffordsynthesis/encoding/TableauEncoder.hpp"
 #include "operations/OpType.hpp"
 
+#include <algorithm>
 #include <cstddef>
 #include <memory>
 #include <utility>
 #include <vector>
 
 namespace cs::encoding {
 class GateSet : public std::vector<qc::OpType> {
+  static constexpr std::array<qc::OpType, 9> SINGLE_QUBIT_CLIFFORDS = {
+      qc::OpType::I,   qc::OpType::H,  qc::OpType::X,
+      qc::OpType::Y,   qc::OpType::Z,  qc::OpType::S,
+      qc::OpType::Sdg, qc::OpType::SX, qc::OpType::SXdg};
+
 public:
   using std::vector<qc::OpType>::vector;
 
@@ -34,9 +41,15 @@ class GateSet : public std::vector<qc::OpType> {
   [[nodiscard]] bool containsZ() const { return containsGate<qc::OpType::Z>(); }
   [[nodiscard]] bool containsH() const { return containsGate<qc::OpType::H>(); }
   [[nodiscard]] bool containsS() const { return containsGate<qc::OpType::S>(); }
-  [[nodiscard]] bool containsSdag() const {
+  [[nodiscard]] bool containsSdg() const {
     return containsGate<qc::OpType::Sdg>();
   }
+  [[nodiscard]] bool containsSX() const {
+    return containsGate<qc::OpType::SX>();
+  }
+  [[nodiscard]] bool containsSXdg() const {
+    return containsGate<qc::OpType::SXdg>();
+  }
   [[nodiscard]] std::size_t gateToIndex(const qc::OpType type) const {
     for (std::size_t i = 0; i < this->size(); ++i) {
       if (this->at(i) == type) {
@@ -45,6 +58,14 @@ class GateSet : public std::vector<qc::OpType> {
     }
     return 0;
   }
+
+  [[nodiscard]] bool isValidGateSet() const {
+    return std::all_of(this->begin(), this->end(), [](const auto& g) {
+      return std::find(SINGLE_QUBIT_CLIFFORDS.begin(),
+                       SINGLE_QUBIT_CLIFFORDS.end(),
+                       g) != SINGLE_QUBIT_CLIFFORDS.end();
+    });
+  }
 };
 class GateEncoder {
 public:
@@ -57,7 +78,11 @@ class GateEncoder {
                                       qc::OpType::X, qc::OpType::Y,
                                       qc::OpType::Z})
       : N(nQubits), S(tableauSize), T(timestepLimit), tvars(tableauVars),
-        lb(std::move(logicBlock)), singleQubitGates(std::move(singleQGates)) {}
+        lb(std::move(logicBlock)), singleQubitGates(std::move(singleQGates)) {
+    if (!singleQGates.isValidGateSet()) {
+      throw qc::QFRException("Invalid gate set");
+    }
+  }
   virtual ~GateEncoder() = default;
 
   struct Variables {

src/cliffordsynthesis/encoding/GateEncoder.cpp

@@ -266,7 +266,7 @@ void GateEncoder::assertSingleQubitGateCancellationConstraints(
       disallowed     = disallowed && !gSNext[gateIndex][qubit];
     }
 
-    if (singleQubitGates.containsS() && singleQubitGates.containsSdag()) {
+    if (singleQubitGates.containsS() && singleQubitGates.containsSdg()) {
       const auto gateIndexS   = singleQubitGates.gateToIndex(qc::OpType::S);
       const auto gateIndexSdg = singleQubitGates.gateToIndex(qc::OpType::Sdg);
 
@@ -297,7 +297,7 @@ void GateEncoder::assertSingleQubitGateCancellationConstraints(
       auto gates      = gSNow[gateIndexS][qubit];
       auto disallowed = !gSNext[gateIndexS][qubit];
 
-      if (singleQubitGates.containsSdag()) {
+      if (singleQubitGates.containsSdg()) {
         auto gateIndexSdag = singleQubitGates.gateToIndex(qc::OpType::Sdg);
 
         // -Sd-Sd- = -Z-
@@ -312,7 +312,7 @@ void GateEncoder::assertSingleQubitGateCancellationConstraints(
 
       lb->assertFormula(LogicTerm::implies(gates, disallowed));
     } else {
-      if (singleQubitGates.containsSdag()) {
+      if (singleQubitGates.containsSdg()) {
         auto gateIndexSdag = singleQubitGates.gateToIndex(qc::OpType::Sdg);
 
         // -S-Sd- = -I-