synkit 1.6.5__py3-none-win_amd64.whl

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/core/runtime.h

@@ -0,0 +1,130 @@
+#ifndef SYNKIT_MAPPER_RUNTIME_H
+#define SYNKIT_MAPPER_RUNTIME_H
+
+#include "synkit_mapper/mapper.h"
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <cmath>
+#include <map>
+#include <stdexcept>
+#include <vector>
+
+namespace synkit_mapper {
+using Clock = std::chrono::steady_clock;
+struct Cancellation {
+  std::atomic<bool> requested{false};
+};
+struct Stop {
+  int reason;
+};
+inline double elapsed(Clock::time_point start) {
+  return std::chrono::duration<double>(Clock::now() - start).count();
+}
+inline bool cancelled(const Request &r) {
+  return r.cancel_token && static_cast<Cancellation *>(r.cancel_token)
+                               ->requested.load(std::memory_order_relaxed);
+}
+class Budget {
+public:
+  explicit Budget(const Request &request)
+      : request_(request), start_(Clock::now()) {}
+  double remaining() const {
+    return request_.seconds < 0
+               ? 1e100
+               : std::max(0.0, request_.seconds - elapsed(start_));
+  }
+  double seconds() const { return elapsed(start_); }
+  int reason() const {
+    if (cancelled(request_))
+      return SYNKIT_STOP_CANCELLED;
+    return remaining() == 0 ? SYNKIT_STOP_TIME : SYNKIT_STOP_NONE;
+  }
+  void check() const {
+    int r = reason();
+    if (r)
+      throw Stop{r};
+  }
+
+private:
+  const Request &request_;
+  Clock::time_point start_;
+};
+inline void initialize(Statistics &s, const Request &r) {
+  s = {};
+  s.abi_version = 1;
+  s.backend = r.backend;
+  s.minimum2 = s.incumbent2 = s.lower_bound2 = -1;
+  s.class_count = s.labeled_count = s.peak_memory_bytes = -1;
+  s.classification_complete = r.classify == 0;
+  s.hydrogen_complete = 1;
+}
+inline void stopped(Statistics &s, int reason) {
+  s.status = SYNKIT_LIMIT;
+  s.reason = reason;
+  s.search_complete = 0;
+}
+inline int unsupported(Statistics &s) {
+  s.status = SYNKIT_UNSUPPORTED;
+  s.reason = SYNKIT_STOP_UNSUPPORTED;
+  s.search_complete = 0;
+  return 0;
+}
+inline int64_t mapping_cost2(const Problem &p,
+                             const std::vector<int32_t> &map) {
+  if (static_cast<int>(map.size()) != p.n)
+    throw std::invalid_argument("Wrong mapping size");
+  std::vector<bool> used(p.n, false);
+  for (int i = 0; i < p.n; ++i) {
+    int j = map[i];
+    if (j < 0 || j >= p.n || used[j] || p.types_r[i] != p.types_p[j])
+      throw std::invalid_argument("Incompatible atom bijection");
+    used[j] = true;
+  }
+  int64_t cost = 0;
+  for (int i = 0; i < p.n; ++i)
+    for (int k = i + 1; k < p.n; ++k)
+      cost += std::abs(p.a2[i * p.n + k] - p.b2[map[i] * p.n + map[k]]);
+  return cost;
+}
+inline void validate(const Problem &p, const Request &r) {
+  if (p.abi_version != 1 || r.abi_version != 1 || p.n < 1 || p.n > 1024 ||
+      !p.a2 || !p.b2 || !p.types_r || !p.types_p)
+    throw std::invalid_argument("Invalid core problem ABI or dimensions");
+  if (r.backend < 0 || r.backend > SYNKIT_SEPDP || r.query < 0 || r.query > 3 ||
+      r.workers != 1 || (r.symmetry != 0 && r.symmetry != 1) ||
+      (r.classify != 0 && r.classify != 1) || !std::isfinite(r.seconds) ||
+      (r.seconds < 0 && r.seconds != -1) ||
+      ((r.query == SYNKIT_EXACT_DISTANCE ||
+        r.query == SYNKIT_AT_MOST_DISTANCE) &&
+       r.target2 < 0))
+    throw std::invalid_argument("Invalid core request");
+  for (int64_t cap : {r.max_states, r.max_candidates, r.max_classes,
+                      r.max_frontier, r.memory_limit_bytes})
+    if (cap == 0 || cap < -1)
+      throw std::invalid_argument("Core limits must be positive or -1");
+  std::map<int32_t, int> counts;
+  for (int i = 0; i < p.n; ++i) {
+    ++counts[p.types_r[i]];
+    --counts[p.types_p[i]];
+    if (p.a2[i * p.n + i] || p.b2[i * p.n + i])
+      throw std::invalid_argument("Core matrices must be loop free");
+    for (int j = 0; j < p.n; ++j) {
+      auto a = p.a2[i * p.n + j], b = p.b2[i * p.n + j];
+      if (a < 0 || b < 0 || a > 1000000 || b > 1000000 ||
+          a != p.a2[j * p.n + i] || b != p.b2[j * p.n + i])
+        throw std::invalid_argument(
+            "Core weights must be bounded nonnegative symmetric integers");
+      if ((p.edge_colors_r &&
+           p.edge_colors_r[i * p.n + j] != p.edge_colors_r[j * p.n + i]) ||
+          (p.edge_colors_p &&
+           p.edge_colors_p[i * p.n + j] != p.edge_colors_p[j * p.n + i]))
+        throw std::invalid_argument("Class edge attributes must be symmetric");
+    }
+  }
+  for (auto [type, count] : counts)
+    if (count)
+      throw std::invalid_argument("Unequal compatible atom inventories");
+}
+} // namespace synkit_mapper
+#endif

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/hydrogen/hydrogen.h

@@ -0,0 +1,73 @@
+#ifndef SYNKIT_MAPPER_HYDROGEN_H
+#define SYNKIT_MAPPER_HYDROGEN_H
+#include "synkit_mapper/mapper.h"
+#include "synkit_mapper/symmetry/classification.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Additive hydrogen ABI1. Metadata uses original full endpoint indices.
+ * Objective matrices already contain forced electron anchors; neutral terminal
+ * H has exactly one weight2=2 edge and no additional electron cost. */
+typedef struct SynkitHydrogenAttributes {
+  const int32_t *atomic_numbers_r,*atomic_numbers_p;
+  const int32_t *isotopes_r,*isotopes_p;
+  const int32_t *charges_r,*charges_p;
+  const int32_t *radicals_r,*radicals_p;
+  const int32_t *dummies_r,*dummies_p;
+  const int32_t *stereo_r,*stereo_p;
+} SynkitHydrogenAttributes;
+enum SynkitHydrogenEligibility {
+  SYNKIT_H_SUPPORTED=0,SYNKIT_H_NO_HYDROGEN=1,SYNKIT_H_ISOTOPE=2,
+  SYNKIT_H_STEREO=3,SYNKIT_H_DUMMY_BOND=4,SYNKIT_H_ELECTRON_STATE=5,
+  SYNKIT_H_NONTERMINAL=6,SYNKIT_H_BOND_STATE=7,SYNKIT_H_CLASS_ATTRIBUTES=8,
+  SYNKIT_H_REDUCED_BACKEND=9
+};
+typedef struct SynkitHydrogenStatistics {
+  int32_t supported,eligibility_reason,transport_complete,reason;
+  int64_t full_nodes,quotient_nodes,heavy_candidates,transport_plans,transport_nodes;
+  double reduction_seconds,heavy_seconds,transport_seconds;
+} SynkitHydrogenStatistics;
+typedef struct SynkitHydrogenTransportStatistics {
+  int64_t minimum2,plans,nodes;
+  int32_t complete,reason;
+  double elapsed_seconds;
+} SynkitHydrogenTransportStatistics;
+/* Flow cells are groups*groups, row-major. Their exact labeled multiplicity
+ * is decimal text, not a saturated int64. Costs are doubled CD. */
+typedef int (*SynkitHydrogenTransportCallback)(const int32_t *cells,int64_t cost2,
+                                             const char *multiplicity,void *);
+SYNKIT_MAPPER_API int synkit_mapper_hydrogen_abi(void);
+SYNKIT_MAPPER_API const char *synkit_mapper_hydrogen_error(void);
+/* reservoir=-1 means all groups are real parents; otherwise it is the single
+ * isolated dummy-H group. Queries use the shared minimum/exact/at-most enum.
+ * Caps are -1 unlimited or positive. minimum2 ignores dummy-reservoir edges. */
+SYNKIT_MAPPER_API int synkit_mapper_hydrogen_transport(
+    int groups,const int32_t *rows,const int32_t *columns,int reservoir,int query,
+    int64_t target2,double seconds,int64_t max_plans,int64_t max_nodes,void *cancel_token,
+    SynkitHydrogenTransportCallback,void *,SynkitHydrogenTransportStatistics *);
+/* Request.backend chooses the reduced heavy solver. Unsupported H states
+ * return UNSUPPORTED + eligibility_reason; no implicit full-search fallback.
+ * Numeric queries use a heavy minimum-H lower envelope and enumerate all
+ * bounded H allocations. max_candidates counts lifted flow representatives.
+ * memory_limit_bytes retains the selected heavy backend's accounted units;
+ * H/class intermediate buffers and RSS are outside those units. */
+SYNKIT_MAPPER_API int synkit_mapper_hydrogen_solve(
+    const SynkitMapperProblem *,const SynkitHydrogenAttributes *,const SynkitMapperRequest *,
+    int64_t max_transport_plans,SynkitMapperCallback,void *,SynkitMapperStatistics *,
+    SynkitHydrogenStatistics *);
+SYNKIT_MAPPER_API int synkit_mapper_hydrogen_solve_classified(
+    const SynkitMapperProblem *,const SynkitHydrogenAttributes *,const SynkitMapperRequest *,
+    const SynkitClassProblem *,int64_t max_transport_plans,int64_t max_canonical_nodes,
+    SynkitClassCallback,void *,SynkitMapperStatistics *,SynkitHydrogenStatistics *,
+    SynkitClassStatistics *);
+/* Additive first-discovery/cumulative-count delivery. See the classification
+ * update API; legacy hydrogen classified callbacks remain final batch counts. */
+SYNKIT_MAPPER_API int synkit_mapper_hydrogen_solve_classified_updates(
+    const SynkitMapperProblem *,const SynkitHydrogenAttributes *,const SynkitMapperRequest *,
+    const SynkitClassProblem *,int64_t max_transport_plans,int64_t max_canonical_nodes,
+    SynkitClassCallback,void *,SynkitMapperStatistics *,SynkitHydrogenStatistics *,
+    SynkitClassStatistics *);
+#ifdef __cplusplus
+}
+#endif
+#endif

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/mapper.h

@@ -0,0 +1,175 @@
+#ifndef SYNKIT_MAPPER_CORE_H
+#define SYNKIT_MAPPER_CORE_H
+
+#include "synkit_mapper/slap.h"
+#include <stdint.h>
+
+// Additive core ABI; the original SLAP ABI1 and PABS ABI3 remain separate.
+#define SYNKIT_MAPPER_CORE_ABI 1
+
+enum SynkitBackend {
+  SYNKIT_SLAP = 0,
+  SYNKIT_PABS = 1,
+  SYNKIT_CP_SAT = 2,
+  SYNKIT_SCIP = 3,
+  SYNKIT_MAXSAT = 4,
+  SYNKIT_ASTAR = 5,
+  SYNKIT_CPABS = 6,
+  SYNKIT_ABB = 7,
+  SYNKIT_KBB = 8,
+  SYNKIT_KMILP = 9,
+  SYNKIT_EDIT = 10,
+  SYNKIT_DFS = 11,
+  SYNKIT_MCES = 12,
+  SYNKIT_SEPDP = 13
+};
+enum SynkitQuery {
+  SYNKIT_MINIMUM_CLASSES = 0,
+  SYNKIT_EXACT_DISTANCE = 1,
+  SYNKIT_AT_MOST_DISTANCE = 2,
+  SYNKIT_MINIMUM_PROOF = 3
+};
+enum SynkitRunStatus {
+  SYNKIT_FINISHED = 0,
+  SYNKIT_LIMIT = 1,
+  SYNKIT_UNSUPPORTED = 2,
+  SYNKIT_ERROR = 3
+};
+enum SynkitStopReason {
+  SYNKIT_STOP_NONE = 0,
+  SYNKIT_STOP_TIME = 1,
+  SYNKIT_STOP_STATES = 2,
+  SYNKIT_STOP_CANDIDATES = 3,
+  SYNKIT_STOP_CLASSES = 4,
+  SYNKIT_STOP_CALLBACK = 5,
+  SYNKIT_STOP_FRONTIER = 6,
+  SYNKIT_STOP_MEMORY = 7,
+  SYNKIT_STOP_UNSUPPORTED = 8,
+  SYNKIT_STOP_HEURISTIC = 9,
+  SYNKIT_STOP_CANCELLED = 10
+};
+
+typedef struct SynkitMapperProblem {
+  int32_t abi_version;
+  int32_t n;
+  // Actual objective matrices in doubled chemical-distance units. Unary
+  // electron/H terms, if encoded as forced anchors, are already in these.
+  const int64_t *a2;
+  const int64_t *b2;
+  const int32_t *types_r;
+  const int32_t *types_p;
+  // Optional extra endpoint attributes for symmetry/class identity. They are
+  // NOT hard matching restrictions. Palettes must be shared across endpoints.
+  const int32_t *node_colors_r;
+  const int32_t *node_colors_p;
+  const int32_t *edge_colors_r;
+  const int32_t *edge_colors_p;
+} SynkitMapperProblem;
+
+typedef struct SynkitMapperRequest {
+  int32_t abi_version;
+  int32_t backend;
+  int32_t query;
+  int32_t
+      symmetry; // 0 disabled, 1 verified subgroup; cPABS is its own backend.
+  int32_t
+      classify; // Reserved: 0 raw candidates, 1 requires native class support.
+  int32_t workers; // Primary common track requires one worker.
+  int64_t target2; // Numeric query threshold in doubled CD; otherwise ignored.
+  double seconds;  // -1 unlimited; shared deadline includes callback wall time.
+  int64_t max_states;
+  int64_t max_candidates;
+  int64_t max_classes;
+  int64_t max_frontier;
+  int64_t memory_limit_bytes;
+  int32_t slap_max_fingerprints;
+  const int32_t
+      *slap_stop_flags; // Optional original-label policy; not type IDs.
+  void *cancel_token;   // Created/freed through the core cancellation API.
+} SynkitMapperRequest;
+
+typedef struct SynkitMapperStatistics {
+  int32_t abi_version;
+  int32_t backend;
+  int32_t status;
+  int32_t reason;
+  int32_t minimum_proven;
+  int32_t search_complete;
+  int32_t classification_complete;
+  int32_t hydrogen_complete;
+  int32_t heuristic_finished;
+  int64_t minimum2;
+  int64_t incumbent2;
+  int64_t lower_bound2;
+  int64_t nodes;
+  int64_t leaves;
+  int64_t candidate_count;
+  int64_t class_count;
+  int64_t labeled_count;
+  int64_t peak_frontier;
+  int64_t peak_frontier_bytes;
+  int64_t peak_memory_bytes; // -1 unavailable, not a fabricated process RSS.
+  double model_seconds;
+  double optimization_seconds;
+  double
+      enumeration_seconds; // Includes callbacks; callback time also recorded.
+  double classification_seconds;
+  double callback_seconds;
+  double elapsed_seconds;
+} SynkitMapperStatistics;
+
+typedef int (*SynkitMapperCallback)(const int32_t *mapping, int64_t cost2,
+                                    void *userdata);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+SYNKIT_MAPPER_API int synkit_mapper_core_abi(void);
+SYNKIT_MAPPER_API uint64_t synkit_mapper_capabilities(void);
+SYNKIT_MAPPER_API const char *synkit_mapper_core_error(void);
+SYNKIT_MAPPER_API const char *synkit_mapper_backend_version(int backend);
+SYNKIT_MAPPER_API const char *synkit_mapper_backend_metadata(int backend);
+SYNKIT_MAPPER_API int synkit_mapper_solve(const SynkitMapperProblem *,
+                                          const SynkitMapperRequest *,
+                                          SynkitMapperCallback, void *,
+                                          SynkitMapperStatistics *);
+// Explicit row-major allowed-correspondence mask for restricted kernel
+// methods. Scope is the supplied domains, never a full-space proof by default.
+SYNKIT_MAPPER_API int synkit_mapper_solve_domains(
+    const SynkitMapperProblem *, const SynkitMapperRequest *, const uint8_t *,
+    SynkitMapperCallback, void *, SynkitMapperStatistics *);
+SYNKIT_MAPPER_API void *synkit_mapper_cancel_create(void);
+SYNKIT_MAPPER_API void synkit_mapper_cancel_request(void *);
+SYNKIT_MAPPER_API void synkit_mapper_cancel_free(void *);
+#ifdef __cplusplus
+}
+
+// Backend entry points are C++ functions inside the one library. The public C
+// dispatcher validates input, catches exceptions and translates error state.
+namespace synkit_mapper {
+using Problem = SynkitMapperProblem;
+using Request = SynkitMapperRequest;
+using Statistics = SynkitMapperStatistics;
+using Callback = SynkitMapperCallback;
+int solve_pabs(const Problem &, const Request &, Callback, void *,
+               Statistics &);
+int solve_ortools(const Problem &, const Request &, Callback, void *,
+                  Statistics &);
+int solve_maxsat(const Problem &, const Request &, Callback, void *,
+                 Statistics &);
+int solve_astar(const Problem &, const Request &, Callback, void *,
+                Statistics &);
+int solve_cpabs(const Problem &, const Request &, Callback, void *,
+                Statistics &);
+int solve_abb(const Problem &, const Request &, const uint8_t *, Callback,
+              void *, Statistics &);
+int solve_kernel_milp(const Problem &, const Request &, const uint8_t *,
+                      Callback, void *, Statistics &);
+int solve_edit_support(const Problem &, const Request &, Callback, void *,
+                       Statistics &);
+int solve_dfs(const Problem &, const Request &, Callback, void *, Statistics &);
+int solve_mces(const Problem &, const Request &, Callback, void *, Statistics &);
+int solve_sepdp(const Problem &, const Request &, Callback, void *, Statistics &);
+} // namespace synkit_mapper
+#endif
+#endif

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/mces/mces.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "synkit_mapper/mapper.h"
+namespace synkit_mapper {
+// Full-bijection weighted common-edge overlap, via size-n cliques of the
+// explicit compatible-correspondence association graph. Not binary-only MCES.
+int solve_mces(const Problem &, const Request &, Callback, void *,
+               Statistics &);
+const char *mces_run_metadata();
+} // namespace synkit_mapper

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/pabs/seed.h

@@ -0,0 +1,34 @@
+#ifndef SYNKIT_MAPPER_PABS_SEED_H
+#define SYNKIT_MAPPER_PABS_SEED_H
+
+#include "synkit_mapper/core/runtime.h"
+
+namespace synkit_mapper {
+namespace pabs {
+
+// Shared input-only feasible incumbent policy. The Problem must satisfy the
+// common validated weighted/type-compatible graph contract. Returns false,
+// without changing outputs, outside the legacy PABS seed domain: n<=512,
+// doubled edge weights<=1024, at most16 distinct edge values, combined endpoint
+// undirected edge mass<=500000. A caller with a broader domain must retain its
+// own supported seed policy rather than declaring its exact backend unsupported.
+//
+// On true, mapping is a full compatible bijection, incumbent2 is its separately
+// rescored pairwise cost, and lower_bound2 is ceil(profile-LAP minimum/2).
+// The LAP uses the unchanged legacy Hungarian tie rules. polish=false retains
+// just this profile assignment; true applies the existing eight swap passes
+// and bounded native-SLAP/mixed-start policy. No reference, hard domains or
+// optimality claim is introduced. All work shares the caller's Budget.
+//
+// Stop can interrupt preparation. Once a feasible initial map is available,
+// mapping/incumbent2/lower_bound2 are published and remain valid on Stop; before
+// that the outputs remain unchanged. The wall-limited policy does not promise
+// identical seed maps or costs across independent executions.
+bool prepare_seed(const Problem &problem, Budget &budget, bool polish,
+                  std::vector<int32_t> &mapping, int64_t &incumbent2,
+                  int64_t &lower_bound2, bool *original_profile_zero=nullptr);
+
+} // namespace pabs
+} // namespace synkit_mapper
+
+#endif

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/reaction/reaction.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "synkit_mapper/mapper.h"
+
+typedef struct SynkitReactionOptions {
+  int32_t abi_version;
+  int32_t explicit_hydrogens;
+  int32_t lewis_objective;
+  int32_t dummy_balance;
+  int32_t binary;
+  int32_t hydrogen_quotient;
+  int32_t empty_numeric_shell;
+  int64_t max_canonical_nodes;
+  int64_t max_hydrogen_plans;
+} SynkitReactionOptions;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+SYNKIT_MAPPER_API int synkit_mapper_reaction_abi(void);
+SYNKIT_MAPPER_API const char *synkit_mapper_reaction_error(void);
+SYNKIT_MAPPER_API const char *synkit_mapper_rdkit_version(void);
+// Entire parse -> objective -> native search/classification -> mapped-SMILES
+// pipeline. Returned UTF-8 JSON is owned by the caller and freed below.
+SYNKIT_MAPPER_API int synkit_mapper_reaction_solve(
+    const char *, const SynkitReactionOptions *, const SynkitMapperRequest *,
+    char **json_output);
+SYNKIT_MAPPER_API void synkit_mapper_reaction_free(char *);
+#ifdef __cplusplus
+}
+#endif

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/sepdp/sepdp.h

@@ -0,0 +1,21 @@
+#ifndef SYNKIT_MAPPER_SEPDP_H
+#define SYNKIT_MAPPER_SEPDP_H
+
+#include "synkit_mapper/mapper.h"
+
+typedef struct SynkitSepDPProfile {
+  int64_t separator_width;
+  int64_t states;
+  int64_t predecessor_arcs;
+  int64_t transitions;
+  int64_t peak_accounted_table_bytes;
+} SynkitSepDPProfile;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+SYNKIT_MAPPER_API void synkit_mapper_sepdp_profile(SynkitSepDPProfile *);
+#ifdef __cplusplus
+}
+#endif
+#endif

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/slap.h

@@ -0,0 +1,72 @@
+#ifndef SYNKIT_MAPPER_SLAP_H
+#define SYNKIT_MAPPER_SLAP_H
+
+#include <stdint.h>
+
+#if defined(_WIN32)
+#define SYNKIT_MAPPER_API __declspec(dllexport)
+#else
+#define SYNKIT_MAPPER_API
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SlapStatistics {
+  int64_t states;
+  int64_t lap_calls;
+  int64_t fingerprints;
+  int64_t candidates;
+  // Sum of incident-neighborhood costs in doubled-edge units. For a finished
+  // singleton mapping this is twice its cost2. -1 means no finished candidate.
+  int64_t best_proxy2;
+  // Finished heuristic exploration is not a global optimum/completeness proof.
+  int32_t completed;
+  // 0 finished, 1 deadline, 2 state cap, 3 mapping cap, 4 callback stop.
+  int32_t reason;
+  double elapsed_seconds;
+  double callback_seconds;
+} SlapStatistics;
+
+typedef int (*SlapMappingCallback)(const int32_t *mapping, int64_t cost2,
+                                   void *userdata);
+
+SYNKIT_MAPPER_API int synkit_mapper_abi(void);
+SYNKIT_MAPPER_API const char *synkit_mapper_error(void);
+
+// Dependency-free deterministic weighted SLAP. A2/B2 are dense, symmetric,
+// loop-free nonnegative matrices in twice chemical-distance units. Labels
+// enforce original atom compatibility. The caller explicitly supplies the
+// original algorithm's stop-on-multiple policy per source atom; label IDs have
+// no special chemical meaning. n is 1..512. Negative seconds/caps must be -1,
+// meaning unlimited. Output is the best completed mappings reached by the
+// heuristic, never a claim to globally optimal/all-class enumeration.
+// The inherited stop-on-multiple policy can leave no completed bijection on
+// some graph inputs; this is reported explicitly rather than silently using
+// another heuristic or claiming infeasibility.
+//
+// All neighborhood refinement, structural-fingerprint exploration, component
+// filtering, LAP solving and noninteractive all-atom splitting run in C++.
+// Stable collision-free signature interning, a deterministic Hungarian tie
+// rule and native stable-WL split representatives distinguish this weighted
+// variant from Python's hash/tie-dependent implementation.
+//
+// Return 0 on a finished/interrupted run; -1 on invalid input/heuristic failure
+// or an internal error.
+// The thread-local error string remains valid until the next call in that
+// thread. Callbacks occur only for completed, independently rescored
+// bijections.
+SYNKIT_MAPPER_API int
+synkit_slap_solve(int n, const int64_t *a2, const int64_t *b2,
+                  const int32_t *labels_r, const int32_t *labels_p,
+                  const int32_t *stop_on_multiple_per_source_node,
+                  int max_fingerprints, double seconds, int64_t max_states,
+                  int64_t max_mappings, SlapMappingCallback callback,
+                  void *userdata, SlapStatistics *statistics);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

synkit/Chem/Mapper/solvers/native/cpp/include/synkit_mapper/solvers/solvers.h

@@ -0,0 +1,16 @@
+#ifndef SYNKIT_MAPPER_SOLVERS_H
+#define SYNKIT_MAPPER_SOLVERS_H
+#include "synkit_mapper/mapper.h"
+
+// Optional production adapters. Numerical SCIP proofs use the engine's
+// configured tolerances (zero requested relative/absolute optimality gap);
+// they are not independently checked formal certificates.
+namespace synkit_mapper {
+const char *ortools_solver_version(int backend);
+const char *maxsat_solver_version();
+const char *ortools_run_metadata();
+const char *maxsat_run_metadata();
+int solve_kernel_milp(const Problem &, const Request &, const uint8_t *,
+                      Callback, void *, Statistics &);
+} // namespace synkit_mapper
+#endif