synkit 1.6.5__py3-none-win_amd64.whl

synkit/CRN/cpp/CMakeLists.txt

@@ -0,0 +1,58 @@
+cmake_minimum_required(VERSION 3.20)
+project(synkit_crn VERSION 1.6.5 LANGUAGES CXX)
+
+option(SYNKIT_CRN_EXACT "Build exact Boost-backed CRN analysis" ON)
+if(SYNKIT_CRN_EXACT)
+  find_path(SYNKIT_CRN_BOOST_INCLUDE_DIR boost/multiprecision/cpp_int.hpp
+    HINTS "$ENV{BOOST_INCLUDE_DIR}" "$ENV{BOOST_ROOT}"
+    PATH_SUFFIXES include)
+  if(NOT SYNKIT_CRN_BOOST_INCLUDE_DIR)
+    message(FATAL_ERROR "CRN exact analysis requires Boost headers. Set BOOST_INCLUDE_DIR to the directory containing boost/.")
+  endif()
+endif()
+
+add_library(synkit_crn SHARED closure.cpp structural.cpp)
+if(SYNKIT_CRN_EXACT)
+  target_sources(synkit_crn PRIVATE semiflows.cpp algebra.cpp pathway.cpp symmetry.cpp)
+  target_include_directories(synkit_crn PRIVATE "${SYNKIT_CRN_BOOST_INCLUDE_DIR}")
+endif()
+target_compile_features(synkit_crn PRIVATE cxx_std_17)
+set_target_properties(synkit_crn PROPERTIES
+  CXX_EXTENSIONS OFF
+  WINDOWS_EXPORT_ALL_SYMBOLS ON
+  POSITION_INDEPENDENT_CODE ON)
+set_property(TARGET synkit_crn APPEND PROPERTY LINK_DEPENDS
+  "${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt"
+  "${CMAKE_CURRENT_SOURCE_DIR}/write_manifest.cmake")
+if(MSVC)
+  target_compile_definitions(synkit_crn PRIVATE NOMINMAX WIN32_LEAN_AND_MEAN)
+  set_property(TARGET synkit_crn PROPERTY MSVC_RUNTIME_LIBRARY
+    "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+elseif(MINGW)
+  target_link_options(synkit_crn PRIVATE -static)
+endif()
+
+set(boost_version null)
+if(SYNKIT_CRN_EXACT)
+  file(STRINGS "${SYNKIT_CRN_BOOST_INCLUDE_DIR}/boost/version.hpp" boost_version
+    REGEX "^#define BOOST_VERSION [0-9]+$")
+  string(REGEX REPLACE ".* ([0-9]+)$" "\\1" boost_version "${boost_version}")
+endif()
+file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/crn-build.json" CONTENT
+  "{\"compiler\":\"${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}\",\"compiler_path\":\"${CMAKE_CXX_COMPILER}\",\"boost_version\":${boost_version}}\n")
+
+add_custom_command(TARGET synkit_crn POST_BUILD
+  COMMAND "${CMAKE_COMMAND}"
+    "-DLIBRARY_FILE=$<TARGET_FILE:synkit_crn>"
+    "-DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}"
+    "-DBUILD_METADATA=${CMAKE_CURRENT_BINARY_DIR}/crn-build.json"
+    "-DEXACT_ENABLED=${SYNKIT_CRN_EXACT}"
+    -P "${CMAKE_CURRENT_SOURCE_DIR}/write_manifest.cmake"
+  VERBATIM)
+
+install(TARGETS synkit_crn
+  LIBRARY DESTINATION synkit/CRN/lib
+  RUNTIME DESTINATION synkit/CRN/lib)
+install(FILES
+  "$<TARGET_FILE_DIR:synkit_crn>/$<TARGET_FILE_PREFIX:synkit_crn>$<TARGET_FILE_BASE_NAME:synkit_crn>.json"
+  DESTINATION synkit/CRN/lib)

synkit/CRN/cpp/algebra.cpp

@@ -0,0 +1,46 @@
+#include "exact.h"
+#include <map>
+#include <set>
+#include <functional>
+using namespace crn_exact;
+extern "C" {
+int synkit_crn_algebra_abi(){return 1;}
+int synkit_crn_matrix(std::size_t n,std::size_t m,const std::int64_t* input,int kernels,double seconds,char** output){
+ if(!output || !std::isfinite(seconds)||seconds<=0||seconds>1e9)return 2;*output=nullptr;Budget budget(seconds);
+ try{
+  Matrix s(n,std::vector<Rat>(m)),t(m,std::vector<Rat>(n));
+  for(std::size_t i=0;i<n;++i){budget.check();for(std::size_t j=0;j<m;++j)s[i][j]=t[j][i]=input[i*m+j];}
+  std::size_t rank=0;std::vector<std::vector<Int>> left,right;
+  if(kernels&1)left=kernel(t,n,budget,rank);else{auto copy=s;rank=rref(copy,m,budget).size();}
+  if(kernels&2){std::size_t ignored;right=kernel(s,m,budget,ignored);}
+  std::ostringstream out;out<<"{\"termination_reason\":\"complete\",\"rank\":"<<rank<<",\"left\":";matrix_json(out,left);out<<",\"right\":";matrix_json(out,right);out<<'}';return output_json(out.str(),output);
+ }catch(const Limit& l){return output_json(std::string("{\"termination_reason\":\"")+l.reason+"\"}",output);}catch(...){return 2;}
+}
+int synkit_crn_crnt(std::size_t n,std::size_t m,const std::int64_t* pre,const std::int64_t* post,double seconds,char** output){
+ if(!output || !std::isfinite(seconds)||seconds<=0||seconds>1e9)return 2;*output=nullptr;Budget budget(seconds);
+ try{
+  std::map<std::vector<std::int64_t>,std::size_t> index;std::vector<std::vector<std::int64_t>> complexes;
+  std::vector<std::pair<std::size_t,std::size_t>> arrows;
+  auto intern=[&](const std::int64_t* data,std::size_t j){std::vector<std::int64_t> column(n);for(std::size_t i=0;i<n;++i)column[i]=data[i*m+j];auto found=index.find(column);if(found!=index.end())return found->second;std::size_t id=complexes.size();index[column]=id;complexes.push_back(std::move(column));return id;};
+  Matrix vectors(m,std::vector<Rat>(n));
+  for(std::size_t j=0;j<m;++j){budget.check();auto a=intern(pre,j);auto b=intern(post,j);arrows.emplace_back(a,b);for(std::size_t i=0;i<n;++i)vectors[j][i]=Int(post[i*m+j])-Int(pre[i*m+j]);}
+  auto copy=vectors;std::size_t rank=rref(copy,n,budget).size(), count=complexes.size();
+  std::vector<std::vector<std::size_t>> adj(count),rev(count),undirected(count);
+  std::set<std::pair<std::size_t,std::size_t>> edges(arrows.begin(),arrows.end());
+  for(auto edge:edges){adj[edge.first].push_back(edge.second);rev[edge.second].push_back(edge.first);undirected[edge.first].push_back(edge.second);undirected[edge.second].push_back(edge.first);}
+  std::vector<int> component(count,-1),scc(count,-1);std::vector<std::vector<std::size_t>> classes;std::vector<std::size_t> order;std::vector<bool> seen(count,false);
+  std::function<void(std::size_t)> visit=[&](std::size_t v){budget.check();seen[v]=true;for(auto w:adj[v])if(!seen[w])visit(w);order.push_back(v);};
+  for(std::size_t v=0;v<count;++v)if(!seen[v])visit(v);
+  std::function<void(std::size_t,int)> assign=[&](std::size_t v,int c){budget.check();scc[v]=c;for(auto w:rev[v])if(scc[w]<0)assign(w,c);};
+  int sc=0;for(auto it=order.rbegin();it!=order.rend();++it)if(scc[*it]<0)assign(*it,sc++);
+  for(std::size_t v=0;v<count;++v)if(component[v]<0){int c=classes.size();classes.push_back({});std::vector<std::size_t> stack{v};component[v]=c;while(!stack.empty()){budget.check();auto x=stack.back();stack.pop_back();classes.back().push_back(x);for(auto w:undirected[x])if(component[w]<0){component[w]=c;stack.push_back(w);}}std::sort(classes.back().begin(),classes.back().end());}
+  std::vector<int> terminal(sc,1);for(auto edge:edges)if(scc[edge.first]!=scc[edge.second])terminal[scc[edge.first]]=0;
+  std::vector<int> deficiencies,terminal_counts;bool weak=true,reversible=true;
+  for(auto edge:edges)if(!edges.count({edge.second,edge.first}))reversible=false;
+  for(std::size_t c=0;c<classes.size();++c){Matrix local;std::set<int> strong;for(auto v:classes[c])strong.insert(scc[v]);if(strong.size()!=1)weak=false;
+   for(std::size_t j=0;j<m;++j)if(component[arrows[j].first]==int(c))local.push_back(vectors[j]);
+   auto r=rref(local,n,budget).size();deficiencies.push_back(int(classes[c].size())-1-int(r));int terminals=0;for(auto k:strong)terminals+=terminal[k];terminal_counts.push_back(terminals);}
+  std::ostringstream out;out<<"{\"termination_reason\":\"complete\",\"rank\":"<<rank<<",\"n_species\":"<<n<<",\"n_reactions\":"<<m<<",\"n_complexes\":"<<count<<",\"n_linkage_classes\":"<<classes.size()<<",\"n_terminal_strong_linkage_classes\":"<<std::count(terminal.begin(),terminal.end(),1)<<",\"deficiency\":"<<int(count)-int(classes.size())-int(rank)<<",\"is_weakly_reversible\":"<<(weak?"true":"false")<<",\"is_reversible\":"<<(reversible?"true":"false")<<",\"linkage_class_deficiencies\":";vector_json(out,deficiencies);out<<",\"terminal_counts\":";vector_json(out,terminal_counts);out<<",\"complex_coefficients\":";matrix_json(out,complexes);out<<'}';return output_json(out.str(),output);
+ }catch(const Limit& l){return output_json(std::string("{\"termination_reason\":\"")+l.reason+"\"}",output);}catch(...){return 2;}
+}
+}

synkit/CRN/cpp/closure.cpp

@@ -0,0 +1,29 @@
+// Exact Boolean incidence closure. Coefficients remain in the Python model.
+#include <cstdint>
+#include <cstddef>
+#include <cstdlib>
+extern "C" {
+int synkit_crn_abi() { return 1; }
+void synkit_crn_free_text(void* pointer) { std::free(pointer); }
+int synkit_crn_closure(std::size_t words, std::size_t transitions,
+                      const std::uint64_t* trigger, const std::uint64_t* required,
+                      std::uint64_t* current) {
+    bool changed = true;
+    while (changed) {
+        changed = false;
+        for (std::size_t t=0; t<transitions; ++t) {
+            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 0;
+}
+}

synkit/CRN/cpp/exact.h

@@ -0,0 +1,55 @@
+#ifndef SYNKIT_CRN_EXACT_H
+#define SYNKIT_CRN_EXACT_H
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/rational.hpp>
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <sstream>
+#include <vector>
+namespace crn_exact {
+using Int=boost::multiprecision::cpp_int;
+using Rat=boost::rational<Int>;
+using Matrix=std::vector<std::vector<Rat>>;
+using Clock=std::chrono::steady_clock;
+struct Limit { const char* reason; };
+struct Budget {
+ Clock::time_point end;
+ explicit Budget(double seconds): end(Clock::now()+std::chrono::duration_cast<Clock::duration>(std::chrono::duration<double>(seconds))) {}
+ void check() const { if (Clock::now()>=end) throw Limit{"time_limit"}; }
+};
+inline Int gcd(Int a, Int b) { if(a<0)a=-a;if(b<0)b=-b;while(b!=0){Int r=a%b;a=std::move(b);b=std::move(r);}return a; }
+inline std::vector<Int> primitive(const std::vector<Rat>& row) {
+ Int scale=1;for(const auto& v:row){Int d=v.denominator();scale=scale/gcd(scale,d)*d;}
+ std::vector<Int> out;Int divisor=0;
+ for(const auto& v:row){Int x=v.numerator()*(scale/v.denominator());divisor=gcd(divisor,x);out.push_back(std::move(x));}
+ if(divisor>1)for(auto& x:out)x/=divisor;
+ for(const auto& x:out)if(x!=0){if(x<0)for(auto& y:out)y=-y;break;}
+ return out;
+}
+inline std::vector<std::size_t> rref(Matrix& matrix,std::size_t columns,const Budget& budget) {
+ std::vector<std::size_t> pivots;std::size_t r=0;
+ for(std::size_t c=0;c<columns && r<matrix.size();++c){
+  budget.check();std::size_t p=r;while(p<matrix.size() && matrix[p][c]==0)++p;
+  if(p==matrix.size())continue;std::swap(matrix[r],matrix[p]);Rat pivot=matrix[r][c];
+  for(std::size_t j=c;j<columns;++j)matrix[r][j]/=pivot;
+  for(std::size_t i=0;i<matrix.size();++i){budget.check();if(i==r || matrix[i][c]==0)continue;Rat factor=matrix[i][c];
+   for(std::size_t j=c;j<columns;++j)matrix[i][j]-=factor*matrix[r][j];}
+  pivots.push_back(c);++r;
+ }
+ return pivots;
+}
+inline std::vector<std::vector<Int>> kernel(Matrix matrix,std::size_t columns,const Budget& budget,std::size_t& rank) {
+ auto pivots=rref(matrix,columns,budget);rank=pivots.size();std::vector<std::vector<Int>> out;
+ for(std::size_t c=0;c<columns;++c){budget.check();if(std::find(pivots.begin(),pivots.end(),c)!=pivots.end())continue;
+  std::vector<Rat> row(columns);row[c]=1;for(std::size_t r=0;r<pivots.size();++r)row[pivots[r]]=-matrix[r][c];out.push_back(primitive(row));}
+ return out;
+}
+template<class T> inline void vector_json(std::ostream& out,const std::vector<T>& row){out<<'[';for(std::size_t i=0;i<row.size();++i){if(i)out<<',';out<<row[i];}out<<']';}
+template<class T> inline void matrix_json(std::ostream& out,const std::vector<std::vector<T>>& rows){out<<'[';for(std::size_t i=0;i<rows.size();++i){if(i)out<<',';vector_json(out,rows[i]);}out<<']';}
+inline int output_json(const std::string& text,char** output){auto* p=static_cast<char*>(std::malloc(text.size()+1));if(!p)return 2;std::memcpy(p,text.c_str(),text.size()+1);*output=p;return 0;}
+}
+#endif

synkit/CRN/cpp/pathway.cpp

@@ -0,0 +1,46 @@
+#include "exact.h"
+#include <deque>
+#include <unordered_set>
+using namespace crn_exact;
+namespace {
+struct Node { std::vector<Int> marking; std::size_t parent, transition, depth; };
+std::string key(const std::vector<Int>& marking){std::ostringstream out;for(const auto& x:marking)out<<x<<';';return out.str();}
+}
+extern "C" {
+int synkit_crn_pathway_abi(){return 1;}
+int synkit_crn_pathway(std::size_t n,std::size_t m,const std::int64_t* pre,const std::int64_t* post,
+ const std::int64_t* initial,const std::int64_t* exact,const std::int64_t* atleast,
+ std::size_t max_states,std::size_t max_depth,double seconds,int qualitative,char** output){
+ if(!output||!std::isfinite(seconds)||seconds<=0||seconds>1e9||!max_states)return 2;*output=nullptr;Budget budget(seconds);
+ std::string status="inconclusive",reason="time_limit";std::size_t explored=0,deepest=0;bool exhaustive=false,limited=false;
+ std::vector<std::size_t> certificate;
+ try{
+  auto goal=[&](const std::vector<Int>& marking){for(std::size_t i=0;i<n;++i)if((exact[i]>=0 && marking[i]!=exact[i]) || marking[i]<atleast[i])return false;return true;};
+  std::vector<Node> nodes;Node first;first.parent=std::size_t(-1);first.depth=0;for(std::size_t i=0;i<n;++i)first.marking.push_back(initial[i]);
+  if(goal(first.marking)){status="realizable";reason="certificate";}
+  else{
+   nodes.push_back(std::move(first));std::deque<std::size_t> queue{0};std::unordered_set<std::string> seen{key(nodes[0].marking)};bool found=false;
+   while(!queue.empty()&&!found){
+    budget.check();if(explored>=max_states)throw Limit{"state_limit"};auto index=queue.front();queue.pop_front();
+    // Copy: adding successors may reallocate the node vector.
+    Node current=nodes[index];++explored;deepest=std::max(deepest,current.depth);
+    for(std::size_t t=0;t<m;++t){
+     budget.check();bool enabled=true;for(std::size_t i=0;i<n;++i)if(current.marking[i]<(qualitative?(pre[i*m+t]>0?1:0):pre[i*m+t])){enabled=false;break;}
+     if(!enabled)continue;if(current.depth>=max_depth){limited=true;continue;}
+     Node child;child.parent=index;child.transition=t;child.depth=current.depth+1;child.marking=current.marking;
+     for(std::size_t i=0;i<n;++i){if(qualitative){if(post[i*m+t]>0)child.marking[i]=1;}else child.marking[i]+=Int(post[i*m+t])-Int(pre[i*m+t]);}
+     if(goal(child.marking)){
+      certificate.push_back(t);auto p=index;while(nodes[p].parent!=std::size_t(-1)){certificate.push_back(nodes[p].transition);p=nodes[p].parent;}std::reverse(certificate.begin(),certificate.end());
+      deepest=std::max(deepest,child.depth);status="realizable";reason="certificate";found=true;break;
+     }
+     auto signature=key(child.marking);if(seen.insert(signature).second){
+      if(nodes.size()>=max_states*16)throw Limit{"frontier_limit"};queue.push_back(nodes.size());nodes.push_back(std::move(child));}
+    }
+   }
+   if(!found){status=limited?"inconclusive":"unrealizable";reason=limited?"depth_limit":"exhausted";exhaustive=!limited;}
+  }
+ }catch(const Limit& limit){reason=limit.reason;status="inconclusive";certificate.clear();}catch(const std::bad_alloc&){reason="allocation_failure";}catch(...){return 2;}
+ std::ostringstream out;out<<"{\"status\":\""<<status<<"\",\"termination_reason\":\""<<reason<<"\",\"explored_states\":"<<explored<<",\"max_depth_reached\":"<<deepest<<",\"exhaustive\":"<<(exhaustive?"true":"false")<<",\"certificate\":";
+ if(status=="realizable")vector_json(out,certificate);else out<<"null";out<<'}';return output_json(out.str(),output);
+}
+}

synkit/CRN/cpp/semiflows.cpp

@@ -0,0 +1,209 @@
+// Exact nonnegative cone generators by Farkas elimination.
+// Boost.Multiprecision is header-only; coefficients have arbitrary precision.
+#include <boost/multiprecision/cpp_int.hpp>
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace {
+using Integer = boost::multiprecision::cpp_int;
+using Clock = std::chrono::steady_clock;
+struct Limit { const char* reason; };
+struct Row {
+    std::vector<Integer> values;
+    std::vector<std::uint64_t> support;
+    std::size_t support_size = 0;
+};
+struct Search {
+    std::size_t n, columns, max_rows, max_results, max_bits;
+    std::uint64_t max_candidates, candidates = 0;
+    std::size_t peak_rows = 0, eliminated = 0;
+    Clock::time_point deadline;
+    void check() const {
+        if (Clock::now() >= deadline) throw Limit{"time_limit"};
+    }
+    bool full_rank(const std::int64_t* matrix) const {
+        if (n > columns) return false;
+        constexpr std::int64_t prime = 1000003;
+        std::vector<std::vector<std::int64_t>> work(n, std::vector<std::int64_t>(columns));
+        for (std::size_t i=0; i<n; ++i) {
+            check();
+            for (std::size_t j=0; j<columns; ++j) {
+                auto v = matrix[i*columns+j] % prime;
+                work[i][j] = v < 0 ? v+prime : v;
+            }
+        }
+        std::size_t rank=0;
+        for (std::size_t col=0; col<columns && rank<n; ++col) {
+            check();
+            std::size_t pivot=rank;
+            while (pivot<n && work[pivot][col]==0) ++pivot;
+            if (pivot==n) continue;
+            std::swap(work[pivot], work[rank]);
+            std::int64_t inverse=1, power=prime-2, base=work[rank][col];
+            while (power) { if (power&1) inverse=(inverse*base)%prime; base=(base*base)%prime; power>>=1; }
+            for (std::size_t j=col; j<columns; ++j) work[rank][j]=(work[rank][j]*inverse)%prime;
+            for (std::size_t i=rank+1; i<n; ++i) {
+                check();
+                auto factor=work[i][col];
+                if (!factor) continue;
+                for (std::size_t j=col; j<columns; ++j)
+                    work[i][j]=(work[i][j] - factor*work[rank][j]%prime + prime)%prime;
+            }
+            ++rank;
+        }
+        return rank==n;
+    }
+    void normalize(Row& row) const {
+        Integer g = 0;
+        for (std::size_t i=0; i<n; ++i) {
+            check();
+            if (row.values[i] != 0) {
+                if (max_bits && boost::multiprecision::msb(row.values[i]) >= max_bits)
+                    throw Limit{"coefficient_limit"};
+                Integer b = row.values[i];
+                while (b != 0) { Integer r = g % b; g = std::move(b); b = std::move(r); }
+                if (g == 1) break;
+            }
+        }
+        if (g > 1) for (auto& v: row.values) { check(); v /= g; }
+        row.support.assign((n+63)/64, 0);
+        row.support_size = 0;
+        for (std::size_t i=0; i<n; ++i) if (row.values[i] != 0) {
+            if (max_bits && boost::multiprecision::msb(row.values[i]) >= max_bits)
+                throw Limit{"coefficient_limit"};
+            row.support[i/64] |= std::uint64_t(1) << (i%64);
+            ++row.support_size;
+        }
+    }
+    static bool subset(const Row& a, const Row& b) {
+        if (a.support_size > b.support_size) return false;
+        for (std::size_t w=0; w<a.support.size(); ++w)
+            if (a.support[w] & ~b.support[w]) return false;
+        return true;
+    }
+    void insert(std::vector<Row>& kept, Row row) {
+        check();
+        // Incremental antichain filtering avoids materializing all pair rows.
+        for (const auto& k: kept) {
+            check();
+            if (subset(k, row)) return;
+        }
+        kept.erase(std::remove_if(kept.begin(), kept.end(), [&](const Row& k) {
+            check(); return subset(row, k);
+        }), kept.end());
+        if (kept.size() >= max_rows) throw Limit{"row_limit"};
+        kept.push_back(std::move(row));
+        peak_rows = std::max(peak_rows, kept.size());
+    }
+};
+char* copy_text(const std::string& text) {
+    auto* buffer = static_cast<char*>(std::malloc(text.size()+1));
+    if (!buffer) return nullptr;
+    std::memcpy(buffer, text.c_str(), text.size()+1);
+    return buffer;
+}
+}
+extern "C" {
+int synkit_crn_semiflows_abi() { return 1; }
+// Returns JSON in *output, owned by caller via synkit_crn_free_text.
+// On any resource limit no intermediate (non-kernel) tableau rows are exposed.
+int synkit_crn_semiflows(std::size_t n, std::size_t columns, const std::int64_t* matrix,
+                        double seconds, std::uint64_t max_candidates,
+                        std::size_t max_rows, std::size_t max_results, std::size_t max_bits,
+                        char** output) {
+    if (!output || !std::isfinite(seconds) || seconds <= 0 || seconds > 1e9) return 2;
+    *output = nullptr;
+    Search search{n, columns, max_rows, max_results, max_bits, max_candidates};
+    search.deadline = Clock::now() + std::chrono::duration_cast<Clock::duration>(std::chrono::duration<double>(seconds));
+    const char* reason = "complete";
+    std::vector<Row> rows;
+    try {
+        const bool empty_kernel = search.full_rank(matrix);
+        for (std::size_t i=0; !empty_kernel && i<n; ++i) {
+            search.check();
+            Row row;
+            row.values.resize(n+columns);
+            row.values[i] = 1;
+            for (std::size_t j=0; j<columns; ++j) row.values[n+j] = matrix[i*columns+j];
+            search.normalize(row);
+            if (rows.size() >= max_rows) throw Limit{"row_limit"};
+            rows.push_back(std::move(row));
+        }
+        search.peak_rows = rows.size();
+        for (std::size_t col=0; col<columns && !rows.empty(); ++col) {
+            search.check();
+            std::vector<std::size_t> pos, neg;
+            std::vector<Row> kept;
+            for (std::size_t i=0; i<rows.size(); ++i) {
+                const auto& v = rows[i].values[n+col];
+                if (v > 0) pos.push_back(i);
+                else if (v < 0) neg.push_back(i);
+                else kept.push_back(rows[i]); // Existing rows already form an antichain.
+            }
+            for (auto pi: pos) for (auto ni: neg) {
+                search.check();
+                if (search.candidates >= max_candidates) throw Limit{"candidate_limit"};
+                ++search.candidates;
+                const Row& p = rows[pi]; const Row& m = rows[ni];
+                // Positive combinations have exactly the union support. Reject
+                // dominated supports before arbitrary-precision arithmetic.
+                Row support_union;
+                support_union.support.resize(p.support.size());
+                for (std::size_t w=0; w<p.support.size(); ++w) {
+                    auto word=p.support[w] | m.support[w];
+                    support_union.support[w]=word;
+                    while (word) { word &= word-1; ++support_union.support_size; }
+                }
+                bool dominated=false;
+                for (const auto& k: kept) {
+                    search.check();
+                    if (Search::subset(k, support_union)) { dominated=true; break; }
+                }
+                if (dominated) continue;
+                Integer a = p.values[n+col], b = -m.values[n+col];
+                Row combined;
+                combined.values.resize(n+columns);
+                for (std::size_t j=0; j<n+columns; ++j) {
+                    search.check();
+                    combined.values[j] = b*p.values[j] + a*m.values[j];
+                }
+                search.normalize(combined);
+                search.insert(kept, std::move(combined));
+            }
+            rows = std::move(kept);
+            ++search.eliminated;
+        }
+        if (rows.size() > max_results) throw Limit{"result_limit"};
+    } catch (const Limit& limit) {
+        reason = limit.reason;
+        rows.clear();
+    } catch (const std::bad_alloc&) {
+        reason = "allocation_failure";
+        rows.clear();
+    } catch (...) { return 2; }
+    try {
+        std::ostringstream out;
+        out << "{\"termination_reason\":\"" << reason << "\",\"candidates\":" << search.candidates
+            << ",\"peak_rows\":" << search.peak_rows << ",\"eliminated_columns\":" << search.eliminated
+            << ",\"flows\":[";
+        for (std::size_t r=0; r<rows.size(); ++r) {
+            if (r) out << ',';
+            out << '[';
+            for (std::size_t i=0; i<n; ++i) { if (i) out << ','; out << rows[r].values[i]; }
+            out << ']';
+        }
+        out << "]}";
+        *output = copy_text(out.str());
+        return *output ? 0 : 2;
+    } catch (...) { return 2; }
+}
+}