Minor changes

Signed-off-by: Dragana Grbic <draganaurosgrbic@gmail.com>

n#	modified:   src/tesseract.cc

Author: draganaurosgrbic

src/tesseract.cc

@@ -24,12 +24,11 @@ bool Node::operator>(const Node& other) const {
 
 double TesseractDecoder::get_detcost(size_t d,
                                      const std::vector<char>& blocked_errs,
-                                     const std::vector<size_t>& det_counts,
-                                     const std::vector<char>& dets) const {
+                                     const std::vector<size_t>& det_counts) const {
   double min_cost = INF;
   for (size_t ei : d2e[d]) {
     if (!blocked_errs[ei]) {
-      double ecost = (errors[ei].likelihood_cost) / det_counts[ei];
+      double ecost = errors[ei].likelihood_cost / det_counts[ei];
       min_cost = std::min(min_cost, ecost);
       assert(det_counts[ei]);
     }
@@ -46,7 +45,7 @@ TesseractDecoder::TesseractDecoder(TesseractConfig config_) : config(config_) {
       assert(config.det_orders[i].size() == config.dem.count_detectors());
     }
   }
-  assert(this->config.det_orders.size());
+  assert(config.det_orders.size());
   errors = get_errors_from_dem(config.dem.flattened());
   num_detectors = config.dem.count_detectors();
   num_errors = config.dem.count_errors();
@@ -112,7 +111,7 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections)
       size_t det_order = beam % config.det_orders.size();
       decode_to_errors(detections, det_order);
       double this_cost = cost_from_errors(predicted_errors_buffer);
-      if (!low_confidence_flag and this_cost < best_cost) {
+      if (!low_confidence_flag && this_cost < best_cost) {
         best_errors = predicted_errors_buffer;
         best_cost = this_cost;
       }
@@ -129,7 +128,7 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections)
          ++det_order) {
       decode_to_errors(detections, det_order);
       double this_cost = cost_from_errors(predicted_errors_buffer);
-      if (!low_confidence_flag and this_cost < best_cost) {
+      if (!low_confidence_flag && this_cost < best_cost) {
         best_errors = predicted_errors_buffer;
         best_cost = this_cost;
       }
@@ -145,7 +144,7 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections)
   }
   config.det_beam = max_det_beam;
   predicted_errors_buffer = best_errors;
-  low_confidence_flag = (best_cost == std::numeric_limits<double>::max());
+  low_confidence_flag = best_cost == std::numeric_limits<double>::max();
 }
 
 bool QNode::operator>(const QNode& other) const {
@@ -175,20 +174,16 @@ void TesseractDecoder::to_node(const QNode& qnode,
     // Reconstruct the blocked_errs
     for (size_t oei : d2e[min_det]) {
       node.blocked_errs[oei] = true;
-      if (!config.at_most_two_errors_per_detector and oei == ei) break;
+      if (!config.at_most_two_errors_per_detector && oei == ei) break;
     }
 
     // Reconstruct the dets
     for (size_t d : edets[ei]) {
-      if (node.dets[d]) {
-        node.dets[d] = false;
-        if (config.at_most_two_errors_per_detector) {
-          for (size_t oei : d2e[d]) {
-            node.blocked_errs[oei] = true;
-          }
+      node.dets[d] = !node.dets[d];
+      if (!node.dets[d] && config.at_most_two_errors_per_detector) {
+        for (size_t oei : d2e[d]) {
+          node.blocked_errs[oei] = true;
         }
-      } else {
-        node.dets[d] = true;
       }
     }
   }
@@ -209,40 +204,37 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
                      std::unordered_set<std::vector<char>, VectorCharHash>>
       discovered_dets;
 
-  size_t min_num_dets;
-  {
-    std::vector<size_t> errs;
-    std::vector<char> blocked_errs(num_errors, false);
-    std::vector<size_t> det_counts(num_errors, 0);
+  size_t min_num_dets = detections.size();
+  std::vector<size_t> errs;
+  std::vector<char> blocked_errs(num_errors, false);
+  std::vector<size_t> det_counts(num_errors, 0);
 
-    for (size_t d = 0; d < num_detectors; ++d) {
-      if (!dets[d]) continue;
-      for (int ei : d2e[d]) {
-        det_counts[ei]++;
-      }
+  for (size_t d = 0; d < num_detectors; ++d) {
+    if (!dets[d]) continue;
+    for (int ei : d2e[d]) {
+      ++det_counts[ei];
     }
-    double initial_cost = 0.0;
-    for (size_t d = 0; d < num_detectors; ++d) {
-      if (!dets[d]) continue;
-      initial_cost += get_detcost(d, blocked_errs, det_counts, dets);
-    }
-    if (initial_cost == INF) {
-      low_confidence_flag = true;
-      return;
-    }
-    min_num_dets =
-        static_cast<size_t>(std::count(dets.begin(), dets.end(), true));
-    // pq.push({errs, dets, initial_cost, min_num_dets, blocked_errs});
-    pq.push({initial_cost, min_num_dets, errs});
   }
-  size_t num_pq_pushed = 1;
+  double initial_cost = 0.0;
+  for (size_t d = 0; d < num_detectors; ++d) {
+    if (!dets[d]) continue;
+    initial_cost += get_detcost(d, blocked_errs, det_counts);
+  }
+  if (initial_cost == INF) {
+    low_confidence_flag = true;
+    return;
+  }
+  // pq.push({errs, dets, initial_cost, min_num_dets, blocked_errs});
+  pq.push({initial_cost, min_num_dets, errs});
 
+  size_t num_pq_pushed = 1;
   size_t max_num_dets = min_num_dets + det_beam;
   Node node;
   std::vector<size_t> next_det_counts;
   std::vector<char> next_next_blocked_errs;
   std::vector<char> next_dets;
   std::vector<size_t> next_errs;
+
   while (!pq.empty()) {
     const QNode qnode = pq.top();
     if (qnode.num_dets > max_num_dets) {
@@ -260,13 +252,12 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
       }
       // Store the predicted errors into the buffer
       predicted_errors_buffer = node.errs;
-
       return;
     }
 
     if (node.num_dets > max_num_dets) continue;
 
-    if (config.no_revisit_dets and
+    if (config.no_revisit_dets &&
         !discovered_dets[node.num_dets].insert(node.dets).second) {
       continue;
     }
@@ -308,9 +299,10 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
     for (size_t d = 0; d < num_detectors; ++d) {
       if (!node.dets[d]) continue;
       for (int ei : d2e[d]) {
-        det_counts[ei]++;
+        ++det_counts[ei];
       }
     }
+
     // We cache as we recompute the det costs
     std::vector<double> det_costs(num_detectors, -1);
     std::vector<char> next_blocked_errs = node.blocked_errs;
@@ -334,19 +326,14 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
       // iteration
       if (last_ei != std::numeric_limits<size_t>::max()) {
         for (int d : edets[last_ei]) {
-          if (node.dets[d]) {
-            for (int oei : d2e[d]) {
-              ++next_det_counts[oei];
-            }
-          } else {
-            for (int oei : d2e[d]) {
-              --next_det_counts[oei];
-            }
+          int fired = node.dets[d] ? 1 : -1;
+          for (int oei : d2e[d]) {
+            next_det_counts[oei] += fired;
           }
         }
       }
-      last_ei = ei;
 
+      last_ei = ei;
       next_blocked_errs[ei] = true;
 
       next_errs = node.errs;
@@ -359,23 +346,18 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
       if (config.at_most_two_errors_per_detector) {
         next_next_blocked_errs = next_blocked_errs;
       }
+
       for (int d : edets[ei]) {
-        if (next_dets[d]) {
-          next_dets[d] = false;
-          --next_num_dets;
-          for (int oei : d2e[d]) {
-            --next_det_counts[oei];
-          }
-          if (config.at_most_two_errors_per_detector) {
-            for (size_t oei : d2e[d]) {
-              next_next_blocked_errs[oei] = true;
-            }
-          }
-        } else {
-          next_dets[d] = true;
-          ++next_num_dets;
-          for (int oei : d2e[d]) {
-            ++next_det_counts[oei];
+        next_dets[d] = !next_dets[d];
+        int fired = next_dets[d] ? 1 : -1;
+        next_num_dets += fired;
+        for (int oei : d2e[d]) {
+          next_det_counts[oei] += fired;
+        }
+
+        if (!next_dets[d] && config.at_most_two_errors_per_detector) {
+          for (size_t oei : d2e[d]) {
+            next_next_blocked_errs[oei] = true;
           }
         }
       }
@@ -384,7 +366,7 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
         continue;
       }
 
-      if (config.no_revisit_dets and
+      if (config.no_revisit_dets &&
           discovered_dets[next_num_dets].find(next_dets) !=
               discovered_dets[next_num_dets].end()) {
         continue;
@@ -394,23 +376,22 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
         if (node.dets[d]) {
           if (det_costs[d] == -1) {
             det_costs[d] =
-                get_detcost(d, node.blocked_errs, det_counts, node.dets);
+                get_detcost(d, node.blocked_errs, det_counts);
           }
           next_cost -= det_costs[d];
         } else {
-          next_cost += get_detcost(d, config.at_most_two_errors_per_detector ? next_next_blocked_errs : next_blocked_errs, next_det_counts,
-                                   next_dets);
+          next_cost += get_detcost(d, config.at_most_two_errors_per_detector ? next_next_blocked_errs : next_blocked_errs, next_det_counts);
         }
       }
       for (size_t od : eneighbors[ei]) {
         if (!node.dets[od] || !next_dets[od]) continue;
         if (det_costs[od] == -1) {
           det_costs[od] =
-              get_detcost(od, node.blocked_errs, det_counts, node.dets);
+              get_detcost(od, node.blocked_errs, det_counts);
         }
         next_cost -= det_costs[od];
         next_cost +=
-            get_detcost(od, config.at_most_two_errors_per_detector ? next_next_blocked_errs : next_blocked_errs, next_det_counts, next_dets);
+            get_detcost(od, config.at_most_two_errors_per_detector ? next_next_blocked_errs : next_blocked_errs, next_det_counts);
       }
 
       if (next_cost == INF) {

src/tesseract.h

@@ -19,6 +19,7 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
+#include <unordered_set>
 
 #include "common.h"
 #include "stim.h"
@@ -70,10 +71,12 @@ struct TesseractDecoder {
   // these detection events, using a specified detector ordering index.
   void decode_to_errors(const std::vector<uint64_t>& detections,
                         size_t det_order);
+
   // Returns the bitwise XOR of all the observables bitmasks of all errors in
   // the predicted errors buffer.
   common::ObservablesMask mask_from_errors(
       const std::vector<size_t>& predicted_errors);
+
   // Returns the sum of the likelihood costs (minus-log-likelihood-ratios) of
   // all errors in the predicted errors buffer.
   double cost_from_errors(const std::vector<size_t>& predicted_errors);
@@ -97,8 +100,7 @@ struct TesseractDecoder {
 
   void initialize_structures(size_t num_detectors);
   double get_detcost(size_t d, const std::vector<char>& blocked_errs,
-                     const std::vector<size_t>& det_counts,
-                     const std::vector<char>& dets) const;
+                     const std::vector<size_t>& det_counts) const;
   void to_node(const QNode& qnode, const std::vector<char>& shot_dets,
                size_t det_order, Node& node) const;
 };