synkit 1.6.5__py3-none-win_amd64.whl

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

@@ -0,0 +1,228 @@
+#include "synkit_mapper/astar/astar.h"
+#include "synkit_mapper/astar/bound.h"
+#include "synkit_mapper/core/runtime.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <limits>
+#include <map>
+#include <numeric>
+#include <utility>
+#include <vector>
+
+namespace synkit_mapper {
+namespace {
+
+struct State {
+  int64_t bound;
+  uint64_t serial;
+  int depth;
+  std::vector<int32_t> mapping;
+};
+
+struct Later {
+  bool operator()(const State &a, const State &b) const {
+    if (a.bound != b.bound)
+      return a.bound > b.bound;
+    // Deeper equal-bound states reach a first solution sooner without changing
+    // the best-first bound order or discarding any tied completion.
+    if (a.depth != b.depth)
+      return a.depth < b.depth;
+    return a.serial > b.serial;
+  }
+};
+
+class Frontier {
+public:
+  Frontier(const Request &r, Statistics &s) : request(r), statistics(s) {}
+  bool empty() const { return heap.empty(); }
+  int64_t bound() const { return heap.front().bound; }
+  void push(State state) {
+    if (request.max_frontier >= 0 &&
+        heap.size() >= static_cast<std::size_t>(request.max_frontier))
+      throw Stop{SYNKIT_STOP_FRONTIER};
+    // Explicit reserve prevents an allocator's unspecified growth policy from
+    // overshooting the declared accounted-frontier budget before it is checked.
+    std::size_t new_capacity = heap.capacity();
+    if (new_capacity == heap.size())
+      new_capacity = std::max<std::size_t>(1, new_capacity * 2);
+    const auto vector_bytes = state.mapping.capacity() * sizeof(int32_t);
+    const auto proposed =
+        new_capacity * sizeof(State) + mapping_bytes + vector_bytes;
+    if (request.memory_limit_bytes >= 0 &&
+        proposed > static_cast<uint64_t>(request.memory_limit_bytes))
+      throw Stop{SYNKIT_STOP_MEMORY};
+    if (new_capacity != heap.capacity())
+      heap.reserve(new_capacity);
+    mapping_bytes += vector_bytes;
+    heap.push_back(std::move(state));
+    std::push_heap(heap.begin(), heap.end(), Later{});
+    statistics.peak_frontier =
+        std::max<int64_t>(statistics.peak_frontier, heap.size());
+    statistics.peak_frontier_bytes =
+        std::max<int64_t>(statistics.peak_frontier_bytes,
+                          heap.capacity() * sizeof(State) + mapping_bytes);
+  }
+  State pop() {
+    std::pop_heap(heap.begin(), heap.end(), Later{});
+    State result = std::move(heap.back());
+    heap.pop_back();
+    mapping_bytes -= result.mapping.capacity() * sizeof(int32_t);
+    return result;
+  }
+
+private:
+  const Request &request;
+  Statistics &statistics;
+  std::vector<State> heap;
+  std::size_t mapping_bytes = 0;
+};
+
+std::vector<int> source_order(const Problem &p) {
+  std::map<int32_t, int> count;
+  for (int i = 0; i < p.n; ++i)
+    ++count[p.types_p[i]];
+  std::vector<int64_t> mass(p.n);
+  std::vector<int> order(p.n);
+  std::iota(order.begin(), order.end(), 0);
+  for (int i = 0; i < p.n; ++i)
+    for (int j = 0; j < p.n; ++j)
+      mass[i] += p.a2[i * p.n + j];
+  std::stable_sort(order.begin(), order.end(), [&](int i, int k) {
+    if (count[p.types_r[i]] != count[p.types_r[k]])
+      return count[p.types_r[i]] < count[p.types_r[k]];
+    if (mass[i] != mass[k])
+      return mass[i] > mass[k];
+    return i < k;
+  });
+  return order;
+}
+
+} // namespace
+
+int solve_astar(const Problem &p, const Request &r, Callback callback,
+                void *userdata, Statistics &s) {
+  initialize(s, r);
+  // Raw enumeration cannot interpret a cap measured in exact ITS classes.
+  // The shared class pipeline applies its own cap through callback control.
+  if (r.classify || r.max_classes != -1)
+    return unsupported(s);
+  Budget budget(r);
+  Frontier frontier(r, s);
+  uint64_t serial = 0;
+  const bool numeric =
+      r.query == SYNKIT_EXACT_DISTANCE || r.query == SYNKIT_AT_MOST_DISTANCE;
+  int64_t threshold = numeric ? r.target2 : std::numeric_limits<int64_t>::max();
+  double proof_at = -1;
+  bool model_phase = true;
+  const std::function<void()> poll = [&]() { budget.check(); };
+  try {
+    budget.check();
+    const auto order = source_order(p);
+    std::vector<int32_t> initial(p.n, -1);
+    const int64_t initial_bound = astar::partial_lower_bound2(
+        p.n, p.a2, p.b2, p.types_r, p.types_p, initial, poll);
+    s.lower_bound2 = initial_bound;
+    s.model_seconds = budget.seconds();
+    model_phase = false;
+    if (initial_bound <= threshold)
+      frontier.push({initial_bound, serial++, 0, std::move(initial)});
+    while (!frontier.empty()) {
+      budget.check();
+      if (frontier.bound() > threshold)
+        break;
+      if (r.max_states >= 0 && s.nodes >= r.max_states)
+        throw Stop{SYNKIT_STOP_STATES};
+      State state = frontier.pop();
+      if (!s.minimum_proven)
+        s.lower_bound2 = state.bound;
+      ++s.nodes;
+      if (state.depth == p.n) {
+        ++s.leaves;
+        // A full state's bound is its exact edge cost. Its first removal from
+        // a best-bound frontier proves the global minimum, including when the
+        // caller requested a higher numeric shell.
+        const int64_t cost = state.bound;
+        if (!s.minimum_proven) {
+          s.minimum_proven = 1;
+          s.minimum2 = s.incumbent2 = s.lower_bound2 = cost;
+          proof_at = budget.seconds();
+          if (!numeric)
+            threshold = cost;
+        }
+        if (r.query == SYNKIT_MINIMUM_PROOF)
+          break;
+        if (r.query == SYNKIT_EXACT_DISTANCE && cost != r.target2)
+          continue;
+        ++s.candidate_count;
+        if (callback) {
+          const auto before = Clock::now();
+          const int stop = callback(state.mapping.data(), cost, userdata);
+          s.callback_seconds += elapsed(before);
+          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};
+        continue;
+      }
+      std::vector<bool> used(p.n, false);
+      for (int j : state.mapping)
+        if (j >= 0)
+          used[j] = true;
+      const int i = order[state.depth];
+      for (int j = 0; j < p.n; ++j) {
+        budget.check();
+        if (used[j] || p.types_r[i] != p.types_p[j])
+          continue;
+        auto mapping = state.mapping;
+        mapping[i] = j;
+        int64_t bound = astar::partial_lower_bound2(p.n, p.a2, p.b2, p.types_r,
+                                                    p.types_p, mapping, poll);
+        // Pathmax preserves admissibility even if a future stronger heuristic
+        // is inconsistent. It cannot change a full state's true cost.
+        bound = std::max(bound, state.bound);
+        if (bound <= threshold)
+          frontier.push({bound, serial++, state.depth + 1, std::move(mapping)});
+      }
+    }
+    s.search_complete = 1;
+    if (r.query != SYNKIT_MINIMUM_PROOF)
+      s.labeled_count = s.candidate_count;
+  } catch (const Stop &stop) {
+    if (model_phase)
+      s.model_seconds = budget.seconds();
+    stopped(s, stop.reason);
+  }
+  s.elapsed_seconds = budget.seconds();
+  s.optimization_seconds = proof_at < 0 ? s.elapsed_seconds - s.model_seconds
+                                        : proof_at - s.model_seconds;
+  s.enumeration_seconds = proof_at < 0 ? 0 : s.elapsed_seconds - proof_at;
+  return 0;
+}
+
+} // namespace synkit_mapper
+
+extern "C" int synkit_astar_partial_bound2(const SynkitMapperProblem *p,
+                                           const int32_t *partial,
+                                           int64_t *bound2) {
+  if (!p || !partial || !bound2)
+    return -1;
+  try {
+    SynkitMapperRequest r{};
+    r.abi_version = 1;
+    r.backend = SYNKIT_ASTAR;
+    r.workers = 1;
+    r.seconds = -1;
+    r.max_states = r.max_candidates = r.max_classes = r.max_frontier = -1;
+    r.memory_limit_bytes = -1;
+    synkit_mapper::validate(*p, r);
+    *bound2 = synkit_mapper::astar::partial_lower_bound2(
+        p->n, p->a2, p->b2, p->types_r, p->types_p,
+        std::vector<int32_t>(partial, partial + p->n));
+    return 0;
+  } catch (...) {
+    return -1;
+  }
+}

synkit/Chem/Mapper/solvers/native/cpp/src/astar/astar_graph.cpp

@@ -0,0 +1,37 @@
+#include "synkit_mapper/mapper.h"
+
+#include <iostream>
+
+int main() {
+  const int64_t a2[] = {0, 1, 0, 1, 0, 2, 0, 2, 0};
+  const int64_t b2[] = {0, 2, 0, 2, 0, 1, 0, 1, 0};
+  const int32_t types[] = {6, 6, 6};
+  SynkitMapperProblem problem{};
+  problem.abi_version = 1;
+  problem.n = 3;
+  problem.a2 = a2;
+  problem.b2 = b2;
+  problem.types_r = problem.types_p = types;
+  SynkitMapperRequest request{};
+  request.abi_version = 1;
+  request.backend = SYNKIT_ASTAR;
+  request.workers = 1;
+  request.seconds = -1;
+  request.max_states = request.max_candidates = request.max_classes = -1;
+  request.max_frontier = request.memory_limit_bytes = -1;
+  SynkitMapperStatistics statistics{};
+  const int status = synkit_mapper::solve_astar(
+      problem, request,
+      [](const int32_t *mapping, int64_t cost2, void *) {
+        std::cout << "mapping " << mapping[0] << ' ' << mapping[1] << ' '
+                  << mapping[2] << "; doubled CD " << cost2 << '\n';
+        return 0;
+      },
+      nullptr, statistics);
+  std::cout << "minimum proved " << statistics.minimum_proven
+            << "; search complete " << statistics.search_complete
+            << "; peak frontier " << statistics.peak_frontier
+            << "; accounted frontier bytes " << statistics.peak_frontier_bytes
+            << '\n';
+  return status || !statistics.minimum_proven || !statistics.search_complete;
+}

synkit/Chem/Mapper/solvers/native/cpp/src/astar/bound.cpp

@@ -0,0 +1,212 @@
+#include "synkit_mapper/astar/bound.h"
+
+#include <algorithm>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace synkit_mapper {
+namespace astar {
+namespace {
+
+constexpr int64_t infinity = std::numeric_limits<int64_t>::max() / 16;
+
+int64_t add(int64_t a, int64_t b) {
+  if (a < 0 || b < 0 || a >= infinity || b >= infinity || a >= infinity - b)
+    throw std::overflow_error("A* bound exceeds its checked integer range");
+  return a + b;
+}
+
+int64_t difference(int64_t a, int64_t b) { return a >= b ? a - b : b - a; }
+
+// Dense primal-dual assignment. Forbidden entries are infinity, not a large
+// finite edit penalty that could silently admit an incompatible atom pairing.
+int64_t assignment_cost(const std::vector<std::vector<int64_t>> &costs,
+                        const std::function<void()> &poll,
+                        std::vector<int32_t> *mapping = nullptr) {
+  const int n = static_cast<int>(costs.size());
+  std::vector<int64_t> u(n + 1), v(n + 1);
+  std::vector<int> p(n + 1), way(n + 1);
+  for (int i = 1; i <= n; ++i) {
+    if (poll)
+      poll();
+    p[0] = i;
+    int j0 = 0;
+    std::vector<int64_t> best(n + 1, infinity);
+    std::vector<bool> used(n + 1, false);
+    do {
+      used[j0] = true;
+      const int i0 = p[j0];
+      int j1 = 0;
+      int64_t delta = infinity;
+      for (int j = 1; j <= n; ++j) {
+        if (used[j])
+          continue;
+        if (costs[i0 - 1][j - 1] != infinity) {
+          const int64_t reduced = costs[i0 - 1][j - 1] - u[i0] - v[j];
+          if (reduced < best[j]) {
+            best[j] = reduced;
+            way[j] = j0;
+          }
+        }
+        if (best[j] < delta) {
+          delta = best[j];
+          j1 = j;
+        }
+      }
+      if (delta == infinity)
+        throw std::invalid_argument("No compatible residual bijection");
+      for (int j = 0; j <= n; ++j) {
+        if (used[j]) {
+          u[p[j]] += delta;
+          v[j] -= delta;
+        } else if (best[j] != infinity) {
+          best[j] -= delta;
+        }
+      }
+      j0 = j1;
+    } while (p[j0] != 0);
+    do {
+      const int j1 = way[j0];
+      p[j0] = p[j1];
+      j0 = j1;
+    } while (j0 != 0);
+  }
+  int64_t total = 0;
+  if (mapping)
+    mapping->assign(n, -1);
+  for (int j = 1; j <= n; ++j)
+  {
+    total = add(total, costs[p[j] - 1][j - 1]);
+    if (mapping)
+      (*mapping)[p[j] - 1] = j - 1;
+  }
+  return total;
+}
+
+using Spectrum = std::map<int32_t, std::vector<int64_t>>;
+
+std::vector<Spectrum> spectra(int n, const int64_t *matrix,
+                              const int32_t *types,
+                              const std::vector<int> &remaining,
+                              const std::function<void()> &poll) {
+  std::vector<Spectrum> result(remaining.size());
+  for (std::size_t i = 0; i < remaining.size(); ++i) {
+    if (poll)
+      poll();
+    for (int k : remaining)
+      if (remaining[i] != k)
+        result[i][types[k]].push_back(matrix[remaining[i] * n + k]);
+    for (auto &group : result[i])
+      std::sort(group.second.begin(), group.second.end());
+  }
+  return result;
+}
+
+} // namespace
+
+std::vector<int32_t> profile_assignment_seed(
+    int n, const int64_t *a2, const int64_t *b2,
+    const int32_t *types_r, const int32_t *types_p,
+    const std::function<void()> &poll) {
+  if (n < 0 || (n && (!a2 || !b2 || !types_r || !types_p)))
+    throw std::invalid_argument("Invalid profile assignment input");
+  std::vector<int> vertices;
+  for (int i = 0; i < n; ++i)
+    vertices.push_back(i);
+  const auto source = spectra(n, a2, types_r, vertices, poll);
+  const auto target = spectra(n, b2, types_p, vertices, poll);
+  std::vector<std::vector<int64_t>> costs(n, std::vector<int64_t>(n, infinity));
+  for (int i = 0; i < n; ++i) {
+    if (poll)
+      poll();
+    for (int j = 0; j < n; ++j) {
+      if (types_r[i] != types_p[j])
+        continue;
+      if (source[i].size() != target[j].size())
+        throw std::invalid_argument("Incompatible profile type inventories");
+      int64_t cost = 0;
+      for (const auto &group : source[i]) {
+        const auto other = target[j].find(group.first);
+        if (other == target[j].end() || other->second.size() != group.second.size())
+          throw std::invalid_argument("Incompatible profile type inventories");
+        for (std::size_t k = 0; k < group.second.size(); ++k)
+          cost = add(cost, difference(group.second[k], other->second[k]));
+      }
+      costs[i][j] = cost;
+    }
+  }
+  std::vector<int32_t> mapping;
+  assignment_cost(costs, poll, &mapping);
+  return mapping;
+}
+
+int64_t partial_lower_bound2(int n, const int64_t *a2, const int64_t *b2,
+                             const int32_t *types_r, const int32_t *types_p,
+                             const std::vector<int32_t> &mapping,
+                             const std::function<void()> &poll) {
+  if (n < 0 || mapping.size() != static_cast<std::size_t>(n) ||
+      (n && (!a2 || !b2 || !types_r || !types_p)))
+    throw std::invalid_argument("Invalid A* partial-bound input");
+  std::vector<int> assigned, remaining, targets;
+  std::vector<bool> used(n, false);
+  for (int i = 0; i < n; ++i) {
+    const int j = mapping[i];
+    if (j == -1) {
+      remaining.push_back(i);
+    } else {
+      if (j < 0 || j >= n || used[j] || types_r[i] != types_p[j])
+        throw std::invalid_argument("Invalid A* partial bijection");
+      used[j] = true;
+      assigned.push_back(i);
+    }
+  }
+  for (int j = 0; j < n; ++j)
+    if (!used[j])
+      targets.push_back(j);
+  int64_t committed = 0;
+  for (std::size_t i = 0; i < assigned.size(); ++i)
+    for (std::size_t k = 0; k < i; ++k)
+      committed =
+          add(committed,
+              difference(a2[assigned[i] * n + assigned[k]],
+                         b2[mapping[assigned[i]] * n + mapping[assigned[k]]]));
+  if (remaining.empty())
+    return committed;
+  const auto source_spectra = spectra(n, a2, types_r, remaining, poll);
+  const auto target_spectra = spectra(n, b2, types_p, targets, poll);
+  std::vector<std::vector<int64_t>> costs(
+      remaining.size(), std::vector<int64_t>(targets.size(), infinity));
+  for (std::size_t u = 0; u < remaining.size(); ++u) {
+    const int i = remaining[u];
+    for (std::size_t v = 0; v < targets.size(); ++v) {
+      if (poll && v % 16 == 0)
+        poll();
+      const int j = targets[v];
+      if (types_r[i] != types_p[j])
+        continue;
+      int64_t cross = 0, residual = 0;
+      for (int k : assigned)
+        cross = add(cross, difference(a2[i * n + k], b2[j * n + mapping[k]]));
+      if (source_spectra[u].size() != target_spectra[v].size())
+        throw std::invalid_argument("Incompatible residual type inventories");
+      for (const auto &group : source_spectra[u]) {
+        const auto other = target_spectra[v].find(group.first);
+        if (other == target_spectra[v].end() ||
+            other->second.size() != group.second.size())
+          throw std::invalid_argument("Incompatible residual type inventories");
+        for (std::size_t k = 0; k < group.second.size(); ++k)
+          residual =
+              add(residual, difference(group.second[k], other->second[k]));
+      }
+      costs[u][v] = add(add(cross, cross), residual);
+    }
+  }
+  const int64_t doubled_residual_bound = assignment_cost(costs, poll);
+  return add(committed,
+             doubled_residual_bound / 2 + doubled_residual_bound % 2);
+}
+
+} // namespace astar
+} // namespace synkit_mapper