[Generator] Use row representation in RepGen (#173)

* [Generator] Use row representation to compare circuits

* Add sort() to Dataset

* Compare gate count first

* common subcircuit pruning in repgen and topological equivalence

* Generate Nam ECC Sets

* Make gen_ecc_set able to run from any directory

* Fix tmp json location

* Use row representation to compare for the case not invoking Python verifier

Author: xumingkuan

src/quartz/circuitseq/circuitseq.cpp

@@ -9,6 +9,7 @@
 #include <cassert>
 #include <charconv>
 #include <fstream>
+#include <optional>
 #include <queue>
 #include <unordered_set>
 #include <utility>
@@ -85,6 +86,78 @@ bool CircuitSeq::fully_equivalent(const CircuitSeq &other) const {
   return true;
 }
 
+bool CircuitSeq::topologically_equivalent(const CircuitSeq &other) const {
+  if (this == &other) {
+    return true;
+  }
+  if (num_qubits != other.num_qubits) {
+    return false;
+  }
+  if (wires.size() != other.wires.size() ||
+      gates.size() != other.gates.size()) {
+    return false;
+  }
+  // Mapping from this circuit to the other circuit
+  std::unordered_map<CircuitWire *, CircuitWire *> wires_mapping;
+  std::queue<CircuitWire *> wires_to_search;
+  std::unordered_map<CircuitGate *, int> gate_remaining_in_degree;
+  for (int i = 0; i < num_qubits; i++) {
+    wires_mapping[wires[i].get()] = other.wires[i].get();
+    wires_to_search.push(wires[i].get());
+  }
+  // Topological sort on this circuit
+  while (!wires_to_search.empty()) {
+    auto this_wire = wires_to_search.front();
+    auto other_wire = wires_mapping[this_wire];
+    assert(other_wire);
+    wires_to_search.pop();
+    if (this_wire->output_gates.size() != other_wire->output_gates.size()) {
+      return false;
+    }
+    for (int i = 0; i < (int)this_wire->output_gates.size(); i++) {
+      auto this_gate = this_wire->output_gates[i];
+      if (gate_remaining_in_degree.count(this_gate) == 0) {
+        // A new gate
+        gate_remaining_in_degree[this_gate] = this_gate->gate->get_num_qubits();
+      }
+      if (!--gate_remaining_in_degree[this_gate]) {
+        // Check if this gate is the same as the other gate
+        auto other_gate = other_wire->output_gates[i];
+        if (this_gate->gate->tp != other_gate->gate->tp) {
+          return false;
+        }
+        if (this_gate->input_wires.size() != other_gate->input_wires.size() ||
+            this_gate->output_wires.size() != other_gate->output_wires.size()) {
+          return false;
+        }
+        for (int j = 0; j < (int)this_gate->input_wires.size(); j++) {
+          if (this_gate->input_wires[j]->is_qubit()) {
+            // The input wire must have been mapped.
+            assert(wires_mapping.count(this_gate->input_wires[j]) != 0);
+            if (wires_mapping[this_gate->input_wires[j]] !=
+                other_gate->input_wires[j]) {
+              return false;
+            }
+          } else {
+            // parameters should not be mapped
+            if (other_gate->input_wires[j] != this_gate->input_wires[j]) {
+              return false;
+            }
+          }
+        }
+        // Map output wires
+        for (int j = 0; j < (int)this_gate->output_wires.size(); j++) {
+          assert(wires_mapping.count(this_gate->output_wires[j]) == 0);
+          wires_mapping[this_gate->output_wires[j]] =
+              other_gate->output_wires[j];
+          wires_to_search.push(this_gate->output_wires[j]);
+        }
+      }
+    }
+  }
+  return true;  // equivalent
+}
+
 bool CircuitSeq::fully_equivalent(Context *ctx, CircuitSeq &other) {
   if (hash(ctx) != other.hash(ctx)) {
     return false;
@@ -102,33 +175,106 @@ bool CircuitSeq::less_than(const CircuitSeq &other) const {
   if (get_num_gates() != other.get_num_gates()) {
     return get_num_gates() < other.get_num_gates();
   }
-  for (int i = 0; i < (int)gates.size(); i++) {
-    if (gates[i]->gate->tp != other.gates[i]->gate->tp) {
-      return gates[i]->gate->tp < other.gates[i]->gate->tp;
-    }
-    assert(gates[i]->input_wires.size() == other.gates[i]->input_wires.size());
-    assert(gates[i]->output_wires.size() ==
-           other.gates[i]->output_wires.size());
-    for (int j = 0; j < (int)gates[i]->input_wires.size(); j++) {
-      if (gates[i]->input_wires[j]->is_qubit() !=
-          other.gates[i]->input_wires[j]->is_qubit()) {
-        return gates[i]->input_wires[j]->is_qubit();
+  if (kUseRowRepresentationToCompare) {
+    for (int i = 0; i < num_qubits; i++) {
+      // Compare all gates on qubit i.
+      auto this_ptr = wires[i].get();
+      auto other_ptr = other.wires[i].get();
+      std::optional<bool> compare_outcome = std::nullopt;
+      while (this_ptr != outputs[i]) {
+        if (other_ptr == other.outputs[i]) {
+          // This circuit sequence has more gates on qubit i,
+          // so this circuit is greater.
+          return false;
+        }
+        assert(this_ptr->output_gates->size() == 1);
+        assert(other_ptr->output_gates->size() == 1);
+        auto this_gate = this_ptr->output_gates[0];
+        auto other_gate = other_ptr->output_gates[0];
+        if (!compare_outcome.has_value()) {
+          if (this_gate->gate->tp != other_gate->gate->tp) {
+            compare_outcome = this_gate->gate->tp < other_gate->gate->tp;
+          } else {
+            assert(this_gate->input_wires.size() ==
+                   other_gate->input_wires.size());
+            assert(this_gate->output_wires.size() ==
+                   other_gate->output_wires.size());
+            for (int j = 0; j < (int)this_gate->input_wires.size(); j++) {
+              if (this_gate->input_wires[j]->is_qubit() !=
+                  other_gate->input_wires[j]->is_qubit()) {
+                compare_outcome = this_gate->input_wires[j]->is_qubit();
+                break;
+              }
+              if (this_gate->input_wires[j]->index !=
+                  other_gate->input_wires[j]->index) {
+                compare_outcome = this_gate->input_wires[j]->index <
+                                  other_gate->input_wires[j]->index;
+                break;
+              }
+            }
+          }
+        }
+        // No need to compare output wires for quantum gates.
+        bool found_output_wire = false;
+        for (auto &output_wire : this_gate->output_wires) {
+          if (output_wire->index == i) {
+            found_output_wire = true;
+            this_ptr = output_wire;
+            break;
+          }
+        }
+        assert(found_output_wire);
+        found_output_wire = false;
+        for (auto &output_wire : other_gate->output_wires) {
+          if (output_wire->index == i) {
+            found_output_wire = true;
+            other_ptr = output_wire;
+            break;
+          }
+        }
+        assert(found_output_wire);
+      }
+      if (other_ptr != other.outputs[i]) {
+        // The other circuit sequence has more gates on qubit i,
+        // so this circuit is less.
+        return true;
       }
-      if (gates[i]->input_wires[j]->index !=
-          other.gates[i]->input_wires[j]->index) {
-        return gates[i]->input_wires[j]->index <
-               other.gates[i]->input_wires[j]->index;
+      // Two circuit sequences have the same number of gates on qubit i.
+      // Compare the contents.
+      if (compare_outcome.has_value()) {
+        return compare_outcome.value();
       }
     }
-    for (int j = 0; j < (int)gates[i]->output_wires.size(); j++) {
-      if (gates[i]->output_wires[j]->is_qubit() !=
-          other.gates[i]->output_wires[j]->is_qubit()) {
-        return gates[i]->output_wires[j]->is_qubit();
+  } else {
+    for (int i = 0; i < (int)gates.size(); i++) {
+      if (gates[i]->gate->tp != other.gates[i]->gate->tp) {
+        return gates[i]->gate->tp < other.gates[i]->gate->tp;
+      }
+      assert(gates[i]->input_wires.size() ==
+             other.gates[i]->input_wires.size());
+      assert(gates[i]->output_wires.size() ==
+             other.gates[i]->output_wires.size());
+      for (int j = 0; j < (int)gates[i]->input_wires.size(); j++) {
+        if (gates[i]->input_wires[j]->is_qubit() !=
+            other.gates[i]->input_wires[j]->is_qubit()) {
+          return gates[i]->input_wires[j]->is_qubit();
+        }
+        if (gates[i]->input_wires[j]->index !=
+            other.gates[i]->input_wires[j]->index) {
+          return gates[i]->input_wires[j]->index <
+                 other.gates[i]->input_wires[j]->index;
+        }
       }
-      if (gates[i]->output_wires[j]->index !=
-          other.gates[i]->output_wires[j]->index) {
-        return gates[i]->output_wires[j]->index <
-               other.gates[i]->output_wires[j]->index;
+      for (int j = 0; j < (int)gates[i]->output_wires.size(); j++) {
+        if (gates[i]->output_wires[j]->is_qubit() !=
+            other.gates[i]->output_wires[j]->is_qubit()) {
+          return gates[i]->output_wires[j]->is_qubit();
+        }
+        if (gates[i]->output_wires[j]->index !=
+            other.gates[i]->output_wires[j]->index) {
+          return gates[i]->output_wires[j]->index <
+                 other.gates[i]->output_wires[j]->index;
+        }
       }
     }
   }
@@ -308,6 +454,20 @@ bool CircuitSeq::remove_last_gate() {
   return true;
 }
 
+bool CircuitSeq::remove_gate(int gate_position) {
+  if (gate_position < 0 || gate_position >= (int)gates.size()) {
+    return false;
+  }
+  CircuitGate *circuit_gate = gates[gate_position].get();
+  auto *gate = circuit_gate->gate;
+  assert(gate->is_quantum_gate());
+  remove_quantum_gate_from_graph(circuit_gate);
+  // Remove the gate.
+  gates.erase(gates.begin() + gate_position);
+  hash_value_valid_ = false;
+  return true;
+}
+
 bool CircuitSeq::remove_gate(CircuitGate *circuit_gate) {
   auto gate_pos = std::find_if(
       gates.begin(), gates.end(),
@@ -1410,6 +1570,28 @@ std::vector<CircuitGate *> CircuitSeq::first_quantum_gates() const {
   return result;
 }
 
+std::vector<int> CircuitSeq::first_quantum_gate_positions() const {
+  std::vector<int> result;
+  std::unordered_set<CircuitGate *> depend_on_other_gates;
+  depend_on_other_gates.reserve(gates.size());
+  for (int i = 0; i < (int)gates.size(); i++) {
+    CircuitGate *circuit_gate = gates[i].get();
+    if (circuit_gate->gate->is_parameter_gate()) {
+      continue;
+    }
+    if (depend_on_other_gates.find(circuit_gate) ==
+        depend_on_other_gates.end()) {
+      result.push_back(i);
+    }
+    for (const auto &output_wire : circuit_gate->output_wires) {
+      for (const auto &output_gate : output_wire->output_gates) {
+        depend_on_other_gates.insert(output_gate);
+      }
+    }
+  }
+  return result;
+}
+
 std::vector<CircuitGate *> CircuitSeq::last_quantum_gates() const {
   std::vector<CircuitGate *> result;
   for (const auto &circuit_gate : gates) {

src/quartz/circuitseq/circuitseq.h

@@ -28,6 +28,14 @@ class CircuitSeq {
    * @return True iff two circuit sequences are fully equivalent.
    */
   [[nodiscard]] bool fully_equivalent(const CircuitSeq &other) const;
+  /**
+   * Compare if two circuits are topologically equivalent.
+   * X(Q0) X(Q1) and X(Q1) X(Q0) are topologically equivalent but not
+   * fully equivalent.
+   * @param other The other circuit sequence to be compared.
+   * @return True iff two circuit sequences are topologically equivalent.
+   */
+  [[nodiscard]] bool topologically_equivalent(const CircuitSeq &other) const;
   /**
    * Compute the hash value and compare if two circuit sequences are fully
    * equivalent including the hash value.
@@ -36,6 +44,15 @@ class CircuitSeq {
    * @return True iff two circuit sequences are fully equivalent.
    */
   [[nodiscard]] bool fully_equivalent(Context *ctx, CircuitSeq &other);
+  /**
+   * Compare two circuit sequences first by the qubit count (fewer is less),
+   * then by the gate count (fewer is less), then by the gate sequence.
+   * If |kUseRowRepresentationToCompare| is true, compare the gates on qubit 0
+   * first (fewer is less, then compare by the content), then qubit 1, ...
+   * @param other The other circuit sequence to compare with.
+   * @return True iff this circuit sequence is strictly less than the other
+   * circuit sequence.
+   */
   [[nodiscard]] bool less_than(const CircuitSeq &other) const;
 
   /**
@@ -90,7 +107,13 @@ class CircuitSeq {
 
   /**
    * Remove a quantum gate.
-   * @param circuit_gate the gate to be removed.
+   * @param gate_position The position of the gate to be removed (0-indexed).
+   * @return True iff the removal is successful.
+   */
+  bool remove_gate(int gate_position);
+  /**
+   * Remove a quantum gate.
+   * @param circuit_gate The gate to be removed.
    * @return True iff the removal is successful.
    */
   bool remove_gate(CircuitGate *circuit_gate);
@@ -272,11 +295,23 @@ class CircuitSeq {
    */
   std::unique_ptr<CircuitSeq> get_ccz_to_cx_rz(Context *ctx) const;
 
-  // Returns quantum gates which do not topologically depend on any other
-  // quantum gates.
+  /**
+   * Returns quantum gates which do not topologically depend on any other
+   * quantum gates.
+   * @return The pointers to the first quantum gates.
+   */
   [[nodiscard]] std::vector<CircuitGate *> first_quantum_gates() const;
-  // Returns quantum gates which can appear at last in some topological
-  // order of the CircuitSeq.
+  /**
+   * Returns quantum gates which do not topologically depend on any other
+   * quantum gates.
+   * @return The positions (0-indexed) of the first quantum gates.
+   */
+  [[nodiscard]] std::vector<int> first_quantum_gate_positions() const;
+  /**
+   * Returns quantum gates which can appear at last in some topological
+   * order of the CircuitSeq.
+   * @return The pointers to the last quantum gates.
+   */
   [[nodiscard]] std::vector<CircuitGate *> last_quantum_gates() const;
 
   static bool same_gate(const CircuitSeq &seq1, int index1,

src/quartz/dataset/dataset.cpp

@@ -161,6 +161,13 @@ int Dataset::normalize_to_canonical_representations(Context *ctx) {
   return num_removed;
 }
 
+void Dataset::sort() {
+  for (auto &it : dataset) {
+    std::sort(it.second.begin(), it.second.end(),
+              UniquePtrCircuitSeqComparator());
+  }
+}
+
 bool Dataset::insert(Context *ctx, std::unique_ptr<CircuitSeq> dag) {
   const auto hash_value = dag->hash(ctx);
   bool ret = dataset.count(hash_value) == 0;

src/quartz/dataset/dataset.h

@@ -24,6 +24,11 @@ class Dataset {
   // Return the number of DAGs removed.
   int normalize_to_canonical_representations(Context *ctx);
 
+  /**
+   * Sort the circuits with the same hash value by CircuitSeq::less_than().
+   */
+  void sort();
+
   // This function runs in O(1).
   [[nodiscard]] int num_hash_values() const;