synkit 1.6.5__py3-none-win_amd64.whl

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

@@ -0,0 +1,170 @@
+// Bridge-private proposal decoder. Requires legacy Solver::assignment, Perm
+// and INF from the existing kernel; it never changes exact-search domains.
+auto round_primal = [&](bool refine) {
+  if (provider.primal().size() != model->costs.size())
+    return;
+  if (incumbent_mapping && incumbent_cost &&
+      incumbent_mapping->size() == size_t(n)) {
+    if (mapping_cost2(p, *incumbent_mapping) != *incumbent_cost)
+      throw std::runtime_error("Invalid LP-rounding incoming seed");
+  }
+  const int m = rows.size();
+  std::vector<double> prior(n * n, 0);
+  for (int i : rows)
+    for (int j : domains[i]) {
+      double value = primal_value(x[i * n + j]);
+      prior[i * n + j] =
+          std::isfinite(value) ? std::max(0.0, std::min(1.0, value)) : 0.0;
+    }
+  auto accept = [&](const std::vector<int32_t> &candidate) {
+    check();
+    const int64_t cost = mapping_cost2(p, candidate);
+    check();
+    if (incumbent_mapping && incumbent_cost && cost < *incumbent_cost) {
+      *incumbent_mapping = candidate;
+      *incumbent_cost = cost;
+      stop_target = cost;
+    }
+  };
+  int anchor_i = -1, anchor_j = -1, anchor_k = -1, anchor_l = -1;
+  auto lap = [&](const std::vector<double> &weights,
+                 std::vector<int32_t> &candidate) {
+    check();
+    Perm costs(m * m, INF), matching, u, v;
+    for (int r = 0; r < m; ++r) {
+      double maximum = 0;
+      for (int j : domains[rows[r]])
+        maximum = std::max(maximum, weights[rows[r] * n + j]);
+      for (int c = 0; c < m; ++c)
+        if (x[rows[r] * n + cols[c]] >= 0) {
+          const int source = rows[r], target = cols[c];
+          // Temporary proposal-only anchors. Original domains, groups and
+          // exact search are never modified by these local LAP exclusions.
+          if (anchor_i >= 0 && ((source == anchor_i && target != anchor_j) ||
+                                (source == anchor_k && target != anchor_l) ||
+                                (source != anchor_i && target == anchor_j) ||
+                                (source != anchor_k && target == anchor_l)))
+            continue;
+          double reward =
+              maximum > 0 ? weights[rows[r] * n + cols[c]] / maximum : 0;
+          if (!std::isfinite(reward))
+            reward = 0;
+          reward = std::max(0.0, std::min(1.0, reward));
+          costs[r * m + c] = int(std::llround(10000 * (1 - reward)));
+        }
+    }
+    if (m && Solver::assignment(costs, m, matching, u, v) >= INF / 2)
+      return false;
+    candidate.assign(fixed.begin(), fixed.end());
+    for (int r = 0; r < m; ++r)
+      candidate[rows[r]] = cols[matching[r]];
+    if (anchor_i >= 0 &&
+        (candidate[anchor_i] != anchor_j || candidate[anchor_k] != anchor_l))
+      throw std::runtime_error("LP proposal LAP violated a temporary anchor");
+    check();
+    accept(candidate);
+    return true;
+  };
+  std::vector<int32_t> candidate;
+  if (!lap(prior, candidate))
+    return;
+  if (!refine || best >= stop_target)
+    return;
+  // Deterministic pair-agreement refinement is heuristic only. Products
+  // incident to the current image reward coherent edge correspondences.
+  // A fresh input-only seed is a second starting point when supplied.
+  std::vector<std::vector<int32_t>> starts{candidate};
+  if (incumbent_mapping && *incumbent_mapping != candidate)
+    starts.push_back(*incumbent_mapping);
+  for (auto current : starts)
+    for (int pass = 0; pass < 4 && best < stop_target; ++pass) {
+      check();
+      std::vector<double> agreement = prior;
+      for (const auto &z : products) {
+        const auto &edge = source[z.e];
+        double value = primal_value(z.index);
+        if (!std::isfinite(value))
+          continue;
+        value = std::max(0.0, std::min(1.0, value));
+        if (current[edge.k] == z.right)
+          agreement[edge.i * n + z.left] += value;
+        if (current[edge.i] == z.left)
+          agreement[edge.k * n + z.right] += value;
+      }
+      std::vector<int32_t> next;
+      if (!lap(agreement, next) || next == current)
+        break;
+      current = std::move(next);
+    }
+  if (best >= stop_target)
+    return;
+  // Break fractional-face tie inconsistencies by holding one positive
+  // LP edge correspondence during a few otherwise unchanged LAP rounds.
+  // The two typed images are distinct, so residual type counts balance.
+  struct Anchor {
+    int i, k, j, l;
+    double support, first, second, rank;
+  };
+  std::vector<Anchor> anchors;
+  anchors.reserve(std::min(size_t(16), products.size()));
+  auto preferred = [](const Anchor &a, const Anchor &b) {
+    if (a.rank != b.rank)
+      return a.rank > b.rank;
+    return std::tie(a.i, a.k, a.j, a.l) < std::tie(b.i, b.k, b.j, b.l);
+  };
+  for (size_t h = 0; h < products.size(); ++h) {
+    if (!(h % 128))
+      check();
+    const auto &z = products[h];
+    const auto &e = source[z.e];
+    double y = primal_value(z.index);
+    if (!std::isfinite(y))
+      continue;
+    y = std::max(0.0, std::min(1.0, y));
+    const double first = prior[e.i * n + z.left],
+                 second = prior[e.k * n + z.right];
+    const double uncertainty = 2 - first - second;
+    if (y <= 1e-9 || uncertainty <= 1e-12)
+      continue;
+    Anchor a{e.i, e.k, z.left, z.right, y, first, second, y * uncertainty};
+    if (anchors.size() < 16) {
+      anchors.push_back(a);
+      std::sort(anchors.begin(), anchors.end(), preferred);
+    } else if (preferred(a, anchors.back())) {
+      anchors.back() = a;
+      std::sort(anchors.begin(), anchors.end(), preferred);
+    }
+  }
+  for (const auto &a : anchors) {
+    if (best >= stop_target)
+      break;
+    check();
+    anchor_i = a.i;
+    anchor_j = a.j;
+    anchor_k = a.k;
+    anchor_l = a.l;
+    std::vector<int32_t> current;
+    if (!lap(prior, current))
+      continue;
+    for (int pass = 0; pass < 4 && best < stop_target; ++pass) {
+      check();
+      std::vector<double> agreement = prior;
+      for (const auto &z : products) {
+        const auto &e = source[z.e];
+        double value = primal_value(z.index);
+        if (!std::isfinite(value))
+          continue;
+        value = std::max(0.0, std::min(1.0, value));
+        if (current[e.k] == z.right)
+          agreement[e.i * n + z.left] += value;
+        if (current[e.i] == z.left)
+          agreement[e.k * n + z.right] += value;
+      }
+      std::vector<int32_t> next;
+      if (!lap(agreement, next) || next == current)
+        break;
+      current = std::move(next);
+    }
+  }
+  anchor_i = anchor_j = anchor_k = anchor_l = -1;
+};

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

@@ -0,0 +1,342 @@
+#pragma once
+
+// Explicit test builds only. No production snapshots, serializers or runtime
+// provider selectors are installed by these mathematical-oracle entry points.
+#ifdef SYNKIT_MAPPER_TEST_HOOKS
+#include <iomanip>
+#include <set>
+#include <sstream>
+
+namespace synkit_mapper {
+namespace sparse_root_lp {
+inline Problem test_problem(int n, const int64_t *a, const int64_t *b,
+                            const int32_t *tr, const int32_t *tp) {
+  Problem p{};
+  p.abi_version = 1;
+  p.n = n;
+  p.a2 = a;
+  p.b2 = b;
+  p.types_r = tr;
+  p.types_p = tp;
+  return p;
+}
+
+template <class Values>
+void test_array(std::ostream &out, const Values &values) {
+  out << '[';
+  for (size_t i = 0; i < values.size(); ++i) {
+    if (i)
+      out << ',';
+    out << values[i];
+  }
+  out << ']';
+}
+
+inline void test_model_json(std::ostream &out, const PreparedModel &m) {
+  out << "{\"valid\":true,\"n\":" << m.n << ",\"constant\":" << m.constant
+      << ",\"mass\":" << m.mass << ",\"gcd\":" << m.gcd
+      << ",\"scale\":" << certificate_scale << ",\"objective_coefficients\":";
+  test_array(out, m.costs);
+  out << ",\"constraints\":[";
+  for (size_t r = 0; r < m.rows.size(); ++r) {
+    if (r)
+      out << ',';
+    const auto &row = m.rows[r];
+    out << "{\"rhs\":" << row.rhs
+        << ",\"equal\":" << (row.equality ? "true" : "false") << ",\"coeff\":[";
+    for (size_t k = 0; k < row.terms.size(); ++k) {
+      if (k)
+        out << ',';
+      out << '[' << row.terms[k].column << ',' << row.terms[k].coefficient
+          << ']';
+    }
+    out << "]}";
+  }
+  std::vector<std::string> keys(m.costs.size());
+  for (int i : m.variable_rows)
+    for (int j : m.domains[i])
+      keys[m.assignment[i * m.n + j]] =
+          "[\"x\"," + std::to_string(i) + ',' + std::to_string(j) + ']';
+  for (const auto &z : m.products) {
+    const auto &e = m.source_edges[z.e];
+    keys[z.index] = "[\"y\"," + std::to_string(e.i) + ',' +
+                    std::to_string(e.k) + ',' + std::to_string(z.left) + ',' +
+                    std::to_string(z.right) + ']';
+  }
+  for (size_t e = 0; e < m.source_totals.size(); ++e)
+    if (m.source_totals[e] >= 0)
+      keys[m.source_totals[e]] = "[\"ts\"," +
+                                 std::to_string(m.source_edges[e].i) + ',' +
+                                 std::to_string(m.source_edges[e].k) + ']';
+  for (size_t e = 0; e < m.target_totals.size(); ++e)
+    if (m.target_totals[e] >= 0)
+      keys[m.target_totals[e]] = "[\"tt\"," +
+                                 std::to_string(m.target_edges[e].i) + ',' +
+                                 std::to_string(m.target_edges[e].k) + ']';
+  out << "],\"keys\":[";
+  for (size_t i = 0; i < keys.size(); ++i) {
+    if (i)
+      out << ',';
+    out << keys[i];
+  }
+  out << "]}";
+}
+
+#if defined(__SIZEOF_INT128__)
+inline void test_certificate_json(std::ostream &out,
+                                  const IntegerCertificate &certificate) {
+  out << "{\"valid\":true,\"scale\":" << certificate_scale
+      << ",\"integer_box_bound_numerator\":" << decimal(certificate.numerator)
+      << ",\"rounded_original_lattice_bound2\":" << certificate.bound2
+      << ",\"bound2\":" << certificate.bound2 << ",\"dual\":";
+  test_array(out, certificate.dual);
+  out << '}';
+}
+#endif
+} // namespace sparse_root_lp
+} // namespace synkit_mapper
+
+extern "C" const char *synkit_test_lp_model_json(int n, const int64_t *a,
+                                                 const int64_t *b,
+                                                 const int32_t *tr,
+                                                 const int32_t *tp) {
+  using namespace synkit_mapper::sparse_root_lp;
+  static thread_local std::string text;
+  try {
+    auto model = build_model(test_problem(n, a, b, tr, tp), [] {});
+    if (!model)
+      throw std::invalid_argument("Invalid LP model");
+    std::ostringstream out;
+    test_model_json(out, *model);
+    text = out.str();
+  } catch (...) {
+    text = "{\"valid\":false}";
+  }
+  return text.c_str();
+}
+
+extern "C" const char *synkit_test_lp_incumbent_point_json(
+    int n, const int64_t *a, const int64_t *b, const int32_t *tr,
+    const int32_t *tp, const int32_t *mapping, int64_t cost,
+    double seconds) {
+  using namespace synkit_mapper;
+  using namespace synkit_mapper::sparse_root_lp;
+  static thread_local std::string text;
+#if defined(__SIZEOF_INT128__)
+  try {
+    if (n < 1 || !mapping || !std::isfinite(seconds) || seconds < 0)
+      throw std::invalid_argument("Invalid seed point arguments");
+    Request request{};
+    request.seconds = seconds > 0 ? seconds : -1;
+    Budget budget(request);
+    auto check = [&] { budget.check(); };
+    auto problem = test_problem(n, a, b, tr, tp);
+    auto model = build_model(problem, check);
+    std::vector<int64_t> point;
+    if (!model || !embed_incumbent(problem, *model,
+                                   std::vector<int32_t>(mapping, mapping + n),
+                                   cost, point, check))
+      throw std::invalid_argument("Invalid incumbent point");
+    std::ostringstream out;
+    out << "{\"valid\":true,\"point\":";
+    test_array(out, point);
+    out << ",\"model\":";
+    test_model_json(out, *model);
+#if defined(SYNKIT_MAPPER_WITH_ORTOOLS)
+    std::vector<double> initial_dual;
+    const bool dual_ready = make_initial_dual(*model, initial_dual, check);
+    out << std::setprecision(17);
+    out << ",\"initial_dual_ready\":" << (dual_ready ? "true" : "false");
+    if (dual_ready) {
+      out << ",\"initial_dual\":";
+      test_array(out, initial_dual);
+      out << ",\"initial_certificate\":";
+      test_certificate_json(out, certify_proposal(*model, initial_dual, check));
+    }
+    if (seconds > 0) {
+      PDLPProvider provider(model->costs, model->rows, model->constant, check);
+      provider.set_initial_primal(point, check, dual_ready ? &initial_dual : nullptr);
+      provider.solve(budget.remaining() * 0.8, cost, 2 * model->gcd);
+      auto certificate = certify_proposal(*model, provider.dual(), check);
+      out << ",\"certificate\":";
+      test_certificate_json(out, certificate);
+      out << ",\"provider_reason\":" << provider.reason;
+    }
+#endif
+    out << '}';
+    text = out.str();
+  } catch (...) {
+    text = "{\"valid\":false}";
+  }
+#else
+  (void)n; (void)a; (void)b; (void)tr; (void)tp; (void)mapping;
+  (void)cost; (void)seconds;
+  text = "{\"valid\":false,\"wide_arithmetic_available\":false}";
+#endif
+  return text.c_str();
+}
+
+extern "C" const char *synkit_test_lp_integer_certificate_json(
+    int n, const int64_t *a, const int64_t *b, const int32_t *tr,
+    const int32_t *tp, const int64_t *dual, int count) {
+  using namespace synkit_mapper::sparse_root_lp;
+  static thread_local std::string text;
+#if defined(__SIZEOF_INT128__)
+  try {
+    auto model = build_model(test_problem(n, a, b, tr, tp), [] {});
+    if (!model || count < 0 || size_t(count) != model->rows.size() ||
+        (count && !dual))
+      throw std::invalid_argument("Invalid LP certificate");
+    std::vector<int64_t> proposed;
+    if (count)
+      proposed.assign(dual, dual + count);
+    auto checked = evaluate_integer_dual(*model, proposed, [] {});
+    std::ostringstream out;
+    test_certificate_json(out, checked);
+    text = out.str();
+  } catch (...) {
+    text = "{\"valid\":false}";
+  }
+#else
+  (void)n;
+  (void)a;
+  (void)b;
+  (void)tr;
+  (void)tp;
+  (void)dual;
+  (void)count;
+  text = "{\"valid\":false,\"wide_arithmetic_available\":false}";
+#endif
+  return text.c_str();
+}
+
+extern "C" const char *
+synkit_test_lp_default_certificate_json(int n, const int64_t *a,
+                                        const int64_t *b, const int32_t *tr,
+                                        const int32_t *tp, double seconds) {
+  using namespace synkit_mapper;
+  using namespace synkit_mapper::sparse_root_lp;
+  static thread_local std::string text;
+#if defined(SYNKIT_MAPPER_WITH_ORTOOLS) && defined(__SIZEOF_INT128__)
+  try {
+    if (!std::isfinite(seconds) || seconds <= 0)
+      throw std::invalid_argument("Invalid LP budget");
+    Request request{};
+    request.seconds = seconds;
+    Budget budget(request);
+    auto check = [&] { budget.check(); };
+    auto model = build_model(test_problem(n, a, b, tr, tp), check);
+    if (!model)
+      throw std::invalid_argument("Invalid LP model");
+    PDLPProvider provider(model->costs, model->rows, model->constant, check);
+    provider.solve(budget.remaining() * 0.8);
+    auto checked = certify_proposal(*model, provider.dual(), check);
+    std::ostringstream out;
+    test_certificate_json(out, checked);
+    text = out.str();
+    text.pop_back();
+    text += ",\"available\":true,\"threads\":1,\"provider_reason\":" +
+            std::to_string(provider.reason) + ",\"primal_dimension\":" +
+            std::to_string(provider.primal().size()) +
+            ",\"dual_dimension\":" + std::to_string(provider.dual().size()) +
+            ",\"solver_status_is_not_proof\":true}";
+  } catch (...) {
+    text = "{\"available\":true,\"valid\":false}";
+  }
+#else
+  (void)n;
+  (void)a;
+  (void)b;
+  (void)tr;
+  (void)tp;
+  (void)seconds;
+  text = "{\"available\":false,\"valid\":false}";
+#endif
+  return text.c_str();
+}
+#endif // SYNKIT_MAPPER_TEST_HOOKS
+
+#if defined(SYNKIT_MAPPER_TEST_HOOKS) && defined(__SIZEOF_INT128__)
+extern "C" const char *synkit_test_lp_assignment_certificate_json(
+    int n, const int64_t *a, const int64_t *b, const int32_t *tr,
+    const int32_t *tp, const int64_t *dual, int count,
+    const int32_t *partial, const int32_t *seed) {
+  using namespace synkit_mapper;
+  using namespace synkit_mapper::sparse_root_lp;
+  static thread_local std::string text;
+  try {
+    auto model = build_model(test_problem(n, a, b, tr, tp), [] {});
+    if (!model || !partial || count < 0 || size_t(count) != model->rows.size() ||
+        (count && !dual)) throw std::invalid_argument("Invalid assignment oracle");
+    std::vector<int64_t> proposed;
+    if (count) proposed.assign(dual, dual + count);
+    std::vector<Wide> reduced;
+    auto box = evaluate_integer_dual(*model, proposed, [] {}, &reduced);
+    auto certificate = AssignmentCertificate::build(*model, box, reduced, [] {});
+    if (!certificate.ready) throw std::invalid_argument("Unavailable assignment oracle");
+    Perm mapping(partial, partial + n), used(n, 0);
+    for (int i = 0; i < n; ++i) {
+      int j = mapping[i];
+      if (j < -1 || (j >= 0 && (j >= n || used[j]++ || tr[i] != tp[j])))
+        throw std::invalid_argument("Invalid partial injection");
+    }
+    std::ostringstream out;
+    out << "{\"valid\":true,\"n\":" << n << ",\"m\":" << certificate.m
+        << ",\"box_numerator\":" << decimal(box.numerator)
+        << ",\"base_numerator\":" << decimal(certificate.base)
+        << ",\"quantum\":" << decimal(certificate.quantum)
+        << ",\"root_bound2\":" << certificate.root_bound2
+        << ",\"conditional_bound2\":" << certificate.bound(mapping.data(), used.data())
+        << ",\"rows\":";
+    test_array(out, certificate.rows);
+    out << ",\"columns\":"; test_array(out, certificate.columns);
+    out << ",\"penalties\":"; test_array(out, certificate.penalties);
+    out << ",\"assignment_reduced\":[";
+    for (size_t i = 0; i < reduced.size(); ++i) {
+      if (i) out << ',';
+      out << decimal(reduced[i]);
+    }
+    out << ']';
+    if (seed) {
+      std::vector<int> aa(a, a + n*n), bb(b, b + n*n), cr(n), cp(n), order(n),
+          pred(n*n, 0), best(n), rg, pg;
+      std::map<int32_t, int> types;
+      std::set<int> levels(aa.begin(), aa.end());
+      levels.insert(bb.begin(), bb.end());
+      for (int i=0;i<n;++i) {
+        cr[i]=types.emplace(tr[i],types.size()).first->second;
+        cp[i]=types.emplace(tp[i],types.size()).first->second;
+        order[i]=i;
+      }
+      auto twins = [&](const std::vector<int> &matrix, const int32_t *labels,
+                       std::vector<int> &generators) {
+        for (int i=0;i<n;++i) for(int j=i+1;j<n;++j) {
+          if(labels[i]!=labels[j]) continue;
+          bool equal=true;
+          for(int k=0;k<n;++k)
+            if(k!=i && k!=j && matrix[i*n+k]!=matrix[j*n+k]) equal=false;
+          if(!equal) continue;
+          Perm g(n); std::iota(g.begin(),g.end(),0); std::swap(g[i],g[j]);
+          generators.insert(generators.end(),g.begin(),g.end());
+        }
+      };
+      twins(aa,tr,rg);twins(bb,tp,pg);
+      int best4=0;int64_t statistics[6]={};
+      int status=native_minimum_impl(n,types.size(),levels.size()-1,2.0,
+          aa.data(),bb.data(),cr.data(),cp.data(),order.data(),pred.data(),
+          pg.data(),pg.size()/n,rg.data(),rg.size()/n,seed,best.data(),&best4,
+          statistics,0,0,false,int(2*std::max(int64_t(0),certificate.root_bound2)),
+          nullptr,nullptr,nullptr,
+          +[](const int *mapping,const int *used,int,void *pointer) {
+            return static_cast<AssignmentCertificate *>(pointer)->bound(mapping,used);
+          },&certificate);
+      out << ",\"search_status\":" << status << ",\"minimum2\":" << best4/2
+          << ",\"mapping\":";test_array(out,best);
+    }
+    out << '}';text=out.str();
+  } catch (const std::exception &e) {
+    text="{\"valid\":false}";
+  }
+  return text.c_str();
+}
+#endif

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

@@ -0,0 +1,137 @@
+// Private to bridge.cpp; not a standalone translation unit.
+namespace synkit_mapper {
+namespace {
+struct ReducedBlocks {
+  std::vector<int64_t> a, b;
+  int64_t offset = 0;
+};
+ReducedBlocks reduce_constant_blocks(const Problem &p, Budget &budget) {
+  const int n = p.n;
+  struct Block {
+    int64_t amin = INT64_MAX, amax = -1, bmin = INT64_MAX, bmax = -1;
+  };
+  std::map<int32_t, int> registry;
+  Perm tr(n), tp(n);
+  for (int i = 0; i < n; ++i) {
+    tr[i] = registry.emplace(p.types_r[i], registry.size()).first->second;
+    tp[i] = registry.emplace(p.types_p[i], registry.size()).first->second;
+  }
+  const int nt = registry.size();
+  Perm balance(nt, 0);
+  for (int i = 0; i < n; ++i) {
+    ++balance[tr[i]];
+    --balance[tp[i]];
+  }
+  if (std::any_of(balance.begin(), balance.end(), [](int x) { return x != 0; }))
+    throw std::invalid_argument("Unbalanced reduction types");
+  std::vector<Block> blocks(nt * nt);
+  auto index = [&](int a, int b) {
+    if (a > b)
+      std::swap(a, b);
+    return a * nt + b;
+  };
+  for (int i = 0; i < n; ++i) {
+    budget.check();
+    for (int j = i + 1; j < n; ++j) {
+      auto &left = blocks[index(tr[i], tr[j])];
+      auto &right = blocks[index(tp[i], tp[j])];
+      left.amin = std::min(left.amin, p.a2[i * n + j]);
+      left.amax = std::max(left.amax, p.a2[i * n + j]);
+      right.bmin = std::min(right.bmin, p.b2[i * n + j]);
+      right.bmax = std::max(right.bmax, p.b2[i * n + j]);
+    }
+  }
+  ReducedBlocks result;
+  result.a.assign(n * n, 0);
+  result.b.assign(n * n, 0);
+  for (int i = 0; i < n; ++i) {
+    budget.check();
+    for (int j = i + 1; j < n; ++j) {
+      const auto &left = blocks[index(tr[i], tr[j])];
+      const auto &right = blocks[index(tp[i], tp[j])];
+      int64_t a = 0, b = 0;
+      if (left.bmin == left.bmax)
+        result.offset += std::abs(p.a2[i * n + j] - left.bmin);
+      else if (left.amin != left.amax)
+        a = p.a2[i * n + j] - std::min(left.amin, left.bmin);
+      if (right.bmin != right.bmax && right.amin == right.amax)
+        result.offset += std::abs(p.b2[i * n + j] - right.amin);
+      else if (right.bmin != right.bmax && right.amin != right.amax)
+        b = p.b2[i * n + j] - std::min(right.amin, right.bmin);
+      result.a[i * n + j] = result.a[j * n + i] = a;
+      result.b[i * n + j] = result.b[j * n + i] = b;
+    }
+  }
+  std::set<int64_t> levels(result.a.begin(), result.a.end());
+  levels.insert(result.b.begin(), result.b.end());
+  if (levels.size() > 16) {
+    // Removing constant-opposite blocks cannot enlarge the old alphabet.
+    // If centering would exceed the kernel's alphabet, omit centering only.
+    for (int i = 0; i < n; ++i) {
+      budget.check();
+      for (int j = i + 1; j < n; ++j) {
+        const auto &left = blocks[index(tr[i], tr[j])];
+        const auto &right = blocks[index(tp[i], tp[j])];
+        result.a[i * n + j] = result.a[j * n + i] =
+            (left.amin != left.amax && left.bmin != left.bmax) ? p.a2[i * n + j]
+                                                               : 0;
+        result.b[i * n + j] = result.b[j * n + i] =
+            (right.amin != right.amax && right.bmin != right.bmax)
+                ? p.b2[i * n + j]
+                : 0;
+      }
+    }
+  }
+  return result;
+}
+struct RestoreOriginalScore {
+  Statistics &s;
+  int64_t offset;
+  double preparation;
+  ~RestoreOriginalScore() {
+    s.model_seconds += preparation;
+    if (s.minimum2 >= 0)
+      s.minimum2 += offset;
+    if (s.incumbent2 >= 0)
+      s.incumbent2 += offset;
+    if (s.lower_bound2 >= 0)
+      s.lower_bound2 += offset;
+    if (offset) {
+      std::array<int32_t, 1024> mapping;
+      int64_t cost = -1;
+      int proven = 0;
+      int n =
+          synkit_mapper_last_pmcd_witness(mapping.data(), 1024, &cost, &proven);
+      if (n > 0 && proven)
+        synkit_mapper_store_pmcd_witness(n, mapping.data(), cost + offset,
+                                         proven);
+    }
+  }
+};
+} // namespace
+int solve_pabs(const Problem &p, const Request &r, Callback callback,
+               void *userdata, Statistics &s) {
+  // Only numeric proof uses the larger objective-equivalence group. Exact
+  // enumeration keeps the original chemical endpoint groups and class keys.
+  if (r.query != SYNKIT_MINIMUM_PROOF || p.n > 512)
+    return solve_pabs_original(p, r, callback, userdata, s);
+  synkit_mapper_clear_pmcd_witness();
+  const auto started = Clock::now();
+  Budget budget(r);
+  budget.check();
+  auto reduced = reduce_constant_blocks(p, budget);
+  budget.check();
+  Problem q = p;
+  q.a2 = reduced.a.data();
+  q.b2 = reduced.b.data();
+  // These are objective symmetries only: the raw chemical classes are never
+  // quotiented by a graph with removed cost-constant edges.
+  q.node_colors_r = q.node_colors_p = nullptr;
+  q.edge_colors_r = q.edge_colors_p = nullptr;
+  Request remaining = r;
+  if (r.seconds >= 0)
+    remaining.seconds = std::max(0.0, budget.remaining());
+  RestoreOriginalScore restore{s, reduced.offset, elapsed(started)};
+  return solve_pabs_original(q, remaining, callback, userdata, s);
+}
+} // namespace synkit_mapper