python-sat 1.9.dev18__tar.gz → 1.9.dev20__tar.gz

{python_sat-1.9.dev18/python_sat.egg-info → python_sat-1.9.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev18
+Version: 1.9.dev20
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado

python_sat-1.9.dev20/cardenc/iseq.hh

@@ -0,0 +1,151 @@
+/*
+ * iseq.hh
+ *
+ *  Created on: Dec 15, 2025
+ *      Author: Jesse Looney
+ *      E-mail: jesselooney+dev@pm.me
+ */
+
+#ifndef ISEQ_HH_
+#define ISEQ_HH_
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include <deque>
+#include "clset.hh"
+#include "ptypes.hh"
+#include "utils.hh"
+
+using namespace std;
+
+struct SeqState {
+    vector<int> lhs;
+    // We maintain the invariant that `rhs.size() < lhs.size()`.
+    vector<int> rhs;
+    // A map from pairs of integers to SAT literals (encoded as integers).
+    // We maintain the invariant that, for `1 <= i <= rhs.size()` and
+    // `i <= j <= lhs.size()`, `s_vars` contains the key `(i, j)`, and the
+    // corresponding element is a literal whose negation requires that the sum
+    // of the first `j` literals of `lhs` is at most `i - 1`.
+    Pair2IntMap s_vars;
+};
+
+// Create an at-most-0 constraint in an instantiated sequential counters state.
+// This must always be the first constraint added.
+//=============================================================================
+void _iseq_add_atmost0(SeqState *state, ClauseSet& dest, int& top)
+{
+    assert(state->rhs.size() == 0);
+    assert(state->lhs.size() > 0);
+
+    int n = state->lhs.size();
+
+    // s_1^1 <-- x_0. We could just reuse the literal for x_0, but it is better
+    // to have our own copy: iseq_get() hands out s-variables as standalone
+    // constraint literals, and callers should be able to treat s_1^1 as
+    // distinct from the input literal x_0.
+    int s11 = mk_yvar(top, state->s_vars, make_pair(1, 1));
+    int x0 = state->lhs[0];
+    dest.create_binary_clause(-x0, s11);
+
+    for (int j = 1; j < n; j++) {
+        int s1j1 = mk_yvar(top, state->s_vars, make_pair(1, j + 1));
+        int s1j  = mk_yvar(top, state->s_vars, make_pair(1, j));
+        int xj   = state->lhs[j];
+        // s_1^(j+1) <-- s_1^j v x_j
+        dest.create_binary_clause(-s1j, s1j1);
+        dest.create_binary_clause(-xj, s1j1);
+    }
+
+    int s1n = mk_yvar(top, state->s_vars, make_pair(1, n));
+    state->rhs.push_back(s1n);
+}
+
+// Create an at-most-k constraint in an instantiated sequential counters state.
+// This must always be the (k+1)-th constraint added.
+//=============================================================================
+void _iseq_add_atmostk(SeqState *state, ClauseSet& dest, int& top, unsigned k)
+{
+    assert(state->rhs.size() == k);
+    assert(state->lhs.size() > k);
+
+    int n = state->lhs.size();
+
+    int sk1k1 = mk_yvar(top, state->s_vars, make_pair(k + 1, k + 1));
+    int skk   = mk_yvar(top, state->s_vars, make_pair(k, k));
+    int xk    = state->lhs[k];
+    // s_(k+1)^(k+1) <-- s_k^k ^ x_k
+    dest.create_ternary_clause(-skk, -xk, sk1k1);
+
+    for (int j = k + 1; j < n; j++) {
+        int sk1j1 = mk_yvar(top, state->s_vars, make_pair(k + 1, j + 1));
+        int sk1j  = mk_yvar(top, state->s_vars, make_pair(k + 1, j));
+        int skj   = mk_yvar(top, state->s_vars, make_pair(k, j));
+        int xj    = state->lhs[j];
+        // s_(k+1)^(j+1) <-- s_(k+1)^j v (s_k^j ^ x_j)
+        dest.create_binary_clause(-sk1j, sk1j1);
+        dest.create_ternary_clause(-skj, -xj, sk1j1);
+    }
+
+    int sk1n = mk_yvar(top, state->s_vars, make_pair(k + 1, n));
+    state->rhs.push_back(sk1n);
+}
+
+//
+//=============================================================================
+SeqState *iseq_new(ClauseSet& dest, vector<int>& lhs, unsigned rhs, int& top)
+{
+    SeqState *state = new SeqState();
+    state->lhs = lhs;
+
+    unsigned kmin = std::min(rhs + 1, (unsigned)state->lhs.size());
+    state->rhs.reserve(kmin);
+
+    for (unsigned i = 0; i < kmin; i++) {
+        if (i == 0) {
+            _iseq_add_atmost0(state, dest, top);
+        } else {
+            _iseq_add_atmostk(state, dest, top, i);
+        }
+    }
+
+    return state;
+}
+
+//
+//=============================================================================
+void iseq_increase(SeqState *state, ClauseSet& dest, unsigned rhs, int& top)
+{
+    unsigned kmin = std::min(rhs + 1, (unsigned)state->lhs.size());
+    state->rhs.reserve(kmin);
+
+    for (unsigned i = (unsigned)state->rhs.size(); i < kmin; i++) {
+        if (i == 0) {
+            _iseq_add_atmost0(state, dest, top);
+        } else {
+            _iseq_add_atmostk(state, dest, top, i);
+        }
+    }
+}
+
+//
+//=============================================================================
+int iseq_get(SeqState *state, int prefix_len, unsigned bound) {
+    assert(bound < state->rhs.size());
+
+    assert((int)bound < prefix_len);
+    assert(prefix_len <= (int)state->lhs.size());
+
+    // The above assertions ensure that this key exists in the map.
+    return state->s_vars.at(make_pair(bound + 1, prefix_len));
+}
+
+//
+//=============================================================================
+static void iseq_destroy(SeqState *state)
+{
+	delete state;
+}
+
+#endif // ISEQ_HH_

{python_sat-1.9.dev18 → python_sat-1.9.dev20}/cardenc/mto.hh

@@ -116,6 +116,16 @@ inline void to_TO(
 
 		to_UA(top_id, clset, *olst, *outfsthalf, *outsndhalf);
 
+		// leaf vectors are not queued
+		if (half < 2) {
+			delete fsthalf;
+			delete outfsthalf;
+		}
+		if (n - half < 2) {
+			delete sndhalf;
+			delete outsndhalf;
+		}
+
 		delete ilst;
 		delete olst;
 	}
@@ -387,6 +397,18 @@ inline void mto_MTO_A(
 		mto_MUA_A(top_id, clset, *ulst, *llst, *ufsthalf, *lfsthalf,
 				*usndhalf, *lsndhalf, p);
 
+		// leaf vectors are not queued
+		if (half < p) {
+			delete fsthalf;
+			delete ufsthalf;
+			delete lfsthalf;
+		}
+		if (ni - half < p) {
+			delete sndhalf;
+			delete usndhalf;
+			delete lsndhalf;
+		}
+
 		delete ilst;
 		delete ulst;
 		delete llst;

{python_sat-1.9.dev18 → python_sat-1.9.dev20}/cardenc/pycard.cc

@@ -16,6 +16,7 @@
 
 #include "card.hh"
 #include "itot.hh"
+#include "iseq.hh"
 
 using namespace std;
 
@@ -39,6 +40,13 @@ static char itot_ext_docstring[] = "Extends the set of inputs in an iterative"
 static char itot_mrg_docstring[] = "Merge two totalizer objects into one.";
 static char itot_del_docstring[] = "Delete an iterative totalizer object";
 
+static char iseq_new_docstring[] = "Create an iterative sequential counter"
+                                   "object for an AtMost(k) constraint.";
+static char iseq_inc_docstring[] = "Increase bound in an iterative sequential"
+                                   "counter object";
+static char iseq_del_docstring[] = "Delete an iterative sequential counter";
+static char iseq_get_docstring[] = "Get a constraint for an iterative sequential counter";
+
 static PyObject *CardError;
 static jmp_buf env;
 
@@ -124,6 +132,10 @@ extern "C" {
 	static PyObject *py_itot_ext       (PyObject *, PyObject *);
 	static PyObject *py_itot_mrg       (PyObject *, PyObject *);
 	static PyObject *py_itot_del       (PyObject *, PyObject *);
+	static PyObject *py_iseq_new       (PyObject *, PyObject *);
+	static PyObject *py_iseq_inc       (PyObject *, PyObject *);
+	static PyObject *py_iseq_del       (PyObject *, PyObject *);
+	static PyObject *py_iseq_get       (PyObject *, PyObject *);
 }
 
 // module specification
@@ -137,6 +149,11 @@ static PyMethodDef module_methods[] = {
 	{ "itot_mrg",       py_itot_mrg,       METH_VARARGS, itot_mrg_docstring },
 	{ "itot_del",       py_itot_del,       METH_VARARGS, itot_del_docstring },
 
+	{ "iseq_new",       py_iseq_new,        METH_VARARGS, iseq_new_docstring },
+	{ "iseq_inc",       py_iseq_inc,        METH_VARARGS, iseq_inc_docstring },
+	{ "iseq_del",       py_iseq_del,        METH_VARARGS, iseq_del_docstring },
+	{ "iseq_get",       py_iseq_get,        METH_VARARGS, iseq_get_docstring },
+
 	{ NULL, NULL, 0, NULL }
 };
 
@@ -860,4 +877,203 @@ static PyObject *py_itot_del(PyObject *self, PyObject *args)
 	return ret;
 }
 
+// Incremental sequential counter contributed by Jesse Looney.
+// From jesselooney/pysat, commit 8d3449e8d1845cc9e0f682a45beb888bbac8be0c.
+//
+//=============================================================================
+static PyObject *py_iseq_new(PyObject *self, PyObject *args)
+{
+	PyObject *lhs_obj;
+	int rhs;
+	int top;
+	int main_thread;
+
+	if (!PyArg_ParseTuple(args, "Oiii", &lhs_obj, &rhs, &top, &main_thread))
+		return NULL;
+
+	vector<int> lhs;
+	if (pyiter_to_vector(lhs_obj, lhs) == false)
+		return NULL;
+
+	PyOS_sighandler_t sig_save;
+	if (main_thread) {
+		sig_save = PyOS_setsig(SIGINT, sigint_handler);
+
+		if (setjmp(env) != 0) {
+			PyErr_SetString(CardError, "Caught keyboard interrupt");
+			return NULL;
+		}
+	}
+
+	// calling encoder
+	ClauseSet dest;
+	SeqState *state = iseq_new(dest, lhs, rhs, top);
+
+	if (main_thread)
+		PyOS_setsig(SIGINT, sig_save);
+
+	PyIntCache cache = {};
+	PyObject *dest_obj = clauseset_to_pylist(dest, &cache);
+	pyint_cache_clear(&cache);
+	if (dest_obj == NULL) {
+		iseq_destroy(state);
+		return NULL;
+	}
+
+	PyObject *ubs_obj = vector_to_pylist(state->rhs);
+	if (ubs_obj == NULL) {
+		Py_DECREF(dest_obj);
+		iseq_destroy(state);
+		return NULL;
+	}
+	PyObject *state_obj = void_to_pyobj((void *)state);
+	if (state_obj == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		iseq_destroy(state);
+		return NULL;
+	}
+	PyObject *top_obj = pyint_from_cint(top);
+	if (top_obj == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		Py_DECREF(state_obj);
+		iseq_destroy(state);
+		return NULL;
+	}
+
+	PyObject *ret = PyTuple_New(4);
+	if (ret == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		Py_DECREF(state_obj);
+		Py_DECREF(top_obj);
+		iseq_destroy(state);
+		return NULL;
+	}
+	PyTuple_SET_ITEM(ret, 0, state_obj);
+	PyTuple_SET_ITEM(ret, 1, dest_obj);
+	PyTuple_SET_ITEM(ret, 2, ubs_obj);
+	PyTuple_SET_ITEM(ret, 3, top_obj);
+	return ret;
+}
+
+//
+//=============================================================================
+static PyObject *py_iseq_inc(PyObject *self, PyObject *args)
+{
+	PyObject *t_obj;
+	int rhs;
+	int top;
+	int main_thread;
+
+	if (!PyArg_ParseTuple(args, "Oiii", &t_obj, &rhs, &top, &main_thread))
+		return NULL;
+
+	// get pointer to state
+	SeqState *state = (SeqState *)pyobj_to_void(t_obj);
+
+	PyOS_sighandler_t sig_save;
+	if (main_thread) {
+		sig_save = PyOS_setsig(SIGINT, sigint_handler);
+
+		if (setjmp(env) != 0) {
+			PyErr_SetString(CardError, "Caught keyboard interrupt");
+			return NULL;
+		}
+	}
+
+	// calling encoder
+	ClauseSet dest;
+	iseq_increase(state, dest, rhs, top);
+
+	if (main_thread)
+		PyOS_setsig(SIGINT, sig_save);
+
+	PyIntCache cache = {};
+	PyObject *dest_obj = clauseset_to_pylist(dest, &cache);
+	pyint_cache_clear(&cache);
+	if (dest_obj == NULL)
+		return NULL;
+
+	PyObject *ubs_obj = vector_to_pylist(state->rhs);
+	if (ubs_obj == NULL) {
+		Py_DECREF(dest_obj);
+		return NULL;
+	}
+	PyObject *top_obj = pyint_from_cint(top);
+	if (top_obj == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		return NULL;
+	}
+
+	PyObject *ret = PyTuple_New(3);
+	if (ret == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		Py_DECREF(top_obj);
+		return NULL;
+	}
+	PyTuple_SET_ITEM(ret, 0, dest_obj);
+	PyTuple_SET_ITEM(ret, 1, ubs_obj);
+	PyTuple_SET_ITEM(ret, 2, top_obj);
+	return ret;
+}
+
+//
+//=============================================================================
+static PyObject *py_iseq_get(PyObject *self, PyObject *args)
+{
+	PyObject *t_obj;
+	int prefix_len;
+	int bound;
+	int main_thread;
+
+	if (!PyArg_ParseTuple(args, "Oiii", &t_obj, &prefix_len, &bound, &main_thread))
+		return NULL;
+
+	// get pointer to state
+	SeqState *state = (SeqState *)pyobj_to_void(t_obj);
+
+	PyOS_sighandler_t sig_save;
+	if (main_thread) {
+		sig_save = PyOS_setsig(SIGINT, sigint_handler);
+
+		if (setjmp(env) != 0) {
+			PyErr_SetString(CardError, "Caught keyboard interrupt");
+			return NULL;
+		}
+	}
+
+	// calling encoder
+	int lit = iseq_get(state, prefix_len, bound);
+
+	if (main_thread)
+		PyOS_setsig(SIGINT, sig_save);
+
+	PyObject *ret = Py_BuildValue("i", lit);
+
+	return ret;
+}
+
+//
+//=============================================================================
+static PyObject *py_iseq_del(PyObject *self, PyObject *args)
+{
+	PyObject *t_obj;
+
+	if (!PyArg_ParseTuple(args, "O", &t_obj))
+		return NULL;
+
+	// get pointer to state
+	SeqState *state = (SeqState *)pyobj_to_void(t_obj);
+
+	// delete
+	iseq_destroy(state);
+
+	PyObject *ret = Py_BuildValue("");
+	return ret;
+}
+
 }  // extern "C"

{python_sat-1.9.dev18 → python_sat-1.9.dev20}/pysat/__init__.py

@@ -10,7 +10,7 @@
 
 # current version
 #==============================================================================
-VERSION = (1, 9, 'dev', 18)
+VERSION = (1, 9, 'dev', 20)
 
 
 # PEP440 Format