synkit 1.6.5__py3-none-win_amd64.whl

synkit/CRN/cpp/structural.cpp

@@ -0,0 +1,240 @@
+// Exact minimal siphon/trap models: implication propagation and closure minimization.
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <sstream>
+#include <string>
+#include <unordered_set>
+#include <vector>
+namespace {
+using Mask = std::vector<std::uint64_t>;
+using Clock = std::chrono::steady_clock;
+struct Limit { const char* reason; };
+struct Hash {
+    std::size_t operator()(const Mask& mask) const {
+        std::size_t h=0;
+        for (auto w: mask) h ^= std::hash<std::uint64_t>{}(w)+0x9e3779b9+(h<<6)+(h>>2);
+        return h;
+    }
+};
+struct Search {
+    std::size_t n, words, transitions;
+    const std::uint64_t* trigger;
+    const std::uint64_t* required;
+    Clock::time_point deadline;
+    void check() const { if (deadline != Clock::time_point::max() && Clock::now() >= deadline) throw Limit{"time_limit"}; }
+    static bool nonempty(const Mask& mask) {
+        return std::any_of(mask.begin(), mask.end(), [](std::uint64_t w){return w!=0;});
+    }
+    Mask closure(Mask current) const {
+        bool changed=true;
+        while (changed) {
+            check(); changed=false;
+            for (std::size_t t=0; t<transitions; ++t) {
+                if ((t & 127) == 0) check();
+                bool hit=false, satisfied=false;
+                for (std::size_t w=0; w<words; ++w) {
+                    hit |= bool(trigger[t*words+w] & current[w]);
+                    satisfied |= bool(required[t*words+w] & current[w]);
+                }
+                if (hit && !satisfied) {
+                    for (std::size_t w=0; w<words; ++w) current[w] &= ~trigger[t*words+w];
+                    changed=true;
+                }
+            }
+        }
+        return current;
+    }
+};
+}
+extern "C" {
+int synkit_crn_structural_abi() { return 2; }
+int synkit_crn_structural_sets(std::size_t n, std::size_t transitions,
+                              const std::uint64_t* trigger, const std::uint64_t* required,
+                              double seconds, std::uint64_t max_nodes, std::size_t max_results,
+                              char** output) {
+    if (!output || !std::isfinite(seconds) || seconds < 0 || seconds > 1e9) return 2;
+    *output=nullptr;
+    Search search{n, (n+63)/64, transitions, trigger, required,
+        seconds == 0 ? Clock::time_point::max() :
+        Clock::now()+std::chrono::duration_cast<Clock::duration>(std::chrono::duration<double>(seconds))};
+    struct State { Mask selected, excluded; };
+    std::vector<Mask> results;
+    std::unordered_set<Mask,Hash> emitted;
+    std::uint64_t evaluations=0, states=0, closures=0;
+    std::size_t peak=0;
+    const char* reason="complete";
+    auto tick = [&]() {
+        search.check();
+        if (max_nodes && evaluations>=max_nodes) throw Limit{"node_limit"};
+        ++evaluations;
+    };
+    auto count = [](const Mask& mask) {
+        std::size_t total=0;
+        for (auto word: mask) {
+#if defined(__GNUC__) || defined(__clang__)
+            total += __builtin_popcountll(word);
+#else
+            while (word) { word &= word - 1; ++total; }
+#endif
+        }
+        return total;
+    };
+    try {
+        // Each minimal model has one least selected species. These roots and
+        // the ordered positive/negative branches partition the model space.
+        for (std::size_t seed=0; seed<n; ++seed) {
+            State root{Mask(search.words,0),Mask(search.words,0)};
+            root.selected[seed/64] |= std::uint64_t(1)<<(seed%64);
+            for (std::size_t p=0; p<seed; ++p)
+                root.excluded[p/64] |= std::uint64_t(1)<<(p%64);
+            std::vector<State> stack;
+            stack.push_back(std::move(root));
+            while (!stack.empty()) {
+                tick(); ++states;
+                State current=std::move(stack.back()); stack.pop_back();
+                bool conflict=false, changed=true;
+                while (changed && !conflict) {
+                    search.check(); changed=false;
+                    // An emitted minimal model blocks every strict superset.
+                    for (const auto& known: results) {
+                        bool blocked=false;
+                        Mask missing(search.words,0);
+                        for (std::size_t w=0; w<search.words; ++w) {
+                            blocked |= bool(known[w] & current.excluded[w]);
+                            missing[w] = known[w] & ~current.selected[w];
+                        }
+                        if (blocked) continue;
+                        auto remaining=count(missing);
+                        if (!remaining) { conflict=true; break; }
+                        if (remaining==1) {
+                            for (std::size_t w=0; w<search.words; ++w) {
+                                auto next=current.excluded[w] | missing[w];
+                                changed |= next != current.excluded[w];
+                                current.excluded[w]=next;
+                            }
+                        }
+                    }
+                    if (conflict) break;
+                    for (std::size_t t=0; t<transitions; ++t) {
+                        if ((t & 127)==0) search.check();
+                        bool hit=false, satisfied=false;
+                        Mask choices(search.words,0);
+                        for (std::size_t w=0; w<search.words; ++w) {
+                            hit |= bool(trigger[t*search.words+w] & current.selected[w]);
+                            satisfied |= bool(required[t*search.words+w] & current.selected[w]);
+                            choices[w]=required[t*search.words+w] & ~current.excluded[w];
+                        }
+                        if (satisfied) continue;
+                        auto available=count(choices);
+                        if (!available) {
+                            for (std::size_t w=0; w<search.words; ++w) {
+                                auto next=current.excluded[w] | trigger[t*search.words+w];
+                                changed |= next != current.excluded[w];
+                                current.excluded[w]=next;
+                            }
+                        } else if (hit && available==1) {
+                            for (std::size_t w=0; w<search.words; ++w) {
+                                auto next=current.selected[w] | choices[w];
+                                changed |= next != current.selected[w];
+                                current.selected[w]=next;
+                            }
+                        }
+                    }
+                    for (std::size_t w=0; w<search.words; ++w)
+                        conflict |= bool(current.selected[w] & current.excluded[w]);
+                }
+                if (conflict) continue;
+                Mask choices(search.words,0);
+                bool needs_branch=false;
+                std::size_t best=n+1;
+                for (std::size_t t=0; t<transitions; ++t) {
+                    bool hit=false, satisfied=false;
+                    Mask available(search.words,0);
+                    for (std::size_t w=0; w<search.words; ++w) {
+                        hit |= bool(trigger[t*search.words+w] & current.selected[w]);
+                        satisfied |= bool(required[t*search.words+w] & current.selected[w]);
+                        available[w]=required[t*search.words+w] & ~current.excluded[w];
+                    }
+                    if (hit && !satisfied && count(available)<best) {
+                        choices=std::move(available); best=count(choices); needs_branch=true;
+                    }
+                }
+                if (!needs_branch) {
+                    Mask minimal=current.selected;
+                    for (std::size_t p=0; p<n; ++p) {
+                        if (!(minimal[p/64] & (std::uint64_t(1)<<(p%64)))) continue;
+                        tick(); ++closures;
+                        Mask child=minimal;
+                        child[p/64] &= ~(std::uint64_t(1)<<(p%64));
+                        child=search.closure(std::move(child));
+                        if (Search::nonempty(child)) minimal=std::move(child);
+                    }
+                    if (emitted.insert(minimal).second) results.push_back(std::move(minimal));
+                    if (max_results && results.size()>=max_results &&
+                        (!stack.empty() || seed+1<n)) throw Limit{"result_limit"};
+                } else {
+                    // Choose one required member; earlier choices are false
+                    // in later alternatives, avoiding redundant unions.
+                    for (std::size_t p=0; p<n; ++p) {
+                        auto bit=std::uint64_t(1)<<(p%64);
+                        if (!(choices[p/64] & bit)) continue;
+                        State child=current;
+                        child.selected[p/64] |= bit;
+                        stack.push_back(std::move(child));
+                        current.excluded[p/64] |= bit;
+                    }
+                    peak=std::max(peak,stack.size());
+                }
+            }
+        }
+    } catch (const Limit& limit) { reason=limit.reason; }
+      catch (const std::bad_alloc&) { reason="allocation_failure"; }
+      catch (...) { return 2; }
+    try {
+        std::ostringstream out;
+        out << "{\"termination_reason\":\"" << reason
+            << "\",\"algorithm\":\"implication propagation and closure minimization\""
+            << ",\"search_evaluations\":" << evaluations
+            << ",\"states_explored\":" << states
+            << ",\"closure_evaluations\":" << closures
+            << ",\"peak_frontier\":" << peak << ",\"sets\":[";
+        for (std::size_t r=0; r<results.size(); ++r) {
+            if (r) out << ',';
+            out << '['; bool first=true;
+            for (std::size_t p=0; p<n; ++p) if (results[r][p/64] & (std::uint64_t(1)<<(p%64))) {
+                if (!first) out << ',';
+                first=false; out << p;
+            }
+            out << ']';
+        }
+        out << "]}";
+        auto text=out.str();
+        auto* buffer=static_cast<char*>(std::malloc(text.size()+1));
+        if (!buffer) return 2;
+        std::memcpy(buffer,text.c_str(),text.size()+1); *output=buffer;
+        return 0;
+    } catch (...) { return 2; }
+}
+}
+
+extern "C" int synkit_crn_exhaustive_siphons(std::size_t n,std::size_t transitions,
+ const std::uint64_t* pre,const std::uint64_t* post,double seconds,char** output){
+ if(!output||n>24||!std::isfinite(seconds)||seconds<=0||seconds>1e9)return 2;
+ *output=nullptr;auto deadline=Clock::now()+std::chrono::duration_cast<Clock::duration>(std::chrono::duration<double>(seconds));
+ std::vector<std::uint64_t> minimal;const char* reason="complete";std::uint64_t inspected=0;
+ try{
+  for(std::uint64_t mask=1;mask<(std::uint64_t(1)<<n);++mask){
+   if(Clock::now()>=deadline)throw Limit{"time_limit"};++inspected;bool valid=true;
+   for(std::size_t t=0;t<transitions;++t)if((post[t]&mask) && !(pre[t]&mask)){valid=false;break;}
+   if(!valid)continue;bool dominated=false;for(auto m:minimal)if((m&mask)==m){dominated=true;break;}
+   if(!dominated)minimal.push_back(mask);
+  }
+ }catch(const Limit& l){reason=l.reason;}catch(...){return 2;}
+ std::ostringstream out;out<<"{\"termination_reason\":\""<<reason<<"\",\"subsets\":"<<inspected<<",\"sets\":[";
+ for(std::size_t r=0;r<minimal.size();++r){if(r)out<<',';out<<'[';bool first=true;for(std::size_t i=0;i<n;++i)if(minimal[r]&(std::uint64_t(1)<<i)){if(!first)out<<',';first=false;out<<i;}out<<']';}out<<"]}";
+ auto text=out.str();auto* buffer=static_cast<char*>(std::malloc(text.size()+1));if(!buffer)return 2;std::memcpy(buffer,text.c_str(),text.size()+1);*output=buffer;return 0;
+}

synkit/CRN/cpp/symmetry.cpp

@@ -0,0 +1,45 @@
+#include "exact.h"
+#include <map>
+#include <numeric>
+#include <functional>
+using namespace crn_exact;
+extern "C" {
+int synkit_crn_symmetry_abi(){return 1;}
+int synkit_crn_symmetry(std::size_t n,const std::int64_t* kinds,const std::int64_t* adjacency,
+                       double seconds,std::size_t max_states,std::size_t max_count,char** output){
+ if(!output||!std::isfinite(seconds)||seconds<=0||seconds>1e9||!max_states||!max_count)return 2;*output=nullptr;Budget budget(seconds);
+ std::size_t states=0;Int count=0;std::vector<std::int64_t> best;std::vector<std::size_t> base,parent(n);std::iota(parent.begin(),parent.end(),0);
+ std::vector<std::vector<std::pair<std::size_t,std::int64_t>>> incoming(n),outgoing(n);
+ auto find=[&](std::size_t v){while(parent[v]!=v)v=parent[v];return v;};const char* reason="complete";
+ try{
+  for(std::size_t i=0;i<n;++i){budget.check();for(std::size_t j=0;j<n;++j)if(adjacency[i*n+j]){outgoing[i].push_back({j,adjacency[i*n+j]});incoming[j].push_back({i,adjacency[i*n+j]});}}
+  auto refine=[&](std::vector<std::int64_t> colors){
+   while(true){budget.check();std::vector<std::vector<std::int64_t>> signatures(n);std::map<std::vector<std::int64_t>,std::int64_t> ids;
+    for(std::size_t v=0;v<n;++v){auto& sig=signatures[v];sig.push_back(colors[v]);
+     for(auto* edges:{&incoming[v],&outgoing[v]}){std::vector<std::pair<std::int64_t,std::int64_t>> neighbors;for(auto edge:*edges)neighbors.push_back({colors[edge.first],edge.second});std::sort(neighbors.begin(),neighbors.end());sig.push_back(neighbors.size());for(auto pair:neighbors){sig.push_back(pair.first);sig.push_back(pair.second);}}
+     ids.emplace(sig,0);}
+    std::int64_t id=0;for(auto& entry:ids)entry.second=id++;
+    std::vector<std::int64_t> next;for(const auto& sig:signatures)next.push_back(ids[sig]);if(next==colors)return colors;colors=std::move(next);
+   }
+  };
+  std::function<void(std::vector<std::int64_t>)> visit=[&](std::vector<std::int64_t> colors){
+   budget.check();if(states>=max_states)throw Limit{"state_limit"};++states;colors=refine(std::move(colors));
+   std::map<std::int64_t,std::vector<std::size_t>> cells;for(std::size_t v=0;v<n;++v)cells[colors[v]].push_back(v);
+   std::vector<std::size_t> selected;for(const auto& entry:cells)if(entry.second.size()>1 && (selected.empty()||entry.second.size()<selected.size()))selected=entry.second;
+   if(!selected.empty()){
+    auto fresh=*std::max_element(colors.begin(),colors.end())+1;for(auto v:selected){auto next=colors;next[v]=fresh;visit(std::move(next));}return;
+   }
+   std::vector<std::size_t> order;for(const auto& entry:cells)order.push_back(entry.second[0]);
+   std::vector<std::int64_t> certificate;certificate.reserve(n+n*n);
+   for(auto v:order)certificate.push_back(kinds[v]);for(auto v:order)for(auto w:order)certificate.push_back(adjacency[v*n+w]);
+   if(base.empty() || certificate<best){best=std::move(certificate);base=order;count=1;std::iota(parent.begin(),parent.end(),0);}
+   else if(certificate==best){++count;for(std::size_t i=0;i<n;++i){auto a=find(base[i]),b=find(order[i]);if(a!=b)parent[b]=a;}}
+   if(count>=max_count)throw Limit{"count_limit"};
+  };
+  std::vector<std::int64_t> initial(kinds,kinds+n);visit(std::move(initial));
+ }catch(const Limit& limit){reason=limit.reason;}catch(const std::bad_alloc&){reason="allocation_failure";}catch(...){return 2;}
+ std::map<std::size_t,std::vector<std::size_t>> orbits;for(std::size_t v=0;v<n;++v)orbits[find(v)].push_back(v);
+ std::vector<std::vector<std::size_t>> groups;for(auto entry:orbits)groups.push_back(std::move(entry.second));
+ std::ostringstream out;out<<"{\"termination_reason\":\""<<reason<<"\",\"states\":"<<states<<",\"automorphism_count\":"<<count<<",\"order\":";vector_json(out,base);out<<",\"orbits\":";matrix_json(out,groups);out<<'}';return output_json(out.str(),output);
+}
+}

synkit/CRN/cpp/write_manifest.cmake

@@ -0,0 +1,28 @@
+# A CMake-built CRN library has the same sidecar contract as build_native().
+file(READ "${BUILD_METADATA}" metadata)
+string(JSON metadata SET "${metadata}" abi 1)
+if(EXACT_ENABLED)
+  string(JSON metadata SET "${metadata}" semiflows_abi 1)
+  string(JSON metadata SET "${metadata}" capabilities
+    "[\"closure\",\"structural_sets\",\"structural_unlimited\",\"exhaustive_siphons\",\"exact_semiflows\",\"exact_algebra\",\"crnt\",\"pathway\",\"symmetry\"]")
+else()
+  string(JSON metadata SET "${metadata}" semiflows_abi null)
+  string(JSON metadata SET "${metadata}" capabilities
+    "[\"closure\",\"structural_sets\",\"structural_unlimited\",\"exhaustive_siphons\"]")
+endif()
+string(JSON metadata SET "${metadata}" source_sha256 "{}")
+file(GLOB sources
+  "${SOURCE_DIR}/*.cpp" "${SOURCE_DIR}/*.h"
+  "${SOURCE_DIR}/*.cmake" "${SOURCE_DIR}/CMakeLists.txt")
+foreach(source IN LISTS sources)
+  file(SHA256 "${source}" digest)
+  get_filename_component(name "${source}" NAME)
+  string(JSON metadata SET "${metadata}" source_sha256 "${name}" "\"${digest}\"")
+endforeach()
+string(SHA256 digest "${metadata}")
+string(JSON metadata SET "${metadata}" build_sha256 "\"${digest}\"")
+file(SHA256 "${LIBRARY_FILE}" digest)
+string(JSON metadata SET "${metadata}" library_sha256 "\"${digest}\"")
+get_filename_component(directory "${LIBRARY_FILE}" DIRECTORY)
+get_filename_component(stem "${LIBRARY_FILE}" NAME_WE)
+file(WRITE "${directory}/${stem}.json" "${metadata}\n")

synkit/CRN/kinds.py

@@ -0,0 +1,137 @@
+"""Shared node-kind vocabulary for SynKit-CRN bipartite graphs.
+
+Every SynKit CRN graph is bipartite over *species* nodes and *reaction* nodes.
+Historically the two halves of the package disagreed about how a reaction node
+is spelled: the rule-expansion builder emits ``kind="rule"`` (a concrete rule
+application), while :meth:`SynCRN.from_digraph` also accepts and round-trips
+``kind="reaction"``. Modules that hard-coded a single spelling silently ignored
+the other, producing empty stoichiometric matrices rather than an error.
+
+This module is the single source of truth. Any code that classifies CRN graph
+nodes must use :func:`is_species_node` and :func:`is_reaction_node` rather than
+comparing the ``kind`` attribute directly.
+
+.. rubric:: Example
+
+.. code-block:: python
+
+    from synkit.CRN.kinds import is_reaction_node, REACTION_KINDS
+
+    print(sorted(REACTION_KINDS))
+    print(is_reaction_node({"kind": "reaction"}))
+    print(is_reaction_node({"kind": "rule"}))
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+__all__ = [
+    "KIND_ATTR",
+    "SPECIES_KIND",
+    "REACTION_KIND",
+    "RULE_KIND",
+    "SPECIES_KINDS",
+    "REACTION_KINDS",
+    "ALL_KINDS",
+    "node_kind",
+    "is_species_node",
+    "is_reaction_node",
+]
+
+#: Node attribute holding the kind discriminator.
+KIND_ATTR = "kind"
+
+#: Canonical spelling for species nodes.
+SPECIES_KIND = "species"
+
+#: Canonical spelling for reaction nodes.
+REACTION_KIND = "reaction"
+
+#: Legacy spelling for a concrete rule application, still emitted by
+#: :class:`~synkit.CRN.Construct.builder.CRNExpand` and preserved on round-trip.
+RULE_KIND = "rule"
+
+#: All accepted spellings for species nodes.
+SPECIES_KINDS = frozenset({SPECIES_KIND})
+
+#: All accepted spellings for reaction nodes.
+#:
+#: ``"rule"`` denotes a concrete reaction instance produced by applying a rule;
+#: it is *not* an abstract rule template. Abstract rules live in
+#: :class:`~synkit.CRN.Structure.rule.Rule` records and never become graph nodes.
+REACTION_KINDS = frozenset({REACTION_KIND, RULE_KIND})
+
+#: Every node kind recognised anywhere in the CRN package.
+ALL_KINDS = SPECIES_KINDS | REACTION_KINDS
+
+
+def node_kind(data: Mapping[str, Any]) -> str:
+    """Return the normalized node kind for a node-attribute mapping.
+
+    The value is lower-cased and stripped so that ``"Rule"``, ``" rule "`` and
+    ``"rule"`` compare equal. A missing ``kind`` yields the empty string.
+
+    :param data:
+        Node attribute mapping.
+    :type data: Mapping[str, Any]
+
+    :return:
+        Normalized kind string, or ``""`` when absent.
+    :rtype: str
+
+    .. rubric:: Example
+
+    .. code-block:: python
+
+        node_kind({"kind": " Rule "})
+        # 'rule'
+    """
+    return str(data.get(KIND_ATTR, "")).strip().lower()
+
+
+def is_species_node(data: Mapping[str, Any]) -> bool:
+    """Return whether a node-attribute mapping describes a species node.
+
+    :param data:
+        Node attribute mapping.
+    :type data: Mapping[str, Any]
+
+    :return:
+        ``True`` when the node is a species node.
+    :rtype: bool
+
+    .. rubric:: Example
+
+    .. code-block:: python
+
+        is_species_node({"kind": "species"})
+        # True
+    """
+    return node_kind(data) in SPECIES_KINDS
+
+
+def is_reaction_node(data: Mapping[str, Any]) -> bool:
+    """Return whether a node-attribute mapping describes a reaction node.
+
+    Both ``kind="reaction"`` and the legacy ``kind="rule"`` are accepted, since
+    both denote a concrete reaction instance.
+
+    :param data:
+        Node attribute mapping.
+    :type data: Mapping[str, Any]
+
+    :return:
+        ``True`` when the node is a reaction node.
+    :rtype: bool
+
+    .. rubric:: Example
+
+    .. code-block:: python
+
+        is_reaction_node({"kind": "rule"})
+        # True
+        is_reaction_node({"kind": "reaction"})
+        # True
+    """
+    return node_kind(data) in REACTION_KINDS

synkit/CRN/lib/synkit_crn.json

@@ -0,0 +1,33 @@
+{
+  "abi": 1,
+  "boost_version": 109200,
+  "build_sha256": "717100ca1a049cb769983ed578544a9b585a077c598848631e317bdbaf4eab85",
+  "capabilities": [
+    "closure",
+    "structural_sets",
+    "structural_unlimited",
+    "exhaustive_siphons",
+    "exact_semiflows",
+    "exact_algebra",
+    "crnt",
+    "pathway",
+    "symmetry"
+  ],
+  "compiler": "MSVC 19.51.36260.0",
+  "compiler_path": "C:/Program Files/Microsoft Visual Studio/18/Enterprise/VC/Tools/MSVC/14.51.36231/bin/Hostx64/x64/cl.exe",
+  "integrity": "wheel-record",
+  "platform": "win-amd64",
+  "root_cmake_sha256": "2c1433ff868633931a01066207978428cc29bb01660ae206d56458a62523f776",
+  "semiflows_abi": 1,
+  "source_sha256": {
+    "CMakeLists.txt": "3dec4ad1a8192f019329dd99629f8f80dc84ac7440de512ee7686111b33ceff5",
+    "algebra.cpp": "cbbbd7d54fe4f6816dbd61a4f1516facf69b3e560660099cb0c37f2724dcf5bb",
+    "closure.cpp": "135e14d375b161975e2363953f98195c180cff46bf1fb53100f5ff027e08ce18",
+    "exact.h": "31c4225e7636e468237b3d547fc546972b662bffc8a0f09ec0d877aec5d41462",
+    "pathway.cpp": "b06604694b97f398c982557d55d46161951cafe2feac9034ec39a73733bbf7b7",
+    "semiflows.cpp": "cf677624f399f45a4c62e5eaf4a2e29b2748de5edef6da82e006ccea87fb45c4",
+    "structural.cpp": "8ca653e5ce396ecab494740ee14f848927ceced1bcad4fbcdc2183166a39d06e",
+    "symmetry.cpp": "d5a14d49396d51f64a210784afb26ff8bad1b57241652d1dbfc67ebb8a268df0",
+    "write_manifest.cmake": "2b58e875b7c2719331375762013abff18ebc968cc7c61489439b69baced7d799"
+  }
+}