Changes 'next_errors' variable in main decoding loop to a linked list (#173)

* Prevents unnecessary vector copies as we can just rebuild the history
when we need to.
* Also use arena allocator to prevent repeated heap allocation.

Tested with:
```
(venv13) dandragona@kaonashi:~/Documents/tesseract/indep/optimizations$ bazel-8.2.1 test --cache_test_results=no //src:all //src/py:all
INFO: Analyzed 24 targets (0 packages loaded, 23 targets configured).
INFO: Found 16 targets and 8 test targets...
INFO: Elapsed time: 6.390s, Critical Path: 5.97s
INFO: 9 processes: 42 action cache hit, 12 linux-sandbox, 2 local.
INFO: Build completed successfully, 9 total actions
//src:common_tests                                                       PASSED in 0.0s
//src:tesseract_tests                                                    PASSED in 0.7s
//src/py:common_test                                                     PASSED in 1.5s
//src/py:requirements_test                                               PASSED in 5.9s
//src/py:simplex_test                                                    PASSED in 1.6s
//src/py:tesseract_sinter_compat_test                                    PASSED in 4.6s
//src/py:tesseract_test                                                  PASSED in 1.5s
//src/py:utils_test                                                      PASSED in 1.0s

Executed 8 out of 8 tests: 8 tests pass.
```
Additional accuracy comparisons:
```
# d=11, p=0.001 Surface Code Transversal CNOT X
# baseline:
num_shots = 5000 num_low_confidence = 0 num_errors = 25 total_time_seconds = 364.1171770000001
# arena allocator + linked list optimization:
num_shots = 5000 num_low_confidence = 0 num_errors = 25 total_time_seconds = 253.3283590000004


# d=9, p=.002 Superdense Color Code X
# baseline:
num_shots = 5000 num_low_confidence = 0 num_errors = 64 total_time_seconds = 604.9724190000003
# arena allocator + linked list optimization:
num_shots = 5000 num_low_confidence = 0 num_errors = 64 total_time_seconds = 585.220854999997


# d=12, p=0.002 Bivariate Bicycle X
# baseline:
num_shots = 5000 num_low_confidence = 0 num_errors = 15 total_time_seconds = 3232.868145999989
# arena allocator + linked list optimization:
num_shots = 5000 num_low_confidence = 0 num_errors = 15 total_time_seconds = 3099.478287000002


# d=23, p=0.008 Surface Code Unrotated Memory Z
# baseline:
num_shots = 5000 num_low_confidence = 0 num_errors = 0 total_time_seconds = 803.0619609999993
# arena allocator + linked list optimization:
num_shots = 5000 num_low_confidence = 0 num_errors = 0 total_time_seconds = 142.359363
```

Co-authored-by: Noah Shutty <noajshu@users.noreply.github.com>

Author: dandragona-dev

src/common.h

@@ -45,6 +45,15 @@ struct Symptom {
   std::string str() const;
 };
 
+// Represents a specific subset of errors in the power set of all errors.
+// `parent_idx` is the index of the parent node in the error chain arena, and is
+// used to trace back to the root of the error set.
+struct ErrorChainNode {
+  size_t error_index;
+  size_t min_detector;
+  int64_t parent_idx = -1;
+};
+
 // Represents an error / weighted hyperedge
 struct Error {
   double likelihood_cost;

src/tesseract.cc

@@ -72,7 +72,7 @@ std::string Node::str() {
   std::stringstream ss;
   auto& self = *this;
   ss << "Node(";
-  ss << "errors=" << self.errors << ", ";
+  ss << "error_chain_idx=" << self.error_chain_idx << ", ";
   ss << "cost=" << self.cost << ", ";
   ss << "num_dets=" << self.num_dets << ", ";
   return ss.str();
@@ -243,16 +243,13 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections)
 }
 
 void TesseractDecoder::flip_detectors_and_block_errors(
-    size_t detector_order, const std::vector<size_t>& errors, boost::dynamic_bitset<>& detectors,
+    size_t detector_order, int64_t error_chain_idx, boost::dynamic_bitset<>& detectors,
     std::vector<DetectorCostTuple>& detector_cost_tuples) const {
-  for (size_t ei : errors) {
-    size_t min_detector = std::numeric_limits<size_t>::max();
-    for (size_t d = 0; d < num_detectors; ++d) {
-      if (detectors[config.det_orders[detector_order][d]]) {
-        min_detector = config.det_orders[detector_order][d];
-        break;
-      }
-    }
+  int64_t walker_idx = error_chain_idx;
+  while (walker_idx != -1) {
+    const auto& node = error_chain_arena[walker_idx];
+    size_t ei = node.error_index;
+    size_t min_detector = node.min_detector;
 
     for (int oei : d2e[min_detector]) {
       detector_cost_tuples[oei].error_blocked = 1;
@@ -262,13 +259,18 @@ void TesseractDecoder::flip_detectors_and_block_errors(
     for (int d : edets[ei]) {
       detectors[d] = !detectors[d];
     }
+    walker_idx = node.parent_idx;
   }
 }
 
 void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
                                         size_t detector_order, size_t detector_beam) {
   predicted_errors_buffer.clear();
   low_confidence_flag = false;
+  error_chain_arena.clear();
+  // Can technically be larger than pqlimit, but we need an initial guess on how many nodes we
+  // will process from the queue.
+  error_chain_arena.reserve(config.pqlimit);
 
   std::priority_queue<Node, std::vector<Node>, std::greater<Node>> pq;
   std::unordered_map<size_t, std::unordered_set<boost::dynamic_bitset<>>> visited_detectors;
@@ -296,11 +298,10 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
   size_t min_num_dets = detections.size();
   size_t max_num_dets = min_num_dets + detector_beam;
 
-  std::vector<size_t> next_errors;
   boost::dynamic_bitset<> next_detectors;
   std::vector<DetectorCostTuple> next_detector_cost_tuples;
 
-  pq.push({initial_cost, min_num_dets, std::vector<size_t>()});
+  pq.push({initial_cost, min_num_dets, 0, -1});
   size_t num_pq_pushed = 1;
 
   while (!pq.empty()) {
@@ -311,17 +312,20 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
 
     boost::dynamic_bitset<> detectors = initial_detectors;
     std::vector<DetectorCostTuple> detector_cost_tuples(num_errors);
-    flip_detectors_and_block_errors(detector_order, node.errors, detectors, detector_cost_tuples);
+    flip_detectors_and_block_errors(detector_order, node.error_chain_idx, detectors,
+                                    detector_cost_tuples);
 
     if (node.num_dets == 0) {
       if (config.create_visualization) {
-        visualizer.add_activated_errors(node.errors);
+        visualizer.add_activated_errors(node.error_chain_idx, error_chain_arena);
         visualizer.add_activated_detectors(detectors, num_detectors);
       }
       if (config.verbose) {
         std::cout << "activated_errors = ";
-        for (size_t oei : node.errors) {
-          std::cout << oei << ", ";
+        int64_t walker_idx = node.error_chain_idx;
+        while (walker_idx != -1) {
+          std::cout << error_chain_arena[walker_idx].error_index << ", ";
+          walker_idx = error_chain_arena[walker_idx].parent_idx;
         }
         std::cout << std::endl;
         std::cout << "activated_detectors = ";
@@ -335,15 +339,20 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
         std::cout << "Decoding complete. Cost: " << node.cost
                   << " num_pq_pushed = " << num_pq_pushed << std::endl;
       }
-      predicted_errors_buffer = node.errors;
+      predicted_errors_buffer.resize(node.depth);
+      int64_t walker_idx = node.error_chain_idx;
+      for (size_t i = 0; i < node.depth; ++i) {
+        predicted_errors_buffer[node.depth - 1 - i] = error_chain_arena[walker_idx].error_index;
+        walker_idx = error_chain_arena[walker_idx].parent_idx;
+      }
       return;
     }
 
     if (config.no_revisit_dets && !visited_detectors[node.num_dets].insert(detectors).second)
       continue;
 
     if (config.create_visualization) {
-      visualizer.add_activated_errors(node.errors);
+      visualizer.add_activated_errors(node.error_chain_idx, error_chain_arena);
       visualizer.add_activated_detectors(detectors, num_detectors);
     }
     if (config.verbose) {
@@ -352,8 +361,10 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
       std::cout << "num_dets = " << node.num_dets << " max_num_dets = " << max_num_dets
                 << " cost = " << node.cost << std::endl;
       std::cout << "activated_errors = ";
-      for (size_t oei : node.errors) {
-        std::cout << oei << ", ";
+      int64_t walker_idx = node.error_chain_idx;
+      while (walker_idx != -1) {
+        std::cout << error_chain_arena[walker_idx].error_index << ", ";
+        walker_idx = error_chain_arena[walker_idx].parent_idx;
       }
       std::cout << std::endl;
       std::cout << "activated_detectors = ";
@@ -408,8 +419,13 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
       }
       prev_ei = ei;
 
-      next_errors = node.errors;
-      next_errors.push_back(ei);
+      // Create the error chain node for this candidate.
+      error_chain_arena.emplace_back();
+      auto& next_node = error_chain_arena.back();
+      next_node.error_index = ei;
+      next_node.min_detector = min_detector;
+      next_node.parent_idx = node.error_chain_idx;
+
       next_detectors = detectors;
       next_detector_cost_tuples[ei].error_blocked = 1;
 
@@ -453,7 +469,7 @@ void TesseractDecoder::decode_to_errors(const std::vector<uint64_t>& detections,
 
       if (next_cost == INF) continue;
 
-      pq.push({next_cost, next_num_dets, next_errors});
+      pq.push({next_cost, next_num_dets, node.depth + 1, (int64_t)(error_chain_arena.size() - 1)});
       ++num_pq_pushed;
 
       if (num_pq_pushed > config.pqlimit) {

src/tesseract.h

@@ -52,7 +52,8 @@ class Node {
   double cost;
   // The number of activated detectors (dets for short) at this node
   size_t num_dets;
-  std::vector<size_t> errors;
+  size_t depth;
+  int64_t error_chain_idx = -1;
 
   bool operator>(const Node& other) const;
   std::string str();
@@ -111,10 +112,11 @@ struct TesseractDecoder {
   std::vector<std::vector<int>> edets;
   size_t num_errors;
   std::vector<ErrorCost> error_costs;
+  std::vector<common::ErrorChainNode> error_chain_arena;
 
   void initialize_structures(size_t num_detectors);
   double get_detcost(size_t d, const std::vector<DetectorCostTuple>& detector_cost_tuples) const;
-  void flip_detectors_and_block_errors(size_t detector_order, const std::vector<size_t>& errors,
+  void flip_detectors_and_block_errors(size_t detector_order, int64_t error_chain_idx,
                                        boost::dynamic_bitset<>& detectors,
                                        std::vector<DetectorCostTuple>& detector_cost_tuples) const;
 };

src/visualization.cc

@@ -20,11 +20,15 @@ void Visualizer::add_detector_coords(const std::vector<std::vector<double>>& det
   }
 }
 
-void Visualizer::add_activated_errors(const std::vector<size_t>& activated_errors) {
+void Visualizer::add_activated_errors(int64_t node_idx,
+                                      const std::vector<common::ErrorChainNode>& arena) {
   std::stringstream ss;
   ss << "activated_errors = ";
-  for (size_t oei : activated_errors) {
-    ss << oei << ", ";
+  int64_t walker_idx = node_idx;
+  while (walker_idx != -1) {
+    const auto& node = arena[walker_idx];
+    ss << node.error_index << ", ";
+    walker_idx = node.parent_idx;
   }
   lines.push_back(ss.str());
 }

src/visualization.h

@@ -10,7 +10,7 @@
 struct Visualizer {
   void add_detector_coords(const std::vector<std::vector<double>>&);
   void add_errors(const std::vector<common::Error>&);
-  void add_activated_errors(const std::vector<size_t>&);
+  void add_activated_errors(int64_t node_idx, const std::vector<common::ErrorChainNode>& arena);
   void add_activated_detectors(const boost::dynamic_bitset<>&, size_t);
 
   void write(const char* fpath);