synkit 1.6.5__py3-none-win_amd64.whl

synkit/Chem/Mapper/solvers/native/cpp/src/solvers/weighted_cnf.h

@@ -0,0 +1,256 @@
+#pragma once
+#include "formulation.h"
+#include "synkit_mapper/core/runtime.h"
+#include <fstream>
+
+namespace synkit_mapper::solvers::detail {
+// Exact Boolean arithmetic encoding only. Optimization remains in a maintained
+// native MaxSAT engine. Products and every adder/comparator gate are
+// equivalences.
+struct WeightedCnf {
+  int variables, zero;
+  int64_t sum_weights = 0;
+  Budget &budget;
+  std::vector<std::vector<int>> hard;
+  std::vector<std::pair<int64_t, int>> soft;
+  std::vector<int> bits;
+  explicit WeightedCnf(const Formulation &f, Budget &b)
+      : variables(f.variables), zero(f.cost + 1), budget(b) {
+    hard.push_back({-zero});
+    for (int i = 0; i < f.n; ++i) {
+      budget.check();
+      std::vector<int> row, column;
+      for (int j = 0; j < f.n; ++j) {
+        if (f.x[i * f.n + j] >= 0)
+          row.push_back(f.x[i * f.n + j] + 1);
+        if (f.x[j * f.n + i] >= 0)
+          column.push_back(f.x[j * f.n + i] + 1);
+      }
+      exactly_one(row);
+      exactly_one(column);
+    }
+    size_t checked = 0;
+    for (const auto &p : f.products) {
+      if (!(++checked % 1024))
+        budget.check();
+      int y = p.variable + 1, u = p.left + 1, v = p.right + 1;
+      add({-y, u});
+      add({-y, v});
+      add({y, -u, -v});
+      if (p.benefit > std::numeric_limits<int64_t>::max() - sum_weights)
+        throw std::overflow_error("MaxSAT weight sum overflow");
+      sum_weights += p.benefit;
+    }
+  }
+  int variable() {
+    if (variables == std::numeric_limits<int>::max())
+      throw std::overflow_error("MaxSAT Boolean index overflow");
+    return ++variables;
+  }
+  void add(std::vector<int> clause) {
+    if (std::find(clause.begin(), clause.end(), -zero) != clause.end())
+      return;
+    clause.erase(std::remove(clause.begin(), clause.end(), zero), clause.end());
+    std::sort(clause.begin(), clause.end());
+    clause.erase(std::unique(clause.begin(), clause.end()), clause.end());
+    for (int literal : clause)
+      if (std::binary_search(clause.begin(), clause.end(), -literal))
+        return;
+    hard.push_back(std::move(clause));
+  }
+  void exactly_one(const std::vector<int> &xs) {
+    add(xs);
+    if (xs.size() < 2)
+      return;
+    int previous = variable();
+    add({-xs[0], previous});
+    for (size_t i = 1; i + 1 < xs.size(); ++i) {
+      int next = variable();
+      add({-xs[i], next});
+      add({-previous, next});
+      add({-xs[i], -previous});
+      previous = next;
+    }
+    add({-xs.back(), -previous});
+  }
+  int conjunction(int a, int b) {
+    if (a == zero || b == zero || a == -b)
+      return zero;
+    if (a == -zero || a == b)
+      return b;
+    if (b == -zero)
+      return a;
+    int z = variable();
+    add({-z, a});
+    add({-z, b});
+    add({z, -a, -b});
+    return z;
+  }
+  int disjunction(int a, int b) {
+    if (a == -zero || b == -zero || a == -b)
+      return -zero;
+    if (a == zero || a == b)
+      return b;
+    if (b == zero)
+      return a;
+    int z = variable();
+    add({z, -a});
+    add({z, -b});
+    add({-z, a, b});
+    return z;
+  }
+  int parity(int a, int b) {
+    if (a == zero)
+      return b;
+    if (b == zero)
+      return a;
+    if (a == -zero)
+      return -b;
+    if (b == -zero)
+      return -a;
+    if (a == b)
+      return zero;
+    if (a == -b)
+      return -zero;
+    int z = variable();
+    add({-a, -b, -z});
+    add({a, b, -z});
+    add({a, -b, z});
+    add({-a, b, z});
+    return z;
+  }
+  int majority(int a, int b, int c) {
+    if (a == b)
+      return a;
+    if (a == -b)
+      return c;
+    if (a == c)
+      return a;
+    if (a == -c)
+      return b;
+    if (b == c)
+      return b;
+    if (b == -c)
+      return a;
+    if (a == zero)
+      return conjunction(b, c);
+    if (b == zero)
+      return conjunction(a, c);
+    if (c == zero)
+      return conjunction(a, b);
+    if (a == -zero)
+      return disjunction(b, c);
+    if (b == -zero)
+      return disjunction(a, c);
+    if (c == -zero)
+      return disjunction(a, b);
+    int z = variable();
+    add({-a, -b, z});
+    add({-a, -c, z});
+    add({-b, -c, z});
+    add({a, b, -z});
+    add({a, c, -z});
+    add({b, c, -z});
+    return z;
+  }
+  void build_sum(const Formulation &f) {
+    if (!bits.empty())
+      return;
+    std::vector<std::vector<int>> buckets(64);
+    size_t checked = 0;
+    for (const auto &p : f.products) {
+      if (!(++checked % 512))
+        budget.check();
+      uint64_t weight = p.benefit;
+      for (int bit = 0; weight; ++bit, weight >>= 1)
+        if (weight & 1)
+          buckets[bit].push_back(p.variable + 1);
+    }
+    for (size_t bit = 0; bit + 1 < buckets.size(); ++bit) {
+      budget.check();
+      auto &bucket = buckets[bit];
+      while (bucket.size() >= 3) {
+        if (!(++checked % 512))
+          budget.check();
+        int a = bucket.back();
+        bucket.pop_back();
+        int b = bucket.back();
+        bucket.pop_back();
+        int c = bucket.back();
+        bucket.pop_back();
+        bucket.push_back(parity(parity(a, b), c));
+        buckets[bit + 1].push_back(majority(a, b, c));
+      }
+    }
+    int carry = zero;
+    int width = 1;
+    for (uint64_t value = sum_weights; value >>= 1;)
+      ++width;
+    for (int bit = 0; bit < width; ++bit) {
+      int a = buckets[bit].empty() ? zero : buckets[bit][0];
+      int b = buckets[bit].size() < 2 ? zero : buckets[bit][1];
+      bits.push_back(parity(parity(a, b), carry));
+      carry = majority(a, b, carry);
+    }
+    if (carry != zero)
+      add({-carry});
+  }
+  void bound(int64_t value, bool lower) {
+    if (lower ? value <= 0 : value >= sum_weights)
+      return;
+    if (lower ? value > sum_weights : value < 0) {
+      add({});
+      return;
+    }
+    int equal = -zero;
+    for (int bit = static_cast<int>(bits.size()) - 1; bit >= 0; --bit) {
+      bool one = (static_cast<uint64_t>(value) >> bit) & 1;
+      if (lower && one)
+        add({-equal, bits[bit]});
+      if (!lower && !one)
+        add({-equal, -bits[bit]});
+      equal = conjunction(equal, one ? bits[bit] : -bits[bit]);
+    }
+  }
+  int64_t accounted_bytes() const {
+    int64_t bytes = sizeof(*this) + hard.capacity() * sizeof(std::vector<int>) +
+                    soft.capacity() * sizeof(soft[0]) +
+                    bits.capacity() * sizeof(int);
+    for (const auto &clause : hard)
+      bytes += clause.capacity() * sizeof(int);
+    return bytes;
+  }
+  void write(const std::string &path) {
+    std::ofstream out(path);
+    if (!out)
+      throw std::runtime_error("Cannot write weighted CNF");
+    int64_t total = 0;
+    for (auto [weight, literal] : soft) {
+      (void)literal;
+      total += weight;
+    }
+    if (total == std::numeric_limits<int64_t>::max())
+      throw std::overflow_error("WCNF top weight overflow");
+    int64_t top = total + 1;
+    out << "p wcnf " << variables << ' ' << hard.size() + soft.size() << ' '
+        << top << '\n';
+    size_t checked = 0;
+    for (const auto &clause : hard) {
+      if (!(++checked % 512))
+        budget.check();
+      out << top;
+      for (int v : clause)
+        out << ' ' << v;
+      out << " 0\n";
+    }
+    for (auto [weight, literal] : soft) {
+      if (!(++checked % 512))
+        budget.check();
+      out << weight << ' ' << literal << " 0\n";
+    }
+    out.close();
+    if (!out)
+      throw std::runtime_error("Failed to finish weighted CNF");
+  }
+};
+} // namespace synkit_mapper::solvers::detail

synkit/Chem/Mapper/solvers/native/cpp/src/supporting/README.md

@@ -0,0 +1,43 @@
+# Native supporting algorithms
+
+`dfs.cpp` is a deliberately exhaustive compatible-permutation DFS. It has no
+assignment relaxation, partial-cost pruning, symmetry pruning or incumbent
+branch pruning. Each leaf is scored independently in native code. Minimum
+queries exhaust one optimization pass and then one pass emitting every minimum
+mapping; a shared deadline spans both. Numeric shells traverse all compatible
+permutations and filter only the actual leaf cost. The independent Python
+multiset/permutation oracle remains in the test suite.
+
+`edit_support.cpp` is a different algorithm for binary bond-presence distance.
+For a distance k, it enumerates subsets of deleted source edges and inserted
+source nonedges. If the source and target edge counts are eA and eB, the only
+possible counts are `deletions=(k+eA-eB)/2` and `insertions=k-deletions`.
+For each concrete support it constructs the edited source graph and enumerates
+exact hard-type-compatible isomorphisms to the target, with exact degree and
+neighbor-type invariants followed by full adjacency checks. These invariants
+are necessary isomorphism conditions, not chemistry-based correspondence
+restrictions. Atom class attributes do not become hard atom matching rules.
+
+Any compatible mapping determines exactly one support: the source pairs whose
+binary adjacency disagrees with the pulled-back target. Conversely an exact
+isomorphism of an edited source graph to the target has exactly that support
+and distance k. Distinct supports cannot duplicate a mapping. Exhausting supports
+and their exact isomorphisms therefore enumerates the entire labeled binary
+shell. Minimum search visits possible support sizes increasingly; finding the
+first isomorphism proves the minimum after all smaller shells were exhausted,
+then all supports in that minimum shell are completed. At-most and exact numeric
+thresholds remain fixed. This is edit-support enumeration with isomorphism
+reconstruction, not an assignment search renamed EDIT.
+
+The binary native domain is `A2,B2 in {0,2}`, with `n <= 256`. Any other weighted
+graph returns unsupported. Calling a Python wrapper with `binary=True` explicitly
+changes the objective to bond presence; this is a separate binary track, not a
+Lewis-distance result. Binary CD is integral; odd doubled exact thresholds give
+a complete empty shell. Genuine weighted bond/edit support and Lewis-unary
+extensions are not claimed by this implementation.
+
+Both raw algorithms enforce soft shared deadline/cancellation, visited-state and
+candidate caps. Raw class caps, native classification requests, requested symmetry
+pruning and frontier/process-memory controls that are not implemented are
+explicitly unsupported. They stream candidates to the independently qualified
+class pipeline, and interrupted enumeration never reports total multiplicity.

synkit/Chem/Mapper/solvers/native/cpp/src/supporting/dfs.cpp

@@ -0,0 +1,123 @@
+#include "synkit_mapper/core/runtime.h"
+
+#include <functional>
+#include <limits>
+#include <numeric>
+
+namespace synkit_mapper {
+
+int solve_dfs(const Problem &p, const Request &r, Callback callback,
+              void *userdata, Statistics &s) {
+  initialize(s, r);
+  if (r.classify || r.max_classes != -1 || r.symmetry || r.max_frontier != -1 ||
+      r.memory_limit_bytes != -1)
+    return unsupported(s);
+  Budget budget(r);
+  std::vector<int32_t> mapping(p.n, -1);
+  std::vector<bool> used(p.n, false);
+  std::vector<int> order(p.n);
+  std::iota(order.begin(), order.end(), 0);
+  // Ordering is deterministic; no assignment bound or incumbent pruning is
+  // used. This deliberately enumerates every compatible permutation.
+  std::map<int32_t, int> counts;
+  for (int i = 0; i < p.n; ++i)
+    ++counts[p.types_p[i]];
+  std::stable_sort(order.begin(), order.end(), [&](int i, int k) {
+    return counts[p.types_r[i]] < counts[p.types_r[k]];
+  });
+  int64_t best = std::numeric_limits<int64_t>::max();
+  bool emitting = false;
+  const bool minimum =
+      r.query == SYNKIT_MINIMUM_CLASSES || r.query == SYNKIT_MINIMUM_PROOF;
+  double proof_at = -1;
+  auto score = [&]() {
+    int64_t value = 0;
+    // Independent native oracle scoring; no shared production cost/bound call.
+    for (int i = 0; i < p.n; ++i)
+      for (int k = 0; k < i; ++k) {
+        int64_t a = p.a2[i * p.n + k];
+        int64_t b = p.b2[mapping[i] * p.n + mapping[k]];
+        value += a > b ? a - b : b - a;
+      }
+    return value;
+  };
+  std::function<void(int)> visit = [&](int depth) {
+    budget.check();
+    if (s.nodes == std::numeric_limits<int64_t>::max() ||
+        (r.max_states >= 0 && s.nodes >= r.max_states))
+      throw Stop{SYNKIT_STOP_STATES};
+    ++s.nodes;
+    if (depth == p.n) {
+      ++s.leaves;
+      const auto value = score();
+      if (value < best) {
+        best = value;
+        s.incumbent2 = value;
+      }
+      if (!emitting)
+        return;
+      const bool selected = minimum ? value == s.minimum2
+                            : r.query == SYNKIT_EXACT_DISTANCE
+                                ? value == r.target2
+                                : value <= r.target2;
+      if (!selected)
+        return;
+      ++s.candidate_count;
+      if (callback) {
+        auto before = Clock::now();
+        int stop = callback(mapping.data(), value, 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};
+      return;
+    }
+    int i = order[depth];
+    for (int j = 0; j < p.n; ++j)
+      if (!used[j] && p.types_r[i] == p.types_p[j]) {
+        mapping[i] = j;
+        used[j] = true;
+        visit(depth + 1);
+        used[j] = false;
+        mapping[i] = -1;
+      }
+  };
+  try {
+    budget.check();
+    s.model_seconds = budget.seconds();
+    if (minimum) {
+      visit(0);
+      s.minimum2 = s.lower_bound2 = best;
+      s.minimum_proven = 1;
+      proof_at = budget.seconds();
+      if (r.query != SYNKIT_MINIMUM_PROOF) {
+        emitting = true;
+        visit(0);
+      }
+    } else {
+      emitting = true;
+      visit(0);
+      // Numeric queries traverse the full compatible space too; only after
+      // exhausting it may the observed least cost become a proved minimum.
+      s.minimum2 = s.lower_bound2 = best;
+      s.minimum_proven = 1;
+    }
+    s.search_complete = 1;
+    if (r.query != SYNKIT_MINIMUM_PROOF)
+      s.labeled_count = s.candidate_count;
+  } catch (const Stop &stop) {
+    stopped(s, stop.reason);
+  }
+  s.elapsed_seconds = budget.seconds();
+  s.optimization_seconds =
+      minimum ? (proof_at < 0 ? s.elapsed_seconds : proof_at) - s.model_seconds
+              : 0;
+  s.enumeration_seconds =
+      minimum ? (proof_at < 0 ? 0 : s.elapsed_seconds - proof_at)
+              : s.elapsed_seconds - s.model_seconds;
+  return 0;
+}
+} // namespace synkit_mapper

synkit/Chem/Mapper/solvers/native/cpp/src/supporting/edit_support.cpp

@@ -0,0 +1,224 @@
+#include "synkit_mapper/core/runtime.h"
+
+#include <functional>
+#include <limits>
+#include <numeric>
+
+namespace synkit_mapper {
+namespace {
+using Pair = std::pair<int, int>;
+struct ProofDone {};
+
+// Enumerate k-subsets themselves, not vertex assignments with a renamed cost.
+void subsets(int n, int k,
+             const std::function<void(const std::vector<int> &)> &f,
+             const Budget &budget) {
+  if (k < 0 || k > n)
+    return;
+  std::vector<int> indices(k);
+  std::iota(indices.begin(), indices.end(), 0);
+  while (true) {
+    budget.check();
+    f(indices);
+    int position = k - 1;
+    while (position >= 0 && indices[position] == n - k + position)
+      --position;
+    if (position < 0)
+      break;
+    ++indices[position];
+    for (int i = position + 1; i < k; ++i)
+      indices[i] = indices[i - 1] + 1;
+  }
+}
+} // namespace
+
+int solve_edit_support(const Problem &p, const Request &r, Callback callback,
+                       void *userdata, Statistics &s) {
+  initialize(s, r);
+  if (p.n > 256 || r.classify || r.max_classes != -1 || r.symmetry ||
+      r.max_frontier != -1 || r.memory_limit_bytes != -1)
+    return unsupported(s);
+  for (int i = 0; i < p.n * p.n; ++i)
+    if ((p.a2[i] != 0 && p.a2[i] != 2) || (p.b2[i] != 0 && p.b2[i] != 2))
+      return unsupported(s);
+  Budget budget(r);
+  std::vector<Pair> present, absent;
+  std::vector<uint8_t> original(p.n * p.n), product(p.n * p.n);
+  std::vector<int> product_degree(p.n);
+  std::vector<std::map<int32_t, int>> product_neighbours(p.n);
+  for (int i = 0; i < p.n; ++i) {
+    budget.check();
+    for (int k = 0; k < p.n; ++k) {
+      original[i * p.n + k] = p.a2[i * p.n + k] != 0;
+      product[i * p.n + k] = p.b2[i * p.n + k] != 0;
+      if (product[i * p.n + k]) {
+        ++product_degree[i];
+        ++product_neighbours[i][p.types_p[k]];
+      }
+      if (k < i)
+        (original[i * p.n + k] ? present : absent).emplace_back(i, k);
+    }
+  }
+  int target_edges = 0;
+  for (int value : product_degree)
+    target_edges += value;
+  target_edges /= 2;
+  const int source_edges = static_cast<int>(present.size());
+  const int lower = std::abs(source_edges - target_edges);
+  const int upper =
+      std::min(source_edges + target_edges,
+               2 * static_cast<int>(present.size() + absent.size()) -
+                   source_edges - target_edges);
+  const bool minimum =
+      r.query == SYNKIT_MINIMUM_CLASSES || r.query == SYNKIT_MINIMUM_PROOF;
+  double proof_at = -1;
+  auto node = [&]() {
+    budget.check();
+    if (s.nodes == std::numeric_limits<int64_t>::max() ||
+        (r.max_states >= 0 && s.nodes >= r.max_states))
+      throw Stop{SYNKIT_STOP_STATES};
+    ++s.nodes;
+  };
+  try {
+    s.model_seconds = budget.seconds();
+    const int first =
+        r.query == SYNKIT_EXACT_DISTANCE
+            ? static_cast<int>(std::min<int64_t>(r.target2 / 2, upper + 1))
+            : lower;
+    const int last =
+        minimum ? upper
+                : static_cast<int>(std::min<int64_t>(r.target2 / 2, upper));
+    if (r.query == SYNKIT_EXACT_DISTANCE && r.target2 % 2) {
+      s.search_complete = 1;
+      s.labeled_count = 0;
+    } else {
+      for (int shell = first; shell <= last; ++shell) {
+        if (shell < lower || (shell + source_edges - target_edges) % 2)
+          continue;
+        const int deletions = (shell + source_edges - target_edges) / 2;
+        const int insertions = shell - deletions;
+        bool shell_has_mapping = false;
+        subsets(
+            static_cast<int>(present.size()), deletions,
+            [&](const std::vector<int> &removed) {
+              subsets(
+                  static_cast<int>(absent.size()), insertions,
+                  [&](const std::vector<int> &added) {
+                    node();
+                    auto edited = original;
+                    for (int index : removed) {
+                      auto [i, k] = present[index];
+                      edited[i * p.n + k] = edited[k * p.n + i] = 0;
+                    }
+                    for (int index : added) {
+                      auto [i, k] = absent[index];
+                      edited[i * p.n + k] = edited[k * p.n + i] = 1;
+                    }
+                    std::vector<std::vector<int>> domains(p.n);
+                    for (int i = 0; i < p.n; ++i) {
+                      budget.check();
+                      int degree = 0;
+                      std::map<int32_t, int> neighbours;
+                      for (int k = 0; k < p.n; ++k)
+                        if (edited[i * p.n + k]) {
+                          ++degree;
+                          ++neighbours[p.types_r[k]];
+                        }
+                      for (int j = 0; j < p.n; ++j)
+                        if (p.types_r[i] == p.types_p[j] &&
+                            degree == product_degree[j] &&
+                            neighbours == product_neighbours[j])
+                          domains[i].push_back(j);
+                      if (domains[i].empty())
+                        return;
+                    }
+                    std::vector<int> order(p.n);
+                    std::iota(order.begin(), order.end(), 0);
+                    std::stable_sort(
+                        order.begin(), order.end(), [&](int i, int k) {
+                          return domains[i].size() < domains[k].size();
+                        });
+                    std::vector<int32_t> mapping(p.n, -1);
+                    std::vector<bool> used(p.n, false);
+                    std::function<void(int)> isomorphisms = [&](int depth) {
+                      node();
+                      if (depth == p.n) {
+                        ++s.leaves;
+                        shell_has_mapping = true;
+                        s.incumbent2 =
+                            s.incumbent2 < 0
+                                ? 2 * shell
+                                : std::min<int64_t>(s.incumbent2, 2 * shell);
+                        if (minimum && !s.minimum_proven) {
+                          s.minimum_proven = 1;
+                          s.minimum2 = s.lower_bound2 = 2 * shell;
+                          proof_at = budget.seconds();
+                        }
+                        if (r.query == SYNKIT_MINIMUM_PROOF)
+                          throw ProofDone{};
+                        ++s.candidate_count;
+                        if (callback) {
+                          auto before = Clock::now();
+                          int stop =
+                              callback(mapping.data(), 2 * shell, 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};
+                        return;
+                      }
+                      int i = order[depth];
+                      for (int j : domains[i]) {
+                        if (used[j])
+                          continue;
+                        bool compatible = true;
+                        for (int d = 0; d < depth; ++d) {
+                          int k = order[d];
+                          if (edited[i * p.n + k] !=
+                              product[j * p.n + mapping[k]]) {
+                            compatible = false;
+                            break;
+                          }
+                        }
+                        if (!compatible)
+                          continue;
+                        mapping[i] = j;
+                        used[j] = true;
+                        isomorphisms(depth + 1);
+                        used[j] = false;
+                        mapping[i] = -1;
+                        if (r.query == SYNKIT_MINIMUM_PROOF && s.minimum_proven)
+                          return;
+                      }
+                    };
+                    isomorphisms(0);
+                  },
+                  budget);
+            },
+            budget);
+        if (minimum && shell_has_mapping)
+          break;
+      }
+      s.search_complete = 1;
+      if (r.query != SYNKIT_MINIMUM_PROOF)
+        s.labeled_count = s.candidate_count;
+    }
+  } catch (const ProofDone &) {
+    s.search_complete = 1;
+  } catch (const Stop &stop) {
+    stopped(s, stop.reason);
+  }
+  s.elapsed_seconds = budget.seconds();
+  s.optimization_seconds =
+      minimum ? (proof_at < 0 ? s.elapsed_seconds : proof_at) - s.model_seconds
+              : 0;
+  s.enumeration_seconds =
+      minimum ? (proof_at < 0 ? 0 : s.elapsed_seconds - proof_at)
+              : s.elapsed_seconds - s.model_seconds;
+  return 0;
+}
+} // namespace synkit_mapper