python-sat 1.8.dev24__tar.gz → 1.8.dev26__tar.gz

{python_sat-1.8.dev24/python_sat.egg-info → python_sat-1.8.dev26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.8.dev24
+Version: 1.8.dev26
 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.8.dev24 → python_sat-1.8.dev26}/examples/rc2.py

@@ -140,6 +140,7 @@ from pysat.formula import CNFPlus, WCNFPlus, IDPool
 from pysat.card import ITotalizer
 from pysat.process import Processor
 from pysat.solvers import Solver, SolverNames
+from threading import Timer
 import re
 import six
 from six.moves import range
@@ -222,6 +223,9 @@ class RC2(object):
         # oracles are initialised to be None
         self.oracle, self.processor = None, None
 
+        # parameters related to asynchronous interruption
+        self.expect_interrupt, self.interrupted = False, False
+
         # clause selectors and mapping from selectors to clause ids
         # .sall, .s2cl, and .sneg are required only for model enumeration
         self.sels, self.smap, self.sall, self.s2cl, self.sneg = [], {}, [], {}, set([])
@@ -248,6 +252,23 @@ class RC2(object):
         if not formula.hard and len(self.sels) > 100000 and min(wght) == max(wght):
             self.minz = False
 
+    def _call_oracle(self, assumptions=[], expect_interrupt=False):
+        """
+            Makes a call to the internal SAT solver by means of invoking
+            `oracle.solve_limited()`. The two arguments are the list of
+            assumption literals and the Boolean flag indicating whether the
+            call can be interrupted.
+
+            :param assumptions: a list of assumption literals.
+            :param expect_interrupt: whether :meth:`interrupt` may be called
+
+            :type assumptions: iterable(int)
+            :type expect_interrupt: bool
+        """
+
+        return self.oracle.solve_limited(assumptions=assumptions,
+                                         expect_interrupt=expect_interrupt)
+
     def __del__(self):
         """
             Destructor.
@@ -469,7 +490,7 @@ class RC2(object):
             self.processor.delete()
             self.processor = None
 
-    def compute(self):
+    def compute(self, expect_interrupt=False):
         """
             This method can be used for computing one MaxSAT solution,
             i.e. for computing an assignment satisfying all hard
@@ -484,6 +505,12 @@ class RC2(object):
             can enumerate top-:math:`k` MaxSAT solutions (this can
             also be done by calling :meth:`enumerate()`).
 
+            This MaxSAT call can be asynchronously interrupted, in which case
+            the value of ``expect_interrupt`` must be set to ``True``.
+
+            :param expect_interrupt: whether :meth:`interrupt` may be called
+            :type expect_interrupt: bool
+
             :return: a MaxSAT model
             :rtype: list(int)
 
@@ -509,6 +536,9 @@ class RC2(object):
                 >>> rc2.delete()
         """
 
+        # keeping the current interruption preference
+        self.expect_interrupt = expect_interrupt
+
         # simply apply MaxSAT only once
         res = self.compute_()
 
@@ -532,7 +562,7 @@ class RC2(object):
 
             return self.model
 
-    def enumerate(self, block=0):
+    def enumerate(self, block=0, expect_interrupt=False):
         """
             Enumerate top MaxSAT solutions (from best to worst). The
             method works as a generator, which iteratively calls
@@ -546,8 +576,15 @@ class RC2(object):
             it to ``-1``. By the default (for blocking MaxSAT models),
             ``block`` is set to ``0``.
 
+            This MaxSAT enumeration call can be asynchronously interrupted, in
+            which case the value of ``expect_interrupt`` must be set to
+            ``True``.
+
             :param block: preferred way to block solutions when enumerating
+            :param expect_interrupt: whether :meth:`interrupt` may be called
+
             :type block: int
+            :type expect_interrupt: bool
 
             :return: a MaxSAT model
             :rtype: list(int)
@@ -577,7 +614,7 @@ class RC2(object):
 
         done = False
         while not done:
-            model = self.compute()
+            model = self.compute(expect_interrupt=expect_interrupt)
 
             if model != None:
                 if block == 1:
@@ -631,8 +668,21 @@ class RC2(object):
         if self.adapt:
             self.adapt_am1()
 
+        # at the beginning, the solver is not interrupted
+        self.interrupted = False
+
         # main solving loop
-        while not self.oracle.solve(assumptions=self.sels + self.sums):
+        while not self._call_oracle(assumptions=self.sels + self.sums,
+                                    expect_interrupt=self.expect_interrupt):
+
+            # even if the call has been interrupted, we
+            # still need to finish the current iteration
+            if self.oracle.get_status() is None:
+                self.clear_interrupt()
+
+                if self.verbose > 1:
+                    print('c interrupted; processing the last found core')
+
             self.get_core()
 
             if not self.core:
@@ -645,6 +695,10 @@ class RC2(object):
                 print('c cost: {0}; core sz: {1}; soft sz: {2}'.format(self.cost,
                     len(self.core), len(self.sels) + len(self.sums)))
 
+            # the solver got interrupted => returning None
+            if self.interrupted:
+                return  # None
+
         return True
 
     def get_core(self):
@@ -892,7 +946,7 @@ class RC2(object):
         for i in range(self.trim):
             # call solver with core assumption only
             # it must return 'unsatisfiable'
-            self.oracle.solve(assumptions=self.core)
+            self._call_oracle(assumptions=self.core)
 
             # extract a new core
             new_core = self.oracle.get_core()
@@ -930,13 +984,16 @@ class RC2(object):
             while i < len(self.core):
                 to_test = self.core[:i] + self.core[(i + 1):]
 
-                if self.oracle.solve_limited(assumptions=to_test) == False:
+                if self._call_oracle(assumptions=to_test) == False:
                     self.core = to_test
                 elif self.oracle.get_status() == True:
                     i += 1
                 else:
                     break
 
+            # disabling the budget
+            self.oracle.conf_budget(budget=-1)
+
     def exhaust_core(self, tobj):
         """
             Exhaust core by increasing its bound as much as possible.
@@ -962,7 +1019,7 @@ class RC2(object):
         """
 
         # the first case is simpler
-        if self.oracle.solve(assumptions=[-tobj.rhs[1]]):
+        if self._call_oracle(assumptions=[-tobj.rhs[1]]):
             return 1
         else:
             self.cost += self.minw
@@ -975,7 +1032,7 @@ class RC2(object):
             # increasing the bound
             self.update_sum(-tobj.rhs[i - 1])
 
-            if self.oracle.solve(assumptions=[-tobj.rhs[i]]):
+            if self._call_oracle(assumptions=[-tobj.rhs[i]]):
                 # the bound should be equal to i
                 return i
 
@@ -1259,6 +1316,65 @@ class RC2(object):
 
             return int(copysign(i, l))
 
+    def interrupt(self):
+        """
+            Interrupt the execution of the current *limited* SAT call in the
+            RC2 algorithm. Can be used to enforce time limits using timer
+            objects. The interrupt must be cleared before performing another
+            `compute` call (see :meth:`clear_interrupt`).
+
+            Importantly, interruption is implemented such that it can work
+            incrementally with multiple MaxSAT calls, i.e. upon an interrupted
+            invocation a user may extend the resources / time and call the
+            solver again. To make this work, none of the SAT calls used by the
+            heuristics are interrupted. For this reason, the solver may take
+            slightly more time than assumed (spent to properly finish the
+            processing of the last unsatisfiable core).
+
+            **Note** that this method can be called if the `compute` call was
+            made with the option ``expect_interrupt`` set to ``True``.
+            Behaviour is **undefined** if used to ``expect_interrupt`` was set
+            to ``False``.
+
+            Example:
+
+            .. code-block:: python
+
+                >>> from pysat.examples.rc2 import RC2
+                >>> from pysat.formula import WCNF
+                >>> from threading import Timer
+                >>>
+                >>> wcnf = WCNF(from_file='somefile.wcnf')
+                >>>
+                >>> with RC2(wcnf) as rc2:
+                >>>
+                >>>     def interrupt(s):
+                >>>         print('interrupted!')
+                >>>         s.interrupt()
+                >>>
+                >>>     timer = Timer(1, interrupt, [rc2])
+                >>>     timer.start()
+                >>>     print('computing...')
+                >>>     rc2.compute(expect_interrupt=True)
+                >>>     print('done')
+        """
+
+        if self.oracle:
+            self.oracle.interrupt()
+
+            # recording the interruption request
+            self.interrupted = True
+
+    def clear_interrupt(self):
+        """
+            Clears a previous interrupt. Technically, this method should be
+            used every time after the previous MaxSAT call gets interrupted.
+            **However**, the current implementation handles this on its own.
+        """
+
+        if self.oracle:
+            self.oracle.clear_interrupt()
+
 
 #
 #==============================================================================
@@ -1343,7 +1459,7 @@ class RC2Stratified(RC2, object):
         # number of finished levels
         self.done = 0
 
-    def compute(self):
+    def compute(self, expect_interrupt=False):
         """
             This method solves the MaxSAT problem iteratively. Each
             optimization level is tackled the standard way, i.e. by
@@ -1354,6 +1470,9 @@ class RC2Stratified(RC2, object):
             :func:`activate_clauses`.
         """
 
+        # keeping the current interruption preference
+        self.expect_interrupt = expect_interrupt
+
         if self.done == 0 and self.levl != None:
             # it is a fresh start of the solver
             # i.e. no optimization level is finished yet
@@ -1369,7 +1488,7 @@ class RC2Stratified(RC2, object):
                     print('c wght str:', self.blop[self.levl])
 
                 # call RC2
-                if self.compute_() == False:
+                if self.compute_() != True:  # can be either False or None
                     return
 
                 # updating the list of distinct weight levels
@@ -1397,7 +1516,7 @@ class RC2Stratified(RC2, object):
             # i.e. all levels are finished and so all clauses are present
             # thus, we need to simply call RC2 for the next model
             self.done = -1  # we are done with stratification, disabling it
-            if self.compute_() == False:
+            if self.compute_() != True:
                 return
 
         # extracting a model
@@ -1679,10 +1798,10 @@ def parse_options():
     """
 
     try:
-        opts, args = getopt.getopt(sys.argv[1:], 'ab:c:e:hil:mp:s:t:vx',
+        opts, args = getopt.getopt(sys.argv[1:], 'ab:c:e:hil:mp:s:t:T:vx',
                 ['adapt', 'block=', 'comp=', 'enum=', 'exhaust', 'help',
                     'incr', 'blo=', 'minimize', 'process=', 'solver=',
-                    'trim=', 'verbose', 'vnew'])
+                    'trim=', 'timeout=', 'verbose', 'vnew'])
     except getopt.GetoptError as err:
         sys.stderr.write(str(err).capitalize())
         usage()
@@ -1699,6 +1818,7 @@ def parse_options():
     process = 0
     solver = 'g3'
     trim = 0
+    timeout = None
     verbose = 1
     vnew = False
 
@@ -1730,6 +1850,9 @@ def parse_options():
             solver = str(arg)
         elif opt in ('-t', '--trim'):
             trim = int(arg)
+        elif opt in ('-T', '--timeout'):
+            if str(arg) != 'none':
+                timeout = float(arg)
         elif opt in ('-v', '--verbose'):
             verbose += 1
         elif opt == '--vnew':
@@ -1745,7 +1868,7 @@ def parse_options():
     block = bmap[block]
 
     return adapt, blo, block, cmode, to_enum, exhaust, incr, minz, \
-            process, solver, trim, verbose, vnew, args
+            process, solver, trim, timeout, verbose, vnew, args
 
 
 #
@@ -1775,6 +1898,8 @@ def usage():
     print('                                 Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default = g3)')
     print('        -t, --trim=<int>         How many times to trim unsatisfiable cores')
     print('                                 Available values: [0 .. INT_MAX] (default = 0)')
+    print('        -T, --timeout=<float>    Set time limit for MaxSAT solver')
+    print('                                 Available values: [0 .. FLOAT_MAX], none (default: none)')
     print('        -v, --verbose            Be verbose')
     print('        --vnew                   Print v-line in the new format')
     print('        -x, --exhaust            Exhaust new unsatisfiable cores')
@@ -1784,7 +1909,7 @@ def usage():
 #==============================================================================
 if __name__ == '__main__':
     adapt, blo, block, cmode, to_enum, exhaust, incr, minz, process, solver, \
-            trim, verbose, vnew, files = parse_options()
+            trim, timeout, verbose, vnew, files = parse_options()
 
     if files:
         # parsing the input formula
@@ -1826,14 +1951,26 @@ if __name__ == '__main__':
                     print('c hardening is disabled for model enumeration')
                     rc2.hard = False
 
+            # setting a timer if necessary
+            if timeout is not None:
+                if verbose > 1:
+                    print('c timeout: {0}'.format(timeout))
+
+                timer = Timer(timeout, lambda s: s.interrupt(), [rc2])
+                timer.start()
+            else:
+                timer = None
+
             optimum_found = False
-            for i, model in enumerate(rc2.enumerate(block=block), 1):
+            for i, model in enumerate(rc2.enumerate(block=block,
+                                                    expect_interrupt=timeout is not None), 1):
                 optimum_found = True
 
                 if verbose:
                     if i == 1:
-                        print('s OPTIMUM FOUND')
-                        print('o {0}'.format(rc2.cost))
+                        if not rc2.interrupted:
+                            print('s OPTIMUM FOUND')
+                            print('o {0}'.format(rc2.cost))
 
                     if verbose > 2:
                         if vnew:  # new format of the v-line
@@ -1849,10 +1986,14 @@ if __name__ == '__main__':
                     print('v')
 
             if verbose:
-                if not optimum_found:
+                if not optimum_found and not rc2.interrupted:
                     print('s UNSATISFIABLE')
                 elif to_enum != 1:
                     print('c models found:', i)
 
                 if verbose > 1:
                     print('c oracle time: {0:.4f}'.format(rc2.oracle_time()))
+
+            # cancelling the timer (if any) because we are done
+            if timer:
+                timer.cancel()

{python_sat-1.8.dev24 → python_sat-1.8.dev26}/pysat/__init__.py

@@ -10,7 +10,7 @@
 
 # current version
 #==============================================================================
-VERSION = (1, 8, 'dev', 24)
+VERSION = (1, 8, 'dev', 26)
 
 
 # PEP440 Format

{python_sat-1.8.dev24 → python_sat-1.8.dev26}/pysat/formula.py

@@ -297,19 +297,28 @@ class IDPool(object):
         necessary the top variable ID can be accessed directly using the
         ``top`` variable.
 
+        The final parameter ``with_neg``, if set to ``True``, indicates that
+        the *negation* of an object assigned a variable ID ``n`` is to be
+        represented using the negative integer ``-n``. For this to work, the
+        object must have the method ``__neg__()`` implemented. This behaviour
+        is disabled by default.
+
         :param start_from: the smallest ID to assign.
         :param occupied: a list of occupied intervals.
+        :param with_neg: whether to support automatic negation handling
 
         :type start_from: int
         :type occupied: list(list(int))
+        :type with_neg: bool
     """
 
-    def __init__(self, start_from=1, occupied=[]):
+    def __init__(self, start_from=1, occupied=[], with_neg=False):
         """
             Constructor.
         """
 
-        self.restart(start_from=start_from, occupied=occupied)
+        self.restart(start_from=start_from, occupied=occupied,
+                     with_neg=with_neg)
 
     def __repr__(self):
         """
@@ -318,7 +327,7 @@ class IDPool(object):
 
         return f'IDPool(start_from={self.top+1}, occupied={self._occupied})'
 
-    def restart(self, start_from=1, occupied=[]):
+    def restart(self, start_from=1, occupied=[], with_neg=False):
         """
             Restart the manager from scratch. The arguments replicate those of
             the constructor of :class:`IDPool`.
@@ -337,6 +346,10 @@ class IDPool(object):
         # (if for whatever reason necessary)
         self.id2obj = {}
 
+        # flag to indicate whether this IDPool object
+        # should support automatic negation handling
+        self.with_neg = with_neg
+
     def id(self, obj=None):
         """
             The method is to be used to assign an integer variable ID for a
@@ -385,6 +398,11 @@ class IDPool(object):
 
             if vid not in self.id2obj:
                 self.id2obj[vid] = obj
+
+                # adding the object's negation, if required and supported
+                if self.with_neg and hasattr(obj, '__neg__'):
+                    self.obj2id[-obj] = -vid
+                    self.id2obj[-vid] = -obj
         else:
             # no object is provided => simply return a new ID
             vid = self._next()
@@ -1022,6 +1040,13 @@ class Formula(object):
             return Neg(self)
         return self.subformula
 
+    def __neg__(self):
+        """
+            Negation operator. Takes the same effect as ``__invert__()``.
+        """
+
+        return self.__invert__()
+
     def __and__(self, other):
         """
             Logical conjunction operator overloaded for class

{python_sat-1.8.dev24 → python_sat-1.8.dev26}/pysat/pb.py

@@ -137,6 +137,8 @@ class EncType(object):
         cases, this invokes the ``bdd`` encoder).
     """
 
+    assert pblib_present, 'Package \'pypblib\' is unavailable. Check your installation.'
+
     best       = 0
     bdd        = 1
     seqcounter = 2
@@ -242,7 +244,7 @@ class PBEnc(object):
 
     @classmethod
     def _encode(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
-            encoding=EncType.best, comparator='<'):
+            encoding=EncType.best, comparator='<', conditionals=None):
         """
             This is the method that wraps the encoder of PyPBLib. Although the
             method can be invoked directly, a user is expected to call one of
@@ -310,7 +312,9 @@ class PBEnc(object):
             top_id = vpool.top
 
         # choosing the maximum id among the current top and the list of literals
-        top_id = max(map(lambda x: abs(x), lits + [top_id if top_id != None else 0]))
+        if conditionals is None:
+            conditionals = []
+        top_id = max(map(lambda x: abs(x), conditionals + lits + [top_id if top_id != None else 0]))
 
         # native representation
         if encoding == 6:
@@ -331,8 +335,13 @@ class PBEnc(object):
         # pseudo-Boolean constraint and variable manager
         constr = pblib.PBConstraint([pblib.WeightedLit(*wl) for wl in wlits],
                 EncType._to_pbcmp[comparator], bound)
+
         varmgr = pblib.AuxVarManager(top_id + 1)
 
+        # add optional conditionals
+        if len(conditionals) > 0:
+            constr.add_conditionals(conditionals)
+
         # encoder configuration
         config = pblib.PBConfig()
         config.set_PB_Encoder(EncType._to_pbenc[encoding])
@@ -358,7 +367,7 @@ class PBEnc(object):
 
     @classmethod
     def leq(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
-            encoding=EncType.best):
+            encoding=EncType.best, conditionals=None):
         """
             This method can be used for creating a CNF encoding of a LEQ
             (weighted AtMostK) constraint, i.e. of
@@ -374,12 +383,18 @@ class PBEnc(object):
             ``EncType.best``, i.e. it is up to the PBLib encoder to choose the
             encoding type.
 
+            The final optional argument is ``conditionals``, where a list of
+            literals can be passed to be used as the antecedent for the PB
+            constraint, which makes it *"reified"*. If the argument is set to
+            ``None``, the constraint won't be reified.
+
             :param lits: a list of literals in the sum.
             :param weights: a list of weights
             :param bound: the value of bound :math:`k`.
             :param top_id: top variable identifier used so far.
             :param vpool: variable pool for counting the number of variables.
             :param encoding: identifier of the encoding to use.
+            :param conditionals: a list of variables that imply this constraint.
 
             :type lits: iterable(int)
             :type weights: iterable(int)
@@ -387,26 +402,29 @@ class PBEnc(object):
             :type top_id: integer or None
             :type vpool: :class:`.IDPool`
             :type encoding: integer
+            :type conditionals: list(int) or None
 
             :rtype: :class:`pysat.formula.CNFPlus`
         """
 
         return cls._encode(lits, weights=weights, bound=bound, top_id=top_id,
-                vpool=vpool, encoding=encoding, comparator='<')
+                           vpool=vpool, encoding=encoding, comparator='<',
+                           conditionals=conditionals)
 
     @classmethod
     def atmost(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
-            encoding=EncType.best):
+            encoding=EncType.best, conditionals=None):
         """
             A synonim for :meth:`PBEnc.leq`.
         """
 
         return cls.leq(lits, weights=weights, bound=bound, top_id=top_id,
-                vpool=vpool, encoding=encoding)
+                       vpool=vpool, encoding=encoding,
+                       conditionals=conditionals)
 
     @classmethod
     def geq(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
-            encoding=EncType.best):
+            encoding=EncType.best, conditionals=None):
         """
             This method can be used for creating a CNF encoding of a GEQ
             (weighted AtLeastK) constraint, i.e. of
@@ -416,21 +434,23 @@ class PBEnc(object):
         """
 
         return cls._encode(lits, weights=weights, bound=bound, top_id=top_id,
-                vpool=vpool, encoding=encoding, comparator='>')
+                           vpool=vpool, encoding=encoding, comparator='>',
+                           conditionals=conditionals)
 
     @classmethod
     def atleast(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
-            encoding=EncType.best):
+            encoding=EncType.best, conditionals=None):
         """
             A synonym for :meth:`PBEnc.geq`.
         """
 
         return cls.geq(lits, weights=weights, bound=bound, top_id=top_id,
-                vpool=vpool, encoding=encoding)
+                       vpool=vpool, encoding=encoding,
+                       conditionals=conditionals)
 
     @classmethod
     def equals(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
-            encoding=EncType.best):
+            encoding=EncType.best, conditionals=None):
         """
             This method can be used for creating a CNF encoding of a weighted
             EqualsK constraint, i.e. of :math:`\\sum_{i=1}^{n}{a_i\\cdot x_i}=
@@ -439,4 +459,5 @@ class PBEnc(object):
         """
 
         return cls._encode(lits, weights=weights, bound=bound, top_id=top_id,
-                vpool=vpool, encoding=encoding, comparator='=')
+                           vpool=vpool, encoding=encoding, comparator='=',
+                           conditionals=conditionals)

{python_sat-1.8.dev24 → python_sat-1.8.dev26/python_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.8.dev24
+Version: 1.8.dev26
 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.8.dev24 → python_sat-1.8.dev26}/python_sat.egg-info/SOURCES.txt

@@ -88,8 +88,10 @@ tests/test_atmostk.py
 tests/test_boolengine.py
 tests/test_clausification.py
 tests/test_cnf.py
+tests/test_encode_pb_conditional.py
 tests/test_equals1.py
 tests/test_formula_unique.py
+tests/test_idpool.py
 tests/test_process.py
 tests/test_propagate.py
 tests/test_unique_model.py

python_sat-1.8.dev26/tests/test_encode_pb_conditional.py

@@ -0,0 +1,54 @@
+from pysat.formula import IDPool
+from pysat.card import CardEnc
+import pytest
+
+@pytest.mark.skip(reason="PBLIB not installed in CI")
+def test_pbenc_conditional():
+    from pysat.pb import PBEnc, EncType
+    L = 3
+    LITS = list(range(1, L + 1))  # Variables x1, x2, x3, x4
+    WEIGHTS = [2, 1, 1]        # Coefficients: 2*x1 + 3*x2 + 5*x3 + 8*x4
+    bound = 10                 # Constraint: ... <= 10
+
+    CONDS = [L+1]
+
+    # We need a vpool even if we don't use it, to handle PySAT internal structure
+    vpool = IDPool()
+
+    # Generate the CNF clauses
+    cnf = PBEnc.atleast(
+        lits=LITS,
+        weights=WEIGHTS,
+        bound=bound,
+        vpool=vpool,
+        conditionals=CONDS
+    )
+
+    assert cnf.clauses == [[-4]] # without PR to pblib this will be [[3, -4], [1, -4], [2, -4], [-4]]
+
+    bound = 2
+
+    # Generate the CNF clauses
+    cnf = PBEnc.atleast(
+        lits=LITS,
+        weights=WEIGHTS,
+        bound=bound,
+        vpool=vpool,
+        conditionals=CONDS
+    )
+
+    assert cnf.clauses == [[5], [-5, 6], [3, 6], [-5, 3, 7], [2, 6], [-5, 2, 7], [3, 2, 7], [-5, 3, 2, 8], [1, 9], [-7, 9], [1, -7, 10], [-10, -4]]
+
+    bound = 0
+
+    # Generate the CNF clauses
+    cnf = PBEnc.atleast(
+        lits=LITS,
+        weights=WEIGHTS,
+        bound=bound,
+        vpool=vpool,
+        conditionals=CONDS
+    )
+
+    assert cnf.clauses == []
+

python_sat-1.8.dev26/tests/test_idpool.py

@@ -0,0 +1,27 @@
+from pysat.formula import IDPool
+
+def test_idpool_neg():
+    pool = IDPool(with_neg=True)
+
+    pool.id('hello')
+    pool.id(+25)
+    pool.id(-42)
+    pool.id('world')
+
+    assert pool.id('hello') == 1
+    assert pool.id(25) == -pool.id(-25) == +2
+    assert pool.id(42) == -pool.id(-42) == -3
+    assert pool.id('world') == 4
+
+def test_idpool_occupied():
+    pool = IDPool(start_from=5, occupied=[[2, 10], [12, 20], [22, 30]], with_neg=True)
+
+    pool.id('hello')
+    pool.id(+25)
+    pool.id(-42)
+    pool.id('world')
+
+    assert pool.id('hello') == 11
+    assert pool.id(25) == -pool.id(-25) == +21
+    assert pool.id(42) == -pool.id(-42) == -31
+    assert pool.id('world') == 32