synkit 1.6.5__py3-none-win_amd64.whl

synkit/Chem/Mapper/solvers/native/cpp/src/mces/mces.cpp

@@ -0,0 +1,287 @@
+#include "synkit_mapper/mces/mces.h"
+#include "../solvers/seed.h"
+#include "synkit_mapper/core/runtime.h"
+#include <limits>
+#include <numeric>
+#include <sstream>
+#include <string>
+
+namespace synkit_mapper {
+namespace {
+struct Vertex {
+  int32_t source, target;
+};
+struct Metadata {
+  int64_t vertices = 0, edges = 0, graph_bytes = 0;
+};
+thread_local Metadata metadata;
+struct PhaseTimer {
+  double &total;
+  Clock::time_point start = Clock::now();
+  ~PhaseTimer() { total += elapsed(start); }
+};
+class CliqueSearch {
+  const Problem &p;
+  const Request &r;
+  Callback callback;
+  void *userdata;
+  Statistics &s;
+  Budget budget;
+  std::vector<Vertex> vertices;
+  std::vector<std::vector<uint64_t>> adjacency;
+  std::vector<int64_t> pair_upper;
+  std::vector<int> clique;
+  int64_t constant = 0, best_overlap = -1, target_overlap = 0, base_bytes = 0,
+          live_bytes = 0;
+  bool optimize = false, at_most = false;
+  bool adjacent(int a, int b) const {
+    return (adjacency[a][b / 64] >> (b % 64)) & 1ULL;
+  }
+  int64_t weight(int a, int b) const {
+    const auto &u = vertices[a], &v = vertices[b];
+    return std::min(p.a2[u.source * p.n + v.source],
+                    p.b2[u.target * p.n + v.target]);
+  }
+  void memory(int64_t extra) {
+    int64_t proposed = live_bytes + extra;
+    if (r.memory_limit_bytes >= 0 &&
+        base_bytes + proposed > r.memory_limit_bytes)
+      throw Stop{SYNKIT_STOP_MEMORY};
+    live_bytes = proposed;
+    s.peak_memory_bytes =
+        std::max(s.peak_memory_bytes, base_bytes + live_bytes);
+  }
+  void visit(const std::vector<int> &candidates, int64_t overlap) {
+    budget.check();
+    if (r.max_states >= 0 && s.nodes >= r.max_states)
+      throw Stop{SYNKIT_STOP_STATES};
+    ++s.nodes;
+    if (static_cast<int>(clique.size()) == p.n) {
+      ++s.leaves;
+      std::vector<int32_t> mapping(p.n, -1);
+      for (int v : clique)
+        mapping[vertices[v].source] = vertices[v].target;
+      int64_t cost = mapping_cost2(p, mapping);
+      if (cost != constant - 2 * overlap)
+        throw std::runtime_error(
+            "Weighted MCES overlap disagrees with chemical rescoring");
+      if (s.incumbent2 < 0 || cost < s.incumbent2)
+        s.incumbent2 = cost;
+      if (optimize) {
+        best_overlap = std::max(best_overlap, overlap);
+        return;
+      }
+      if ((at_most && overlap < target_overlap) ||
+          (!at_most && overlap != target_overlap))
+        return;
+      ++s.candidate_count;
+      s.labeled_count = s.candidate_count;
+      int stop = 0;
+      {
+        PhaseTimer timer{s.callback_seconds};
+        if (callback)
+          stop = callback(mapping.data(), cost, userdata);
+      }
+      if (stop)
+        throw Stop{SYNKIT_STOP_CALLBACK};
+      budget.check();
+      if (r.max_candidates >= 0 && s.candidate_count >= r.max_candidates)
+        throw Stop{SYNKIT_STOP_CANDIDATES};
+      return;
+    }
+    // Source rows form a proper coloring of the association graph: no clique
+    // contains two vertices with the same source. A full clique needs every
+    // remaining color, giving both a size bound and safe weighted bounds.
+    std::vector<uint8_t> selected(p.n, 0);
+    for (int v : clique)
+      selected[vertices[v].source] = 1;
+    std::vector<int64_t> maximum(p.n, -1),
+        minimum(p.n, std::numeric_limits<int64_t>::max());
+    size_t checked = 0;
+    for (int v : candidates) {
+      if (!(++checked % 1024))
+        budget.check();
+      int row = vertices[v].source;
+      int64_t increment = 0;
+      for (int q : clique)
+        increment += weight(v, q);
+      maximum[row] = std::max(maximum[row], increment);
+      minimum[row] = std::min(minimum[row], increment);
+    }
+    int64_t upper = overlap, lower = overlap;
+    for (int i = 0; i < p.n; ++i)
+      if (!selected[i]) {
+        if (maximum[i] < 0)
+          return;
+        upper += maximum[i];
+        lower += minimum[i];
+        for (int k = i + 1; k < p.n; ++k)
+          if (!selected[k])
+            upper += pair_upper[i * p.n + k];
+      }
+    if (optimize
+            ? upper <= best_overlap
+            : upper < target_overlap || (!at_most && lower > target_overlap))
+      return;
+    for (size_t i = 0; i < candidates.size(); ++i) {
+      budget.check();
+      int v = candidates[i];
+      std::vector<int> next;
+      next.reserve(candidates.size() - i - 1);
+      for (size_t j = i + 1; j < candidates.size(); ++j)
+        if (adjacent(v, candidates[j]))
+          next.push_back(candidates[j]);
+      if (next.size() + clique.size() + 1 < static_cast<size_t>(p.n))
+        continue;
+      int64_t increment = 0;
+      for (int q : clique)
+        increment += weight(v, q);
+      clique.push_back(v);
+      int64_t bytes = next.capacity() * sizeof(int);
+      memory(bytes);
+      try {
+        visit(next, overlap + increment);
+      } catch (...) {
+        live_bytes -= bytes;
+        clique.pop_back();
+        throw;
+      }
+      live_bytes -= bytes;
+      clique.pop_back();
+    }
+  }
+
+public:
+  CliqueSearch(const Problem &problem, const Request &request, Callback cb,
+               void *data, Statistics &stats)
+      : p(problem), r(request), callback(cb), userdata(data), s(stats),
+        budget(request) {}
+  void solve() {
+    struct Finish {
+      Statistics &s;
+      Budget &b;
+      ~Finish() { s.elapsed_seconds = b.seconds(); }
+    } finish{s, budget};
+    try {
+      budget.check();
+      std::vector<int32_t> seed;
+      {
+        PhaseTimer timer{s.model_seconds};
+        for (int i = 0; i < p.n; ++i) {
+          budget.check();
+          for (int j = 0; j < p.n; ++j)
+            if (p.types_r[i] == p.types_p[j])
+              vertices.push_back({i, j});
+          for (int k = i + 1; k < p.n; ++k)
+            constant += p.a2[i * p.n + k] + p.b2[i * p.n + k];
+        }
+        if (vertices.size() > 8192) {
+          unsupported(s);
+          return;
+        }
+        metadata.vertices = vertices.size();
+        int64_t words = (vertices.size() + 63) / 64;
+        base_bytes = sizeof(*this) + vertices.capacity() * sizeof(Vertex) +
+                     vertices.size() * (sizeof(std::vector<uint64_t>) +
+                                        words * sizeof(uint64_t)) +
+                     static_cast<int64_t>(p.n) * p.n * sizeof(int64_t) +
+                     p.n * sizeof(int);
+        metadata.graph_bytes = base_bytes;
+        memory(0);
+        adjacency.resize(vertices.size(), std::vector<uint64_t>(words, 0));
+        pair_upper.assign(p.n * p.n, 0);
+        size_t checks = 0;
+        for (size_t i = 0; i < vertices.size(); ++i) {
+          budget.check();
+          for (size_t j = i + 1; j < vertices.size(); ++j) {
+            if (!(++checks % 1024))
+              budget.check();
+            const auto &u = vertices[i], &v = vertices[j];
+            if (u.source == v.source || u.target == v.target)
+              continue;
+            adjacency[i][j / 64] |= uint64_t{1} << (j % 64);
+            adjacency[j][i / 64] |= uint64_t{1} << (i % 64);
+            ++metadata.edges;
+            int64_t w = weight(i, j);
+            auto &bound = pair_upper[u.source * p.n + v.source];
+            bound = std::max(bound, w);
+            pair_upper[v.source * p.n + u.source] = bound;
+          }
+        }
+        seed = solvers::detail::feasible_seed(p, budget);
+        if (!seed.empty())
+          s.incumbent2 = mapping_cost2(p, seed);
+      }
+      std::vector<int> root(vertices.size());
+      std::iota(root.begin(), root.end(), 0);
+      int64_t root_bytes = root.capacity() * sizeof(int);
+      memory(root_bytes);
+      if (r.query == SYNKIT_MINIMUM_CLASSES ||
+          r.query == SYNKIT_MINIMUM_PROOF) {
+        optimize = true;
+        if (s.incumbent2 >= 0)
+          best_overlap = (constant - s.incumbent2) / 2;
+        {
+          PhaseTimer timer{s.optimization_seconds};
+          visit(root, 0);
+        }
+        if (best_overlap < 0) {
+          s.search_complete = 1;
+          return;
+        }
+        s.minimum_proven = 1;
+        s.minimum2 = s.lower_bound2 = constant - 2 * best_overlap;
+        if (r.query == SYNKIT_MINIMUM_PROOF) {
+          s.search_complete = 1;
+          return;
+        }
+        target_overlap = best_overlap;
+      } else {
+        int64_t threshold = constant - r.target2;
+        if (r.query == SYNKIT_EXACT_DISTANCE &&
+            (threshold < 0 || threshold % 2)) {
+          s.search_complete = 1;
+          return;
+        }
+        at_most = r.query == SYNKIT_AT_MOST_DISTANCE;
+        target_overlap = threshold <= 0 ? 0 : (threshold + 1) / 2;
+      }
+      optimize = false;
+      {
+        PhaseTimer timer{s.enumeration_seconds};
+        visit(root, 0);
+      }
+      s.search_complete = 1;
+    } catch (const Stop &stop) {
+      stopped(s, stop.reason);
+    }
+    s.elapsed_seconds = budget.seconds();
+  }
+};
+} // namespace
+const char *mces_run_metadata() {
+  static thread_local std::string value;
+  std::ostringstream out;
+  out << "{\"architecture\":\"weighted_association_graph_size_n_clique\","
+         "\"association_vertices\":"
+      << metadata.vertices << ",\"association_edges\":" << metadata.edges
+      << ",\"accounted_graph_bytes\":" << metadata.graph_bytes
+      << ",\"memory_scope\":\"accounted_native_graph_and_clique_candidates\","
+         "\"objective_equivalence\":\"D2=C-2*weighted_common_edge_overlap\"}";
+  value = out.str();
+  return value.c_str();
+}
+int solve_mces(const Problem &p, const Request &r, Callback callback,
+               void *userdata, Statistics &s) {
+  initialize(s, r);
+  metadata = {};
+  s.labeled_count = 0;
+  s.peak_frontier = s.peak_frontier_bytes = -1;
+  if (r.symmetry || r.classify || r.max_classes != -1 || r.max_frontier != -1 ||
+      p.n > 256)
+    return unsupported(s);
+  CliqueSearch search(p, r, callback, userdata, s);
+  search.solve();
+  return 0;
+}
+} // namespace synkit_mapper

synkit/Chem/Mapper/solvers/native/cpp/src/pabs/bridge.cpp

@@ -0,0 +1,334 @@
+// Compile the common exact kernel once, preserving its ABI3 exports.
+// The shared-core bridge owns preparation, optional bounds and phase
+// accounting.
+#include "../../../../exact/native/native_distance.cpp"
+#include "exact_helpers.h"
+#include "sparse_root_lp.h"
+#include "synkit_mapper/core/pmcd_witness.h"
+#include "synkit_mapper/core/runtime.h"
+#include "synkit_mapper/pabs/seed.h"
+#include "synkit_mapper/slap.h"
+#include <set>
+static thread_local int64_t bridge_embedding_statistics[14] = {};
+static thread_local int64_t bridge_deck_statistics[14] = {};
+#ifdef SYNKIT_MAPPER_TEST_HOOKS
+static thread_local int64_t lp_assignment_statistics[6] = {};
+#endif // SYNKIT_MAPPER_TEST_HOOKS
+
+namespace synkit_mapper {
+namespace {
+
+#include "chemical_floor.inc"
+#include "endpoint_symmetry.inc"
+#include "seed_heuristics.inc"
+
+struct Receiver {
+  const Problem &p;
+  const Request &r;
+  Callback callback;
+  void *userdata;
+  Statistics &s;
+  Budget &budget;
+  static int receive(const int *map, int cost4, void *pointer) {
+    auto &self = *static_cast<Receiver *>(pointer);
+    std::vector<int32_t> mapping(map, map + self.p.n);
+    int64_t cost = mapping_cost2(self.p, mapping);
+    if (cost4 != 2 * cost)
+      throw std::runtime_error(
+          "PABS quarter-CD witness does not match rescoring");
+    const auto start = Clock::now();
+    int stop =
+        self.callback ? self.callback(mapping.data(), cost, self.userdata) : 0;
+    self.s.callback_seconds += elapsed(start);
+    ++self.s.candidate_count;
+    if (stop) {
+      self.s.reason = SYNKIT_STOP_CALLBACK;
+      return 1;
+    }
+    if (self.budget.reason()) {
+      self.s.reason = self.budget.reason();
+      return 1;
+    }
+    return 0;
+  }
+};
+} // namespace
+
+#include "overlap_dual.inc"
+
+#include "profile_seed.inc"
+
+int solve_pabs_original(const Problem &p, const Request &r, Callback callback,
+                        void *userdata, Statistics &s) {
+  synkit_mapper_clear_pmcd_witness();
+  sparse_root_lp::clear();
+  std::fill(bridge_embedding_statistics, bridge_embedding_statistics + 14, 0);
+  std::fill(coherent_seed_statistics, coherent_seed_statistics + 20, 0);
+  coherent_seed_mapping.clear();
+  std::fill(conditioned_factor_cache_statistics,
+            conditioned_factor_cache_statistics + 8, 0);
+
+  std::fill(bridge_deck_statistics, bridge_deck_statistics + 14, 0);
+  bridge_deck_statistics[13] = -1;
+  Budget budget(r);
+  budget.check();
+  if (p.n > SYNKIT_PABS_MAX_VERTICES || r.classify || r.max_states != -1 ||
+      r.max_classes != -1 || r.max_frontier != -1 ||
+      r.memory_limit_bytes != -1 || r.cancel_token)
+    return unsupported(s);
+  const int n = p.n;
+  auto stage = Clock::now();
+  std::vector<int> a(n * n), b(n * n), cr(n), cp(n), order(n), pred(n * n, 0);
+  std::map<int32_t, int> types;
+  std::set<int> levels;
+  int64_t maximum2 = 0;
+  for (int i = 0; i < n; ++i) {
+    cr[i] = types.emplace(p.types_r[i], types.size()).first->second;
+    cp[i] = types.emplace(p.types_p[i], types.size()).first->second;
+    order[i] = i;
+    for (int j = 0; j < n; ++j) {
+      if (p.a2[i * n + j] > 1024 || p.b2[i * n + j] > 1024)
+        return unsupported(s);
+      a[i * n + j] = static_cast<int>(p.a2[i * n + j]);
+      b[i * n + j] = static_cast<int>(p.b2[i * n + j]);
+      levels.insert(a[i * n + j]);
+      levels.insert(b[i * n + j]);
+      if (j > i)
+        maximum2 += a[i * n + j] + b[i * n + j];
+    }
+  }
+  if (levels.size() > 16 || maximum2 > 500000)
+    return unsupported(s);
+  std::vector<int> rg, pg;
+  if (r.symmetry) {
+    rg = endpoint_generators(p, false, budget);
+    pg = endpoint_generators(p, true, budget);
+  }
+  std::stable_sort(order.begin(), order.end(), [&](int i, int j) {
+    int di = 0, dj = 0;
+    for (int k = 0; k < n; ++k) {
+      di += a[i * n + k] != 0;
+      dj += a[j * n + k] != 0;
+    }
+    return di > dj;
+  });
+  Perm seed;
+  RootDualBranchCertificate root_certificate;
+  sparse_root_lp::AssignmentCertificate assignment_certificate;
+#ifdef SYNKIT_MAPPER_TEST_HOOKS
+  std::fill(lp_assignment_statistics, lp_assignment_statistics + 6, 0);
+  struct SaveAssignmentStatistics {
+    sparse_root_lp::AssignmentCertificate &certificate;
+    ~SaveAssignmentStatistics() {
+      lp_assignment_statistics[0] = certificate.ready;
+      lp_assignment_statistics[1] = certificate.m;
+      lp_assignment_statistics[2] = certificate.root_bound2;
+      lp_assignment_statistics[3] = certificate.calls;
+      lp_assignment_statistics[4] = certificate.prunes;
+      lp_assignment_statistics[5] = certificate.ready && certificate.m > 64;
+    }
+  } save_assignment_statistics{assignment_certificate};
+#endif // SYNKIT_MAPPER_TEST_HOOKS
+
+  std::fill(conditioned_dual_statistics, conditioned_dual_statistics + 6, 0);
+  bool original_profile_zero = false;
+  try {
+    const bool polish =
+        r.query == SYNKIT_MINIMUM_CLASSES || r.query == SYNKIT_MINIMUM_PROOF;
+    if (!pabs::prepare_seed(p, budget, polish, seed, s.incumbent2,
+                            s.lower_bound2, &original_profile_zero)) {
+      s.model_seconds += elapsed(stage);
+      return unsupported(s);
+    }
+
+    if (r.query == SYNKIT_MINIMUM_PROOF &&
+        (!original_profile_zero || s.incumbent2 > 8) &&
+        s.incumbent2 > s.lower_bound2 && budget.remaining() > 0.2) {
+      const int64_t dual = conditioned_overlap_dual_floor(
+          p, budget, std::min(0.03, budget.remaining() * 0.05),
+          root_certificate);
+      if (dual > s.incumbent2)
+        throw std::runtime_error("Invalid overlap dual bound");
+      s.lower_bound2 = std::max(s.lower_bound2, dual);
+    }
+    if (r.query == SYNKIT_MINIMUM_PROOF && n <= 256 &&
+        s.incumbent2 > s.lower_bound2 && budget.remaining() > 0.05) {
+      const int64_t lp_floor = sparse_root_lp::run(
+          p, budget, std::min(20.0, budget.remaining() * 0.7), s.incumbent2,
+          &seed, &s.incumbent2, &assignment_certificate);
+      budget.check();
+      if (lp_floor > s.incumbent2)
+        throw std::runtime_error("Invalid exact sparse LP bound");
+      s.lower_bound2 = std::max(s.lower_bound2, lp_floor);
+    }
+
+    if (r.query == SYNKIT_MINIMUM_PROOF && s.incumbent2 == s.lower_bound2) {
+      budget.check();
+      synkit_mapper_store_pmcd_witness(n, seed.data(), s.incumbent2, 1);
+      s.minimum_proven = 1;
+      s.minimum2 = s.incumbent2;
+      s.search_complete = 1;
+      s.model_seconds += elapsed(stage);
+      return 0;
+    }
+  } catch (...) {
+    s.model_seconds += elapsed(stage);
+    throw;
+  }
+  s.model_seconds += elapsed(stage);
+
+  // Eligibility uses the initial profile relaxation, before subsequent exact
+  // bounds strengthen it. This schedules an additional edge-deck proof only.
+  if ((r.query == SYNKIT_MINIMUM_CLASSES || r.query == SYNKIT_MINIMUM_PROOF) &&
+      original_profile_zero && s.incumbent2 > s.lower_bound2 && n <= 512) {
+    stage = Clock::now();
+    int64_t mass_a = 0, mass_b = 0, g = 0, edge_a = 0, edge_b = 0;
+    for (int i = 0; i < n; ++i)
+      for (int j = 0; j < i; ++j) {
+        mass_a += p.a2[i * n + j];
+        mass_b += p.b2[i * n + j];
+        g = std::gcd(g, p.a2[i * n + j]);
+        g = std::gcd(g, p.b2[i * n + j]);
+        edge_a += p.a2[i * n + j] > 0;
+        edge_b += p.b2[i * n + j] > 0;
+      }
+    const int units = g == 1 ? 3 : 2;
+    int64_t families[6] = {};
+    const bool small_families =
+        g > 0 && mass_a == mass_b &&
+        pabs::edge_deck_sizes(n, p.a2, p.b2, p.types_r, p.types_p, units,
+                              families) == 0 &&
+        families[units - 1] <= 60000 && families[units + 2] <= 60000;
+    budget.check();
+    if (g > 0 && mass_a == mass_b && s.incumbent2 <= 16 * g &&
+        s.lower_bound2 < 2LL * (units + 1) * g && small_families) {
+      const double allowance = std::min(0.65, budget.remaining() * 0.70);
+      Perm candidate(n);
+      int64_t lower2 = 0, witness2 = -1;
+      const int result =
+          pabs::edge_deck(n, p.a2, p.b2, p.types_r, p.types_p, units, allowance,
+                          2000000, s.incumbent2, candidate.data(), &lower2,
+                          &witness2, bridge_deck_statistics);
+      bridge_deck_statistics[12] = result;
+      budget.check();
+      if (result >= 0 && lower2 >= 0) {
+        if (lower2 > s.incumbent2)
+          throw std::runtime_error("Overlap bound exceeds feasible incumbent");
+        if (result == 1) {
+          const int64_t score = mapping_cost2(
+              p, std::vector<int32_t>(candidate.begin(), candidate.end()));
+          if (score != witness2 || score != lower2 || score < s.lower_bound2)
+            throw std::runtime_error("Invalid overlap minimum witness");
+          seed = std::move(candidate);
+          s.incumbent2 = score;
+        }
+        s.lower_bound2 = std::max(s.lower_bound2, lower2);
+        bridge_deck_statistics[13] = s.lower_bound2;
+        if (s.incumbent2 == s.lower_bound2) {
+          s.minimum_proven = 1;
+          s.minimum2 = s.incumbent2;
+          synkit_mapper_store_pmcd_witness(n, seed.data(), s.incumbent2, 1);
+        }
+      }
+    }
+    s.optimization_seconds += elapsed(stage);
+  }
+
+  int64_t raw[6] = {};
+  if (r.query == SYNKIT_MINIMUM_CLASSES || r.query == SYNKIT_MINIMUM_PROOF) {
+    if (!s.minimum_proven) {
+      int best4 = 0;
+      Perm best(n);
+      stage = Clock::now();
+      int status = native_minimum_impl(
+          n, types.size(), levels.size() - 1, budget.remaining(), a.data(),
+          b.data(), cr.data(), cp.data(), order.data(), pred.data(), pg.data(),
+          pg.size() / n, rg.data(), rg.size() / n, seed.data(), best.data(),
+          &best4, raw, 0, 0, false, static_cast<int>(2 * s.lower_bound2),
+          root_certificate.ready ? &root_certificate : nullptr,
+          conditioned_dual_statistics, nullptr,
+          assignment_certificate.ready
+              ? +[](const int *mapping, const int *used, [[maybe_unused]] int target, void *data) {
+                  auto &certificate = *static_cast<
+                      sparse_root_lp::AssignmentCertificate *>(data);
+                  const int64_t bound = certificate.bound(mapping, used);
+#ifdef SYNKIT_MAPPER_TEST_HOOKS
+                  ++certificate.calls;
+                  certificate.prunes += 2 * bound > target;
+#endif // SYNKIT_MAPPER_TEST_HOOKS
+                  return bound;
+                }
+              : nullptr,
+          &assignment_certificate);
+      s.optimization_seconds += elapsed(stage);
+      s.nodes += raw[0];
+      s.leaves += raw[1];
+      if (status < 0)
+        throw std::runtime_error("Legacy PABS minimum kernel error");
+      s.incumbent2 =
+          mapping_cost2(p, std::vector<int32_t>(best.begin(), best.end()));
+      if (best4 != 2 * s.incumbent2)
+        throw std::runtime_error("Invalid minimum witness units");
+      if (status) {
+        stopped(s, SYNKIT_STOP_TIME);
+        return 0;
+      }
+      synkit_mapper_store_pmcd_witness(n, best.data(), s.incumbent2, 1);
+      s.minimum_proven = 1;
+      s.minimum2 = s.incumbent2;
+      s.lower_bound2 = s.minimum2;
+    }
+    if (r.query == SYNKIT_MINIMUM_PROOF) {
+      s.search_complete = 1;
+      return 0;
+    }
+  }
+  budget.check();
+  int64_t target = (r.query == SYNKIT_MINIMUM_CLASSES ? s.minimum2 : r.target2);
+  if (r.query != SYNKIT_AT_MOST_DISTANCE && target > maximum2) {
+    s.search_complete = 1;
+    s.labeled_count = 0;
+    return 0;
+  }
+  target = std::min(target, maximum2);
+  Receiver receiver{p, r, callback, userdata, s, budget};
+  stage = Clock::now();
+  int status = synkit_distance_range(
+      n, types.size(), levels.size() - 1,
+      r.query == SYNKIT_AT_MOST_DISTANCE ? 0 : static_cast<int>(2 * target),
+      static_cast<int>(2 * target), budget.remaining(), r.max_candidates,
+      a.data(), b.data(), cr.data(), cp.data(), order.data(), pred.data(),
+      pg.data(), pg.size() / n, rg.data(), rg.size() / n, Receiver::receive,
+      &receiver, raw);
+  s.enumeration_seconds += elapsed(stage);
+  s.nodes += raw[0];
+  s.leaves += raw[1];
+  if (status < 0)
+    throw std::runtime_error("Legacy PABS range kernel error");
+  if (status) {
+    stopped(s, s.reason      ? s.reason
+               : status == 2 ? SYNKIT_STOP_CANDIDATES
+               : status == 3 ? SYNKIT_STOP_CALLBACK
+                             : SYNKIT_STOP_TIME);
+  } else
+    s.search_complete = 1;
+  s.labeled_count = rg.empty() && pg.empty() ? s.candidate_count : -1;
+  return 0;
+}
+} // namespace synkit_mapper
+
+#include "objective_reduction.inc"
+
+#ifdef SYNKIT_MAPPER_TEST_HOOKS
+#include "test_hooks.inc"
+#endif
+
+#ifdef SYNKIT_MAPPER_TEST_HOOKS
+extern "C" int synkit_private_lp_assignment_statistics(int64_t *out,
+                                                       int capacity) {
+  if (!out || capacity < 6)
+    return -1;
+  std::copy(lp_assignment_statistics, lp_assignment_statistics + 6, out);
+  return 6;
+}
+#endif // SYNKIT_MAPPER_TEST_HOOKS