synkit 1.6.5__py3-none-win_amd64.whl

synkit/Chem/Mapper/solvers/native/cpp/src/pabs/chemical_floor.inc

@@ -0,0 +1,181 @@
+// Private to bridge.cpp; exact algebraic lower bound.
+// Integer normalized objective variables obey 2*e_i+h_i+sum_j b_ij=c_type.
+// Conserved total h then makes total CD even. CD2 is impossible: a single
+// bond edit has odd endpoint degree, while two bond units cannot have zero
+// signed degree everywhere. Pure unary changes cost at least3. Therefore a
+// nonzero distance is >=4 (raw doubled cost>=8). Guards are checked exactly;
+// component/WL disagreement is only a negative isomorphism certificate.
+int chemical_positive_floor(const Problem &p, const Perm &tr, const Perm &tp,
+                            int64_t known_lower, Budget &budget,
+                            int *reason = nullptr) {
+  const int n = p.n;
+  if (reason)
+    *reason = 0;
+  if (n < 3 || n > 256 || budget.remaining() < 0.05)
+    return 0;
+  const auto started = Clock::now();
+  const double allowance = std::min(0.005, budget.remaining() * 0.01);
+  auto expired = [&]() {
+    budget.check();
+    return elapsed(started) >= allowance;
+  };
+  std::map<int, int> counts, other_counts, positions;
+  for (int i = 0; i < n; ++i) {
+    ++counts[tr[i]];
+    ++other_counts[tp[i]];
+    positions[tp[i]] = i;
+  }
+  if (counts != other_counts)
+    return 0;
+  Perm dr(n, 0), dp(n, 0);
+  std::vector<Perm> ar(n), ap(n);
+  for (int i = 0; i < n; ++i) {
+    if (expired())
+      return 0;
+    if (p.a2[i * n + i] || p.b2[i * n + i])
+      return 0;
+    for (int j = 0; j < n; ++j) {
+      const int64_t a = p.a2[i * n + j], b = p.b2[i * n + j];
+      if (a < 0 || b < 0 || a % 2 || b % 2 || a != p.a2[j * n + i] ||
+          b != p.b2[j * n + i] || a > 1024 || b > 1024)
+        return 0;
+      dr[i] += a / 2;
+      dp[i] += b / 2;
+      if (a)
+        ar[i].push_back(j);
+      if (b)
+        ap[i].push_back(j);
+    }
+  }
+  int er = -1, hr = -1, ep = -1, hp = -1;
+  for (int orientation = 0; orientation < 2 && er < 0; ++orientation) {
+    const int e = n - 2 + orientation, h = n - 1 - orientation;
+    if (counts[tr[e]] != 1 || counts[tr[h]] != 1)
+      continue;
+    const int pe = positions[tr[e]], ph = positions[tr[h]];
+    if (p.a2[e * n + h] || p.b2[pe * n + ph] || dr[h] != dp[ph])
+      continue;
+    std::map<int, int64_t> constants;
+    bool valid = true;
+    for (int side = 0; side < 2 && valid; ++side) {
+      const auto &types = side ? tp : tr;
+      const auto &degree = side ? dp : dr;
+      const auto *matrix = side ? p.b2 : p.a2;
+      const int electron = side ? pe : e, hydrogen = side ? ph : h;
+      for (int i = 0; i < n; ++i)
+        if (i != electron && i != hydrogen) {
+          const int64_t value = degree[i] + matrix[i * n + electron] / 2;
+          auto entry = constants.emplace(types[i], value);
+          if (entry.first->second != value) {
+            valid = false;
+            break;
+          }
+        }
+    }
+    if (valid) {
+      er = e;
+      hr = h;
+      ep = pe;
+      hp = ph;
+    }
+  }
+  if (er < 0 || expired())
+    return 0;
+  if (known_lower > 0) {
+    if (reason)
+      *reason = 1;
+    return 8;
+  }
+  auto components = [&](const Perm &types, const std::vector<Perm> &adj,
+                        const int64_t *matrix, int e, int h) {
+    std::vector<std::vector<int64_t>> signatures;
+    Perm seen(n, 0);
+    seen[e] = seen[h] = 1;
+    for (int root = 0; root < n; ++root)
+      if (!seen[root]) {
+        std::vector<std::vector<int64_t>> vertices;
+        Perm pending{root};
+        seen[root] = 1;
+        while (!pending.empty()) {
+          int i = pending.back();
+          pending.pop_back();
+          int degree = 0, weight = 0;
+          for (int j : adj[i])
+            if (j != e && j != h) {
+              ++degree;
+              weight += matrix[i * n + j];
+              if (!seen[j]) {
+                seen[j] = 1;
+                pending.push_back(j);
+              }
+            }
+          vertices.push_back(
+              {types[i], matrix[i * n + e], matrix[i * n + h], degree, weight});
+        }
+        std::sort(vertices.begin(), vertices.end());
+        std::vector<int64_t> key{static_cast<int64_t>(vertices.size())};
+        for (const auto &vertex : vertices)
+          key.insert(key.end(), vertex.begin(), vertex.end());
+        signatures.push_back(std::move(key));
+      }
+    std::sort(signatures.begin(), signatures.end());
+    return signatures;
+  };
+  auto left = components(tr, ar, p.a2, er, hr),
+       right = components(tp, ap, p.b2, ep, hp);
+  if (expired())
+    return 0;
+  if (left != right) {
+    if (reason)
+      *reason = 2;
+    return 8;
+  }
+  Perm cr = tr, cp = tp;
+  std::set<int> previous(tr.begin(), tr.end());
+  size_t previous_count = previous.size();
+  for (int round = 0; round < 6; ++round) {
+    std::map<std::vector<int64_t>, int> intern;
+    auto refine = [&](const Perm &colors, const std::vector<Perm> &adj,
+                      const int64_t *matrix, Perm &next) {
+      next.resize(n);
+      for (int i = 0; i < n; ++i) {
+        if (expired())
+          return false;
+        std::vector<std::pair<int, int64_t>> neighbors;
+        for (int j : adj[i])
+          neighbors.emplace_back(colors[j], matrix[i * n + j]);
+        std::sort(neighbors.begin(), neighbors.end());
+        std::vector<int64_t> key{colors[i],
+                                 static_cast<int64_t>(neighbors.size())};
+        for (auto edge : neighbors) {
+          key.push_back(edge.first);
+          key.push_back(edge.second);
+        }
+        next[i] = intern.emplace(std::move(key), intern.size()).first->second;
+      }
+      return true;
+    };
+    Perm nr, np;
+    if (!refine(cr, ar, p.a2, nr) || !refine(cp, ap, p.b2, np))
+      return 0;
+    Perm balance(intern.size(), 0);
+    for (int color : nr)
+      ++balance[color];
+    for (int color : np)
+      --balance[color];
+    if (std::any_of(balance.begin(), balance.end(),
+                    [](int value) { return value != 0; })) {
+      if (expired())
+        return 0;
+      if (reason)
+        *reason = 3;
+      return 8;
+    }
+    if (intern.size() == previous_count)
+      break;
+    previous_count = intern.size();
+    cr = std::move(nr);
+    cp = std::move(np);
+  }
+  return 0;
+}

synkit/Chem/Mapper/solvers/native/cpp/src/pabs/endpoint_symmetry.inc

@@ -0,0 +1,104 @@
+// Private to bridge.cpp; verified endpoint automorphism subgroups.
+std::vector<int> twin_generators(const Problem &p, bool product) {
+  const int n = p.n;
+  const auto *matrix = product ? p.b2 : p.a2;
+  const auto *types = product ? p.types_p : p.types_r;
+  const auto *nodes = product ? p.node_colors_p : p.node_colors_r;
+  const auto *edges = product ? p.edge_colors_p : p.edge_colors_r;
+  std::vector<int> generators;
+  for (int i = 0; i < n; ++i)
+    for (int k = i + 1; k < n; ++k) {
+      if (types[i] != types[k] || (nodes && nodes[i] != nodes[k]) ||
+          (edges && edges[i * n + i] != edges[k * n + k]))
+        continue;
+      bool equal = true;
+      for (int j = 0; j < n; ++j)
+        if (j != i && j != k &&
+            (matrix[i * n + j] != matrix[k * n + j] ||
+             (edges && edges[i * n + j] != edges[k * n + j]))) {
+          equal = false;
+          break;
+        }
+      if (!equal)
+        continue;
+      for (int j = 0; j < n; ++j)
+        generators.push_back(j == i ? k : j == k ? i : j);
+      break;
+    }
+  return generators;
+}
+
+// Individualization/refinement only discovers candidate symmetries. Every
+// retained permutation is verified against all typed, attributed, weighted
+// endpoint edges by NativeCanon::accept. A discovery cutoff retains a subgroup
+// and can only weaken pruning; it cannot remove a feasible mapping class.
+std::vector<int> endpoint_generators(const Problem &p, bool product,
+                                     Budget &budget) {
+  const int n = p.n;
+  auto result = twin_generators(p, product);
+  const auto *weights = product ? p.b2 : p.a2;
+  const auto *types = product ? p.types_p : p.types_r;
+  const auto *nodes = product ? p.node_colors_p : p.node_colors_r;
+  const auto *edges = product ? p.edge_colors_p : p.edge_colors_r;
+  std::map<std::pair<int32_t, int32_t>, int> node_ids;
+  std::map<std::pair<int64_t, int32_t>, int> edge_ids;
+  Perm colors(n), palette(n * n, 0), parent(n);
+  std::iota(parent.begin(), parent.end(), 0);
+  auto find = [&](int x) {
+    while (parent[x] != x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  for (int i = 0; i < n; ++i) {
+    colors[i] = node_ids
+                    .emplace(std::make_pair(types[i], nodes ? nodes[i] : 0),
+                             node_ids.size())
+                    .first->second;
+    for (int j = 0; j < n; ++j) {
+      const int64_t weight = weights[i * n + j];
+      const int32_t edge = edges ? edges[i * n + j] : 0;
+      if (weight || edge)
+        palette[i * n + j] =
+            edge_ids.emplace(std::make_pair(weight, edge), edge_ids.size() + 1)
+                .first->second;
+    }
+  }
+  const double seconds = std::min(0.05, budget.remaining() * 0.02);
+  NativeCanon canon(n, colors.data(), palette.data(), seconds, 10000);
+  for (size_t offset = 0; offset < result.size(); offset += n) {
+    Perm generator(result.begin() + offset, result.begin() + offset + n);
+    canon.accept(generator);
+    // The existing exact transpositions connect freely interchangeable twins,
+    // including adjacent true twins. They may be individualized together.
+    for (int i = 0; i < n; ++i)
+      if (generator[i] != i) {
+        const int x = find(i), y = find(generator[i]);
+        parent[y] = x;
+      }
+  }
+  for (int i = 0; i < n; ++i)
+    canon.twin_class[i] = find(i);
+  const size_t initial = canon.generators.size();
+  std::map<int, Perm> buckets;
+  for (int i = 0; i < n; ++i)
+    buckets[colors[i]].push_back(i);
+  NativeCanon::Partition partition;
+  for (auto &entry : buckets)
+    partition.push_back(std::move(entry.second));
+  partition = canon.refine(std::move(partition));
+  bool twins_only = true;
+  for (const auto &cell : partition)
+    for (int x : cell)
+      if (canon.twin_class[x] != canon.twin_class[cell.front()])
+        twins_only = false;
+  if (!twins_only && seconds > 0)
+    canon.visit(std::move(partition), true);
+  const size_t stop = std::min(canon.generators.size(), initial + 32);
+  for (size_t k = initial; k < stop; ++k)
+    result.insert(result.end(), canon.generators[k].begin(),
+                  canon.generators[k].end());
+  budget.check();
+  return result;
+}

synkit/Chem/Mapper/solvers/native/cpp/src/pabs/exact_helpers.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <cstdint>
+
+namespace synkit_mapper::pabs {
+// Exhaustively compare small weighted deletion decks. A timeout preserves only
+// levels already excluded; hashes are filters, exact canonical forms decide.
+int edge_deck(int n, const int64_t *a, const int64_t *b, const int32_t *types_r,
+              const int32_t *types_p, int units, double seconds,
+              int64_t node_limit, int64_t upper2, int32_t *mapping,
+              int64_t *lower2, int64_t *witness2, int64_t *statistics);
+int edge_deck_sizes(int n, const int64_t *a, const int64_t *b,
+                    const int32_t *types_r, const int32_t *types_p, int units,
+                    int64_t *sizes);
+// Proposal only. Failure or truncation never supplies an optimality bound.
+int sparse_embedding_seed(int n, const int64_t *a, const int64_t *b,
+                          const int32_t *types_r, const int32_t *types_p,
+                          int64_t target2, double seconds, int64_t node_limit,
+                          int32_t *mapping, int64_t *cost2,
+                          int64_t *statistics);
+} // namespace synkit_mapper::pabs

synkit/Chem/Mapper/solvers/native/cpp/src/pabs/lp_assignment_certificate.h

@@ -0,0 +1,165 @@
+#pragma once
+// A call-local, exact assignment relaxation of the checked original LP dual.
+// No primal anchors, guessed domains or previous solves enter this certificate.
+#include "lp_certificate.h"
+namespace synkit_mapper {
+namespace sparse_root_lp {
+struct AssignmentCertificate {
+  bool ready = false;
+  int n = 0, m = 0;
+  int64_t root_bound2 = 0;
+#ifdef SYNKIT_MAPPER_TEST_HOOKS
+  int64_t calls = 0, prunes = 0;
+#endif // SYNKIT_MAPPER_TEST_HOOKS
+#if defined(__SIZEOF_INT128__)
+  Wide base = 0, quantum = 1;
+  int64_t gcd = 0, mass = 0;
+  std::vector<int> rows, columns, row_position, column_position;
+  std::vector<int> penalties;
+
+  int64_t round_bound(Wide numerator) const {
+    Wide value = numerator >= 0
+                     ? (numerator + certificate_scale - 1) / certificate_scale
+                     : numerator / certificate_scale;
+    if (gcd) {
+      const Wide step = 2 * Wide(gcd);
+      Wide correction = (Wide(mass) - value) % step;
+      if (correction < 0)
+        correction += step;
+      value += correction;
+    }
+    // The complete typed space has a mapping of cost at most mass. Clipping
+    // only weakens an optional bound and keeps the legacy callback arithmetic
+    // within the production graph mass guard.
+    return int64_t(std::max(Wide(0), std::min(Wide(mass), value)));
+  }
+
+  template <class Check>
+  static AssignmentCertificate
+  build(const PreparedModel &model, const IntegerCertificate &certificate,
+        const std::vector<Wide> &reduced, Check check) {
+    AssignmentCertificate result;
+    result.n = model.n;
+    result.m = int(model.variable_rows.size());
+    result.mass = model.mass;
+    result.gcd = model.gcd;
+    if (!result.m || result.n > 256 || result.m != int(model.columns.size()) ||
+        reduced.size() != size_t(model.assignment_variables))
+      return result;
+    check();
+    const int n = result.n, m = result.m;
+    result.rows = model.variable_rows;
+    result.columns = model.columns;
+    result.row_position.assign(n, -1);
+    result.column_position.assign(n, -1);
+    for (int i = 0; i < m; ++i) {
+      result.row_position[result.rows[i]] = i;
+      result.column_position[result.columns[i]] = i;
+    }
+    result.base = certificate.numerator;
+    for (Wide value : reduced)
+      result.base -= std::min(Wide(0), value);
+    std::vector<Wide> shifts(m);
+    Wide largest = 0;
+    for (int i = 0; i < m; ++i) {
+      check();
+      int row = result.rows[i];
+      const auto &domain = model.domains[row];
+      if (domain.empty())
+        return AssignmentCertificate{};
+      Wide minimum = reduced[model.assignment[row * n + domain[0]]];
+      for (int image : domain)
+        minimum = std::min(minimum, reduced[model.assignment[row * n + image]]);
+      shifts[i] = minimum;
+      result.base += minimum;
+      for (int image : domain)
+        largest = std::max(largest, reduced[model.assignment[row * n + image]] -
+                                        minimum);
+    }
+    const int safe_entry = INF / (8 * m) - 1;
+    if (safe_entry < 1)
+      return AssignmentCertificate{};
+    result.quantum = std::max(Wide(1), (largest + safe_entry - 1) / safe_entry);
+    std::vector<int> cost(m * m, INF);
+    for (int i = 0; i < m; ++i) {
+      check();
+      int row = result.rows[i];
+      for (int image : model.domains[row]) {
+        int col = result.column_position[image];
+        if (col < 0)
+          return AssignmentCertificate{};
+        Wide value = (reduced[model.assignment[row * n + image]] - shifts[i]) /
+                     result.quantum;
+        if (value < 0 || value > safe_entry)
+          return AssignmentCertificate{};
+        cost[i * m + col] = int(value);
+      }
+    }
+    check();
+    Perm match, u, v;
+    int optimum = Solver::assignment(cost, m, match, u, v);
+    check();
+    if (optimum >= INF / 2 || int(match.size()) != m ||
+        int(u.size()) != m + 1 || int(v.size()) != m + 1)
+      return AssignmentCertificate{};
+    int64_t dual = 0, primal = 0;
+    std::vector<char> used(m, false);
+    result.penalties.assign(m * m, INF);
+    for (int i = 0; i < m; ++i) {
+      check();
+      int image = match[i];
+      if (image < 0 || image >= m || used[image]++ ||
+          cost[i * m + image] >= INF / 2)
+        return AssignmentCertificate{};
+      primal += cost[i * m + image];
+      dual += int64_t(u[i + 1]) + v[i + 1];
+      for (int j = 0; j < m; ++j)
+        if (cost[i * m + j] < INF / 2) {
+          int64_t value = int64_t(cost[i * m + j]) - u[i + 1] - v[j + 1];
+          if (value < 0 || value >= INF)
+            return AssignmentCertificate{};
+          result.penalties[i * m + j] = int(value);
+        }
+    }
+    if (primal != optimum || dual != optimum)
+      return AssignmentCertificate{};
+    result.base += result.quantum * optimum;
+    result.root_bound2 = result.round_bound(result.base);
+    check();
+    result.ready = true;
+    return result;
+  }
+
+  int64_t bound(const int *mapping, const int *used) const {
+    if (!ready)
+      return 0;
+    Wide extra = 0;
+    for (int i = 0; i < m; ++i) {
+      int image = mapping[rows[i]];
+      if (image >= 0) {
+        if (image >= n || column_position[image] < 0)
+          return mass;
+        int penalty = penalties[i * m + column_position[image]];
+        if (penalty >= INF / 2)
+          return mass;
+        extra += penalty;
+      } else if (m <= 64) {
+        // Dropping nonnegative future-row minima for larger problems gives
+        // a weaker valid certificate with O(m) prefix evaluation.
+        int least = INF;
+        for (int j = 0; j < m; ++j)
+          if (!used[columns[j]])
+            least = std::min(least, penalties[i * m + j]);
+        if (least >= INF / 2)
+          return mass;
+        extra += least;
+      }
+    }
+    return round_bound(base + quantum * extra);
+  }
+#else
+  int64_t bound(const int *, const int *) const { return 0; }
+#endif
+};
+} // namespace sparse_root_lp
+} // namespace synkit_mapper

synkit/Chem/Mapper/solvers/native/cpp/src/pabs/lp_certificate.h

@@ -0,0 +1,125 @@
+#pragma once
+
+// Mathematical authority for the optional LP bound. No numerical solver or
+// solver status is trusted: any sign-valid integer multiplier vector gives a
+// box-Lagrangian lower bound on the original exact integer formulation.
+#include "lp_model.h"
+#include <cmath>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+namespace synkit_mapper {
+namespace sparse_root_lp {
+constexpr int64_t certificate_scale = 1000000;
+
+#if defined(__SIZEOF_INT128__)
+__extension__ typedef __int128 Wide;
+struct IntegerCertificate {
+  Wide numerator = 0;
+  int64_t bound2 = 0;
+  std::vector<int64_t> dual;
+};
+
+inline std::string decimal(Wide value) {
+  if (!value)
+    return "0";
+  const bool negative = value < 0;
+  if (negative)
+    value = -value;
+  std::string result;
+  while (value) {
+    result.push_back(char('0' + value % 10));
+    value /= 10;
+  }
+  if (negative)
+    result.push_back('-');
+  std::reverse(result.begin(), result.end());
+  return result;
+}
+
+// Equality multipliers are free. Upper-inequality multipliers must be <= 0.
+// For 0<=z<=1 and Az<=b this is C+b*d+sum(min(0,c-A^T*d)).
+template <class Check>
+IntegerCertificate evaluate_integer_dual(const PreparedModel &model,
+                                         const std::vector<int64_t> &dual,
+                                         Check check,
+                                         std::vector<Wide> *assignment_reduced = nullptr) {
+  if (dual.size() != model.rows.size() || model.costs.size() > max_variables ||
+      model.rows.size() > max_constraints)
+    throw std::invalid_argument("Invalid LP certificate dimensions");
+  std::vector<Wide> reduced;
+  reduced.reserve(model.costs.size());
+  for (int64_t cost : model.costs)
+    reduced.push_back(Wide(cost) * certificate_scale);
+  Wide lower = Wide(model.constant) * certificate_scale;
+  size_t nonzeros = 0;
+  for (size_t i = 0; i < model.rows.size(); ++i) {
+    if (!(i % 128))
+      check();
+    const auto &row = model.rows[i];
+    const int64_t multiplier = dual[i];
+    if ((!row.equality && multiplier > 0) || multiplier < -1000000000000LL ||
+        multiplier > 1000000000000LL)
+      throw std::invalid_argument("Invalid LP certificate multiplier");
+    lower += Wide(row.rhs) * multiplier;
+    nonzeros += row.terms.size();
+    if (nonzeros > max_nonzeros)
+      throw std::invalid_argument("LP certificate exceeds nonzero cap");
+    for (const auto &term : row.terms) {
+      if (term.column < 0 || size_t(term.column) >= reduced.size())
+        throw std::invalid_argument("Invalid LP certificate column");
+      reduced[term.column] -= Wide(term.coefficient) * multiplier;
+    }
+  }
+  for (Wide value : reduced)
+    if (value < 0)
+      lower += value;
+  Wide rounded = lower >= 0
+                     ? (lower + certificate_scale - 1) / certificate_scale
+                     : lower / certificate_scale;
+  // Every true mapping has cost mass-2*overlap, hence the ORIGINAL matrix
+  // lattice mass modulo 2*gcd. No floating rounding enters this step.
+  if (model.gcd) {
+    const Wide step = 2 * Wide(model.gcd);
+    Wide residue = (Wide(model.mass) - rounded) % step;
+    if (residue < 0)
+      residue += step;
+    rounded += residue;
+  }
+  check();
+  if (rounded < std::numeric_limits<int64_t>::min() ||
+      rounded > std::numeric_limits<int64_t>::max())
+    throw std::overflow_error("LP certificate bound exceeds int64");
+  if (assignment_reduced)
+    assignment_reduced->assign(reduced.begin(),
+                               reduced.begin() + model.assignment_variables);
+  return {lower, int64_t(rounded), dual};
+}
+
+// Floating vectors are only proposals; clipping/projection cannot invalidate
+// the subsequent exact bound. Even a numerical failure may yield a usable
+// vector, provided its original dimensions are correct.
+template <class Check>
+IntegerCertificate certify_proposal(const PreparedModel &model,
+                                    const std::vector<double> &proposal,
+                                    Check check,
+                                    std::vector<Wide> *assignment_reduced = nullptr) {
+  if (proposal.size() != model.rows.size())
+    throw std::invalid_argument("Invalid LP proposal dimensions");
+  std::vector<int64_t> dual(proposal.size());
+  for (size_t i = 0; i < proposal.size(); ++i) {
+    if (!(i % 128))
+      check();
+    double value = std::isfinite(proposal[i]) ? proposal[i] : 0;
+    value = std::max(-1000000.0, std::min(1000000.0, value));
+    int64_t encoded = std::llround(value * certificate_scale);
+    if (!model.rows[i].equality)
+      encoded = std::min(int64_t{0}, encoded);
+    dual[i] = encoded;
+  }
+  return evaluate_integer_dual(model, dual, check, assignment_reduced);
+}
+#endif // exact wide arithmetic; unsupported compilers use the PABS fallback.
+} // namespace sparse_root_lp
+} // namespace synkit_mapper